How to get RSSI value, send to sensor, sensor receive package, repackage it?
Hi
I have a project:
1. a client sensor broadcast package
2. there are 5 rooms, each room has 2 sensors
3. the sensors receive package, embed the sensor Id
4. send the new package to server through multihop
5. server get the new package through Delta.
How should I change the following nc code to do it?
Code:#include "CountMsg.h" module RadioDemoM { provides interface StdControl; uses interface Timer; uses interface Leds; uses interface SendMsg; uses interface ReceiveMsg; uses interface Button; } implementation { uint16_t m_count; uint16_t m_lqi; uint16_t m_rssi; TOS_Msg m_msg; bool m_is_sending; uint16_t m_timeout; uint16_t m_mode; enum { MODE_COUNT_RADIO, MODE_EXCHANGE_RSSI, MODE_EXCHANGE_LQI, PERIOD_COUNT_RADIO = 333, PERIOD_EXCHANGE_RSSI = 33, PERIOD_EXCHANGE_LQI = 33, TIMEOUT_EXCHANGE_RSSI = 100, TIMEOUT_EXCHANGE_LQI = 100, }; command result_t StdControl.init() { m_count = 0; m_lqi = 0; m_timeout = 0; m_is_sending = FALSE; m_mode = MODE_COUNT_RADIO; return SUCCESS; } command result_t StdControl.start() { call Button.enable(); m_mode = MODE_COUNT_RADIO; if( TOS_LOCAL_ADDRESS == 1 ) call Timer.start( TIMER_REPEAT, PERIOD_COUNT_RADIO ); return SUCCESS; } command result_t StdControl.stop() { call Timer.stop(); return SUCCESS; } void sendCount( uint16_t count ) { if( m_is_sending == FALSE ) { CountMsg_t* body = (CountMsg_t*)m_msg.data; body->n = count; body->src = 10000 + m_mode; if( call SendMsg.send(TOS_BCAST_ADDR,sizeof(CountMsg_t),&m_msg) == SUCCESS ) { m_is_sending = TRUE; } } } event result_t Timer.fired() { if( TOS_LOCAL_ADDRESS == 1 ) { m_count++; switch( m_mode ) { case MODE_COUNT_RADIO: call Leds.set( m_count ); break; case MODE_EXCHANGE_RSSI: case MODE_EXCHANGE_LQI: if( m_timeout == 0 ) call Leds.set(0); if( m_timeout > 0 ) m_timeout--; break; } sendCount( m_count ); } else { // timeout for address != 1 call Leds.set(0); } return SUCCESS; } event result_t SendMsg.sendDone(TOS_MsgPtr msg, result_t result) { m_is_sending = FALSE; return SUCCESS; } task void processLQI() { uint16_t leds = 1; if( m_lqi >= 85 ) leds |= 2; if( m_lqi >= 106 ) leds |= 4; call Leds.set( leds ); } task void processRSSI() { uint16_t leds = 1; if( m_rssi >= 20 ) leds |= 2; //prev 15 if( m_rssi >= 40 ) leds |= 4; //prev 35 call Leds.set( leds ); } event TOS_MsgPtr ReceiveMsg.receive( TOS_MsgPtr msg ) { CountMsg_t* body = (CountMsg_t*)msg->data; if( body->src >= 10000 ) { if( TOS_LOCAL_ADDRESS == 1 ) { m_timeout = (TIMEOUT_EXCHANGE_LQI + PERIOD_EXCHANGE_LQI - 1) / PERIOD_EXCHANGE_LQI; m_lqi = msg->lqi; post processLQI(); } else { m_mode = body->src - 10000; switch( m_mode ) { case MODE_COUNT_RADIO: m_count = body->n; call Leds.set( m_count ); call Timer.stop(); //stop timeout break; case MODE_EXCHANGE_RSSI: call Timer.start( TIMER_ONE_SHOT, TIMEOUT_EXCHANGE_RSSI ); //timeout m_rssi = (msg->strength + 60) & 255; post processRSSI(); sendCount( m_count ); break; case MODE_EXCHANGE_LQI: call Timer.start( TIMER_ONE_SHOT, TIMEOUT_EXCHANGE_LQI ); //timeout m_lqi = msg->lqi; post processLQI(); sendCount( m_count ); break; } } } return msg; } task void switchMode() { switch( m_mode ) { case MODE_COUNT_RADIO: m_mode = MODE_EXCHANGE_RSSI; call Timer.start( TIMER_REPEAT, PERIOD_EXCHANGE_RSSI ); break; case MODE_EXCHANGE_RSSI: m_mode = MODE_EXCHANGE_LQI; call Timer.start( TIMER_REPEAT, PERIOD_EXCHANGE_LQI ); break; case MODE_EXCHANGE_LQI: default: m_mode = MODE_COUNT_RADIO; call Timer.start( TIMER_REPEAT, PERIOD_COUNT_RADIO ); break; } } async event void Button.pressed(uint32_t time) { if( TOS_LOCAL_ADDRESS == 1 ) post switchMode(); } async event void Button.released(uint32_t time) { } } //---------------------------------------------------------------------------------------------- includes CountMsg; module CountReceiveM { provides interface StdControl; uses interface ReceiveMsg; uses interface Leds; } implementation { command result_t StdControl.init() { call Leds.init(); return SUCCESS; } command result_t StdControl.start() { return SUCCESS; } command result_t StdControl.stop() { return SUCCESS; } event TOS_MsgPtr ReceiveMsg.receive( TOS_MsgPtr msg ) { CountMsg_t* body = (CountMsg_t*)msg->data; call Leds.set( body->n ); return msg; } } //----------------------------------------------------------------------------------------------- includes CountMsg; module CountSendM { provides interface StdControl; uses interface Timer; uses interface SendMsg; uses interface Leds; } implementation { TOS_Msg m_msg; int m_int; bool m_sending; command result_t StdControl.init() { m_int = 0; m_sending = FALSE; call Leds.init(); return SUCCESS; } command result_t StdControl.start() { call Timer.start( TIMER_REPEAT, 200 ); return SUCCESS; } command result_t StdControl.stop() { return SUCCESS; } event result_t Timer.fired() { if( m_sending == FALSE ) { CountMsg_t* body = (CountMsg_t*)m_msg.data; body->n = m_int; body->src = TOS_LOCAL_ADDRESS; if( call SendMsg.send( TOS_BCAST_ADDR, sizeof(CountMsg_t), &m_msg ) == SUCCESS ) { call Leds.set( m_int ); m_sending = TRUE; } } m_int++; return SUCCESS; } event result_t SendMsg.sendDone( TOS_MsgPtr msg, result_t success ) { m_sending = FALSE; return SUCCESS; } } //----------------------------------------------------------------------------------------- #include "Delta.h" #include "circularQueue.h" module DeltaM { provides { interface StdControl; } uses { interface Send as SendDeltaMsg; interface Intercept as SnoopDeltaMsg; interface RouteControl; interface RouteStatistics; interface ADC; interface Timer; interface Timer as TimerBlink; interface Leds; } } implementation { /************************* VARIABLES *******************************/ uint16_t m_adc; uint32_t m_seqno; TOS_Msg msg[DELTA_QUEUE_SIZE]; CircularQueue_t queue; /************************* HELPER FUNCTIONS ************************/ task void sendData() { uint16_t _length; int i; uint16_t neighbors[MHOP_PARENT_SIZE]; uint16_t quality[MHOP_PARENT_SIZE]; if (cqueue_pushBack( &queue ) == SUCCESS) { DeltaMsg* dmsg = (DeltaMsg*)call SendDeltaMsg.getBuffer(&msg[queue.back], &_length); atomic dmsg->reading = m_adc; dmsg->parent = call RouteControl.getParent(); call RouteStatistics.getNeighbors(neighbors, MHOP_PARENT_SIZE); call RouteStatistics.getNeighborQuality(quality, MHOP_PARENT_SIZE); for (i = 0; i < MHOP_PARENT_SIZE; i++) { dmsg->neighbors[i] = neighbors[i]; dmsg->quality[i] = quality[i]; } dmsg->neighborsize = MHOP_PARENT_SIZE; dmsg->retransmissions = call RouteStatistics.getRetransmissions(); dmsg->seqno = m_seqno; if (call SendDeltaMsg.send( &msg[queue.back], sizeof(DeltaMsg) ) == SUCCESS) { call Leds.redOn(); } else { // remove from queue cqueue_popBack( &queue ); } } // always increase seqno. gives a better idea of how many packets // really have been dropped m_seqno++; } void blinkBlue() { call Leds.yellowOn(); call TimerBlink.start(TIMER_ONE_SHOT, 20); } /************************* STD CONTROL *****************************/ command result_t StdControl.init() { cqueue_init( &queue, DELTA_QUEUE_SIZE ); return SUCCESS; } command result_t StdControl.start() { call Timer.start( TIMER_REPEAT, DELTA_TIME ); return SUCCESS; } command result_t StdControl.stop() { return SUCCESS; } /************************* TIMER ***********************************/ event result_t Timer.fired() { call ADC.getData(); return SUCCESS; } event result_t TimerBlink.fired() { call Leds.yellowOff(); return SUCCESS; } /************************* ADC *************************************/ async event result_t ADC.dataReady(uint16_t data) { m_adc = data; post sendData(); return SUCCESS; } /************************* SEND ************************************/ event result_t SendDeltaMsg.sendDone(TOS_MsgPtr _msg, result_t _success) { cqueue_popFront( &queue ); if (cqueue_isEmpty( &queue )) { call Leds.redOff(); } return SUCCESS; } /************************* SEND ************************************/ event result_t SnoopDeltaMsg.intercept(TOS_MsgPtr _msg, void* payload, uint16_t payloadLen) { blinkBlue(); return SUCCESS; } }
