TinyOS

Dhanshree Nimje

Smita Khartad

TinyOS - Design Design

What is TinyOSTinyOS is a highly modular softwareenvironment tailored to the requirements ofNetwork Sensors stressing efficiencymodularity and concurrency

bull Capable of fine grained concurrency (event-driven architecture)bull1048633Small physical size

bull Fewer context switches (FIFOnon-preemptable scheduling)

bull1048633Efficient Resource Utilization (Get done quickly and sleep)

bull1048633Highly Modular

TinyOS - Features

Event-driven architecture Lower layer sends events to higher layer Low overheadndash No busy -wait cycles

Interrupt drivenTwo kinds of interrupt 10486331048633 Clock 10486331048633 Radio

Component driven programming model 10486331048633 Size - 400 bytes 10486331048633 Extremely flexible component graph Single Single-shared stack shared stack

Features Contd

Network management - Active Messaging

No kernel process management virtual memory

File management - Matchbox

2-level FIFO schedulerndash events and tasks

Complete integration with hardware

Hardware Kits

Two Board Sandwich Main CPU board with Radio

Communication 1048633 Secondary Sensor Board 1048633 Allows for expansion and customization 1048633 Current sensors include Acceleration Magnetic Field Temperature Pressure Humidity Light and RF Signal

Strength 1048633 Can control RF transmission

strength amp Sense Reception Strength

Hardware Abstraction

LED (pin numberingHW wiring) CLOCK (counter interrupt) UART (baud rate control transfer) ADC (ADC interrupt handling) RFM (abstracts bit level timing

RFM specific control logic)

Communication stack

building up from the RFM bit level

bit level abstracts away radio specifics

byte level radio component collects individual bits into bytes

packet level constructs packets from bytes

messaging layer interprets packets as messages

Sensor stack

photo and temperature sensing components sits on top of ADC component typical request data wait for data event

TinyOS component model

Component interface commands accepts

(implemented) commands uses events accepts (implemented) events uses

Component implementation functions that implement

interface frame internal state tasks concurrency control

Programming Model

comp1C code

comp3

comp4

ComponentsComponentscompcomp specification specificationCC behaviour behaviourdescdesc select and select and wirewire

specificationspecificationaccepts accepts commandscommandsuses uses commandscommandssignals signals eventseventshandles handles eventsevents

comp2desc

applicationdesc

Scheduler Scheduler 2-level scheduling (events and tasks) single shared stack used by events and function calls

TasksTasks are preemptable by eventsare preemptable by events may call commandsmay call commands may signal eventsmay signal events not preempted by tasksnot preempted by tasks

Events ndash Events ndash Time critical Shorter duration (hand off to task if need be) Interrupts task Last-in first-out semantics (no priority among events) lowest level events support by hardware interruptlowest level events support by hardware interrupt

TinyOS Two-level Scheduling

Tasks do intensive computations Unpreemptable FIFO

scheduling Bounded number of

pending tasks Events handle interrupts

Interrupts trigger lowest level events

Events can signal events call commands or post tasks

Two priorities Eventcommand Tasks

How to handle multiple data flows Datainterrupt are handled by interruptevent

Respond to it quickly A sequence of non-blockingeventcommand (function calls) through the componentgraph eg get bit out of radio hw before it gets lost

Post tasks for long computations eg encoding

bull Assumption long computation are not urgent New events preempt tasks to handle newdata

Receiving a message

What are tasks

Requirement of realtime OS bounded delays between events

Event handler should run to completion within a short duration

If a lot of computation is involved in an event handler we defer execution How Implementing it as a task and scheduling it for later

execution TinyOS has simple FIFO scheduler using which tasks

are scheduled On occurrence of an event a task that is executing is

preempted

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

TinyOS - Design Design

What is TinyOSTinyOS is a highly modular softwareenvironment tailored to the requirements ofNetwork Sensors stressing efficiencymodularity and concurrency

bull Capable of fine grained concurrency (event-driven architecture)bull1048633Small physical size

bull Fewer context switches (FIFOnon-preemptable scheduling)

bull1048633Efficient Resource Utilization (Get done quickly and sleep)

bull1048633Highly Modular

TinyOS - Features

Event-driven architecture Lower layer sends events to higher layer Low overheadndash No busy -wait cycles

Interrupt drivenTwo kinds of interrupt 10486331048633 Clock 10486331048633 Radio

Component driven programming model 10486331048633 Size - 400 bytes 10486331048633 Extremely flexible component graph Single Single-shared stack shared stack

Features Contd

Network management - Active Messaging

No kernel process management virtual memory

File management - Matchbox

2-level FIFO schedulerndash events and tasks

Complete integration with hardware

Hardware Kits

Two Board Sandwich Main CPU board with Radio

Communication 1048633 Secondary Sensor Board 1048633 Allows for expansion and customization 1048633 Current sensors include Acceleration Magnetic Field Temperature Pressure Humidity Light and RF Signal

Strength 1048633 Can control RF transmission

strength amp Sense Reception Strength

Hardware Abstraction

LED (pin numberingHW wiring) CLOCK (counter interrupt) UART (baud rate control transfer) ADC (ADC interrupt handling) RFM (abstracts bit level timing

RFM specific control logic)

Communication stack

building up from the RFM bit level

bit level abstracts away radio specifics

byte level radio component collects individual bits into bytes

packet level constructs packets from bytes

messaging layer interprets packets as messages

Sensor stack

photo and temperature sensing components sits on top of ADC component typical request data wait for data event

TinyOS component model

Component interface commands accepts

(implemented) commands uses events accepts (implemented) events uses

Component implementation functions that implement

interface frame internal state tasks concurrency control

Programming Model

comp1C code

comp3

comp4

ComponentsComponentscompcomp specification specificationCC behaviour behaviourdescdesc select and select and wirewire

specificationspecificationaccepts accepts commandscommandsuses uses commandscommandssignals signals eventseventshandles handles eventsevents

comp2desc

applicationdesc

Scheduler Scheduler 2-level scheduling (events and tasks) single shared stack used by events and function calls

TasksTasks are preemptable by eventsare preemptable by events may call commandsmay call commands may signal eventsmay signal events not preempted by tasksnot preempted by tasks

Events ndash Events ndash Time critical Shorter duration (hand off to task if need be) Interrupts task Last-in first-out semantics (no priority among events) lowest level events support by hardware interruptlowest level events support by hardware interrupt

TinyOS Two-level Scheduling

Tasks do intensive computations Unpreemptable FIFO

scheduling Bounded number of

pending tasks Events handle interrupts

Interrupts trigger lowest level events

Events can signal events call commands or post tasks

Two priorities Eventcommand Tasks

How to handle multiple data flows Datainterrupt are handled by interruptevent

Respond to it quickly A sequence of non-blockingeventcommand (function calls) through the componentgraph eg get bit out of radio hw before it gets lost

Post tasks for long computations eg encoding

bull Assumption long computation are not urgent New events preempt tasks to handle newdata

Receiving a message

What are tasks

Requirement of realtime OS bounded delays between events

Event handler should run to completion within a short duration

If a lot of computation is involved in an event handler we defer execution How Implementing it as a task and scheduling it for later

execution TinyOS has simple FIFO scheduler using which tasks

are scheduled On occurrence of an event a task that is executing is

preempted

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

What is TinyOSTinyOS is a highly modular softwareenvironment tailored to the requirements ofNetwork Sensors stressing efficiencymodularity and concurrency

bull Capable of fine grained concurrency (event-driven architecture)bull1048633Small physical size

bull Fewer context switches (FIFOnon-preemptable scheduling)

bull1048633Efficient Resource Utilization (Get done quickly and sleep)

bull1048633Highly Modular

TinyOS - Features

Event-driven architecture Lower layer sends events to higher layer Low overheadndash No busy -wait cycles

Interrupt drivenTwo kinds of interrupt 10486331048633 Clock 10486331048633 Radio

Component driven programming model 10486331048633 Size - 400 bytes 10486331048633 Extremely flexible component graph Single Single-shared stack shared stack

Features Contd

Network management - Active Messaging

No kernel process management virtual memory

File management - Matchbox

2-level FIFO schedulerndash events and tasks

Complete integration with hardware

Hardware Kits

Two Board Sandwich Main CPU board with Radio

Communication 1048633 Secondary Sensor Board 1048633 Allows for expansion and customization 1048633 Current sensors include Acceleration Magnetic Field Temperature Pressure Humidity Light and RF Signal

Strength 1048633 Can control RF transmission

strength amp Sense Reception Strength

Hardware Abstraction

LED (pin numberingHW wiring) CLOCK (counter interrupt) UART (baud rate control transfer) ADC (ADC interrupt handling) RFM (abstracts bit level timing

RFM specific control logic)

Communication stack

building up from the RFM bit level

bit level abstracts away radio specifics

byte level radio component collects individual bits into bytes

packet level constructs packets from bytes

messaging layer interprets packets as messages

Sensor stack

photo and temperature sensing components sits on top of ADC component typical request data wait for data event

TinyOS component model

Component interface commands accepts

(implemented) commands uses events accepts (implemented) events uses

Component implementation functions that implement

interface frame internal state tasks concurrency control

Programming Model

comp1C code

comp3

comp4

ComponentsComponentscompcomp specification specificationCC behaviour behaviourdescdesc select and select and wirewire

specificationspecificationaccepts accepts commandscommandsuses uses commandscommandssignals signals eventseventshandles handles eventsevents

comp2desc

applicationdesc

Scheduler Scheduler 2-level scheduling (events and tasks) single shared stack used by events and function calls

TasksTasks are preemptable by eventsare preemptable by events may call commandsmay call commands may signal eventsmay signal events not preempted by tasksnot preempted by tasks

Events ndash Events ndash Time critical Shorter duration (hand off to task if need be) Interrupts task Last-in first-out semantics (no priority among events) lowest level events support by hardware interruptlowest level events support by hardware interrupt

TinyOS Two-level Scheduling

Tasks do intensive computations Unpreemptable FIFO

scheduling Bounded number of

pending tasks Events handle interrupts

Interrupts trigger lowest level events

Events can signal events call commands or post tasks

Two priorities Eventcommand Tasks

How to handle multiple data flows Datainterrupt are handled by interruptevent

Respond to it quickly A sequence of non-blockingeventcommand (function calls) through the componentgraph eg get bit out of radio hw before it gets lost

Post tasks for long computations eg encoding

bull Assumption long computation are not urgent New events preempt tasks to handle newdata

Receiving a message

What are tasks

Requirement of realtime OS bounded delays between events

Event handler should run to completion within a short duration

If a lot of computation is involved in an event handler we defer execution How Implementing it as a task and scheduling it for later

execution TinyOS has simple FIFO scheduler using which tasks

are scheduled On occurrence of an event a task that is executing is

preempted

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

TinyOS - Features

Event-driven architecture Lower layer sends events to higher layer Low overheadndash No busy -wait cycles

Interrupt drivenTwo kinds of interrupt 10486331048633 Clock 10486331048633 Radio

Component driven programming model 10486331048633 Size - 400 bytes 10486331048633 Extremely flexible component graph Single Single-shared stack shared stack

Features Contd

Network management - Active Messaging

No kernel process management virtual memory

File management - Matchbox

2-level FIFO schedulerndash events and tasks

Complete integration with hardware

Hardware Kits

Two Board Sandwich Main CPU board with Radio

Communication 1048633 Secondary Sensor Board 1048633 Allows for expansion and customization 1048633 Current sensors include Acceleration Magnetic Field Temperature Pressure Humidity Light and RF Signal

Strength 1048633 Can control RF transmission

strength amp Sense Reception Strength

Hardware Abstraction

LED (pin numberingHW wiring) CLOCK (counter interrupt) UART (baud rate control transfer) ADC (ADC interrupt handling) RFM (abstracts bit level timing

RFM specific control logic)

Communication stack

building up from the RFM bit level

bit level abstracts away radio specifics

byte level radio component collects individual bits into bytes

packet level constructs packets from bytes

messaging layer interprets packets as messages

Sensor stack

photo and temperature sensing components sits on top of ADC component typical request data wait for data event

TinyOS component model

Component interface commands accepts

(implemented) commands uses events accepts (implemented) events uses

Component implementation functions that implement

interface frame internal state tasks concurrency control

Programming Model

comp1C code

comp3

comp4

ComponentsComponentscompcomp specification specificationCC behaviour behaviourdescdesc select and select and wirewire

specificationspecificationaccepts accepts commandscommandsuses uses commandscommandssignals signals eventseventshandles handles eventsevents

comp2desc

applicationdesc

Scheduler Scheduler 2-level scheduling (events and tasks) single shared stack used by events and function calls

TasksTasks are preemptable by eventsare preemptable by events may call commandsmay call commands may signal eventsmay signal events not preempted by tasksnot preempted by tasks

Events ndash Events ndash Time critical Shorter duration (hand off to task if need be) Interrupts task Last-in first-out semantics (no priority among events) lowest level events support by hardware interruptlowest level events support by hardware interrupt

TinyOS Two-level Scheduling

Tasks do intensive computations Unpreemptable FIFO

scheduling Bounded number of

pending tasks Events handle interrupts

Interrupts trigger lowest level events

Events can signal events call commands or post tasks

Two priorities Eventcommand Tasks

How to handle multiple data flows Datainterrupt are handled by interruptevent

Respond to it quickly A sequence of non-blockingeventcommand (function calls) through the componentgraph eg get bit out of radio hw before it gets lost

Post tasks for long computations eg encoding

bull Assumption long computation are not urgent New events preempt tasks to handle newdata

Receiving a message

What are tasks

Requirement of realtime OS bounded delays between events

Event handler should run to completion within a short duration

If a lot of computation is involved in an event handler we defer execution How Implementing it as a task and scheduling it for later

execution TinyOS has simple FIFO scheduler using which tasks

are scheduled On occurrence of an event a task that is executing is

preempted

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

Features Contd

Network management - Active Messaging

No kernel process management virtual memory

File management - Matchbox

2-level FIFO schedulerndash events and tasks

Complete integration with hardware

Hardware Kits

Two Board Sandwich Main CPU board with Radio

Communication 1048633 Secondary Sensor Board 1048633 Allows for expansion and customization 1048633 Current sensors include Acceleration Magnetic Field Temperature Pressure Humidity Light and RF Signal

Strength 1048633 Can control RF transmission

strength amp Sense Reception Strength

Hardware Abstraction

LED (pin numberingHW wiring) CLOCK (counter interrupt) UART (baud rate control transfer) ADC (ADC interrupt handling) RFM (abstracts bit level timing

RFM specific control logic)

Communication stack

building up from the RFM bit level

bit level abstracts away radio specifics

byte level radio component collects individual bits into bytes

packet level constructs packets from bytes

messaging layer interprets packets as messages

Sensor stack

photo and temperature sensing components sits on top of ADC component typical request data wait for data event

TinyOS component model

Component interface commands accepts

(implemented) commands uses events accepts (implemented) events uses

Component implementation functions that implement

interface frame internal state tasks concurrency control

Programming Model

comp1C code

comp3

comp4

ComponentsComponentscompcomp specification specificationCC behaviour behaviourdescdesc select and select and wirewire

specificationspecificationaccepts accepts commandscommandsuses uses commandscommandssignals signals eventseventshandles handles eventsevents

comp2desc

applicationdesc

Scheduler Scheduler 2-level scheduling (events and tasks) single shared stack used by events and function calls

TasksTasks are preemptable by eventsare preemptable by events may call commandsmay call commands may signal eventsmay signal events not preempted by tasksnot preempted by tasks

Events ndash Events ndash Time critical Shorter duration (hand off to task if need be) Interrupts task Last-in first-out semantics (no priority among events) lowest level events support by hardware interruptlowest level events support by hardware interrupt

TinyOS Two-level Scheduling

Tasks do intensive computations Unpreemptable FIFO

scheduling Bounded number of

pending tasks Events handle interrupts

Interrupts trigger lowest level events

Events can signal events call commands or post tasks

Two priorities Eventcommand Tasks

How to handle multiple data flows Datainterrupt are handled by interruptevent

Respond to it quickly A sequence of non-blockingeventcommand (function calls) through the componentgraph eg get bit out of radio hw before it gets lost

Post tasks for long computations eg encoding

bull Assumption long computation are not urgent New events preempt tasks to handle newdata

Receiving a message

What are tasks

Requirement of realtime OS bounded delays between events

Event handler should run to completion within a short duration

If a lot of computation is involved in an event handler we defer execution How Implementing it as a task and scheduling it for later

execution TinyOS has simple FIFO scheduler using which tasks

are scheduled On occurrence of an event a task that is executing is

preempted

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

Hardware Kits

Two Board Sandwich Main CPU board with Radio

Communication 1048633 Secondary Sensor Board 1048633 Allows for expansion and customization 1048633 Current sensors include Acceleration Magnetic Field Temperature Pressure Humidity Light and RF Signal

Strength 1048633 Can control RF transmission

strength amp Sense Reception Strength

Hardware Abstraction

LED (pin numberingHW wiring) CLOCK (counter interrupt) UART (baud rate control transfer) ADC (ADC interrupt handling) RFM (abstracts bit level timing

RFM specific control logic)

Communication stack

building up from the RFM bit level

bit level abstracts away radio specifics

byte level radio component collects individual bits into bytes

packet level constructs packets from bytes

messaging layer interprets packets as messages

Sensor stack

photo and temperature sensing components sits on top of ADC component typical request data wait for data event

TinyOS component model

Component interface commands accepts

(implemented) commands uses events accepts (implemented) events uses

Component implementation functions that implement

interface frame internal state tasks concurrency control

Programming Model

comp1C code

comp3

comp4

ComponentsComponentscompcomp specification specificationCC behaviour behaviourdescdesc select and select and wirewire

specificationspecificationaccepts accepts commandscommandsuses uses commandscommandssignals signals eventseventshandles handles eventsevents

comp2desc

applicationdesc

Scheduler Scheduler 2-level scheduling (events and tasks) single shared stack used by events and function calls

TasksTasks are preemptable by eventsare preemptable by events may call commandsmay call commands may signal eventsmay signal events not preempted by tasksnot preempted by tasks

Events ndash Events ndash Time critical Shorter duration (hand off to task if need be) Interrupts task Last-in first-out semantics (no priority among events) lowest level events support by hardware interruptlowest level events support by hardware interrupt

TinyOS Two-level Scheduling

Tasks do intensive computations Unpreemptable FIFO

scheduling Bounded number of

pending tasks Events handle interrupts

Interrupts trigger lowest level events

Events can signal events call commands or post tasks

Two priorities Eventcommand Tasks

How to handle multiple data flows Datainterrupt are handled by interruptevent

Respond to it quickly A sequence of non-blockingeventcommand (function calls) through the componentgraph eg get bit out of radio hw before it gets lost

Post tasks for long computations eg encoding

bull Assumption long computation are not urgent New events preempt tasks to handle newdata

Receiving a message

What are tasks

Requirement of realtime OS bounded delays between events

Event handler should run to completion within a short duration

If a lot of computation is involved in an event handler we defer execution How Implementing it as a task and scheduling it for later

execution TinyOS has simple FIFO scheduler using which tasks

are scheduled On occurrence of an event a task that is executing is

preempted

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

Hardware Abstraction

LED (pin numberingHW wiring) CLOCK (counter interrupt) UART (baud rate control transfer) ADC (ADC interrupt handling) RFM (abstracts bit level timing

RFM specific control logic)

Communication stack

building up from the RFM bit level

bit level abstracts away radio specifics

byte level radio component collects individual bits into bytes

packet level constructs packets from bytes

messaging layer interprets packets as messages

Sensor stack

photo and temperature sensing components sits on top of ADC component typical request data wait for data event

TinyOS component model

Component interface commands accepts

(implemented) commands uses events accepts (implemented) events uses

Component implementation functions that implement

interface frame internal state tasks concurrency control

Programming Model

comp1C code

comp3

comp4

ComponentsComponentscompcomp specification specificationCC behaviour behaviourdescdesc select and select and wirewire

specificationspecificationaccepts accepts commandscommandsuses uses commandscommandssignals signals eventseventshandles handles eventsevents

comp2desc

applicationdesc

Scheduler Scheduler 2-level scheduling (events and tasks) single shared stack used by events and function calls

TasksTasks are preemptable by eventsare preemptable by events may call commandsmay call commands may signal eventsmay signal events not preempted by tasksnot preempted by tasks

Events ndash Events ndash Time critical Shorter duration (hand off to task if need be) Interrupts task Last-in first-out semantics (no priority among events) lowest level events support by hardware interruptlowest level events support by hardware interrupt

TinyOS Two-level Scheduling

Tasks do intensive computations Unpreemptable FIFO

scheduling Bounded number of

pending tasks Events handle interrupts

Interrupts trigger lowest level events

Events can signal events call commands or post tasks

Two priorities Eventcommand Tasks

How to handle multiple data flows Datainterrupt are handled by interruptevent

Respond to it quickly A sequence of non-blockingeventcommand (function calls) through the componentgraph eg get bit out of radio hw before it gets lost

Post tasks for long computations eg encoding

bull Assumption long computation are not urgent New events preempt tasks to handle newdata

Receiving a message

What are tasks

Requirement of realtime OS bounded delays between events

Event handler should run to completion within a short duration

If a lot of computation is involved in an event handler we defer execution How Implementing it as a task and scheduling it for later

execution TinyOS has simple FIFO scheduler using which tasks

are scheduled On occurrence of an event a task that is executing is

preempted

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

Communication stack

building up from the RFM bit level

bit level abstracts away radio specifics

byte level radio component collects individual bits into bytes

packet level constructs packets from bytes

messaging layer interprets packets as messages

Sensor stack

photo and temperature sensing components sits on top of ADC component typical request data wait for data event

TinyOS component model

Component interface commands accepts

(implemented) commands uses events accepts (implemented) events uses

Component implementation functions that implement

interface frame internal state tasks concurrency control

Programming Model

comp1C code

comp3

comp4

ComponentsComponentscompcomp specification specificationCC behaviour behaviourdescdesc select and select and wirewire

specificationspecificationaccepts accepts commandscommandsuses uses commandscommandssignals signals eventseventshandles handles eventsevents

comp2desc

applicationdesc

Scheduler Scheduler 2-level scheduling (events and tasks) single shared stack used by events and function calls

TasksTasks are preemptable by eventsare preemptable by events may call commandsmay call commands may signal eventsmay signal events not preempted by tasksnot preempted by tasks

Events ndash Events ndash Time critical Shorter duration (hand off to task if need be) Interrupts task Last-in first-out semantics (no priority among events) lowest level events support by hardware interruptlowest level events support by hardware interrupt

TinyOS Two-level Scheduling

Tasks do intensive computations Unpreemptable FIFO

scheduling Bounded number of

pending tasks Events handle interrupts

Interrupts trigger lowest level events

Events can signal events call commands or post tasks

Two priorities Eventcommand Tasks

How to handle multiple data flows Datainterrupt are handled by interruptevent

Respond to it quickly A sequence of non-blockingeventcommand (function calls) through the componentgraph eg get bit out of radio hw before it gets lost

Post tasks for long computations eg encoding

bull Assumption long computation are not urgent New events preempt tasks to handle newdata

Receiving a message

What are tasks

Requirement of realtime OS bounded delays between events

Event handler should run to completion within a short duration

If a lot of computation is involved in an event handler we defer execution How Implementing it as a task and scheduling it for later

execution TinyOS has simple FIFO scheduler using which tasks

are scheduled On occurrence of an event a task that is executing is

preempted

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

Sensor stack

photo and temperature sensing components sits on top of ADC component typical request data wait for data event

TinyOS component model

Component interface commands accepts

(implemented) commands uses events accepts (implemented) events uses

Component implementation functions that implement

interface frame internal state tasks concurrency control

Programming Model

comp1C code

comp3

comp4

ComponentsComponentscompcomp specification specificationCC behaviour behaviourdescdesc select and select and wirewire

specificationspecificationaccepts accepts commandscommandsuses uses commandscommandssignals signals eventseventshandles handles eventsevents

comp2desc

applicationdesc

Scheduler Scheduler 2-level scheduling (events and tasks) single shared stack used by events and function calls

TasksTasks are preemptable by eventsare preemptable by events may call commandsmay call commands may signal eventsmay signal events not preempted by tasksnot preempted by tasks

Events ndash Events ndash Time critical Shorter duration (hand off to task if need be) Interrupts task Last-in first-out semantics (no priority among events) lowest level events support by hardware interruptlowest level events support by hardware interrupt

TinyOS Two-level Scheduling

Tasks do intensive computations Unpreemptable FIFO

scheduling Bounded number of

pending tasks Events handle interrupts

Interrupts trigger lowest level events

Events can signal events call commands or post tasks

Two priorities Eventcommand Tasks

How to handle multiple data flows Datainterrupt are handled by interruptevent

Respond to it quickly A sequence of non-blockingeventcommand (function calls) through the componentgraph eg get bit out of radio hw before it gets lost

Post tasks for long computations eg encoding

bull Assumption long computation are not urgent New events preempt tasks to handle newdata

Receiving a message

What are tasks

Requirement of realtime OS bounded delays between events

Event handler should run to completion within a short duration

If a lot of computation is involved in an event handler we defer execution How Implementing it as a task and scheduling it for later

execution TinyOS has simple FIFO scheduler using which tasks

are scheduled On occurrence of an event a task that is executing is

preempted

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

TinyOS component model

Component interface commands accepts

(implemented) commands uses events accepts (implemented) events uses

Component implementation functions that implement

interface frame internal state tasks concurrency control

Programming Model

comp1C code

comp3

comp4

ComponentsComponentscompcomp specification specificationCC behaviour behaviourdescdesc select and select and wirewire

specificationspecificationaccepts accepts commandscommandsuses uses commandscommandssignals signals eventseventshandles handles eventsevents

comp2desc

applicationdesc

Scheduler Scheduler 2-level scheduling (events and tasks) single shared stack used by events and function calls

TasksTasks are preemptable by eventsare preemptable by events may call commandsmay call commands may signal eventsmay signal events not preempted by tasksnot preempted by tasks

Events ndash Events ndash Time critical Shorter duration (hand off to task if need be) Interrupts task Last-in first-out semantics (no priority among events) lowest level events support by hardware interruptlowest level events support by hardware interrupt

TinyOS Two-level Scheduling

Tasks do intensive computations Unpreemptable FIFO

scheduling Bounded number of

pending tasks Events handle interrupts

Interrupts trigger lowest level events

Events can signal events call commands or post tasks

Two priorities Eventcommand Tasks

How to handle multiple data flows Datainterrupt are handled by interruptevent

Respond to it quickly A sequence of non-blockingeventcommand (function calls) through the componentgraph eg get bit out of radio hw before it gets lost

Post tasks for long computations eg encoding

bull Assumption long computation are not urgent New events preempt tasks to handle newdata

Receiving a message

What are tasks

Requirement of realtime OS bounded delays between events

Event handler should run to completion within a short duration

If a lot of computation is involved in an event handler we defer execution How Implementing it as a task and scheduling it for later

execution TinyOS has simple FIFO scheduler using which tasks

are scheduled On occurrence of an event a task that is executing is

preempted

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

Programming Model

comp1C code

comp3

comp4

ComponentsComponentscompcomp specification specificationCC behaviour behaviourdescdesc select and select and wirewire

specificationspecificationaccepts accepts commandscommandsuses uses commandscommandssignals signals eventseventshandles handles eventsevents

comp2desc

applicationdesc

Scheduler Scheduler 2-level scheduling (events and tasks) single shared stack used by events and function calls

TasksTasks are preemptable by eventsare preemptable by events may call commandsmay call commands may signal eventsmay signal events not preempted by tasksnot preempted by tasks

Events ndash Events ndash Time critical Shorter duration (hand off to task if need be) Interrupts task Last-in first-out semantics (no priority among events) lowest level events support by hardware interruptlowest level events support by hardware interrupt

TinyOS Two-level Scheduling

Tasks do intensive computations Unpreemptable FIFO

scheduling Bounded number of

pending tasks Events handle interrupts

Interrupts trigger lowest level events

Events can signal events call commands or post tasks

Two priorities Eventcommand Tasks

How to handle multiple data flows Datainterrupt are handled by interruptevent

Respond to it quickly A sequence of non-blockingeventcommand (function calls) through the componentgraph eg get bit out of radio hw before it gets lost

Post tasks for long computations eg encoding

bull Assumption long computation are not urgent New events preempt tasks to handle newdata

Receiving a message

What are tasks

Requirement of realtime OS bounded delays between events

Event handler should run to completion within a short duration

If a lot of computation is involved in an event handler we defer execution How Implementing it as a task and scheduling it for later

execution TinyOS has simple FIFO scheduler using which tasks

are scheduled On occurrence of an event a task that is executing is

preempted

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

Scheduler Scheduler 2-level scheduling (events and tasks) single shared stack used by events and function calls

TasksTasks are preemptable by eventsare preemptable by events may call commandsmay call commands may signal eventsmay signal events not preempted by tasksnot preempted by tasks

Events ndash Events ndash Time critical Shorter duration (hand off to task if need be) Interrupts task Last-in first-out semantics (no priority among events) lowest level events support by hardware interruptlowest level events support by hardware interrupt

TinyOS Two-level Scheduling

Tasks do intensive computations Unpreemptable FIFO

scheduling Bounded number of

pending tasks Events handle interrupts

Interrupts trigger lowest level events

Events can signal events call commands or post tasks

Two priorities Eventcommand Tasks

How to handle multiple data flows Datainterrupt are handled by interruptevent

Respond to it quickly A sequence of non-blockingeventcommand (function calls) through the componentgraph eg get bit out of radio hw before it gets lost

Post tasks for long computations eg encoding

bull Assumption long computation are not urgent New events preempt tasks to handle newdata

Receiving a message

What are tasks

Requirement of realtime OS bounded delays between events

Event handler should run to completion within a short duration

If a lot of computation is involved in an event handler we defer execution How Implementing it as a task and scheduling it for later

execution TinyOS has simple FIFO scheduler using which tasks

are scheduled On occurrence of an event a task that is executing is

preempted

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

TinyOS Two-level Scheduling

Tasks do intensive computations Unpreemptable FIFO

scheduling Bounded number of

pending tasks Events handle interrupts

Interrupts trigger lowest level events

Events can signal events call commands or post tasks

Two priorities Eventcommand Tasks

How to handle multiple data flows Datainterrupt are handled by interruptevent

Respond to it quickly A sequence of non-blockingeventcommand (function calls) through the componentgraph eg get bit out of radio hw before it gets lost

Post tasks for long computations eg encoding

bull Assumption long computation are not urgent New events preempt tasks to handle newdata

Receiving a message

What are tasks

Requirement of realtime OS bounded delays between events

Event handler should run to completion within a short duration

If a lot of computation is involved in an event handler we defer execution How Implementing it as a task and scheduling it for later

execution TinyOS has simple FIFO scheduler using which tasks

are scheduled On occurrence of an event a task that is executing is

preempted

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

How to handle multiple data flows Datainterrupt are handled by interruptevent

Respond to it quickly A sequence of non-blockingeventcommand (function calls) through the componentgraph eg get bit out of radio hw before it gets lost

Post tasks for long computations eg encoding

bull Assumption long computation are not urgent New events preempt tasks to handle newdata

Receiving a message

What are tasks

Requirement of realtime OS bounded delays between events

Event handler should run to completion within a short duration

If a lot of computation is involved in an event handler we defer execution How Implementing it as a task and scheduling it for later

execution TinyOS has simple FIFO scheduler using which tasks

are scheduled On occurrence of an event a task that is executing is

preempted

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

Receiving a message

What are tasks

Requirement of realtime OS bounded delays between events

Event handler should run to completion within a short duration

If a lot of computation is involved in an event handler we defer execution How Implementing it as a task and scheduling it for later

execution TinyOS has simple FIFO scheduler using which tasks

are scheduled On occurrence of an event a task that is executing is

preempted

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

What are tasks

Requirement of realtime OS bounded delays between events

Event handler should run to completion within a short duration

If a lot of computation is involved in an event handler we defer execution How Implementing it as a task and scheduling it for later

execution TinyOS has simple FIFO scheduler using which tasks

are scheduled On occurrence of an event a task that is executing is

preempted

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

Data Memory Model

STATIC memory allocation No heap (malloc) No function pointers

Global variables Available on a per-frame basis

Local variables Saved on the stack Declared within a method

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

Application

Is the OS with some specific functionality Application is interrupt driven List of interrupts handled depend on list of hardware

components included in the application (eg clock and receiver)

Waits for interrupts On occurrence of interrupt calls interrupt handler

HardwareInterrupts

ISRInterruptHandler

invokes Calls

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

A Complete Application

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

Example Inter-Node Communication Sender

Receiver

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

Message Buffer Ownership

bullTransmission AM gains ownership of the buffer until sendDone(hellip) is signaledbull Reception Applicationrsquos event handler gains ownershipof the buffer but it must return a free buffer for the nextmessage

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

Potentially Nasty Bug 1

Whatrsquos wrong with the codeSymptom data saved in globalData is lost Reason Racecondition betweentwo tasksSolution Use aqueue or never relyon inter-taskcommunication

uint8_t globalDatatask void processData() call SendDatasend(globalData)command result_t Foobar(uint8_t data) globalData = datapost processData()

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

Potentially Nasty Bug 2

Whatrsquos wrong with the code

Symptom messageis corruptReason TOS_Msgis allocated in thestack lost whenfunction returns Solution DeclareTOS_Msg msg incomponentrsquos frame

command result_t Foobar(uint8_t data) TOS_Msg msgFooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

Potentially Nasty Bug 3

Whatrsquos wrong withthe codeSymptom somemessages are lostReason Racecondition betweentwo componentstrying to sharenetwork stack (whichis split-phase) Solution Use aqueue to storepending messages

command result_t Foobar(uint8_t data) FooData foo = (FooData)msgdatafoodata = datacall SendMsgsend(0x01 sizeof(FooData)ampmsg)Component

Component 2 command result_t Goobar(uint8_t data) GooData goo = (GooData)msgdatagoodata = datacall SendMsgsend(0x02 sizeof(GooData)ampmsg)

THANK YOU

THANK YOU