tinydbshimm.nc

tinyos最新版

   event TOS_MsgPtr RcvDataMsg.receive
                         (TOS_MsgPtr msg, void *payload, uint16_t len) {
      //wsnAddr shop_src = call SingleHopMsg.getSrcAddress(msg);
      //wsnAddr mhop_src = call MultiHopMsg.getSource(msg);
      //dbg(DBG_TEMP, "Signal dataSub from Receive - S.src:%d M.src:%d\n",
      //     shop_src, mhop_src);
      signal Network.dataSub((QueryResultPtr)payload);
      return msg;
   }

   event result_t InterceptDataMsg.intercept
                         (TOS_MsgPtr msg, void *payload, uint16_t len) {
      /* In DSDV it intercepts every packet even though its the final
         destination. Filter out the packet which is the final and 
         give a SUCCESS return to let the DSDV signal the Receive to
         RcvDataMsg.receive */
      if (call MultiHopMsg.getDest(msg) == (wsnAddr)TOS_LOCAL_ADDRESS) {
         return SUCCESS;
      }
      /* ONLY signal to TinyDB if it is a specialized node. We only do
         query processor on the specialized node, the TinyDB anyway
         re-create a new packet and never forward it */
#ifdef HSN_ROUTING
      if (call isAdjuvantNode()) {
         signal Network.dataSub((QueryResultPtr)payload);
         return FAIL;
      } else {
         return SUCCESS;
      }
#else
      /* This is strange, TinyDB doen't want the network layer to forward
         the intercept packet (I'm the middle node), which is fine but
         it should return FAIL instead of assuming network layer knows */
      signal Network.dataSub((QueryResultPtr)payload);
      return FAIL;
#endif   // HSN_ROUTING
   }

   /* Receive |TOS|DATA| from UART, do single hop broadcast to direct neighbors
      neighbor receive it then just signal the dataSub */

//#if SINK_NODE
#if 0
   task void handle_broadcast_task() {

      uint8_t len;
      uint8_t *payload;
      uint8_t *pdata;

      pdata = pbroadcast_msg->data;

      if (!send_broadcast_pending) return;

      /* Convert the data from UART from |TOS_Hdr|TinyDBmsg| to
         |TOS_Hdr|SingleHopHdr|TinyDBMsg|. */
      len = call SingleHopPayload.linkPayload(pbroadcast_msg, (uint8_t **) &payload);

      memmove(payload, pdata, len);

      if (call SendDataBroadcastMsg.send(TOS_BCAST_ADDR, len, pbroadcast_msg) != SUCCESS)
         send_broadcast_pending = FALSE;
      return;
   }

   TOS_MsgPtr handle_broadcast(TOS_MsgPtr msg) {
      TOS_MsgPtr retmsg = msg;

      if (send_broadcast_pending) {
         dbg(DBG_ROUTE, ("Drop since singlehop broadcast is pending\n"));
      } else {
         if (post handle_broadcast_task()) {
            send_broadcast_pending = TRUE;
            retmsg = pbroadcast_msg;
            pbroadcast_msg = msg;
         }
      }
      return retmsg;
   }

   event TOS_MsgPtr RcvDataBroadcastUART.receive(TOS_MsgPtr msg) {
      return handle_broadcast(msg);
   }
#endif

   event result_t SendDataBroadcastMsg.sendDone(TOS_MsgPtr msg, result_t success) {
      // Shall we notify the upper layer by singal snoopedSub here? Not for now!
      // Sink sync time stamp with child
      signal Network.sendDataDone(msg, success);
      return SUCCESS;
   }

#ifdef HSN_ROUTING // FIXME: Abandon after UART_Gateway done
   task void handle_settings_task() {
      if (! send_settings_pending) {
         return;
      }

      if (! call SendSettingsMsg.send
         (psettings_msg->addr, psettings_msg->length, psettings_msg)) {
         send_settings_pending = FALSE;
      }
   }
   
   event TOS_MsgPtr RcvSettingsUART.receive(TOS_MsgPtr incoming) {
      TOS_MsgPtr retmsg = incoming;

      if (!send_settings_pending) {
         if (post handle_settings_task()) {
            retmsg = psettings_msg;
            psettings_msg = incoming;
            send_settings_pending = TRUE;
         }
      }
      return retmsg;
   }

   event result_t SendSettingsMsg.sendDone(TOS_MsgPtr sent, result_t success) {
      if (psettings_msg == sent) {
         send_settings_pending = FALSE;
      }
      return SUCCESS;
   }
#endif // HSN_ROUTING

//#endif

   /* ------ querySub Event ------ */
   default event result_t Network.querySub(QueryMessagePtr qMsg) {
      return SUCCESS;
   }

   event TOS_MsgPtr RcvQueryMsg.receive(TOS_MsgPtr msg) {
      QueryMessagePtr q_ptr;
      call SingleHopPayload.linkPayload(msg, (uint8_t **) &q_ptr);
      signal Network.querySub(q_ptr);
      return msg;
   }

   event TOS_MsgPtr RcvQueryFloodMsg.receive
                         (TOS_MsgPtr msg, void *payload, uint16_t len) {
      signal Network.querySub((QueryMessagePtr)payload);
      return msg;
   }

//#if SINK_NODE      
   task void handle_flood_task() {

      uint16_t len;
      uint8_t *payload;
      uint8_t *pdata;

      pdata  = pforward_msg->data;

      if (!send_flood_pending) return;

      /* Convert the data from UART from |TOS_Hdr|TinyDBmsg| to
         |TOS_Hdr|FloodHdr|TinyDBMsg|. Use SendCommandFloodMsg for all types */
      payload = (uint8_t *)call SendCommandFloodMsg.getBuffer
                                                    (pforward_msg, &len);

      memmove(payload, pdata, len);

      switch (flood_type) {
      case FLOOD_QUERY:
         if (call SendQueryFloodMsg.send(pforward_msg, len) != SUCCESS)
            send_flood_pending = FALSE;
         break;
      case FLOOD_COMMAND:
         if (call SendCommandFloodMsg.send(pforward_msg, len) != SUCCESS)
            send_flood_pending = FALSE;
         mCmd = *pforward_msg; // save off command for later execution
         break;
#ifdef kSUPPORTS_EVENTS
      case FLOOD_EVENT:
         if (call SendEventFloodMsg.send(pforward_msg, len) != SUCCESS)
            send_flood_pending = FALSE;
         break;
#endif
      default:
         send_flood_pending = FALSE;
      }
      
      return;
   }

   TOS_MsgPtr handle_flood(uint8_t type, TOS_MsgPtr msg) {
      TOS_MsgPtr retmsg = msg;

      if (send_flood_pending) {
         dbg(DBG_ROUTE, ("Drop since flood is pending\n"));
      } else {
         if (post handle_flood_task()) {
            send_flood_pending = TRUE;
            flood_type = type;
            retmsg = pforward_msg;
            pforward_msg = msg;
         }
      }
      return retmsg;
   }

   event TOS_MsgPtr RcvQueryFloodUART.receive(TOS_MsgPtr msg) {
      return handle_flood(FLOOD_QUERY, msg);
   }

   event result_t SendQueryFloodMsg.sendDone(TOS_MsgPtr msg, result_t success) {
      uint16_t len;
      QueryMessagePtr q_ptr = 
         (QueryMessagePtr)call SendQueryFloodMsg.getBuffer(msg, &len);
      signal Network.querySub(q_ptr);
      send_flood_pending = FALSE;
      return SUCCESS;
   }
//#endif

   /* ------ snoopedSub Event ------ */
   default event result_t Network.snoopedSub
           (QueryResultPtr qresMsg, bool isFromParent, uint16_t senderid) {
      return SUCCESS;
   }
 
   /* For the packet's single hop dest not to itself */
   event result_t SnoopedDataMsg.intercept
                         (TOS_MsgPtr msg, void *payload, uint16_t len) {
      bool isFromParent = FALSE;
      uint16_t senderid = (uint16_t)call MultiHopMsg.getSource(msg);
      /* compare with parents, which is nexthop */
      if (call SingleHopMsg.getSrcAddress(msg) == 
                    (wsnAddr) call Router.getNextHop(call Router.getRoot()))
         isFromParent = TRUE;
      signal Network.snoopedSub((QueryResultPtr)payload, isFromParent, senderid);
      return SUCCESS;
   }

   /* Root singlehop broadcast data, neighbor snoop it since it's not
      the final destination. Used for root to sync with its child */
   event TOS_MsgPtr RcvDataBroadcastMsg.receive(TOS_MsgPtr msg) {
      bool isFromParent = FALSE;
      uint16_t senderid = (uint16_t)call SingleHopMsg.getSrcAddress(msg);
      QueryResultPtr payload;
      /* compare with parents, which is nexthop */
      if (senderid == 
                    (wsnAddr) call Router.getNextHop(call Router.getRoot()))
         isFromParent = TRUE;
      call SingleHopPayload.linkPayload(msg, (uint8_t **) &payload);
      signal Network.snoopedSub(payload, isFromParent, senderid);
      return msg;
   }

#ifdef kQUERY_SHARING
   /* ------ queryRequestSub Event ------ */
   default event result_t Network.queryRequestSub
                          (QueryRequestMessagePtr qreqMsg) {
      return SUCCESS;
   }

   event TOS_MsgPtr RcvQueryRequest.receive(TOS_MsgPtr msg) {
      QueryRequestMessagePtr qr_ptr;
      call SingleHopPayload.linkPayload(msg, (uint8_t **) &qr_ptr);
      signal Network.queryRequestSub(qr_ptr);
      return msg;
   }
#endif

//#if SINK_NODE
#ifdef kSTATUS
   /* ------ Status ------ */

   event TOS_MsgPtr RcvStatusUART.receive(TOS_MsgPtr msg) {
      short numqs, i;
      StatusMessage *smsg;
      smsg = (StatusMessage *)&(mDbg.data);

      numqs = call QueryProcessor.numQueries();
      if (numqs > kMAX_QUERIES)
         numqs = kMAX_QUERIES;
      smsg->numQueries = numqs;
      for (i = 0; i < numqs; i++) {
         uint8_t qid = (uint8_t)((call QueryProcessor.getQueryIdx(i))->qid);
         dbg(DBG_USR2, "i = %d, qid = %d\n", i, qid );
         smsg->queries[i] = qid;
      }

      call SendStatusUART.send(&mDbg);
      return msg;
   }

   event result_t SendStatusUART.sendDone(TOS_MsgPtr msg, result_t success) {
      return SUCCESS;
   }

   event result_t QueryProcessor.queryComplete(ParsedQueryPtr q) {
      return SUCCESS;
   }

#endif
//#endif

   /* ------ Command ------ */

   event TOS_MsgPtr RcvCommandFloodMsg.receive
                         (TOS_MsgPtr msg, void *payload, uint16_t len) {
      SchemaErrorNo errorNo;
      /* TODO: Don't re-construct msg, just signal payload, wait TOS update */
      memmove(msg->data, payload, len);
      call CommandUse.invokeMsg(msg, NULL, &errorNo);
      return msg;
   }

//if SINK_NODE
   event result_t SendCommandFloodMsg.sendDone(TOS_MsgPtr msg, result_t success) {
      uint16_t len;
      SchemaErrorNo errorNo;
      void *payload = call SendCommandFloodMsg.getBuffer(&mCmd, &len);
      // XXX ignore command return value for now
      /* TODO: Don't re-construct msg, just signal payload, wait TOS update */
      memmove(msg->data, payload, len);
      call CommandUse.invokeMsg(msg, NULL, &errorNo);
      send_flood_pending = FALSE;
      return SUCCESS;
   }

   event TOS_MsgPtr RcvCommandFloodUART.receive(TOS_MsgPtr msg) {
      return handle_flood(FLOOD_COMMAND, msg);
   }
//#endif

   event result_t CommandUse.commandDone(char *commandName, char *resultBuf, SchemaErrorNo err) {
      return SUCCESS;
   }

#ifdef kSUPPORTS_EVENTS
   /* ------ Event ------ */

   event TOS_MsgPtr RcvEventFloodMsg.receive
                         (TOS_MsgPtr msg, void *payload, uint16_t len) {
      /* TODO: Don't re-construct msg, just signal payload, wait TOS update */
      memmove(msg->data, payload, len);
      call EventUse.signalEventMsg(msg);
      return msg;
   }

//if SINK_NODE
   event result_t SendEventFloodMsg.sendDone(TOS_MsgPtr msg, result_t success) {
      uint16_t len;
      void *payload = call SendEventFloodMsg.getBuffer(msg, &len);
      /* TODO: Don't re-construct msg, just signal payload, wait TOS update */
      memmove(msg->data, payload, len);
      call EventUse.signalEventMsg(msg);
      send_flood_pending = FALSE;
      return SUCCESS;
   }

   event TOS_MsgPtr RcvEventFloodUART.receive(TOS_MsgPtr msg) {
      return handle_flood(FLOOD_EVENT, msg);
   }
//#endif

   event result_t EventUse.eventDone(char *name, SchemaErrorNo err) {
      return SUCCESS;
   }

#endif

   /* FIXME ------ Dummy NetworkMonitor ------ */
   command void NetworkMonitor.updateContention(bool failure, int status) {
      return;
   }
   command uint16_t NetworkMonitor.getContention() {
      return 0;
   }
   command uint16_t NetworkMonitor.getParent() {
      return (uint16_t)call Router.getNextHop(call Router.getRoot());
   }
   command uint8_t NetworkMonitor.getQueueLength() {
      return 0;
   }
   command uint8_t NetworkMonitor.getMHopQueueLength() {
      return 0;
   }
   command uint8_t NetworkMonitor.getDepth() {
      return 0;
   }
   command uint8_t NetworkMonitor.getXmitCount() {
      return 0;
   }
   command uint8_t NetworkMonitor.getQuality() {
      return 0;
   }
   command bool NetworkMonitor.isAdjuvantNode() {
#ifdef HSN_ROUTING
      return call isAdjuvantNode();
#else
      /* Every node is adjuvant node if not using HSN routing */
      return TRUE;
#endif
   }
#ifdef kHAS_NEIGHBOR_ATTR
   /** TODO: Refer to tos/lib/TinyDB/NetworkMultiHopM.nc
       Write the list of neighbors we have recently heard into
       the bitmap dest.  Bit n in the bitmap corresponds to a recent
       message from sensor n
   */
   command void NetworkMonitor.getNeighbors(char *dest) {
      return;
   }
#endif
}