tinydbshimm.nc

tinyos最新版

/*                                                                      tab:4
 *  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.  By
 *  downloading, copying, installing or using the software you agree to
 *  this license.  If you do not agree to this license, do not download,
 *
 */
/*                                                                      tab:4
 * "Copyright (c) 2000-2003 The Regents of the University  of California.
 * All rights reserved.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose, without fee, and without written agreement is
 * hereby granted, provided that the above copyright notice, the following
 * two paragraphs and the author appear in all copies of this software.
 *
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
 * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."
 *
 */
/*                                                                      tab:4
 * Copyright (c) 2003 Intel Corporation
 * All rights reserved Contributions to the above software program by Intel
 * Corporation is program is licensed subject to the BSD License, available at
 * http://www.opensource.org/licenses/bsd-license.html
 *
 */
/*
 * Authors:     York Liu
 *
 */

/*
   TODO: Update CommandUse.invokeMsg and EventUse.singal after
         TOS update interface
 */

#if TINYDBSHIM_JITTER
#ifndef TINYDBSHIM_JITTER_FACTOR
#define TINYDBSHIM_JITTER_FACTOR 8	/* Jitter from 0 to 0.8 sec */
#endif
#endif

module TinyDBShimM {
   provides {
      interface Network;
      interface StdControl;
      interface NetworkMonitor;
#ifdef HSN_ROUTING
      event uint16_t getAdjuvantValue();
#endif
   }
   uses {

#ifdef TRACE_ROUTE
      interface StdControl as TRControl;
#endif
      interface StdControl as SettingsControl;
      interface Send as SendDataMsg;
      interface SendMsg as SendQueryMsg;
      interface Payload as SingleHopPayload;
      
      interface Receive as RcvDataMsg;
      interface ReceiveMsg as RcvQueryMsg;
      interface Receive as RcvQueryFloodMsg;

//#if SINK_NODE
      interface BareSendMsg as SendDataUART;
      interface Send as SendQueryFloodMsg;
      interface ReceiveMsg as RcvQueryFloodUART;
      interface StdControl as UARTNoCRCPacketCommControl;

      //interface ReceiveMsg as RcvDataBroadcastUART;
      interface SendMsg as SendDataBroadcastMsg;
#ifdef HSN_ROUTING // FIXME: Abandon after UART_Gateway done
      interface ReceiveMsg as RcvSettingsUART;
      interface SendMsg as SendSettingsMsg;
#endif
#ifdef kSTATUS
      interface BareSendMsg as SendStatusUART;
      interface ReceiveMsg as RcvStatusUART;
      interface QueryProcessor;
#endif
#ifdef kSUPPORTS_EVENTS
      interface ReceiveMsg as RcvEventFloodUART;
      interface Send as SendEventFloodMsg;
#endif
      interface ReceiveMsg as RcvCommandFloodUART;
      interface Send as SendCommandFloodMsg;
//#endif

      interface ReceiveMsg as RcvDataBroadcastMsg;

      interface Receive as RcvCommandFloodMsg;
      interface CommandUse;

#ifdef kSUPPORTS_EVENTS
      interface Receive as RcvEventFloodMsg;
      interface EventUse;
#endif

#ifdef kQUERY_SHARING
      interface SendMsg as SendQueryRequest;
      interface ReceiveMsg as RcvQueryRequest; 
#endif

      interface Intercept as InterceptDataMsg;
      interface Intercept as SnoopedDataMsg;

      interface StdControl as MultiHopControl;
      interface StdControl as FloodControl;

      interface MultiHopMsg;
      interface SingleHopMsg;
      interface Router;
      interface Leds;
#if TINYDBSHIM_JITTER
      interface Random;
      interface Timer;
#endif

      interface HSNValue;
#ifdef HSN_ROUTING
      command bool isAdjuvantNode();
#endif
   }
}

implementation {

//#if SINK_NODE
   TOS_Msg mDbg, mCmd; // mDb stores status, mCmd stores Command after Flood
   enum { FLOOD_QUERY, FLOOD_COMMAND, FLOOD_EVENT };
   int8_t flood_type;

   bool uart_pending;
   bool send_flood_pending; //, send_broadcast_pending;
   TOS_Msg forward_msg, broadcast_msg;
   TOS_MsgPtr pforward_msg, pbroadcast_msg;

#ifdef HSN_ROUTING // FIXME: Abandon after UART_Gateway done
   bool send_settings_pending;
   TOS_Msg settings_msg;
   TOS_MsgPtr psettings_msg;
#endif

//#endif
  
#if TINYDBSHIM_JITTER
   bool send_datamsg_pending;
   uint8_t send_datamsg_interval;
   TOS_Msg data_msg;
   TOS_MsgPtr pdata_msg;
#endif

   command result_t StdControl.init() {
//#if SINK_NODE
      pforward_msg = &forward_msg;
      pbroadcast_msg = &broadcast_msg;
#ifdef HSN_ROUTING // FIXME: Abandon after UART_Gateway done
      psettings_msg = &settings_msg;
#endif
      uart_pending = FALSE;
      send_flood_pending = FALSE;
      //send_broadcast_pending = FALSE;
#ifdef HSN_ROUTING // FIXME: Abandon after UART_Gateway done
      send_settings_pending = FALSE;
#endif
      if (TOS_LOCAL_ADDRESS == 0)
         call UARTNoCRCPacketCommControl.init();
//#endif
      call FloodControl.init();
      call SettingsControl.init();
#ifdef TRACE_ROUTE
      call TRControl.init();
#endif
#if TINYDBSHIM_JITTER
      call Random.init();
      send_datamsg_pending = FALSE;
      send_datamsg_interval = 0;
      pdata_msg = &data_msg;
#endif
      return call MultiHopControl.init();
   }

   command result_t StdControl.start() {
      call FloodControl.start();
      if (TOS_LOCAL_ADDRESS == 0) 
         call UARTNoCRCPacketCommControl.start();
      call SettingsControl.start();
#ifdef TRACE_ROUTE
      call TRControl.start();
#endif
#if TINYDBSHIM_JITTER
      call Timer.start(TIMER_REPEAT, CLOCK_SCALE/10);	/* 10 per sec */
#endif
      return call MultiHopControl.start();
   }

   command result_t StdControl.stop() {
      call SettingsControl.stop();
      call FloodControl.stop();
//#if SINK_NODE
      if (TOS_LOCAL_ADDRESS == 0)
         call UARTNoCRCPacketCommControl.stop();
//#endif
#ifdef TRACE_ROUTE
      call TRControl.stop();
#endif
#if TINYDBSHIM_JITTER
      call Timer.stop();
#endif
      return call MultiHopControl.stop();
   }

#ifdef HSN_ROUTING
   /* ------ getAdjuvantValue ------ */
   event uint16_t getAdjuvantValue() {
      return call HSNValue.getAdjuvantValue();
   }
#endif

   /* ------ HSNValue ------ */

   /* Trigger the route update when a new query arrived in TinyDB,
      To allow SoI to use the up-to-date HSNValue. Both SoI & Quality */
   event void HSNValue.adjuvantValueReset() {
      call Router.triggerRouteAdvertisement();
      return;
   }

   /* ------ Data Message ------ */
   command QueryResultPtr Network.getDataPayLoad(TOS_MsgPtr msg) {
//#if SINK_NODE
      if (TOS_LOCAL_ADDRESS == 0) {
         /* SINK node send the data to UART only */
         return (QueryResultPtr)msg->data;
      } else {
//#else
         uint16_t len;
         return (QueryResultPtr)
              (call SendDataMsg.getBuffer(msg, (uint16_t *)&len));
      }
//#endif
   }

#if TINYDBSHIM_JITTER
   event result_t Timer.fired() {
      uint16_t len;
      if (!send_datamsg_pending) return SUCCESS; 
      if (send_datamsg_interval > 0) {
         send_datamsg_interval--;
         return SUCCESS;
      }
      call SendDataMsg.getBuffer(pdata_msg, (uint16_t *)&len);
      if (call SendDataMsg.send(pdata_msg, len) == SUCCESS) {
         //return err_NoError;
	 return SUCCESS;
      } else {
         dbg(DBG_TEMP, ("Calling SendDataMsg Failed\n"));
         //return err_MessageSendFailed;
         send_datamsg_pending = FALSE;
	 return FAIL;
      }
   }
#endif
   
   command TinyDBError Network.sendDataMessage(TOS_MsgPtr msg) {
//#if SINK_NODE
      if (TOS_LOCAL_ADDRESS == 0) {
         if (uart_pending) {
            dbg(DBG_TEMP, ("SendDataUART pending\n"));
            return err_MessageSendFailed;
         } 
         if (call SendDataUART.send(msg) == SUCCESS) {
            uart_pending = TRUE;
            return err_NoError;
         } else {
            dbg(DBG_TEMP, ("SendDataUART Failure\n"));
            return err_MessageSendFailed;
         }
      } else {
//#else
#if TINYDBSHIM_JITTER
      if (send_datamsg_pending == FALSE) {
         send_datamsg_interval = (TINYDBSHIM_JITTER_FACTOR == 0)?0:
               ((call Random.rand() & 0xff)  % TINYDBSHIM_JITTER_FACTOR) + 1;
         pdata_msg = msg;
         send_datamsg_pending = TRUE;
         return err_NoError;
      } else {
         return err_MessageSendFailed;
      }
#else
      uint16_t len;
      call SendDataMsg.getBuffer(msg, (uint16_t *)&len);
      if (call SendDataMsg.send(msg, len) == SUCCESS) {
         return err_NoError;
      } else {
         dbg(DBG_TEMP, ("Calling SendDataMsg Failed\n"));
         return err_MessageSendFailed;
      }
#endif
      }
//#endif
   }

   command TinyDBError Network.sendDataMessageTo(TOS_MsgPtr msg, uint16_t to) {
      // TODO: Figure out the logic, from Sam, used by Root to send out beacon
//      return call Network.sendDataMessage(msg);
      return err_MessageSendFailed;
   }

   default event result_t Network.sendDataDone
                          (TOS_MsgPtr msg, result_t success) {
      return SUCCESS;
   }

   event result_t SendDataMsg.sendDone(TOS_MsgPtr msg, result_t success) {
      if (success == FAIL)
         dbg(DBG_TEMP, ("SendDataMsg.sendDone signals Failure\n"));
      signal Network.sendDataDone(msg, success);
#if TINYDBSHIM_JITTER
      send_datamsg_pending = FALSE;
#endif
      return SUCCESS;
   }

//#if SINK_NODE
   event result_t SendDataUART.sendDone(TOS_MsgPtr msg, result_t success) {
      if (success == FAIL)
         dbg(DBG_TEMP, ("SendDataUART.sendDone signals Failure\n"));
      uart_pending = FALSE;
      signal Network.sendDataDone(msg, success);
      return SUCCESS;
   }
//#endif

#ifdef kQUERY_SHARING
   /* ------ QueryRequest Message ------ */
   command QueryRequestMessagePtr Network.getQueryRequestPayLoad
                                  (TOS_MsgPtr msg) {
      QueryRequestMessagePtr qr_ptr;
      call SingleHopPayload.linkPayload(msg, (uint8_t **) &qr_ptr);
      return qr_ptr;
   }

   command TinyDBError Network.sendQueryRequest(TOS_MsgPtr msg, uint16_t to) {
      QueryRequestMessagePtr qr_ptr;
      uint16_t len = (uint16_t)call SingleHopPayload.linkPayload(msg, (uint8_t **) &qr_ptr);
      if (call SendQueryRequest.send(to, len, msg) == SUCCESS) {
         return err_NoError;
      } else {
         return err_MessageSendFailed;
      }
   }

   default event result_t Network.sendQueryRequestDone
                          (TOS_MsgPtr msg, result_t success) {
      return SUCCESS;
   }

   event result_t SendQueryRequest.sendDone(TOS_MsgPtr msg, result_t success) {
      signal Network.sendQueryRequestDone(msg, success);
      return SUCCESS;
   }
#endif

   /* ------ Query Message ------ */
   command QueryMessagePtr Network.getQueryPayLoad(TOS_MsgPtr msg) {
      QueryMessagePtr q_ptr;
      call SingleHopPayload.linkPayload(msg, (uint8_t **) &q_ptr);
      return q_ptr;
   }

   /* Mote responses for query request, or forward the query */
   command TinyDBError Network.sendQueryMessage(TOS_MsgPtr msg) {
      QueryMessagePtr q_ptr;
      uint16_t len = (uint16_t)call SingleHopPayload.linkPayload(msg, (uint8_t **) &q_ptr);
      /* Single Hop Broadcast */
      if (call SendQueryMsg.send(TOS_BCAST_ADDR, len, msg) == SUCCESS) {
         return err_NoError;
      } else {
         return err_MessageSendFailed;
      }
   }

   default event result_t Network.sendQueryDone
                          (TOS_MsgPtr msg, result_t success) {
      return SUCCESS;
   }

   event result_t SendQueryMsg.sendDone(TOS_MsgPtr msg, result_t success) {
      signal Network.sendQueryDone(msg, success);
      return SUCCESS;
   }

   /* ------ dataSub Event ------ */
   default event result_t Network.dataSub(QueryResultPtr qresMsg) {
      return SUCCESS;
   }