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

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

网络

开发平台：

Others

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