Receive and Send in Tinyos - tinyos

Question

I have a program comunication communication between two telosb. It is a example of tinyos: https://github.com/tinyos/tinyos-release/tree/tinyos-2_1_2/apps/RadioCountToLeds. This code will send and receive a value count, if the conditions meet, it will turn on the corresponding led. I want to split the code into 2 parts: Send and Receive. And i create 2 app:
Receive:
//RadioCountToLedC.nc
#include "Timer.h"
#include "RadioCountToLeds.h"
module RadioCountToLedsC #safe() {
uses {
interface Leds;
interface Boot;
interface Receive;
interface Packet;
}
}
implementation {
message_t packet;
uint16_t counter = 0;
event void Boot.booted()
{
}
event message_t* Receive.receive(message_t* bufPtr,
void* payload, uint8_t len) {
call Leds.led0On();
dbg("RadioCountToLedsC", "Received packet of length %hhu.\n", len);
if (len != sizeof(radio_count_msg_t)) {return bufPtr;}
else {
radio_count_msg_t* rcm = (radio_count_msg_t*)payload;
if (rcm->counter%3 == 0) {
call Leds.led0On();
}
else {
call Leds.led0Off();
}
if (rcm->counter%3 == 1) {
call Leds.led1On();
}
else {
call Leds.led1Off();
}
if (rcm->counter%3 == 2) {
call Leds.led2On();
}
else {
call Leds.led2Off();
}
return bufPtr;
}
}
}
//RadioToLedAppC.nc
#include "RadioCountToLeds.h"
configuration RadioCountToLedsAppC {}
implementation {
components MainC, RadioCountToLedsC as App, LedsC;
components new AMReceiverC(AM_RADIO_COUNT_MSG);
components new TimerMilliC();
components ActiveMessageC;
}
Send:
//RadioCountToLedC.nc
#include "Timer.h"
#include "RadioCountToLeds.h"
module RadioCountToLedsC #safe() {
uses {
interface Leds;
interface Boot;
interface AMSend;
interface Timer<TMilli> as MilliTimer;
interface SplitControl as AMControl;
interface Packet;
}
}
implementation {
message_t packet;
bool locked;
uint16_t counter = 0;
event void Boot.booted() {
call MilliTimer.startPeriodic(250);
call AMControl.start();
}
event void AMControl.startDone(error_t err) {
if (err == SUCCESS) {
call MilliTimer.startPeriodic(250);
}
else {
call AMControl.start();
}
}
event void AMControl.stopDone(error_t err) {
// do nothing
}
event void MilliTimer.fired() {
if(counter<100){
counter++;
}else{
counter=0;
}
dbg("RadioCountToLedsC", "RadioCountToLedsC: timer fired, counter is %hu.\n", counter);
if (locked) {
return;
}
else {
radio_count_msg_t* rcm = (radio_count_msg_t*)call Packet.getPayload(&packet, sizeof(radio_count_msg_t));
if (rcm == NULL) {
return;
}
rcm->counter = counter;
if (call AMSend.send(AM_BROADCAST_ADDR, &packet, sizeof(radio_count_msg_t)) == SUCCESS) {
dbg("RadioCountToLedsC", "RadioCountToLedsC: packet sent.\n", counter);
locked = TRUE;
}
}
}
event void AMSend.sendDone(message_t* bufPtr, error_t error) {
if (&packet == bufPtr) {
locked = FALSE;
}
}
}
//RadioToLedAppC.nc
#include "RadioCountToLeds.h"
configuration RadioCountToLedsAppC {}
implementation {
components MainC, RadioCountToLedsC as App, LedsC;
components new AMSenderC(AM_RADIO_COUNT_MSG);
components new AMReceiverC(AM_RADIO_COUNT_MSG);
components new TimerMilliC();
components ActiveMessageC;
App.Boot -> MainC.Boot;
App.AMSend -> AMSenderC;
App.AMControl -> ActiveMessageC;
App.Leds -> LedsC;
App.MilliTimer -> TimerMilliC;
App.Packet -> AMSenderC;
}
RadioCountToLed.h
#ifndef RADIO_COUNT_TO_LEDS_H
#define RADIO_COUNT_TO_LEDS_H
typedef nx_struct radio_count_msg {
nx_uint16_t counter;
} radio_count_msg_t;
enum {
AM_RADIO_COUNT_MSG = 6,
};
#endif
But when i run it don't work. If i write Receive and Send in same file RadioCountToLedC.nc as above example. It will work well. What's wrong with my application?

Answer 1

I think you need to
call AMControl.start();
In your booted function of your Receiver. This will turn the radio on and allow you to receive messages.
PS If this doesn't completely solve your problem please provide more detail on what you observe happening when you run.

Answer 2

The are a number of easy ways to tackle this, the easiest way is to just have a variable that controls program flow or alternatively use each nodes TinyOS ID to control flow.
For example you could have (Only 4 small changes have been made):
#include "Timer.h"
#include "RadioCountToLeds.h"
/**
* Implementation of the RadioCountToLeds application. RadioCountToLeds
* maintains a 4Hz counter, broadcasting its value in an AM packet
* every time it gets updated. A RadioCountToLeds node that hears a counter
* displays the bottom three bits on its LEDs. This application is a useful
* test to show that basic AM communication and timers work.
*
* #author Philip Levis
* #date June 6 2005
*/
module RadioCountToLedsC #safe() {
uses {
interface Leds;
interface Boot;
interface Receive;
interface AMSend;
interface Timer<TMilli> as MilliTimer;
interface SplitControl as AMControl;
interface Packet;
}
}
implementation {
message_t packet;
bool locked;
uint16_t counter = 0;
enum state {TX, RX} mode; //Change 1: Define States
event void Boot.booted() {
call AMControl.start();
mode = RX; // CHANGE 2: Set States - "RX" for receiver & "TX" for transmitter
}
event void AMControl.startDone(error_t err) {
if (err == SUCCESS) {
if(mode == TX) //CHANGE 3: Only the transmitter sends
call MilliTimer.startPeriodic(250);
}
else {
call AMControl.start();
}
}
event void AMControl.stopDone(error_t err) {
// do nothing
}
event void MilliTimer.fired() {
counter++;
dbg("RadioCountToLedsC", "RadioCountToLedsC: timer fired, counter is %hu.\n", counter);
if (locked) {
return;
}
else {
radio_count_msg_t* rcm = (radio_count_msg_t*)call Packet.getPayload(&packet, sizeof(radio_count_msg_t));
if (rcm == NULL) {
return;
}
rcm->counter = counter;
if (call AMSend.send(AM_BROADCAST_ADDR, &packet, sizeof(radio_count_msg_t)) == SUCCESS) {
dbg("RadioCountToLedsC", "RadioCountToLedsC: packet sent.\n", counter);
locked = TRUE;
}
}
}
event message_t* Receive.receive(message_t* bufPtr,
void* payload, uint8_t len) {
dbg("RadioCountToLedsC", "Received packet of length %hhu.\n", len);
if(mode == TX) return bufPtr; //CHANGE 4: Only RX processes packets
if (len != sizeof(radio_count_msg_t)) {return bufPtr;}
else {
radio_count_msg_t* rcm = (radio_count_msg_t*)payload;
if (rcm->counter & 0x1) {
call Leds.led0On();
}
else {
call Leds.led0Off();
}
if (rcm->counter & 0x2) {
call Leds.led1On();
}
else {
call Leds.led1Off();
}
if (rcm->counter & 0x4) {
call Leds.led2On();
}
else {
call Leds.led2Off();
}
return bufPtr;
}
}
event void AMSend.sendDone(message_t* bufPtr, error_t error) {
if (&packet == bufPtr) {
locked = FALSE;
}
}
}
Instead of setting the mode in the Booted event, you can alternatively use the C preprocessor to set the mode variable if you wish.
The problem with the receiver application that you made is that it
i) Does not start the transceiver as it does not call AMControl.start() in the Boot.Booted() event.
ii) The wiring in the RadioCountToLedsAppC is not correct as no interfaces are connected. You need to connect all interfaces (Boot, Leds, Receive and AMControl). Similar to how you had connected them in the sender.