How to get RSSI value, send to sensor, sensor receive package, repackage it?

This is a discussion on How to get RSSI value, send to sensor, sensor receive package, repackage it? within the Networking/Device Communication forums, part of the General Programming Boards category; Hi I have a project: 1. a client sensor broadcast package 2. there are 5 rooms, each room has 2 ...

  1. #1
    Registered User
    Join Date
    Mar 2009
    Posts
    1

    Question 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;
      }
    }

  2. #2
    a_capitalist_story
    Join Date
    Dec 2007
    Posts
    2,651
    Cross-posted here

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. sending n no of char data uning send() function,
    By thebrighter in forum Windows Programming
    Replies: 1
    Last Post: 08-22-2007, 12:26 PM
  2. Cannot install lrzsz package, please help
    By ssharish2005 in forum Tech Board
    Replies: 2
    Last Post: 06-20-2007, 05:36 AM
  3. pointers
    By InvariantLoop in forum C Programming
    Replies: 13
    Last Post: 02-04-2005, 08:32 AM
  4. LISP (DrScheme) any one?
    By Jeremy G in forum A Brief History of Cprogramming.com
    Replies: 5
    Last Post: 03-31-2004, 11:52 AM
  5. Possible Loss of data
    By silicon in forum C Programming
    Replies: 3
    Last Post: 03-24-2004, 11:25 AM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21