开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 网络 > 查看源码
DrandM.nc.~1.13.~
资源名称：zmacForRelease.tar.gz　[点击查看]
上传用户：joranyuan
上传日期：2022-06-23
资源大小：3306k
文件大小：47k
源码类别：

网络

开发平台：

Others

DrandM.nc.~1.13.~：源码内容
  1. includes DrandInfo;
  3. module DrandM {
  4.   provides {    
  5.     interface StdControl;
  6.     interface Drand;
  7.   }
  8.   uses {
  9.     interface SendMsg as SendHelloMsg;
  10.     interface SendMsg as SendRequestMsg;
  11.     interface SendMsg as SendRejectMsg;
  12.     interface SendMsg as SendReleaseMsg;
  13.     interface SendMsg as SendTwoHopMsg;
  14.     interface SendMsg as SendGrantMsg;
  15.     interface SendMsg as SendReportMsg;
  16.     interface SendMsg as SendFrameMsg;
  18.     interface ReceiveMsg as ReceiveHelloMsg;
  19.     interface ReceiveMsg as ReceiveRequestMsg;
  20.     interface ReceiveMsg as ReceiveRejectMsg;
  21.     interface ReceiveMsg as ReceiveReleaseMsg;
  22.     interface ReceiveMsg as ReceiveTwoHopMsg;
  23.     interface ReceiveMsg as ReceiveGrantMsg;
  24.     interface ReceiveMsg as ReceiveReportMsg;
  25.     interface ReceiveMsg as ReceiveFrameMsg;
  27. #ifdef LDEBUG    
  28.     interface Leds;
  29. #endif
  30.     interface Timer as roundTimer;
  31.     interface Timer as reXTimer;
  33.     interface SClock;
  34.   }
  35. }
  37. implementation {
  38. #include "DrandMSG.h"
  39. #ifdef DEBUG
  40. #include "SODebug.h"
  41. #endif
  42.   struct TOS_Msg DataPkt;
  44.   uint8_t globalState; // global state
  45.   bool setMySlot;
  47.   uint8_t OneWayId[MAX_NBR]; // hello world variables
  48.   uint8_t TwoWayId[MAX_NBR];
  49.   
  50.   nodeInfo nbrInfo[MAX_NBR], myInfo;
  52.   uint8_t requestFireCount, grantFireCount, frameFireCount, reportFireCount;
  53.   uint16_t OTT, ROUND_TIME, REQUEST_TIME, GRANT_TIME; // timer variables
  54.   GTime requestStartTime, locTime, drandStartTime, drandRunTime;
  55.   uint16_t shiftReg, mask;
  56. #ifdef DEBUG
  57.   GTime roundStartTime;   //variables for debugging
  58.   uint8_t reqCount, graCount, rejCount, relCount, twoCount, reqXCount, graXCount ;
  59.   bool reqX, graX;
  60.   uint8_t roundNum;
  61. #endif
  63.   bool sendBusy, drandFinishedFirstTime, reportFinishedFirstTime, sentRelease, firstGrant;
  64.   uint8_t lastReqID;
  66.   GTime timeDiff(GTime A, GTime B){ // returns A-B
  67.     GTime diff;
  68.     if(A.sticks >= B.sticks){
  69.       diff.mticks = (A.mticks - B.mticks);//*568.88;    //ms
  70.       diff.sticks = (A.sticks - B.sticks);//*0.00868;    //ms
  71.     }
  72.     else{
  73.       uint32_t temp = 65536;
  74.       diff.mticks = (A.mticks - 1 - B.mticks);//*568.88;    //ms
  75.       diff.sticks = ((uint16_t)(temp + A.sticks - B.sticks));//*0.00868);
  76.     }
  77.     return diff;
  78.   }
  80. #ifdef DEBUG
  81.   void printState(){
  82.     SODbg(DBG_USR2, "ID:%u,ST:%u,R:%u,L:%un", TOS_LOCAL_ADDRESS, globalState, roundNum, lastReqID);
  83.   }
  85.   void printMsg(TOS_MsgPtr msg){
  86.     requestMsg *reqPtr = (requestMsg *) msg->data;
  87.     switch(msg->type){
  88.     case AM_GRANT:
  89.       SODbg(DBG_USR2, "MT: Grantn");
  90.       break;
  91.     case AM_REQUEST:
  92.       SODbg(DBG_USR2, "MT: Requestn");
  93.       break;
  94.     case AM_RELEASE:
  95.       SODbg(DBG_USR2, "MT: Releasen");
  96.       break;
  97.     case AM_REJECT:
  98.       SODbg(DBG_USR2, "MT: Rejectn");
  99.       break;
  100.     case AM_TWOHOP:
  101.       SODbg(DBG_USR2, "MT: 2 Hop Reln");
  102.       break;
  103.     }
  104.     SODbg(DBG_USR2, "SID:%u,SS:%u,LID:%u,RD:%un", reqPtr->sendID, reqPtr->myState, reqPtr->lastRequestID,
  105.           reqPtr->roundNum);
  106.   }
  108.   void printNbrInfo(){
  109.     uint8_t i;
  110.     SODbg(DBG_USR2, "*******************************************************n");
  111.     for(i = 0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++){
  112.       switch(globalState){
  113.       case IDLE_STATE2:
  114.         if(nbrInfo[i].bitMap & ONE_HOP){
  115.           SODbg(DBG_USR2, "OneHopNodeID(HELLO) : %u  %u  %un", nbrInfo[i].nodeID, nbrInfo[i].slot,
  116.                 nbrInfo[i].frame);
  117.         } else if(nbrInfo[i].bitMap & TWO_HOP){
  118.           SODbg(DBG_USR2, "TwoHopNodeID(HELLO) : %u  %u  %un", nbrInfo[i].nodeID, nbrInfo[i].slot,
  119.                 nbrInfo[i].frame);
  120.         }
  121.         break;
  122.       case RELEASE_STATE:
  123.         if(nbrInfo[i].bitMap & ONE_HOP){
  124.           SODbg(DBG_USR2, "OneHopNodeID(DRAND) : %u  %u  %un", nbrInfo[i].nodeID, nbrInfo[i].slot,
  125.                 nbrInfo[i].frame);
  126.         } else if(nbrInfo[i].bitMap & TWO_HOP){
  127.           SODbg(DBG_USR2, "TwoHopNodeID(DRAND) : %u  %u  %un", nbrInfo[i].nodeID, nbrInfo[i].slot,
  128.                 nbrInfo[i].frame);
  129.         }
  130.         break;
  131.       case FRAME_STATE:
  132.         if(nbrInfo[i].bitMap & ONE_HOP){
  133.           SODbg(DBG_USR2, "OneHopNodeID(FRAME) : %u  %u  %un", nbrInfo[i].nodeID, nbrInfo[i].slot,
  134.                 nbrInfo[i].frame);
  135.         } else if(nbrInfo[i].bitMap & TWO_HOP){
  136.           SODbg(DBG_USR2, "TwoHopNodeID(FRAME) : %u  %u  %un", nbrInfo[i].nodeID, nbrInfo[i].slot,
  137.                 nbrInfo[i].frame);
  138.         }
  139.         break;
  140.       }
  141.     }
  142.     SODbg(DBG_USR2, "*******************************************************n");
  143.   }
  145.   void timeCheck() {
  146.     GTime roundTime;
  147.     call SClock.getTime(&locTime);
  148.     roundTime = timeDiff(locTime, roundStartTime);
  149.     
  150.     SODbg(DBG_USR2, "MESSAGE sID %u mCt %u rReq %u rGra %u mTime %u sTime %un", 
  151.           TOS_LOCAL_ADDRESS, (reqCount+graCount+rejCount+relCount+twoCount), reqXCount,
  152.           graXCount, (uint16_t) drandRunTime.mticks, (uint16_t) drandRunTime.sticks);
  153.     SODbg(DBG_USR2, "MESSAGE sID %u reqCt %u graCt %u rejCt %u relCt %u twoCt %un",
  154.           TOS_LOCAL_ADDRESS, reqCount, graCount, rejCount, relCount, twoCount);
  155.     SODbg(DBG_USR2, "MESSAGE sID %u Round %u slotNum %u mRound %u sRound %un",
  156.           TOS_LOCAL_ADDRESS, roundNum, myInfo.slot, roundTime.mticks, roundTime.sticks);
  157.     //}
  158.   }
  159. #endif
  161. #ifdef LDEBUG
  162.   void printLED(){
  163.     switch(globalState){
  164.     case IDLE_STATE2:
  165.       call Leds.yellowOff();
  166.       call Leds.greenOff();
  167.       call Leds.redOn();
  168.       break;
  169.     case REQUEST_STATE:
  170.       call Leds.yellowOff();
  171.       call Leds.greenOn();
  172.       call Leds.redOff();
  173.       break;
  174.     case RELEASE_STATE:
  175.       call Leds.yellowOn();
  176.       call Leds.greenOff();
  177.       call Leds.redOff();
  178.       break;
  179.     case GRANT_STATE:
  180.       call Leds.yellowOn();
  181.       call Leds.greenOn();
  182.       call Leds.redOn();
  183.       break;
  184.     }
  185.   }
  186. #endif
  188.   uint64_t Max(uint16_t v1, uint16_t v2){
  189.     if(v1 >= v2)
  190.       return v1;
  191.     else
  192.       return v2;
  193.   }
  195.   uint64_t Min(uint16_t v1, uint16_t v2){
  196.     if(v1 <= v2)
  197.       return v1;
  198.     else
  199.       return v2;
  200.   }
  202.   int isPresentHelloID(uint8_t node, uint8_t *array, uint8_t max){
  203.     // return -1 if not found, else return position
  204.     uint8_t i;
  205.     for(i = 0; i < max; i++)
  206.       if(array[i] == node)
  207.         return i;
  208.     return -1;
  209.   }
  211.   bool checkForRetransGrant(requestMsg *reqMsgPtr){
  212.     if(isPresentHelloID(TOS_LOCAL_ADDRESS, reqMsgPtr->idMap, MAX_NBR) == -1){
  213.       return FALSE;
  214.     }
  215.     else
  216.       return TRUE;
  217.   }
  219.   bool checkForRetransReport(){
  220.     uint8_t i;
  221.     for(i = 0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++)
  222.       if(nbrInfo[i].slot == 0xFF){
  223. #ifdef REPORT_DEBUG
  224.         SODbg(DBG_USR2, "Need to retransmit for node %un", nbrInfo[i].nodeID);
  225. #endif
  226.         return TRUE;
  227.       }
  228.     return FALSE;
  229.   }
  231.   bool checkForRetransFrame(){
  232.     uint8_t i;
  233.     for(i = 0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++)
  234.       if(nbrInfo[i].frame == 0xFF){
  235. #ifdef FRAME_DEBUG
  236.         SODbg(DBG_USR2, "CheckForRetransmitFrame: Need to retransmit for node %un", nbrInfo[i].nodeID);
  237. #endif
  238.         return TRUE;
  239.       }
  240.     return FALSE;
  241.   }
  243.   uint8_t getMaxSlot(){
  244.     uint8_t i, maxSlot = myInfo.slot;
  245.     for(i = 0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++)
  246.       if(nbrInfo[i].slot > maxSlot)
  247.         maxSlot = nbrInfo[i].slot;
  248.     return maxSlot;
  249.   }
  251.   void addNode(uint8_t nodeID, uint8_t type){
  252.     uint8_t i;
  253.     if((nodeID == TOS_LOCAL_ADDRESS) || (nodeID == 0xFF)) return;
  254.     atomic{
  255.       for(i = 0;(i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF) && (nbrInfo[i].nodeID != nodeID); i++);
  256.       if (i == MAX_NBR){
  257. #ifdef DEBUG
  258.         SODbg( DBG_USR2, "addNode: No space to add noden");
  259. #endif
  260.       } else if (nbrInfo[i].nodeID != nodeID){
  261.         nbrInfo[i].nodeID = nodeID;
  262.         nbrInfo[i].bitMap = type;
  263.         nbrInfo[i].slot = 0xFF;
  264.         nbrInfo[i].frame = 0xFF;
  265.       }
  266.     }
  267.   }
  269.   void removeNode(uint8_t nodeID, uint8_t type){
  270.     uint8_t i;
  271.     atomic{
  272.       for(i = 0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF) && (nbrInfo[i].nodeID != nodeID); i++);
  273.       if((i != MAX_NBR) && (nbrInfo[i].nodeID == nodeID) && (nbrInfo[i].bitMap & type)){
  274.         for (;i < MAX_NBR - 1; i++)
  275.           nbrInfo[i] = nbrInfo[i+1];
  276.         nbrInfo[MAX_NBR - 1].nodeID = 0xFF;
  277.       }
  278.     }
  279.   }
  281.   void initializeGrantSent(){
  282.     uint8_t i;
  283.     for(i = 0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++)
  284.       if(nbrInfo[i].bitMap & ONE_HOP)
  285.         nbrInfo[i].bitMap = (nbrInfo[i].bitMap & ~GRANT_SENT);
  286.   }
  288.   uint8_t numGrantsRemaining(){
  289.     uint8_t i, count;
  290.     for(i = 0, count = 0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++)
  291.       if((nbrInfo[i].bitMap & ONE_HOP) && (!(nbrInfo[i].bitMap & GRANT_SENT))){
  292. #ifdef DRAND_DEBUG
  293.         SODbg(DBG_USR2, "RequestTimerFired: Need to retransmit for node %un", nbrInfo[i].nodeID);
  294. #endif
  295.         count++;
  296.       }
  297.     return count;
  298.   }
  300.   uint8_t numOneHop(){
  301.     uint8_t i, count;
  302.     for(i = 0, count = 0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++)
  303.       if(nbrInfo[i].bitMap & ONE_HOP)
  304.         count++;
  305.     return count;
  306.   }
  308.   bool updateNeighborInfo(uint8_t nID, uint8_t slot){ // return true if information has changed
  309.     uint8_t i;
  310.     if((slot == 0xFF) || (nID == 0xFF)) return FALSE;
  311.     for(i = 0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++)
  312.       if((nbrInfo[i].nodeID == nID) && (nbrInfo[i].slot == 0xFF)){
  313.         nbrInfo[i].slot = slot;
  314.         return TRUE;
  315.       }
  316.     return FALSE;
  317.   }
  319.   void fillGrantSendInfo(uint8_t *array){
  320.     uint8_t i, j;
  321.     for(i = 0, j = 0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++)
  322.       if((nbrInfo[i].bitMap & ONE_HOP) && (!(nbrInfo[i].bitMap & GRANT_SENT)))
  323.         array[j++] = nbrInfo[i].nodeID;
  324.     for(; j < MAX_NBR; j++)
  325.       array[j] = 0xFF;
  326.   }
  328.   void fillTimeSlotInfo(uint8_t *array){
  329.     uint8_t i;
  330.     for(i = 0; i < MAX_NBR; i++)     // first clear array
  331.       array[i] = 0xFF;
  332.     for(i = 0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++) // put in one hop slot information
  333.       if((nbrInfo[i].slot != 0xFF) && (nbrInfo[i].bitMap & ONE_HOP))
  334.         array[nbrInfo[i].slot] = nbrInfo[i].nodeID;
  335.     if(setMySlot) // put in my slot info
  336.       array[myInfo.slot] = TOS_LOCAL_ADDRESS;
  337.   }
  339.   void fillFrameInfo(frameMsg *pkt){
  340.     uint8_t i, j;
  341.     for(i = 0; i < MAX_ONE_HOP; i++){     // first clear array
  342.       pkt->oneHopNodeID[i] = 0xFF;
  343.       pkt->frameArray[i] = 0xFF;
  344.     }
  345.     for(i = 0, j = 0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++)
  346.       if((nbrInfo[i].bitMap & ONE_HOP) && (nbrInfo[i].frame != 0xFF)){
  347.         pkt->oneHopNodeID[j] = nbrInfo[i].nodeID;
  348.         pkt->frameArray[j] = nbrInfo[i].frame;
  349.         j++;
  350.       }
  351.   }
  353.   void fillTimeSlotInfoForReport(uint8_t *array){
  354.     uint8_t i;
  355.     for(i = 0; i < MAX_NBR; i++)     // first clear array
  356.       array[i] = 0xFF;
  357.     for(i = 0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++)
  358.       if(nbrInfo[i].slot != 0xFF)
  359.         array[nbrInfo[i].slot] = nbrInfo[i].nodeID;
  360.     if(setMySlot)
  361.       array[myInfo.slot] = TOS_LOCAL_ADDRESS;
  362.   }
  364.   void addHelloID (uint8_t node, uint8_t *array){
  365.     uint8_t i;
  366.     if(node == TOS_LOCAL_ADDRESS) return;
  367.     atomic{
  368.       for(i = 0; (i < MAX_NBR) && (array[i] != 0xFF) && (array[i] != node); i++);
  369.       if(i == MAX_NBR){
  370. #ifdef DEBUG
  371.         SODbg( DBG_USR2, "addNode: No space to add noden");
  372. #endif
  373.       } else if(array[i] != node)
  374.         array[i] = node;
  375.     }
  376.   }
  378.   void removeHelloID(uint8_t node, uint8_t *array){
  379.     uint8_t i;
  380.     atomic{
  381.       for(i = 0; (i < MAX_NBR) && (array[i] != 0xFF) && (array[i] != node); i++);
  382.       if((i != MAX_NBR) && (array[i] == node)){
  383.         for (;i < MAX_NBR - 1; i++)
  384.           array[i]=array[i+1];
  385.         array[MAX_NBR - 1] = 0xFF;
  386.       }
  387.     }
  388.   }
  390.   int isPresent(uint8_t nodeID, uint8_t type){
  391.     uint8_t i;
  392.     if(nodeID == 0xFF) return -1;
  393.     for(i = 0;(i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++)
  394.       if((nbrInfo[i].nodeID == nodeID) && (nbrInfo[i].bitMap & type))
  395.         return i;
  396.     return -1;
  397.   }
  399.   uint8_t getContenders(){
  400.     uint8_t i, contenders = 0;
  401.     for(i = 0;(i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++)
  402.       if(nbrInfo[i].slot == 0xFF)
  403.         contenders++;
  404.     return (contenders + 1); // I am also a contender !
  405.   }
  407.   void removeNodesForRequest(){
  408.     int i;
  409.     for(i = MAX_NBR - 1; i >= 0; i--){
  410.       if(nbrInfo[i].nodeID == 0xFF)
  411.         continue;
  412.       else if((nbrInfo[i].bitMap & ONE_HOP) && !(nbrInfo[i].bitMap & GRANT_SENT)){
  413. #ifdef DEBUG
  414.         SODbg( DBG_USR2, "RemoveNodesForRequest: Removed node %un", nbrInfo[i].nodeID);
  415. #endif
  416.         removeNode(nbrInfo[i].nodeID, nbrInfo[i].bitMap); // TODO - rewrite !!
  417.       }
  418.     }
  419.   }
  421.   void removeNodeForGrant(uint8_t nodeID){
  422.     int i;
  423.     for(i = MAX_NBR - 1; i >= 0; i--){
  424.       if(nbrInfo[i].nodeID == 0xFF)
  425.         continue;
  426.       else if(nbrInfo[i].nodeID == nodeID){
  427. #ifdef DEBUG
  428.         SODbg( DBG_USR2, "RemoveNodeForGrant: Removed node %un", nbrInfo[i].nodeID);
  429. #endif
  430.         removeNode(nbrInfo[i].nodeID, nbrInfo[i].bitMap);
  431.         return;
  432.       }
  433.     }
  434.   }
  436.   void removeNodesForReport(){
  437.     int i;
  438.     for(i = MAX_NBR - 1; i >= 0; i--){
  439.       if(nbrInfo[i].nodeID == 0xFF)
  440.         continue;
  441.       else if(nbrInfo[i].slot == 0xFF){
  442. #ifdef DEBUG
  443.         SODbg( DBG_USR2, "RemoveNodesForReport: Removed node %un", nbrInfo[i].nodeID);
  444. #endif
  445.         removeNode(nbrInfo[i].nodeID, nbrInfo[i].bitMap); // TODO - rewrite !!
  446.       }
  447.     }
  448.   }
  450.   void removeNodesForFrame(){
  451.     int i;
  452.     for(i = MAX_NBR - 1; i >= 0; i--){
  453.       if(nbrInfo[i].nodeID == 0xFF)
  454.         continue;
  455.       else if(nbrInfo[i].frame == 0xFF){
  456. #ifdef DEBUG
  457.         SODbg( DBG_USR2, "RemoveNodesForFrame: Removed node %un", nbrInfo[i].nodeID);
  458. #endif
  459.         removeNode(nbrInfo[i].nodeID, nbrInfo[i].bitMap); // TODO - rewrite !!
  460.       }
  461.     }
  462.   }
  464.   void updateNeighborInfoForReport(uint8_t nIndex, reportMsg *pkt){
  465.     uint8_t i;
  466.     int n;
  467. #ifdef REPORT_DEBUG
  468.     SODbg(DBG_USR2, "updating for node = %u ***********************n", nbrInfo[nIndex].nodeID);
  469. #endif
  470.     nbrInfo[nIndex].slot = pkt->slot;
  471.     nbrInfo[nIndex].bitMap |= REPORT_SENT;
  472.     for(i = 0; i < MAX_NBR; i++)
  473.       if((n = isPresent(pkt->timeSlot[i], ONE_HOP | TWO_HOP)) != -1){
  474.         nbrInfo[n].slot = i;
  475. #ifdef REPORT_DEBUG
  476.         SODbg(DBG_USR2, "updating for node = %u, Slot = %un", nbrInfo[n].nodeID, nbrInfo[n].slot);
  477. #endif
  478.       }
  479.   }
  481.   void updateNeighborInfoForFrame(uint8_t nIndex, frameMsg *pkt){
  482.     uint8_t i;
  483.     int n;
  484. #ifdef FRAME_DEBUG
  485.     SODbg(DBG_USR2, "updating for node = %u ***********************n", nbrInfo[nIndex].nodeID);
  486. #endif
  487.     nbrInfo[nIndex].frame = pkt->frame;
  488.     for(i = 0; (i < MAX_ONE_HOP) && (pkt->oneHopNodeID[i] != 0xFF); i++)
  489.       if(((n = isPresent(pkt->oneHopNodeID[i], ONE_HOP | TWO_HOP)) != -1)){
  490.         nbrInfo[n].frame = pkt->frameArray[i];
  491. #ifdef DEBUG
  492.         SODbg(DBG_USR2, "updating for node = %u, Frame = %un", nbrInfo[n].nodeID, nbrInfo[n].frame);
  493. #endif
  494.       }
  495.   }
  497.   uint16_t randNew() {   /* Return the next 16 bit random number */
  498.     bool endbit;
  499.     uint16_t tmpShiftReg;
  500.     atomic {
  501.       tmpShiftReg = shiftReg;
  502.       endbit = ((tmpShiftReg & 0x8000) != 0);
  503.       tmpShiftReg <<= 1;
  504.       if (endbit)
  505.         tmpShiftReg ^= 0x100b;
  506.       tmpShiftReg++;
  507.       shiftReg = tmpShiftReg;
  508.       tmpShiftReg = tmpShiftReg ^ mask;
  509.     }
  510.     return tmpShiftReg;
  511.   }
  513.   command result_t StdControl.init(){
  514.     atomic {
  515.       uint8_t i;
  517.       for(i = 0 ; i<MAX_NBR ; i++){
  518.         nbrInfo[i].nodeID = 0xFF;
  519.         nbrInfo[i].slot = 0xFF;
  520.         nbrInfo[i].frame = 0xFF;
  521.         nbrInfo[i].bitMap = 0x0;
  522.         OneWayId[i] = TwoWayId[i] = 0xFF;
  523.       }
  524.       myInfo.slot = 0xFF;
  525.       myInfo.nodeID = TOS_LOCAL_ADDRESS;
  526.       myInfo.frame = 0xFF;
  527.       myInfo.bitMap = 0xFF;
  529.       globalState = HELLO_STATE; //start this application with hello mode
  530.       setMySlot = FALSE;
  531.       lastReqID = 0xFF;
  533.       requestFireCount = grantFireCount = reportFireCount = frameFireCount = 0;
  535.       OTT = 100; // all times in ms (OTT = time for one time transmission of request/grant msg)
  536.       ROUND_TIME = 1500;
  537.       REQUEST_TIME = 1000;
  538.       GRANT_TIME = 1000;
  540.       sendBusy = FALSE;
  541.       drandFinishedFirstTime = reportFinishedFirstTime = TRUE;
  542.       sentRelease = FALSE;
  543.       firstGrant = TRUE;
  545.       call SClock.getTime(&locTime);
  546.       shiftReg = 119 * 119 * (locTime.sticks + TOS_LOCAL_ADDRESS + 1);
  547.       mask = 137 * 29 * (locTime.sticks + TOS_LOCAL_ADDRESS + 1);
  549. #ifdef DEBUG
  550.       reqCount = graCount = rejCount = relCount = twoCount = reqXCount = graXCount = 0, roundNum = 0;
  551.       reqX = graX = FALSE;
  552.       init_debug();
  553. #endif
  554. #ifdef LDEBUG
  555.       call Leds.init();
  556. #endif
  557.     }
  558.     return SUCCESS;
  559.   }
  561.   command result_t StdControl.start(){
  562.     globalState = HELLO_STATE;
  563.     call reXTimer.start(TIMER_ONE_SHOT, randNew() % HELLO_INTERVAL);
  564.     call roundTimer.start(TIMER_ONE_SHOT, HELLO_PERIOD);
  565.     return SUCCESS;
  566.   }
  568.   command result_t StdControl.stop(){
  569.     call reXTimer.stop();
  570.     call roundTimer.stop();
  571.     return SUCCESS;
  572.   }
  574.   void sendHelloMsg(){
  575.     atomic{
  576.       if(!sendBusy){
  577.         uint8_t i = 0, j = 0;
  578.         helloMsg *helloMsgData = (helloMsg*)DataPkt.data;
  579.         helloMsgData->sendID = TOS_LOCAL_ADDRESS;
  580.         for(i = 0; i < MAX_NBR; i++)
  581.           helloMsgData->OneWayId[i] = 0xFF;
  582.         
  583.         for(i = 0; (i < MAX_NBR) && (OneWayId[i] != 0xFF); i++)
  584.           helloMsgData->OneWayId[i] = OneWayId[i];
  585.         if(i == MAX_NBR){
  586. #ifdef DEBUG
  587.           SODbg(DBG_USR2, "SendHelloMsg: Too many neighbors, abort !!!!n");
  588. #endif
  589.         }
  590.         helloMsgData->OneWayLen = i;
  591.         for(j = 0; (j < MAX_NBR) && (i < MAX_NBR) && (TwoWayId[j] != 0xFF); j++, i++)
  592.           helloMsgData->OneWayId[i] = TwoWayId[j];
  594.         if (call SendHelloMsg.send(TOS_BCAST_ADDR, sizeof(helloMsg), &DataPkt) == SUCCESS)
  595.           sendBusy = TRUE;
  596.         else{
  597. #ifdef HELLO_DEBUG
  598.           SODbg(DBG_USR2, "SendHelloMsg: Something wrong, send failed !n");
  599. #endif
  600.           call reXTimer.start(TIMER_ONE_SHOT, randNew() % HELLO_INTERVAL);
  601.         }
  602.       } else {
  603. #ifdef HELLO_DEBUG
  604.         printState();SODbg(DBG_USR2,"sendHelloMsg:Channel busyn");
  605. #endif
  606.         call reXTimer.start(TIMER_ONE_SHOT, randNew() % HELLO_INTERVAL);
  607.       }
  608.     }
  609.   }
  611.   void sendRequestMsg(){
  612.     atomic{
  613.       if(!sendBusy){
  614.         requestMsg *requestMsgData = (requestMsg *)DataPkt.data;
  615.         requestMsgData->sendID = TOS_LOCAL_ADDRESS;
  616.         call SClock.getTime(&(requestMsgData->timestamp));
  617. #ifdef DEBUG
  618.         requestMsgData->myState = globalState;
  619.         requestMsgData->roundNum = roundNum;
  620.         requestMsgData->lastRequestID = lastReqID;
  621. #endif
  622.         fillGrantSendInfo(requestMsgData->idMap);
  623.         requestMsgData->numRemaining = numGrantsRemaining();
  624.         requestMsgData->OTT = OTT;
  626.         if(call SendRequestMsg.send(TOS_BCAST_ADDR, sizeof(requestMsg), &DataPkt) != SUCCESS){
  627. #ifdef DRAND_DEBUG
  628.           printState();SODbg(DBG_USR2,"SendRequestMsg: Something wrong, send failed.... n");
  629. #endif
  630.           call reXTimer.start(TIMER_ONE_SHOT, REQUEST_TIME);
  631.         }else{
  632.           sendBusy = TRUE;
  633.         }
  634.       } else {
  635. #ifdef DRAND_DEBUG
  636.         printState();SODbg(DBG_USR2,"SendRequestMsg: Channel Busyn");
  637. #endif
  638.         call reXTimer.start(TIMER_ONE_SHOT, REQUEST_TIME);
  639.       }
  640.     }
  641.   }
  643.   void sendRejectMsg(uint8_t msgADDR){
  644.     atomic{
  645.       if(!sendBusy){
  646.         rejectMsg *rejectMsgData = (rejectMsg*) DataPkt.data;
  647.         rejectMsgData->sendID = TOS_LOCAL_ADDRESS;
  648. #ifdef DEBUG
  649.         rejectMsgData->myState = globalState;
  650.         rejectMsgData->roundNum = roundNum;
  651.         rejectMsgData->lastRequestID = lastReqID;
  652. #endif
  653.         if (call SendRejectMsg.send((uint16_t)msgADDR, sizeof(rejectMsg), &DataPkt) == SUCCESS){
  654.           sendBusy = TRUE;
  655.         }
  656.         else{
  657. #ifdef DRAND_DEBUG
  658.           printState();SODbg(DBG_USR2,"sendRejectMsg:failedn");
  659. #endif
  660.         }
  661.       }
  662.     }
  663.   }
  665.   void sendReleaseMsg(uint8_t slot){
  666.     atomic{
  667.       if(!sendBusy){
  668.         releaseMsg *releaseMsgData = (releaseMsg*)DataPkt.data;
  669.         releaseMsgData->sendID = TOS_LOCAL_ADDRESS;
  670.         releaseMsgData->slot = slot;
  671. #ifdef DEBUG
  672.         releaseMsgData->myState = globalState;
  673.         releaseMsgData->lastRequestID = lastReqID;
  674.         releaseMsgData->roundNum = roundNum;
  675. #endif
  676.         if (call SendReleaseMsg.send(TOS_BCAST_ADDR, sizeof(releaseMsg), &DataPkt) == SUCCESS){
  677.           sendBusy = TRUE;
  678.         }
  679.         else{
  680. #ifdef DRAND_DEBUG
  681.           printState();SODbg(DBG_USR2,"sendReleaseMsg: send failedn");
  682. #endif
  683.         }
  684.       }
  685.     }
  686.   }
  688.   void setSlot(){
  689.     uint8_t i;
  690.     uint32_t slotField;
  691.     atomic{
  692.       for(i = 0, slotField = 0x0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++)
  693.         if(nbrInfo[i].slot != 0xFF)
  694.           slotField = slotField | (0x1 << nbrInfo[i].slot);
  695.       for(i = 0; i < 32; i++)
  696.         if(!(slotField & (0x1 << i))){
  697.           myInfo.slot = i;
  698.           setMySlot = TRUE;
  699.           break;
  700.         }
  702.       if(!setMySlot){
  703. #ifdef DEBUG
  704.         SODbg(DBG_USR2, "SetSlot: Could not set slot, something wrong, abort !!!n");
  705. #endif
  706.       } else{
  707.         uint16_t reportTime;
  708. #ifdef DRAND_DEBUG
  709.         printState();SODbg(DBG_USR2,"SetSlot:Scheduling release msgn");
  710. #endif
  711.         globalState = RELEASE_STATE;
  712.         sendReleaseMsg(myInfo.slot);
  713.         call reXTimer.stop();
  714.         call SClock.getTime(&locTime);
  715.         drandRunTime = timeDiff(locTime, drandStartTime);
  716.         reportTime = (uint16_t) (drandRunTime.mticks * 568.88 + drandRunTime.sticks * .00868);
  717. #ifdef DRAND_DEBUG
  718.         SODbg(DBG_USR2,"SetSlot:Scheduling report period after %u secondsn", DRAND_PERIOD - reportTime);
  719. #endif
  720.         call roundTimer.start(TIMER_ONE_SHOT, DRAND_PERIOD - reportTime);
  721.       }
  722.     }
  723.   }
  725.   void sendTwoHopMsg(uint8_t slot, uint8_t sendID){
  726.     atomic{
  727.       if(!sendBusy){
  728.         twoHopMsg *twoHopMsgData = (twoHopMsg*)DataPkt.data;
  729.         twoHopMsgData->sendID = TOS_LOCAL_ADDRESS;
  730.         twoHopMsgData->slotID = sendID;
  731.         twoHopMsgData->slot = slot;
  732. #ifdef DEBUG
  733.         twoHopMsgData->myState = globalState;
  734.         twoHopMsgData->roundNum = roundNum;
  735.         twoHopMsgData->lastRequestID = lastReqID;
  736. #endif
  737.         if (call SendTwoHopMsg.send(TOS_BCAST_ADDR, sizeof(twoHopMsg), &DataPkt) == SUCCESS){
  738.           sendBusy = TRUE;
  739.         } else{
  740. #ifdef DRAND_DEBUG
  741.           printState();SODbg(DBG_USR2,"sendTwoHopMsg: send failedn");
  742. #endif
  743.         }
  744.       }
  745.     }
  746.   }
  748.   void sendGrantMsg(uint8_t msgADDR){
  749.     atomic{
  750.       if(!sendBusy){
  751.         grantMsg *grantMsgData = (grantMsg*)DataPkt.data;
  752.         grantMsgData->sendID = TOS_LOCAL_ADDRESS;
  753. #ifdef DEBUG
  754.         grantMsgData->myState = globalState;
  755.         grantMsgData->lastRequestID = lastReqID;
  756.         grantMsgData->roundNum = roundNum;
  757. #endif
  758.         grantMsgData->timestamp = requestStartTime;
  759.         fillTimeSlotInfo(grantMsgData->timeSlot);
  761.         if (call SendGrantMsg.send((uint16_t)msgADDR, sizeof(grantMsg), &DataPkt) != SUCCESS){
  762.           call reXTimer.start(TIMER_ONE_SHOT, GRANT_TIME);
  763. #ifdef DRAND_DEBUG
  764.           printState();SODbg(DBG_USR2,"sendGrantMsg:grant postponed-1n");
  765. #endif
  766.         }
  767.         else{
  768.           sendBusy = TRUE;
  769.         }
  770.       } else {
  771.         call reXTimer.start(TIMER_ONE_SHOT, GRANT_TIME);
  772. #ifdef DRAND_DEBUG
  773.         printState();SODbg(DBG_USR2,"sendGrantMsg:grant postponed-2n");
  774. #endif
  775.       }
  776.     }
  777.   }
  779.   void sendReportMsg(uint8_t type){
  780.     atomic{
  781.       if(!sendBusy){
  782.         reportMsg *reportMsgData = (reportMsg *) DataPkt.data;
  783.         reportMsgData->slot = myInfo.slot;
  784.         reportMsgData->sendID = TOS_LOCAL_ADDRESS;
  785.         reportMsgData->type = type;
  786.         fillTimeSlotInfoForReport(reportMsgData->timeSlot);
  787.         if(call SendReportMsg.send(TOS_BCAST_ADDR, sizeof(reportMsg), &DataPkt) != SUCCESS){
  788.           call reXTimer.start(TIMER_ONE_SHOT, REPORT_PERIOD + (randNew() % REPORT_INTERVAL));
  789. #ifdef REPORT_DEBUG
  790.           SODbg(DBG_USR2, "sendReportMsg: Failed to send report msgn");
  791. #endif
  792.         } else{
  793.           sendBusy = TRUE;
  794.         }
  795.       } else{
  796.         call reXTimer.start(TIMER_ONE_SHOT, REPORT_PERIOD + (randNew() % REPORT_INTERVAL));
  797. #ifdef REPORT_DEBUG
  798.         printState();SODbg(DBG_USR2,"sendReportMsg:Channel Busyn");
  799. #endif
  800.       }
  801.     }
  802.   }
  803.   
  804.   void sendFrameMsg(uint8_t frameType){
  805.     atomic{
  806.       if(!sendBusy){
  807.         frameMsg *frameMsgData = (frameMsg*) DataPkt.data;
  808.         frameMsgData->sendID = TOS_LOCAL_ADDRESS;
  809.         frameMsgData->frame = myInfo.frame;
  810.         frameMsgData->type = frameType;
  811.         fillFrameInfo(frameMsgData);
  812.         if (call SendFrameMsg.send(TOS_BCAST_ADDR, sizeof(frameMsg), &DataPkt) == SUCCESS){
  813.           sendBusy = TRUE;
  814.         } else{
  815. #ifdef FRAME_DEBUG
  816.           SODbg(DBG_USR2,"SendFrameMsg.SendDone: Failed to Send Frame Messagen");
  817. #endif
  818.           call reXTimer.start(TIMER_ONE_SHOT, FRAME_PERIOD + (randNew() % FRAME_INTERVAL));
  819.         }
  820.       } else{
  821. #ifdef FRAME_DEBUG
  822.         printState();SODbg(DBG_USR2,"sendFrameMsg: Channel Busyn");
  823. #endif
  824.         call reXTimer.start(TIMER_ONE_SHOT, FRAME_PERIOD + (randNew() % FRAME_INTERVAL));
  825.       }
  826.     }
  827.   }
  829.   event result_t SendHelloMsg.sendDone(TOS_MsgPtr msg, result_t success){
  830.     atomic {
  831.       if(sendBusy){
  832.         sendBusy = FALSE;
  833. #ifdef HELLO_DEBUG
  834.         SODbg(DBG_USR2, "SendHelloMsg.SendDone: Sent Hello Messagen");
  835. #endif
  836.         if(globalState == HELLO_STATE)
  837.           call reXTimer.start(TIMER_ONE_SHOT, randNew() % HELLO_INTERVAL);
  838.       }
  839.     }
  840.     return SUCCESS;
  841.   }
  843.   event result_t SendRequestMsg.sendDone(TOS_MsgPtr msg, result_t success){
  844.     atomic{
  845.       if(sendBusy){
  846.         sendBusy = FALSE;
  847. #ifdef DRAND_DEBUG
  848.         printMsg(msg);
  849. #endif
  850.         if(success == FAIL){
  851. #ifdef DRAND_DEBUG
  852.           printState();SODbg(DBG_USR2,"SendRequestMsgSendDone:Postponed Requestn");
  853. #endif
  854.         } else{
  855. #ifdef DEBUG
  856.           if(reqX) reqXCount ++;
  857.           else if(!reqX) reqX = TRUE;
  858.           reqCount++;
  859. #endif
  860.           requestFireCount++;
  861. #ifdef DRAND_DEBUG
  862.           printState();SODbg(DBG_USR2,"SendRequestMsgSendDone:sent Requestn");
  863.           printMsg(msg);
  864. #endif
  865.         }
  866.         if (globalState == REQUEST_STATE)
  867.           call reXTimer.start(TIMER_ONE_SHOT,REQUEST_TIME);
  868.       }
  869.     }
  870.     return SUCCESS;
  871.   }
  873.   event result_t SendRejectMsg.sendDone(TOS_MsgPtr msg, result_t success){
  874.     atomic{
  875.       if(sendBusy){
  876.         sendBusy = FALSE;
  877. #ifdef DRAND_DEBUG
  878.         printMsg(msg);
  879. #endif
  880.         if(success == SUCCESS){
  881. #ifdef DRAND_DEBUG
  882.           printState();SODbg(DBG_USR2,"SendRejectMsgSendDone:Sent Reject n");
  883. #endif
  884. #ifdef DEBUG
  885.           rejCount++;
  886. #endif
  887.         } else{
  888. #ifdef DRAND_DEBUG
  889.           printState();SODbg(DBG_USR2,"SendRejectMsgSendDone:Reject FAILEDn");
  890. #endif
  891.         }
  892.       }
  893.     }
  894.     return SUCCESS;
  895.   }
  897.   event result_t SendReleaseMsg.sendDone(TOS_MsgPtr msg, result_t success){
  898.     atomic{
  899.       if(sendBusy){
  900.         sendBusy = FALSE;
  901.         if(success == SUCCESS){
  902. #ifdef DEBUG
  903.           relCount++;
  904. #endif
  905. #ifdef DRAND_DEBUG
  906.           printState();SODbg(DBG_USR2,"SendReleaseMsgSendDone:Sent Release n");
  907.           printMsg(msg);
  908. #endif
  909.         } else{
  910. #ifdef DRAND_DEBUG
  911.           printState();SODbg(DBG_USR2,"SendReleaseMsgSendDone:Release failedn");
  912. #endif
  913.         }
  914.       }
  915.     }
  916.     return SUCCESS;
  917.   }
  919.   event result_t SendTwoHopMsg.sendDone(TOS_MsgPtr msg, result_t success){
  920.     atomic {
  921.       if(sendBusy){
  922.         sendBusy = FALSE;
  923.         if(success == SUCCESS){
  924. #ifdef DRAND_DEBUG
  925.           printState();SODbg(DBG_USR2,"SendTwoHopMsgSendDone: Sent TwoHop n");
  926.           printMsg(msg);
  927. #endif
  928. #ifdef DEBUG
  929.           twoCount++;
  930. #endif
  931.         } else{
  932. #ifdef DRAND_DEBUG
  933.           printState();SODbg(DBG_USR2,"SendTwoHopMsgSendDone:failed n");
  934. #endif
  935.         }
  936.       }
  937.     }
  938.     return SUCCESS;
  939.   }
  941.   event result_t SendGrantMsg.sendDone(TOS_MsgPtr msg, result_t success){
  942.     atomic{
  943.       if(sendBusy){
  944.         sendBusy = FALSE;
  945. #ifdef DRAND_DEBUG
  946.         printMsg(msg);
  947. #endif
  948.         if(success == FAIL){
  949. #ifdef DRAND_DEBUG
  950.           printState();SODbg(DBG_USR2,"SendGrantMsgSendDone: grant failed  n");
  951. #endif
  952.         } else{
  953. #ifdef DEBUG
  954.           if(graX) graXCount ++;
  955.           else if(!graX) graX = TRUE ;
  956.           graCount++;
  957.           grantFireCount++;
  958. #endif
  959. #ifdef DRAND_DEBUG
  960.           printState();SODbg(DBG_USR2,"SendGrantMsgSendDone:Sent Grant  n");
  961.           printMsg(msg);
  962. #endif
  963.         }
  964.       }
  965.       if(globalState == GRANT_STATE)
  966.         call reXTimer.start(TIMER_ONE_SHOT, GRANT_TIME);
  967.     }
  968.     return SUCCESS;
  969.   }
  971.   event result_t SendReportMsg.sendDone(TOS_MsgPtr msg, result_t success){
  972.     atomic{
  973. #ifdef LDEBUG
  974.       call Leds.redToggle();
  975. #endif
  976.       if(sendBusy){
  977.         sendBusy = FALSE;
  978. #ifdef REPORT_DEBUG
  979.         if(success == SUCCESS)
  980.           SODbg(DBG_USR2,"SendReport.SendDone:send report message n");
  981. #endif
  982.       }
  983.       if(globalState == REPORT_STATE)
  984.         call reXTimer.start(TIMER_ONE_SHOT, REPORT_PERIOD + (randNew() % REPORT_INTERVAL));
  985.     }
  986.     return SUCCESS;
  987.   }
  989.   event result_t SendFrameMsg.sendDone(TOS_MsgPtr msg, result_t success){
  990.     atomic{
  991.       if(sendBusy){
  992.         sendBusy = FALSE;
  993. #ifdef FRAME_DEBUG
  994.         if(success == SUCCESS)
  995.           SODbg(DBG_USR2,"SendFrame.SendDone:sent frame message n");
  996. #endif
  997.       }
  998.       if(globalState == FRAME_STATE)
  999.         call reXTimer.start(TIMER_ONE_SHOT, FRAME_PERIOD + (randNew() % FRAME_INTERVAL));
  1000.     }
  1001.     return SUCCESS;
  1002.   }
  1004.   event TOS_MsgPtr ReceiveHelloMsg.receive(TOS_MsgPtr m){
  1005.     if (globalState != HELLO_STATE) return m;
  1006.     atomic{
  1007.       uint8_t PacketOneWayID[MAX_NBR], PacketTwoWayID[MAX_NBR];
  1008.       helloMsg *recvHelloPtr = (helloMsg*)(m->data);
  1009.       uint8_t Sender = recvHelloPtr->sendID;
  1010.       uint8_t Me = TOS_LOCAL_ADDRESS;
  1011.       uint8_t i, j;
  1012.       bool SendHelloFlag = FALSE;
  1014. #ifdef HELLO_DEBUG
  1015.       printState();SODbg(DBG_USR2,"ReceiveHelloMsg:Receive Hello Msg from %un",
  1016.                             recvHelloPtr->sendID);
  1017. #endif
  1019. #ifdef LDEBUG
  1020.       call Leds.greenToggle();
  1021. #endif
  1022.       for(i = 0; i < MAX_NBR; i++)
  1023.         PacketOneWayID[i] = PacketTwoWayID[i] = 0xFF;
  1025.       for(i = 0; i < recvHelloPtr->OneWayLen; i++)
  1026.         PacketOneWayID[i] = recvHelloPtr->OneWayId[i];
  1027.       for(j = 0; i < MAX_NBR; i++, j++)
  1028.         PacketTwoWayID[j] = recvHelloPtr->OneWayId[i];
  1029.       if (isPresentHelloID(Me, PacketOneWayID, MAX_NBR) != -1) {
  1030.         if (isPresentHelloID(Sender, OneWayId, MAX_NBR) != -1) {
  1031.           addHelloID(Sender, TwoWayId);
  1032. #ifdef LDEBUG
  1033.           call Leds.redToggle();
  1034. #endif
  1035.           removeHelloID(Sender, OneWayId);
  1036.         }
  1037.         else if (isPresentHelloID(Sender, TwoWayId, MAX_NBR) != -1) {
  1038.           SendHelloFlag = TRUE;
  1039.         }
  1040.         else {
  1041.           addHelloID(Sender, TwoWayId);
  1042. #ifdef LDEBUG
  1043.           call Leds.redToggle();
  1044. #endif
  1045.           SendHelloFlag = TRUE;
  1046.         }
  1047.       }
  1048.       else if (isPresentHelloID(Me, PacketTwoWayID, MAX_NBR) != -1) {
  1049.         if (isPresentHelloID(Sender, OneWayId, MAX_NBR) != -1) {
  1050.           addHelloID(Sender, TwoWayId);
  1051. #ifdef LDEBUG
  1052.           call Leds.redToggle();
  1053. #endif
  1054.           removeHelloID(Sender, OneWayId);
  1055.           SendHelloFlag = TRUE;
  1056.         }
  1057.         else if (isPresentHelloID(Sender, TwoWayId, MAX_NBR) != -1) {}
  1058.         else if ((isPresentHelloID(Sender, TwoWayId, MAX_NBR) == -1) &&
  1059.                  (isPresentHelloID(Sender, OneWayId, MAX_NBR) == -1)) {}
  1060.       }
  1061.       else if ((isPresentHelloID(Me, PacketOneWayID, MAX_NBR) == -1) &&
  1062.                (isPresentHelloID(Me, PacketTwoWayID, MAX_NBR) == -1)) {
  1063.         if (isPresentHelloID(Sender, OneWayId, MAX_NBR) == -1) {
  1064.           addHelloID(Sender, OneWayId);
  1065.         }
  1066.         else if (isPresentHelloID(Sender, OneWayId, MAX_NBR) != -1) {
  1067.           SendHelloFlag = TRUE;
  1068.         }
  1069.         else if (isPresentHelloID(Sender, TwoWayId, MAX_NBR) != -1) {}
  1070.       }
  1072.       if (SendHelloFlag && globalState != HELLO_STATE)
  1073.         sendHelloMsg();
  1074.       // Update Two Hop ID
  1075.       for (i = 0; i < MAX_NBR; i++)
  1076.         if (isPresentHelloID(PacketTwoWayID[i], TwoWayId, MAX_NBR) == -1)
  1077.           addNode(PacketTwoWayID[i], TWO_HOP);
  1078.       // Remove this sender from my two Hop node if it is present
  1079.       removeNode(recvHelloPtr->sendID, TWO_HOP);
  1080.     }//atomic
  1082.     return m;
  1083.   }//end of ReceiveHelloMsg.receive(TOS_MsgPtr m)
  1085.   event TOS_MsgPtr ReceiveRequestMsg.receive(TOS_MsgPtr m){
  1086.     uint8_t i;
  1087.     requestMsg *recvRequestPtr = (requestMsg*)(m->data);
  1088.     uint16_t reqSentID = recvRequestPtr->sendID;
  1089.     if(isPresent(reqSentID, ONE_HOP) == -1) return m;
  1090.     atomic{
  1091.       requestStartTime = recvRequestPtr->timestamp;
  1093.       for(i = 0; (i < MAX_NBR) && (recvRequestPtr->idMap[i] != 0xFF); i++)
  1094.         if(isPresent(recvRequestPtr->idMap[i], ONE_HOP) == -1)
  1095.           addNode(recvRequestPtr->idMap[i], TWO_HOP);
  1096. #ifdef DRAND_DEBUG
  1097.       printState();SODbg(DBG_USR2,"ReceiveRequestMsg:Receive Request Msgn");
  1098.       printMsg(m);
  1099. #endif
  1100.       if (( reqSentID != lastReqID ) && (globalState == GRANT_STATE ||
  1101.                                          globalState == REQUEST_STATE)) {
  1102.         // This node is not the one that I already sent a grant, so send a reject.
  1103. #ifdef DRAND_DEBUG
  1104.         printState();SODbg(DBG_USR2,"ReceiveRequestMsg:Scheduling rejectn");
  1105. #endif
  1106.         sendRejectMsg(reqSentID);
  1107. #ifdef DRAND_DEBUG
  1108.         SODbg( DBG_USR2, "sent reject to %un", reqSentID);
  1109. #endif
  1110.       } else if((globalState == IDLE_STATE2) || (setMySlot)){
  1111.         if(!setMySlot)
  1112.           call roundTimer.stop();
  1113.         globalState = GRANT_STATE;
  1114.         grantFireCount = 0;
  1115. #ifdef LDEBUG
  1116.         printLED();
  1117. #endif
  1118.         lastReqID = reqSentID ; //to distinguish with request which is because of loss of reject
  1119.         GRANT_TIME = ((recvRequestPtr->numRemaining * recvRequestPtr->OTT) + recvRequestPtr->OTT) * 2;
  1120.         // subdue grant because this is costly !
  1121.         call reXTimer.start(TIMER_ONE_SHOT, randNew() % GRANT_INTERVAL);
  1122.       } else if((globalState == GRANT_STATE) && (reqSentID == lastReqID)){
  1123.         GRANT_TIME = ((recvRequestPtr->numRemaining * recvRequestPtr->OTT) + recvRequestPtr->OTT) * 2;
  1124.         // subdue grant because this is costly !
  1125.         if (checkForRetransGrant(recvRequestPtr)){
  1126.           call reXTimer.start(TIMER_ONE_SHOT, randNew() % GRANT_INTERVAL);
  1127.         } else{
  1128.           call reXTimer.start(TIMER_ONE_SHOT, GRANT_TIME);
  1129.           grantFireCount = 0;
  1130.         }
  1131.       }
  1132.     }//atomic
  1133.     return m;
  1134.   }//end of ReceiveRequestMsg.receive(TOS_MsgPtr m)
  1136.   event TOS_MsgPtr ReceiveRejectMsg.receive(TOS_MsgPtr m){
  1137.     if(globalState != REQUEST_STATE) return m;
  1138.     atomic{
  1139. #ifdef DRAND_DEBUG
  1140.       printState();SODbg(DBG_USR2,"ReceiveRejectMsg:Received Reject Msgn");
  1141.       printMsg(m);
  1142. #endif
  1143.       call reXTimer.stop();
  1144.       //      if(!sentRelease){
  1145. #ifdef DRAND_DEBUG
  1146.         printState();SODbg(DBG_USR2, "ReceivedRejectMsg:Scheduling Releasen");
  1147. #endif
  1148.         sendReleaseMsg(0xFF);
  1149.         sentRelease = TRUE;
  1150.         //      }
  1151.       initializeGrantSent();
  1152.       globalState = IDLE_STATE2; //go back to IDLE_STATE2
  1153. #ifdef DEBUG
  1154.       reqX = FALSE;
  1155. #endif
  1156.       call roundTimer.start(TIMER_ONE_SHOT, 1000); // time for current round to finish
  1157. #ifdef LDEBUG
  1158.       printLED();
  1159. #endif
  1160.     }//atomic
  1161.     return m;
  1162.   }//end of ReceiveRejectMsg.receive(TOS_MsgPtr m)
  1164.   event TOS_MsgPtr ReceiveReleaseMsg.receive(TOS_MsgPtr m){
  1165.     int nIndex;
  1166.     releaseMsg *recvReleasePtr = (releaseMsg*)(m->data);
  1167. #ifdef DRAND_DEBUG
  1168.     printState();SODbg(DBG_USR2,"ReceiveReleaseMsg:Received Release Msgn");
  1169.     printMsg(m);
  1170. #endif
  1171.     if(((nIndex = isPresent(recvReleasePtr->sendID, ONE_HOP)) == -1) ||
  1172.        (globalState != GRANT_STATE) || (lastReqID != recvReleasePtr->sendID))
  1173.       return m;
  1174.     atomic{
  1175.       call reXTimer.stop();
  1176.       if(updateNeighborInfo(recvReleasePtr->sendID, recvReleasePtr->slot))
  1177.         sendTwoHopMsg(recvReleasePtr->slot, recvReleasePtr->sendID);
  1178. #ifdef DRAND_DEBUG
  1179.       printState();SODbg(DBG_USR2,"ReceiveReleaseMsg:Scheduling two hop releasen");
  1180. #endif
  1181.       
  1182.       if (setMySlot) {   //&&(globalState == GRANT_STATE)
  1183.         globalState = RELEASE_STATE;
  1184. #ifdef LDEBUG
  1185.         printLED();
  1186. #endif
  1187.       } else {
  1188.         globalState = IDLE_STATE2;
  1189.         call roundTimer.start(TIMER_ONE_SHOT, 100);
  1190. #ifdef LDEBUG
  1191.         printLED();
  1192. #endif
  1193.       }
  1194. #ifdef DEBUG
  1195.       graX = FALSE;
  1196. #endif
  1197.       lastReqID = 0xFF;
  1198.     }
  1199.     return m;
  1200.   }//end of ReceiveReleaseMsg.receive(TOS_MsgPtr m)
  1202.   event TOS_MsgPtr ReceiveTwoHopMsg.receive(TOS_MsgPtr m){
  1203.     int nIndex;
  1204.     twoHopMsg *recvTwoHopPtr = (twoHopMsg*)(m->data);
  1205. #ifdef DRAND_DEBUG
  1206.     printState();SODbg(DBG_USR2,"ReceiveTwoHopMsg:Received Two Hopn");
  1207.     printMsg(m);
  1208. #endif
  1209.     if(((nIndex = isPresent(recvTwoHopPtr->sendID, ONE_HOP)) == -1) ||
  1210.        recvTwoHopPtr->slotID == TOS_LOCAL_ADDRESS)
  1211.       return m;
  1212.     atomic {
  1213.       if((globalState == GRANT_STATE) && (recvTwoHopPtr->slotID == lastReqID)){
  1214.         recvTwoHopPtr->sendID = recvTwoHopPtr->slotID;
  1215.         signal ReceiveReleaseMsg.receive(m);
  1216.       }
  1217.       
  1218.       updateNeighborInfo(recvTwoHopPtr->slotID, recvTwoHopPtr->slot);
  1219.     }
  1220.     return m;
  1221.   }//end of ReceiveTwoHopMsg.receive(TOS_MsgPtr m)
  1223.   event TOS_MsgPtr ReceiveGrantMsg.receive(TOS_MsgPtr m){
  1224.     uint8_t i;
  1225.     GTime rttTime;
  1226.     double currOTT;
  1227.     bool dup = FALSE;
  1228.     grantMsg *recvGrantPtr = (grantMsg*)(m->data);
  1229.     int nIndex = isPresent(recvGrantPtr->sendID, ONE_HOP);
  1230.     if(nIndex == -1)
  1231.       return m;
  1232.     atomic{
  1233.       for (i = 0; i < MAX_NBR; i++){ // copy sender information
  1234.         if(isPresent(recvGrantPtr->timeSlot[i], ONE_HOP) == -1)
  1235.           addNode(recvGrantPtr->timeSlot[i], TWO_HOP);
  1236.         updateNeighborInfo(recvGrantPtr->timeSlot[i], i);
  1237.       }
  1238.         
  1239. #ifdef DRAND_DEBUG
  1240.       printState();SODbg(DBG_USR2,"ReceiveGrantMsg:Received Grant Msgn");
  1241.       printMsg(m);
  1242. #endif
  1243.       if(setMySlot){
  1244. #ifdef DRAND_DEBUG
  1245.         printState();SODbg(DBG_USR2,"ReceiveGrantMsg:Scheduling release msgn");
  1246. #endif
  1247.         sendReleaseMsg(myInfo.slot);
  1248.       } else if((globalState == IDLE_STATE2)|| (globalState == GRANT_STATE)){
  1249.         //        if(!sentRelease){
  1250. #ifdef DRAND_DEBUG
  1251.           printState();SODbg(DBG_USR2,"ReceiveGrantMsg:Scheduling FAIL release msgn");
  1252. #endif
  1253.           sendReleaseMsg(0xFF);
  1254.           sentRelease = TRUE;
  1255.           //        }
  1256.       } else if(globalState == REQUEST_STATE){
  1257.         if(!(nbrInfo[nIndex].bitMap & GRANT_SENT)) // if not duplicate, add to grantSendNode list
  1258.           nbrInfo[nIndex].bitMap |= GRANT_SENT;
  1259.         else
  1260.           dup = TRUE;
  1262.         if(firstGrant){ // update timers using info from first grant
  1263.           call SClock.getTime(&locTime);
  1264.           rttTime = timeDiff(locTime, recvGrantPtr->timestamp);
  1265.           currOTT = (rttTime.mticks * 568.88 + rttTime.sticks * 0.00868)/2;
  1266.           OTT = (uint16_t) (currOTT * .50 + OTT * .50);
  1267. #ifdef DRAND_DEBUG
  1268.           SODbg(DBG_USR2,"ReceiveGrantMsg: Current OTT = %u, average OTT = %un",
  1269.                 (uint16_t) currOTT, OTT);
  1270. #endif          
  1271.           ROUND_TIME = (OTT + (OTT * numOneHop()) + OTT) * 2;
  1272.           REQUEST_TIME = (2 * OTT) * 2;
  1273.           firstGrant = FALSE;
  1274.         }
  1276.         //check that all one hop node sent grant message and set the time slot. And send release message.
  1277.         if ((numGrantsRemaining() == 0) && (!setMySlot)){
  1278.           setSlot(); // set slot, change state, send release and schedule report timer
  1279. #ifdef ES_DEBUG
  1280.           timeCheck();
  1281.           printNbrInfo();
  1282. #endif
  1283. #ifdef LDEBUG
  1284.           printLED();
  1285. #endif
  1286.         } else if(!dup){
  1287.           call reXTimer.start(TIMER_ONE_SHOT, REQUEST_TIME);
  1288.           requestFireCount = 0;
  1289.         }
  1290.       }//else
  1291.     }//atomic  
  1292.     return m;
  1293.   }//end of ReceiveGrantMsg.receive(TOS_MsgPtr m)
  1295.   void reXFrame(){
  1296.     if(frameFireCount > MAX_FRAME)
  1297.       removeNodesForFrame();
  1298.     else
  1299.       frameFireCount++;
  1301.     if(!checkForRetransFrame()){
  1302. #ifdef ES_DEBUG
  1303.       printNbrInfo();
  1304. #endif
  1305.       call reXTimer.stop();
  1306.       signal Drand.gotFrame();
  1307.     } else{
  1308. #ifdef FRAME_DEBUG
  1309.       SODbg(DBG_USR2,"frameTimer.fired:Broadcast request for Frame againn");
  1310. #endif
  1311.       sendFrameMsg(FRAME_REQUEST);
  1312.     }
  1313.   }
  1315.   void startFramePeriod(){
  1316.     atomic{
  1317.       globalState = FRAME_STATE;
  1318.       reXFrame();
  1319.     }
  1320.   }
  1322.   void reXReport(){
  1323.     uint8_t maxSlot, frameLen;
  1325.     if(reportFireCount > MAX_REPORT)
  1326.       removeNodesForReport();
  1327.     else
  1328.       reportFireCount++;
  1329.     
  1330.     if(!checkForRetransReport()){
  1331.       removeNodesForReport(); // clear 2hop nodes still without slot information
  1332.       call reXTimer.stop();
  1333.       maxSlot = getMaxSlot(); // now find nearest power of 2
  1334.       frameLen = 0;
  1335.       while(maxSlot != 0){
  1336.         maxSlot = (int)(maxSlot/2);
  1337.         frameLen++;
  1338.       }
  1339.       myInfo.frame = 0x1 << frameLen;
  1340. #ifdef ES_DEBUG
  1341.       SODbg(DBG_USR2, "Local Frame Size = %u for maxSlot = %un", myInfo.frame, getMaxSlot());
  1342. #endif
  1343.       startFramePeriod();
  1344.     } else{
  1345.       sendReportMsg(REPORT_REQUEST);
  1346. #ifdef REPORT_DEBUG
  1347.       SODbg(DBG_USR2, "ReportTimerFired: Need to retransmit with %un", reportFireCount);
  1348. #endif
  1349.     }
  1350.   }
  1352.   event TOS_MsgPtr ReceiveReportMsg.receive(TOS_MsgPtr m){
  1353.     if(!setMySlot) return m;
  1354.     atomic{
  1355.       reportMsg *recvReportPtr = (reportMsg*)(m->data);
  1356.       int nIndex = isPresent(recvReportPtr->sendID, ONE_HOP);
  1357.       if(globalState != FRAME_STATE){
  1358.         globalState = REPORT_STATE; // if I receive any report msg, automatically go to report state
  1359.         call reXTimer.start(TIMER_ONE_SHOT, REPORT_PERIOD + (randNew() % REPORT_INTERVAL));
  1360.       }
  1361. #ifdef REPORT_DEBUG
  1362.       printState(); SODbg(DBG_USR2,"ReceiveReportMsg.receive: receive report message from %un", recvReportPtr->sendID);
  1363. #endif
  1364.       if(nIndex != -1){
  1365.         updateNeighborInfoForReport(nIndex, recvReportPtr); // update time slots from packet
  1366.         if(recvReportPtr->type == REPORT_REQUEST){
  1367.           sendReportMsg(REPORT_REPLY); // this automatically starts timer if not started yet
  1368. #ifdef REPORT_DEBUG
  1369.           SODbg(DBG_USR2,"ReceiveReportMsg: Sending Replyn");
  1370. #endif
  1371.         }
  1372.       }
  1373.     }
  1374.     return m;
  1375.   }
  1376.   
  1377.   event TOS_MsgPtr ReceiveFrameMsg.receive(TOS_MsgPtr m){
  1378.     if(globalState != FRAME_STATE) return m;
  1379.     atomic{
  1380.       frameMsg *recvFramePtr = (frameMsg*)(m->data);
  1381.       int nIndex = isPresent(recvFramePtr->sendID, ONE_HOP);
  1382.       if(nIndex != -1){
  1383.         updateNeighborInfoForFrame(nIndex, recvFramePtr);
  1384.         if(recvFramePtr->type == FRAME_REQUEST){
  1385. #ifdef FRAME_DEBUG
  1386.           SODbg(DBG_USR2,"ReceiveFrameMsg:receive frame request from %un", recvFramePtr->sendID);
  1387. #endif
  1388.           sendFrameMsg(FRAME_REPLY);
  1389.         }
  1390.       }
  1391.     }
  1392.     return m;
  1393.   }
  1395.   void reXHello(){
  1396.     atomic{
  1397.       sendHelloMsg();
  1398.     }
  1399.   }
  1401.   void reXRequest(){
  1402.     atomic {
  1403.       if (requestFireCount > MAX_REQUEST){
  1404.         removeNodesForRequest(); // remove nodes who have not sent grant yet
  1405.         if((numGrantsRemaining() == 0) && (!setMySlot)){
  1406.           setSlot();
  1407. #ifdef ES_DEBUG
  1408.           timeCheck();
  1409.           printNbrInfo();
  1410. #endif
  1411. #ifdef DRAND_DEBUG
  1412.           printState();SODbg(DBG_USR2,"RequestTimerFired:Scheduling release msgn");
  1413. #endif
  1414. #ifdef LDEBUG
  1415.           printLED();
  1416. #endif
  1417.         }
  1418.       } else {
  1419. #ifdef DRAND_DEBUG
  1420.         printState();SODbg(DBG_USR2,"requestTimerFired:Scheduling request with %un", requestFireCount);
  1421. #endif
  1422.         sendRequestMsg();
  1423.       }
  1424.     }
  1425.   }
  1427.   void reXGrant(){
  1428.     atomic{
  1429.       if (grantFireCount > MAX_GRANT){
  1430.         removeNodeForGrant(lastReqID);
  1431.         if(setMySlot){
  1432.           globalState = RELEASE_STATE;
  1433. #ifdef LDEBUG
  1434.           printLED();
  1435. #endif
  1436.         } else{
  1437.           globalState = IDLE_STATE2;
  1438.           call roundTimer.start(TIMER_ONE_SHOT, 100);
  1439. #ifdef LDEBUG
  1440.           printLED();
  1441. #endif
  1442.         }
  1443. #ifdef DEBUG
  1444.         graX = FALSE;
  1445. #endif
  1446.         lastReqID = 0xFF;
  1447.       } else{
  1448. #ifdef DRAND_DEBUG
  1449.         printState();SODbg(DBG_USR2,"grantTimerFired:Scheduling grant with %un", grantFireCount);
  1450. #endif
  1451.         sendGrantMsg(lastReqID);
  1452.       }
  1453.     }
  1454.   }
  1456.   void helloOver(){ // hello phase over, start drand round
  1457.     uint8_t i, randNum, contender;
  1458.     signal Drand.helloOver(); // signal aplication that hello is over
  1460.     atomic{
  1461.       globalState = IDLE_STATE2;
  1462.       call reXTimer.stop();
  1463. #ifdef LDEBUG
  1464.       printLED();
  1465. #endif
  1466.       call SClock.getTime(&drandStartTime);         //drand starting time
  1467.       for (i = 0; i < MAX_NBR; i++)
  1468.         addNode(TwoWayId[i], ONE_HOP);
  1470. #ifdef ES_DEBUG
  1471.       printNbrInfo();
  1472. #endif
  1473.       contender = getContenders();
  1474.       randNum = randNew();
  1476. #ifdef DRAND_DEBUG
  1477.       printState();SODbg(DBG_USR2,"HelloTimerFired: trying lottery with contenders = %un", contender);
  1478.       SODbg(DBG_USR2,"Random number : %u n", randNum);
  1479. #endif
  1481.       if ((randNum % contender) == 0){ // I am the winner
  1482.         globalState = REQUEST_STATE;
  1483.         requestFireCount = 0;
  1484. #ifdef DEBUG
  1485.         call SClock.getTime(&roundStartTime);
  1486. #endif
  1487. #ifdef LDEBUG
  1488.         printLED();
  1489. #endif
  1490. #ifdef DRAND_DEBUG
  1491.         printState();SODbg(DBG_USR2,"HelloRoundTimerFired:Scheduling requestn");
  1492. #endif
  1493.         sendRequestMsg();
  1494.       } else
  1495.         call roundTimer.start(TIMER_ONE_SHOT, ROUND_TIME);
  1496.     }//atomic
  1497.   }
  1499.   void drandRoundOver(){
  1500.     uint8_t randNum, contender;
  1501.     atomic{
  1502.       sentRelease = FALSE;
  1503.       firstGrant = TRUE;
  1504. #ifdef DEBUG
  1505.       roundNum++;
  1506. #endif
  1507.       randNum = randNew();
  1508.       contender = getContenders();
  1509. #ifdef DRAND_DEBUG
  1510.       printState();SODbg(DBG_USR2,"DrandRoundTimerFired:running lottery n");
  1511.       SODbg(DBG_USR2, "Contender = %un", contender);
  1512.       SODbg(DBG_USR2,"Random number : %u n", randNum);
  1513. #endif
  1514.       if((randNum % contender) == 0){ // I am the winner
  1515.         globalState = REQUEST_STATE;
  1516. #ifdef DEBUG
  1517.         call SClock.getTime(&roundStartTime);
  1518. #endif
  1519.         requestFireCount = 0;
  1520. #ifdef LDEBUG
  1521.         printLED();
  1522. #endif
  1523. #ifdef DRAND_DEBUG
  1524.         printState();SODbg(DBG_USR2,"drandRoundTimerFired:WON LOTTERY, Scheduling requestn");
  1525. #endif
  1526.         sendRequestMsg();
  1527.       } else{
  1528. #ifdef DRAND_DEBUG
  1529.         printState();
  1530.         SODbg(DBG_USR2,"drandRoundTimerFired:LOST LOTTERY, Scheduling request after %un", ROUND_TIME);
  1531. #endif
  1532.         call roundTimer.start(TIMER_ONE_SHOT, ROUND_TIME);
  1533.       }
  1534.       lastReqID = 0xff;
  1535.     }
  1536.   }
  1538.   void startReportPeriod(){
  1539.     atomic{
  1540.       globalState = REPORT_STATE;
  1541.       reXReport();
  1542.     }
  1543.   }
  1545.   event result_t reXTimer.fired(){
  1546.     atomic{
  1547.       switch(globalState){
  1548.       case HELLO_STATE:
  1549.         reXHello();
  1550.         break;
  1551.       case REQUEST_STATE:
  1552.         reXRequest();
  1553.         break;
  1554.       case GRANT_STATE:
  1555.         reXGrant();
  1556.         break;
  1557.       case REPORT_STATE:
  1558.         reXReport();
  1559.         break;
  1560.       case FRAME_STATE:
  1561.         reXFrame();
  1562.         break;
  1563.       }
  1564.     }
  1565.     return SUCCESS;
  1566.   }
  1568.   event result_t roundTimer.fired(){
  1569.     atomic{
  1570.       switch(globalState){
  1571.       case HELLO_STATE:
  1572.         helloOver();
  1573.         break;
  1574.       case IDLE_STATE2:
  1575.         drandRoundOver();
  1576.         break;
  1577.       case RELEASE_STATE:
  1578.         startReportPeriod();
  1579.         break;
  1580.       }
  1581.     }
  1582.     return SUCCESS;
  1583.   }
  1585.   /******************       Drand Interface ********************/
  1586.   default async event void Drand.gotFrame(){}
  1587.   default async event void Drand.helloOver(){}
  1588.   command nodeInfo* Drand.getNeighborInfo(){ return nbrInfo; }
  1589.   command nodeInfo* Drand.getMyInfo(){ return &myInfo; }
  1590.   command void Drand.startDrand(){
  1591.     call StdControl.init();
  1592.     call StdControl.start();
  1593.   }
  1595.   command void Drand.stopDrand(){ call StdControl.stop(); }
  1597.   /**************SClock Interface********/
  1598.   async event result_t SClock.syncDone(){ return SUCCESS; }
  1599.   async event result_t SClock.fire(uint16_t mticks){ return SUCCESS; }
  1600. }//end of implementation