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

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

网络

开发平台：

Others

CC1000RadioIntM.nc：源码内容
  1. includes crc;
  2. includes CC1000Const;
  3. includes zmacInfo;
  4. includes DrandInfo;
  6. module CC1000RadioIntM {
  7.   provides {
  8.     interface StdControl;
  9.     interface BareSendMsg as Send;
  10.     interface ReceiveMsg as Receive;
  11.     interface RadioCoordinator as RadioSendCoordinator;
  12.     interface RadioCoordinator as RadioReceiveCoordinator;
  13.     interface MacControl;
  14.     interface MacBackoff;
  15.     interface LowPowerListening;
  16.     interface SetDrand;
  17.     
  18.     // legacy commands supported, but should now use the
  19.     // Low Power Listening interface
  20.     async command result_t SetListeningMode(uint8_t power);
  21.     async command uint8_t GetListeningMode();
  22.     async command result_t SetTransmitMode(uint8_t power);
  23.     async command uint8_t GetTransmitMode();
  24.     // Used for debugging the noise floor (gets the current squelch value)
  25.     async command uint16_t GetSquelch();
  26.     // Used for debugging; gets an estimate of the power consumed by the radio
  27.     async command uint16_t GetPower();
  28.     async command uint16_t GetDataSent();
  29.     async command uint16_t GetPower_tx();
  30.     async command uint16_t GetPower_rx();
  31.     async command uint16_t GetPower_sp();
  32.     async command result_t ResetPower();
  33.     async command result_t ResetDataSent();
  34.   }
  35.   uses {
  36.     interface SClock;
  37.     interface StdControl as SubControl;
  38.     interface PowerManagement;
  39.     interface StdControl as CC1000StdControl;
  40.     interface CC1000Control;
  41.     interface Random;
  42.     interface ADCControl;
  43.     interface ADC as RSSIADC;
  44.     interface SpiByteFifo;
  45.     interface StdControl as TimerControl;
  46.     interface Timer as WakeupTimer;
  47.     interface Timer as SquelchTimer;
  48.     interface Timer as TDMATimer;
  49.     interface Leds;
  50.   }
  51. }
  52. implementation {
  53. #include "DrandMSG.h"
  54. #include "zmacConst.h"
  55. #ifdef ZMAC_DEBUG
  56. #include "SODebug.h"
  57. #endif
  60.   enum {
  61.     NULL_STATE,
  62.     TX_STATE,
  63.     DISABLED_STATE,
  64.     IDLE_STATE,
  65.     PRETX_STATE,
  66.     SYNC_STATE,
  67.     RX_STATE,
  68.     SENDING_ACK,
  69.     POWER_DOWN_STATE,
  70.     PULSE_CHECK_STATE,
  71.   };
  73.   enum {
  74.     TXSTATE_WAIT,
  75.     TXSTATE_START,
  76.     TXSTATE_PREAMBLE,
  77.     TXSTATE_SYNC,
  78.     TXSTATE_DATA,
  79.     TXSTATE_CRC,
  80.     TXSTATE_FLUSH,
  81.     TXSTATE_WAIT_FOR_ACK,
  82.     TXSTATE_READ_ACK,
  83.     TXSTATE_DONE
  84.   };
  86.   enum {
  87.     SYNC_BYTE = 0x33,
  88.     NSYNC_BYTE = 0xcc,
  89.     SYNC_WORD = 0x33cc,
  90.     NSYNC_WORD = 0xcc33,
  91.     ACK_LENGTH = 16,
  92.     MAX_ACK_WAIT = 18,
  93.     TIME_BETWEEN_CHECKS = 50,
  94.     TIME_AFTER_CHECK = 30,
  95.     CHECK_MA_COUNT = 100, //8888,
  96.     SEND_MA_COUNT = 100, //7200,
  97.     PREAMBLE_LENGTH_TO_BASE = 8,
  98.     RECEIVE_MA_COUNT = 100, //9600
  100.   };
  102.   uint8_t ack_code[5] = {0xab, 0xba, 0x83, 0xaa, 0xaa};
  104.   uint8_t RadioState;
  105.   uint8_t RadioTxState;
  106.   norace uint8_t iRSSIcount;
  107.   uint8_t RSSIInitState;
  108.   uint8_t iSquelchCount;
  109.   uint16_t txlength;
  110.   uint16_t rxlength;
  111.   TOS_MsgPtr txbufptr;  // pointer to transmit buffer
  112.   TOS_MsgPtr rxbufptr;  // pointer to receive buffer
  113.   TOS_Msg retxbuf; //re-transmit buffer in case ECN preempts send 
  114.   TOS_Msg RxBuf; // save received messages
  115.   uint8_t NextTxByte;
  117.   uint8_t lplpower;        //  low power listening mode
  118.   uint8_t lplpowertx;      //  low power listening transmit mode
  120.   uint16_t preamblelen;    //  current length of the preamble
  121.   uint16_t sleeptime;       //  current check interval (sleep time)
  122.  
  123.   uint16_t PreambleCount;   //  found a valid preamble
  124.   uint8_t SOFCount;
  126.   uint16_t search_word;
  128.   //modified by Mahesh
  129.   enum {
  130.     BMAC,
  131.     ZMAC
  132.   };
  134.   enum{
  135.     MAX_VAL = 0xFFFF
  136.   };
  138.   enum{
  139.     POSITIVE = 1,
  140.     NEGATIVE = 2,
  141.     ZERO = 3
  142.   };
  143.   
  144. #ifdef DRAND_ENABLE
  145.   nodeInfo *nbrInfo;
  146. #else
  147.   nodeInfo nbrInfo[MAX_NBR], myInfo; //CHANGE THIS, ONLY FOR TESTING !!!!!!!
  148. #endif
  150.   GTime currentDiff, constOffset;
  151.   uint16_t currentSender;
  152.   uint8_t currentSign;
  153.   uint8_t currentMAC; // default must be BMAC and change to ZMAC after DRAND completes
  154.   uint16_t localFrameLength; // local frame length in slots
  155.   uint16_t globalFrameLength;
  156.   uint16_t slotSize; 
  157.   uint16_t nextHop;
  158.   uint16_t ownSlot;
  159.   uint16_t slots_since_ecnsend;
  160.   uint16_t slots_since_ecnrecv;
  161.   uint16_t slots_since_ecncheck;
  162.   uint16_t globalFrameSize;
  163.   uint16_t localFrameSize;
  164.   uint16_t globalSlot;
  165.   uint16_t currentSlot;
  166.   uint16_t slotMultiplier;
  167.   uint32_t slotNum;
  168.   uint16_t packetsSent;
  169.   uint16_t pktsLastSync;
  170.   bool needTimeSync;
  171.   uint16_t congBackOffs;
  172.   double avgLoss;
  173.   uint32_t curHCLlist;
  174.   bool HCLselect;
  175.   bool ackOrig;
  176.   bool ecnPending;
  177.   bool ecnforward;
  178.   bool enableHCL;
  179.   bool pureHCL;
  180.   TOS_Msg ecnMsgHdr;
  181.   TOS_Msg ecnForwardMsgHdr;
  182.   TOS_Msg syncMsgHdr;
  184.   union {
  185.     uint16_t W;
  186.     struct {
  187.       uint8_t LSB;
  188.       uint8_t MSB;
  189.     };
  190.   } RxShiftBuf;
  192.   uint8_t RxBitOffset; // bit offset for spibus
  193.   uint16_t RxByteCnt; // received byte counter
  194.   uint16_t TxByteCnt;
  195.   uint16_t RSSISampleFreq; // in Bytes rcvd per sample
  196.   norace bool bInvertRxData; // data inverted
  197.   norace bool bTxPending;
  198.   bool bAckEnable;
  199.   bool bCCAEnable;
  200.   bool bTxBusy;
  201.   bool bRSSIValid;
  202.   uint16_t CC1K_PulseLevel;
  203.   uint16_t usRunningCRC; // Running CRC variable
  204.   uint16_t usRSSIVal;
  205.   uint16_t usSquelchVal;
  206.   uint16_t usTempSquelch;
  207.   uint8_t usSquelchIndex;
  208.   norace uint8_t pulse_check_count;
  209.   norace uint16_t pulse_check_sum;
  210.   norace uint16_t send_sum;
  211.   norace uint16_t receive_sum;
  212.   norace uint16_t power_sum;
  213.   norace uint16_t sp_sum;
  214.   norace uint16_t rx_sum;
  215.   norace uint16_t tx_sum;
  216.   norace uint16_t dataSent;
  218.   uint16_t usSquelchTable[CC1K_SquelchTableSize];
  220.   int16_t sMacDelay;    // MAC delay for the next transmission
  221.   // XXX-PB:
  222.   // Here's the deal, the mica (RFM) radio stacks used TOS_LOCAL_ADDRESS
  223.   // to determine if an L2 ack was reqd.  This stack doesn't do L2 acks
  224.   // and, thus doesn't need it.  HOWEVER, some set-mote-id versions
  225.   // break if this symbol is missing from the binary.
  226.   // Thus, I put this LocalAddr here and set it to TOS_LOCAL_ADDRESS
  227.   // to keep things happy for now.
  228.   volatile uint16_t LocalAddr;
  230.   ///**********************************************************
  231.   //* local function definitions
  232.   //**********************************************************/
  234.   /*
  235.     int sortByShort(const void *x, const void *y) {
  236.     uint16_t* x1 = (uint16_t*)x;
  237.     uint16_t* y1 = (uint16_t*)y;
  238.     if (x1[0] > y1[0]) return -1;
  239.     if (x1[0] == y1[0]) return 0;
  240.     if (x1[0] < y1[0]) return 1;
  241.     return 0; // shouldn't reach here becasue it covers all the cases
  242.     }
  243.   */
  245.   uint16_t getOwnerBackoff(){
  246.     return (call Random.rand() & (T_O - 1)) + 1;
  247.   }
  249.   uint16_t getNonOwnerBackoff(){
  250.     return (call Random.rand() & (T_NO - 1)) + T_O + 1;
  251.   }
  253.   void DivTime2(GTime* B, GTime* A){
  254.     if (A->mticks % 2 == 1){
  255.       B->mticks = (A->mticks >> 1);
  256.       B->sticks = (A->sticks >> 1)  + ((MAX_VAL) >>1);
  257.     }
  258.     else{
  259.       B->mticks = (A->mticks >>1);
  260.       B->sticks = (A->sticks >>1);
  261.     }
  262.   }
  264.   void AddTime(GTime* C, GTime* A, GTime* B){
  265.     if ((MAX_VAL - B->sticks) < A->sticks){
  266.       C->sticks = A->sticks - (MAX_VAL - B->sticks);
  267.       C->mticks = A->mticks + B->mticks + 1;
  268.     }
  269.     else{
  270.       C->sticks = A->sticks + B->sticks;
  271.       C->mticks = A->mticks + B->mticks;
  272.     }
  273.   }
  275.   void SubTime(GTime* C, GTime* A, GTime* B){
  276.     if (B->sticks > A->sticks){
  277.       C->sticks = MAX_VAL - (B->sticks - A->sticks);
  278.       C->mticks = A->mticks - (B->mticks + 1);
  279.     }
  280.     else {
  281.       C->sticks = A->sticks -  B->sticks;
  282.       C->mticks = A->mticks -  B->mticks;
  283.     }
  284.   }
  286.   uint16_t getZMACBackoff(uint16_t residualBackoff){
  287.     if(residualBackoff > 0){
  288.       congBackOffs++;
  289.       if((currentSlot == ownSlot) && (residualBackoff >= T_O)){
  290.         return getOwnerBackoff();
  291.       } else if((currentSlot != ownSlot) && (residualBackoff < T_O)){
  292.         if((residualBackoff + T_O) < (T_O + T_NO))
  293.           return (residualBackoff + T_O);
  294.         else
  295.           return getNonOwnerBackoff();
  296.       } else
  297.         return residualBackoff;
  298.     } else{
  299.       if(currentSlot == ownSlot)
  300.         return getOwnerBackoff();
  301.       else
  302.         return getNonOwnerBackoff();
  303.     }
  304.   }
  306.   uint8_t ModSubTime(GTime* C, GTime* A, GTime* B){
  307.     uint8_t retval;
  308.     if (A->mticks > B->mticks) 
  309.       retval = POSITIVE;
  310.     else if (A->mticks < B->mticks) 
  311.       retval = NEGATIVE;
  312.     else{
  313.       if (A->sticks > B->sticks)
  314.         retval = POSITIVE;
  315.       else if (A->sticks < B->sticks)
  316.         retval = NEGATIVE;
  317.       else
  318.         retval = ZERO;
  319.     }
  320.     if (retval == POSITIVE) SubTime(C,A,B);
  321.     else if (retval == NEGATIVE) SubTime(C,B,A);
  322.     else {
  323.       C->sticks = 0;
  324.       C->mticks = 0;
  325.     }
  326.     return retval;
  327.   }
  329.   bool IsHCL(uint32_t gSlot){
  330.     uint32_t tempHCL = 0x1;
  331.     bool flag;
  332.     tempHCL = tempHCL << gSlot;
  333.     atomic{
  334.       if(tempHCL & curHCLlist)
  335.         flag = TRUE;
  336.       else
  337.         flag = FALSE;
  338.     }
  339.     return flag;
  340.   }
  342.   task void adjustSquelch() {
  343.     uint16_t tempArray[CC1K_SquelchTableSize];
  344.     char i,j,min; 
  345.     uint16_t min_value;
  346.     uint32_t tempsquelch;
  348.     atomic {
  349.       usSquelchTable[usSquelchIndex] = usTempSquelch;
  350.       usSquelchIndex++;
  351.       if (usSquelchIndex >= CC1K_SquelchTableSize)
  352.         usSquelchIndex = 0;
  353.       if (iSquelchCount <= CC1K_SquelchCount)
  354.         iSquelchCount++;  
  355.     }
  357.     for (i=0; i<CC1K_SquelchTableSize; i++) {
  358.       tempArray[(int)i] = usSquelchTable[(int)i];
  359.     }
  361.     min = 0;
  362.     //    for (j = 0; j < ((CC1K_SquelchTableSize) >> 1); j++) {
  363.     for (j = 0; j < 3; j++) {
  364.       for (i = 1; i < CC1K_SquelchTableSize; i++) {
  365.         if ((tempArray[(int)i] != 0xFFFF) && 
  366.             ((tempArray[(int)i] > tempArray[(int)min]) ||
  367.              (tempArray[(int)min] == 0xFFFF))) {
  368.           min = i;
  369.         }
  370.       }
  371.       min_value = tempArray[(int)min];
  372.       tempArray[(int)min] = 0xFFFF;
  373.     }
  375.     tempsquelch = ((uint32_t)(usSquelchVal << 5) + (uint32_t)(min_value << 1));
  376.     atomic usSquelchVal = (uint16_t)((tempsquelch / 34) & 0x0FFFF);
  378.     /*
  379.     // XXX: qsort actually causes ~600bits/sec lower bandwidth... why???
  380.     //
  381.     qsort (tempArray,CC1K_SquelchTableSize, sizeof(uint16_t),sortByShort);
  382.     min_value = tempArray[CC1K_SquelchTableSize >> 1];
  383.     atomic usSquelchVal = ((usSquelchVal << 5) + (min_value << 1)) / 34;
  384.     */
  385.   }
  387.   void getTimeDiff(){ // called as soon as time sync message is received, regardless of crc
  388.     atomic{
  389.       uint16_t i, trust;
  390.       GTime loctime, timeStamp;
  391.       syncMsgType* syncMsgPtr = (syncMsgType *) rxbufptr->data;
  392.       timeStamp.mticks = syncMsgPtr->mticks;
  393.       timeStamp.sticks = syncMsgPtr->sticks;
  394.       trust = syncMsgPtr->trust;
  395.       currentSender = syncMsgPtr->sender;
  396.       call SClock.getTime(&loctime);
  397.       currentSign = ModSubTime(&currentDiff, &timeStamp, &loctime);
  399.       if(trust < MIN_TRUST)
  400.         trust = MIN_TRUST;
  401.       if(trust < MAX_TRUST){
  402.         for(i = 0; i < trust; i++){
  403.           DivTime2(&currentDiff, &currentDiff);
  404.         }
  405.       }
  406.     }
  407.   }
  409.   void Blacklist(uint8_t slot, uint8_t fsize){
  410.     uint8_t black_slot;
  411.     atomic {
  412.       if(fsize <= globalFrameLength){
  413.         black_slot = slot;
  414.         while(black_slot < globalFrameLength){
  415.           uint32_t tempHCL2 = 0x1;
  416.           tempHCL2 = tempHCL2 << black_slot;
  417.           curHCLlist = curHCLlist | tempHCL2;
  418.           black_slot = black_slot + fsize;
  419.         }
  420.       }
  421.     }
  422.   }
  423.   
  424.   task void adjustTime(){
  425.     needTimeSync = TRUE;
  426.     call SClock.setTime(currentSign, &currentDiff);
  427. #ifdef ZMAC_TIME_SYNC
  428.     SODbg(DBG_USR2, "diff = %u, %u, from %un", currentDiff.mticks, currentDiff.sticks, currentSender);
  429. #endif
  430.   }
  432.   task void PacketRcvd(){
  433.     TOS_MsgPtr pBuf;
  434.     ecnForwardMsgType *recvEcnMsgPtr;
  435.     ecnForwardMsgType *ecnForwardMsgPtr;
  436.     atomic {
  437.       if(pktsLastSync > SYNC_PERIOD){
  438.         atomic{ 
  439.           ackOrig = bAckEnable;
  440.           bAckEnable = FALSE;
  441.         }
  442.         call Send.send(&syncMsgHdr);
  443.         pktsLastSync = 0;
  444.       }
  446.       pktsLastSync++;
  447.       rxbufptr->time = 0;
  448.       pBuf = rxbufptr;
  449.       recvEcnMsgPtr = (ecnForwardMsgType *) rxbufptr->data;
  450.       ecnForwardMsgPtr = (ecnForwardMsgType *) ecnForwardMsgHdr.data;
  452. #ifdef ZMAC_ECN
  453.       if((currentMAC == ZMAC) && (pBuf->type == ECNTYPE)){
  454.         SODbg(DBG_USR2,"Received %u hop ECN from %u, deciding whether significant..n",
  455.               recvEcnMsgPtr->hopCount, recvEcnMsgPtr->senderAddress);
  456.       }
  457. #endif
  459.       if((currentMAC == ZMAC) && (HCLselect) && (pBuf->type == ECNTYPE) && (pBuf->crc != 0) &&
  460.          (recvEcnMsgPtr->senderAddress != TOS_LOCAL_ADDRESS)){ //Message is an ECN
  461.         if((recvEcnMsgPtr->hopCount == 0) && (recvEcnMsgPtr->nextHop == TOS_LOCAL_ADDRESS)){
  462. #ifdef ZMAC_ECN
  463.           SODbg(DBG_USR2,"Received one-hop ECN from %un", recvEcnMsgPtr->senderAddress);
  464. #endif
  465.           ecnForwardMsgPtr->hopCount = 1;
  466.           ecnForwardMsgPtr->nextHop = nextHop;
  467.           ecnForwardMsgPtr->senderAddress = TOS_LOCAL_ADDRESS;
  468.           if(!bTxBusy){
  469.             ackOrig = bAckEnable;
  470.             bAckEnable = FALSE;
  471.             call Send.send(&ecnForwardMsgHdr);  //take care of case where we are not currently sending
  472. #ifdef ZMAC_ECN
  473.             SODbg(DBG_USR2,"Forwarded ECNn");
  474. #endif
  475.           } else
  476.             ecnforward = TRUE;
  477.         } else if(recvEcnMsgPtr->hopCount == 1){ //check if two-hop ECN
  478. #ifdef ZMAC_ECN
  479.           SODbg(DBG_USR2,"????????????????????? Received two hop ECN from %un", recvEcnMsgPtr->senderAddress);
  480. #endif
  481.           atomic enableHCL = TRUE;
  482.           if(recvEcnMsgPtr->senderAddress == nextHop){  //check forwarding node's address
  483.             //suppress ECN
  484. #ifdef ZMAC_ECN
  485.             SODbg(DBG_USR2,"Suppressed own ECNn");
  486. #endif
  487.             atomic ecnPending = FALSE;
  488.             slots_since_ecnsend = 0;
  489.             slots_since_ecnrecv = 0;
  490.           }
  491.         }
  492.       } else if((pBuf->type != SYNCTYPE) && (pBuf->type != ECNTYPE)){
  493. #ifdef ZMAC_ECN
  494.         //        SODbg(DBG_USR2,"Received packet of type %u, crc = %un", pBuf->type, pBuf->crc);
  495. #endif
  496.         pBuf = signal Receive.receive((TOS_MsgPtr)pBuf);
  497.       }
  498.       
  499.       if (pBuf)
  500.         rxbufptr = pBuf;
  501.       rxbufptr->length = 0;
  502.     }
  503.     call SpiByteFifo.enableIntr();
  504.   }
  505.   
  506.   task void PacketSent() {
  507.     TOS_MsgPtr pBuf; //store buf on stack 
  508.     atomic {
  509.       txbufptr->time = 0;
  510.       pBuf = txbufptr;
  511.     }
  512.       
  513.     if ((txbufptr->type != ECNTYPE) && (txbufptr->type != SYNCTYPE)){
  514.       //      if(txbufptr->type == AM_MULTIHOP)
  515.       //        dataSent++;
  516.       signal Send.sendDone((TOS_MsgPtr)pBuf, SUCCESS);
  517.     } else if(txbufptr->type == SYNCTYPE){
  518. #ifdef ZMAC_DEBUG
  519.       //      SODbg(DBG_USR2, "Sent one sync message $$$$$$$$$n");
  520. #endif
  521.     } else if(txbufptr->type == ECNTYPE){
  522. #ifdef ZMAC_DEBUG
  523.       //      SODbg(DBG_USR2, "Sent one ecn message $$$$$$$$$n");
  524. #endif
  525.     }
  526.       
  527.     atomic bTxBusy = FALSE;
  528.     if(pktsLastSync > SYNC_PERIOD){
  529.       atomic{
  530.         ackOrig = bAckEnable;
  531.         bAckEnable = FALSE;
  532.       }
  533.       call Send.send(&syncMsgHdr);
  534.       pktsLastSync = 0;
  535.     } else if((currentMAC == ZMAC) && (ecnforward == TRUE)){
  536.       atomic{
  537.         ackOrig = bAckEnable;
  538.         bAckEnable = FALSE;
  539.       }
  540.       call Send.send(&ecnForwardMsgHdr);
  541.       atomic ecnforward = FALSE;
  542. #ifdef ZMAC_ECN
  543.       SODbg(DBG_USR2,"Forwarded ECNn");
  544. #endif
  545.     } else if((currentMAC == ZMAC) && (ecnPending == TRUE)){
  546.       atomic{
  547.         ackOrig = bAckEnable;
  548.         bAckEnable = FALSE;
  549.       }
  550.       call Send.send(&ecnMsgHdr);
  551.       atomic ecnPending = FALSE;
  552.       atomic slots_since_ecnsend = 0;
  553. #ifdef ZMAC_ECN
  554.       SODbg(DBG_USR2,"Sent own ECNn");
  555. #endif
  556.     }
  557.   }
  559.   ///**********************************************************
  560.   //* Exported interface functions
  561.   //**********************************************************/
  562.   command void SetDrand.setParent(uint8_t id){ nextHop = id; }
  563.   command result_t SetDrand.Set(nodeInfo *mInfo, uint8_t nHop, nodeInfo *nInfo, uint16_t sSize){
  564.     uint32_t slotOffset = 0, globalTimeStamp = 0;
  565.     GTime loctime;
  566.     uint8_t i = 0;
  568.     slotSize = sSize;
  569.     nextHop = nHop;
  571. #ifdef DRAND_ENABLE
  572.       localFrameLength = mInfo->frame;
  573.       ownSlot = mInfo->slot;
  574.       nbrInfo = nInfo;
  575.       for(i = 0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++)
  576.         if(nbrInfo[i].bitMap & TWO_HOP)
  577.           Blacklist(nbrInfo[i].slot, nbrInfo[i].frame);
  578. #else
  579.       for(i = 0 ; i<MAX_NBR ; i++){ // initialize the nbr table
  580.         nbrInfo[i].nodeID = 0xFF;
  581.         nbrInfo[i].slot = 0xFF;
  582.         nbrInfo[i].frame = 0xFF;
  583.         nbrInfo[i].bitMap = 0x0;
  584.       }
  585. #include "nbrTable.h"
  586.       /*       slotSize = sSize; */
  587.       /*       localFrameLength = 8; */
  588.       /*       nextHop = nHop; */
  589.       /*       switch(TOS_LOCAL_ADDRESS){ */
  590.       /*       case 1: */
  591.       /*         ownSlot = 6; */
  592.       /*         break; */
  593.       /*       case 10: */
  594.       /*         ownSlot = 4; */
  595.       /*         break; */
  596.       /*       case 11: */
  597.       /*         ownSlot = 0; */
  598.       /*         break; */
  599.       /*       case 13: */
  600.       /*         ownSlot = 1; */
  601.       /*         break; */
  602.       /*       case 2: */
  603.       /*         ownSlot = 1; */
  604.       /*         break; */
  605.       /*       case 20: */
  606.       /*         ownSlot = 1; */
  607.       /*         break; */
  608.       /*       case 21: */
  609.       /*         ownSlot = 2; */
  610.       /*         break; */
  611.       /*       case 22: */
  612.       /*         ownSlot = 7; */
  613.       /*         break; */
  614.       /*       case 24: */
  615.       /*         ownSlot = 0; */
  616.       /*         break; */
  617.       /*       case 0: */
  618.       /*         ownSlot = 5; */
  619.       /*         break; */
  620.       /*       case 8: */
  621.       /*         ownSlot = 2; */
  622.       /*         break; */
  623.       /*       case 9: */
  624.       /*         ownSlot = 3; */
  625.       /*         break; */
  626.       /*       } */
  627.       //    }
  628. #endif
  630.     localFrameSize = localFrameLength * slotSize;
  631.     globalFrameSize = globalFrameLength * slotSize;
  632.     slotMultiplier = (uint16_t) (slotSize * 1.024);
  634.     call SClock.getTime(&loctime);
  635.     globalTimeStamp = (uint32_t)(loctime.mticks * 568.889 + loctime.sticks * 0.00868056); //in ms
  636.     slotOffset = (uint32_t) (1.024 * (slotSize - (globalTimeStamp % slotSize))); // in timer units .976562 = 1000/1024
  637.     slotNum = (uint32_t) (globalTimeStamp/slotSize);
  638.     currentSlot = slotNum & (localFrameLength - 1);
  639.     globalSlot = slotNum & (globalFrameLength - 1);
  640.     
  641.     call TDMATimer.start(TIMER_ONE_SHOT, slotOffset);
  642. #ifdef ZMAC_TIMER
  643.     // SODbg(DBG_USR2,"Started timer slotsize - offset is %in",slotSize - slotOffset);
  644. #endif
  645.     return SUCCESS; 
  646.   }
  648.   command result_t StdControl.init() {
  649.     char i;
  650.     ecnMsgType *ecnMsgPtr = (ecnMsgType *) ecnMsgHdr.data;
  651.     syncMsgType* syncMsgPtr;
  652.     atomic {
  653.       RadioState = DISABLED_STATE;
  654.       RadioTxState = TXSTATE_PREAMBLE;
  655.       rxbufptr = &RxBuf;
  656.       rxbufptr->length = 0;
  657.       rxlength = MSG_DATA_SIZE-2;
  658.       RxBitOffset = 0;
  659.       iSquelchCount = 0;
  660.       
  661.       PreambleCount = 0;
  662.       RSSISampleFreq = 0;
  663.       RxShiftBuf.W = 0;
  664.       iRSSIcount = 0;
  665.       bTxPending = FALSE;
  666.       bTxBusy = FALSE;
  667.       bRSSIValid = FALSE;
  668.       bAckEnable = FALSE; // to test for ECN only
  669.       bCCAEnable = TRUE;
  670.       CC1K_PulseLevel = 300;
  671.       sMacDelay = -1;
  672.       usRSSIVal = -1;
  673.       usSquelchIndex = 0;
  674.       pulse_check_count = 0;
  675.       lplpower =  0;//0x87;
  676.       RSSIInitState = NULL_STATE;
  677.       //      if(TOS_LOCAL_ADDRESS == 0) lplpower = 0;
  678.       //      lplpowertx = 7;
  679.       usSquelchVal = CC1K_SquelchInit;
  681.       currentMAC = BMAC;
  682.       congBackOffs = 0;
  683.       packetsSent = 0;
  684.       pktsLastSync = 0;
  685.       avgLoss = 0.0;
  686.       curHCLlist = 0;
  687.       globalFrameLength = GLOBAL_FRAME_LENGTH;
  689.       localFrameLength = GLOBAL_FRAME_LENGTH;
  690.       slotSize = 50;
  691.       localFrameSize = localFrameLength * slotSize;
  692.       globalFrameSize = globalFrameLength * slotSize;
  694.       ackOrig = bAckEnable;
  695.       ecnPending = FALSE;
  696.       ecnforward = FALSE;
  698.       enableHCL = FALSE; // ecn flag, set if currently ecn is going on ...
  699.       pureHCL = FALSE;
  700.       HCLselect = SELECTHCL;
  701.       needTimeSync = FALSE;
  703.       slots_since_ecnsend = 0;
  704.       slots_since_ecnrecv = 0;
  705.       slots_since_ecncheck = 0;
  707.       ecnMsgHdr.type = ECNTYPE;  //set ecnMsg headers
  708.       ecnMsgHdr.addr = TOS_BCAST_ADDR; //ECN Indicator;
  709.       ecnMsgHdr.length = sizeof(ecnMsgType);
  710.       ecnMsgHdr.group = 125;
  711.       ecnMsgHdr.crc = 0;
  713.       ecnForwardMsgHdr.type = ECNTYPE;
  714.       ecnForwardMsgHdr.addr = TOS_BCAST_ADDR; 
  715.       ecnForwardMsgHdr.length = sizeof(ecnMsgType);
  716.       ecnForwardMsgHdr.group = 125;
  717.       ecnForwardMsgHdr.crc = 0;
  719.       syncMsgPtr = (syncMsgType *) syncMsgHdr.data;
  720.       syncMsgPtr->trust = 1;
  721.       syncMsgPtr->sender = TOS_LOCAL_ADDRESS;
  722.       syncMsgHdr.type = SYNCTYPE;  //set syncMsg headers
  723.       syncMsgHdr.addr = TOS_BCAST_ADDR; //SYNC Indicator;
  724.       syncMsgHdr.length = sizeof(syncMsgType);
  725.       syncMsgHdr.group = 125;
  726.       syncMsgHdr.crc = 0;
  728.       ecnMsgPtr->hopCount = 0; //hopcount
  729.       ecnMsgPtr->nextHop = nextHop; //parent node
  730.       ecnMsgPtr->senderAddress = TOS_LOCAL_ADDRESS;
  731.     }
  733.     for (i = 0; i < CC1K_SquelchTableSize; i++)
  734.       usSquelchTable[(int)i] = CC1K_SquelchInit;
  736.     call SpiByteFifo.initSlave(); // set spi bus to slave mode
  737.    
  738.     call CC1000StdControl.init();
  739.     call CC1000Control.SelectLock(0x9); // Select MANCHESTER VIOLATION
  740.     bInvertRxData = call CC1000Control.GetLOStatus();
  742.     call ADCControl.bindPort(TOS_ADC_CC_RSSI_PORT,TOSH_ACTUAL_CC_RSSI_PORT);
  743.     call ADCControl.init();
  744.     
  745.     call Random.init();
  746.     call TimerControl.init();
  748. #ifdef ZMAC_DEBUG
  749.     init_debug();
  750. #endif
  751.     LocalAddr = TOS_LOCAL_ADDRESS;
  753.     return SUCCESS;
  754.   }
  755.   
  756.   /**
  757.    * Get the current Low Power Listening transmit mode
  758.    * @return mode number (see SetListeningMode)
  759.    */
  760.   async command uint8_t LowPowerListening.GetTransmitMode() {
  761.     return lplpowertx;
  762.   }
  763.   // legacy support
  764.   async command uint8_t GetTransmitMode() {
  765.     return call LowPowerListening.GetTransmitMode();
  766.   }
  768.   /**
  769.    * Set the transmit mode.  This allows for hybrid schemes where
  770.    * the transmit mode is different than the receive mode.
  771.    * Use SetListeningMode first, then change the mode with SetTransmitMode.
  772.    *
  773.    * @param mode mode number (see SetListeningMode)
  774.    * @return SUCCESS if the mode was successfully changed
  775.    */
  776.   async command result_t LowPowerListening.SetTransmitMode(uint8_t power) {
  777.     if ((power >= CC1K_LPL_STATES) || (power == lplpowertx))
  778.       return FAIL;
  780.     // check if the radio is currently doing something
  781.     if ((!bTxPending) && ((RadioState == POWER_DOWN_STATE) || 
  782.                           (RadioState == IDLE_STATE) ||
  783.                           (RadioState == DISABLED_STATE))) {
  785.       atomic {
  786.         lplpowertx = power;
  787.         preamblelen = ((PRG_RDB(&CC1K_LPL_PreambleLength[lplpowertx*2]) << 8)
  788.                        | PRG_RDB(&CC1K_LPL_PreambleLength[(lplpowertx*2)+1]));
  789.       }
  790.       return SUCCESS;
  791.     }
  792.     return FAIL;
  793.   }
  794.   // legacy support
  795.   async command result_t SetTransmitMode(uint8_t power) {
  796.     return call LowPowerListening.SetTransmitMode(power);
  797.   }
  799.   /**
  800.    * Set the current Low Power Listening mode.
  801.    * Setting the LPL mode sets both the check interval and preamble length.
  802.    *
  803.    * Modes include:
  804.    *  0 = Radio full on
  805.    *  1 = 10ms check interval
  806.    *  2 = 25ms check interval
  807.    *  3 = 50ms check interval
  808.    *  4 = 100ms check interval (recommended)
  809.    *  5 = 200ms check interval
  810.    *  6 = 400ms check interval
  811.    *  7 = 800ms check interval
  812.    *  8 = 1600ms check interval
  813.    *
  814.    * @param mode the mode number
  815.    * @return SUCCESS if the mode was successfully changed
  816.    */
  817.   async command result_t LowPowerListening.SetListeningMode(uint8_t power) {
  818.     // valid low power listening values are 0 to 8
  819.     // 0 is "always on" and 8 is lowest duty cycle
  820.     if ((power >= CC1K_LPL_STATES) || (power == lplpower))
  821.       return FAIL;
  823.     // check if the radio is currently doing something
  824.     if ((!bTxPending) && ((RadioState == POWER_DOWN_STATE) || 
  825.                           (RadioState == IDLE_STATE) ||
  826.                           (RadioState == DISABLED_STATE))) {
  828.       // change receiving function in CC1000Radio
  829.       call WakeupTimer.stop();
  830.       atomic {
  831.         if (lplpower == lplpowertx) {
  832.           lplpowertx = power;
  833.         }
  834.         lplpower = power;
  835.       }
  837.       // if successful, change power here
  838.       if (RadioState == IDLE_STATE) {
  839.         RadioState = DISABLED_STATE;
  840.         call StdControl.stop();
  841.         call StdControl.start();
  842.       }
  843.       if (RadioState == POWER_DOWN_STATE) {
  844.         RadioState = DISABLED_STATE;
  845.         call StdControl.start();
  846.         call PowerManagement.adjustPower();
  847.       }
  848.     }
  849.     else {
  850.       return FAIL;
  851.     }
  852.     return SUCCESS;
  853.   }
  854.   // legacy support
  855.   async command result_t SetListeningMode(uint8_t power) {
  856.     return call SetListeningMode(power);
  857.   }
  859.   /**
  860.    * Gets the state of low power listening on the chipcon radio.
  861.    * @return Current low power listening state value
  862.    */
  863.   async command uint8_t LowPowerListening.GetListeningMode() {
  864.     return lplpower;
  865.   }
  866.   // legacy support
  867.   async command uint8_t GetListeningMode() {
  868.     return call LowPowerListening.GetListeningMode();
  869.   } 
  871.   /**
  872.    * Set the preamble length of outgoing packets
  873.    *
  874.    * @param bytes length of the preamble in bytes
  875.    * @return SUCCESS if the preamble length was successfully changed
  876.    */
  877.   async command result_t LowPowerListening.SetPreambleLength(uint16_t bytes) {
  878.     result_t result = FAIL;
  879.     atomic {
  880.       if (RadioState != TX_STATE) {
  881.         preamblelen = bytes;
  882.         result = SUCCESS;
  883.       }
  884.     }
  885.     return result;
  886.   }
  888.   /**
  889.    * Get the preamble length of outgoing packets
  890.    *
  891.    * @return length of the preamble in bytes
  892.    */
  893.   async command uint16_t LowPowerListening.GetPreambleLength() {
  894.     return preamblelen;
  895.   }
  897.   /**
  898.    * Set the check interval (time between waking up and sampling
  899.    * the radio for activity in low power listening)
  900.    *
  901.    * @param ms check interval in milliseconds
  902.    * @return SUCCESS if the check interval was successfully changed
  903.    */
  904.   async command result_t LowPowerListening.SetCheckInterval(uint16_t ms) {
  905.     // sleep time will go into effect after the next wakeup time
  906.     atomic sleeptime = ms;
  907.     return SUCCESS;
  908.   }
  910.   /**
  911.    * Get the check interval currently used by low power listening
  912.    *
  913.    * @return length of the check interval in milliseconds
  914.    */
  915.   async command uint16_t LowPowerListening.GetCheckInterval() {
  916.     return sleeptime;
  917.   }
  920.   event result_t SquelchTimer.fired() {
  921.     char currentRadioState;
  922.     atomic currentRadioState = RadioState;
  924.     if (currentRadioState == IDLE_STATE) {
  925.       atomic RSSIInitState = currentRadioState;
  926.       call RSSIADC.getData();
  927.     }
  928.     return SUCCESS;
  929.   }
  931.   event result_t WakeupTimer.fired() {
  932.     uint8_t currentRadioState;
  934.     if (lplpower == 0)
  935.       return SUCCESS;
  936.     
  937.     atomic currentRadioState = RadioState;
  938.     switch(currentRadioState) {
  940.     case IDLE_STATE:
  941.       if (!bTxPending) {
  942.         atomic {
  943.           RadioState = POWER_DOWN_STATE;
  944.           call SpiByteFifo.disableIntr();
  945.         }
  946.         call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  947.         call SquelchTimer.stop();
  948.         call CC1000StdControl.stop();
  949.       } else {
  950.         call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  951.       }
  952.       break;
  954.     case POWER_DOWN_STATE:
  955.       atomic RadioState = PULSE_CHECK_STATE;
  956.       pulse_check_count = 0;
  957.       call CC1000StdControl.start();
  958.       call CC1000Control.BIASOn();
  959.       call WakeupTimer.start(TIMER_ONE_SHOT, 1);
  960.       return SUCCESS;
  961.       break;
  963.     case PULSE_CHECK_STATE:
  964.       call CC1000Control.RxMode();
  965.       if(!(call RSSIADC.getData())){
  966.         call WakeupTimer.start(TIMER_ONE_SHOT, TIME_BETWEEN_CHECKS);
  967.         atomic RadioState = POWER_DOWN_STATE;
  968.       }
  969.       else {
  970.         TOSH_uwait(80);
  971.       }
  972.       call CC1000StdControl.stop();
  973.       pulse_check_sum ++;
  974.       break;
  976.     default:
  977.       call WakeupTimer.start(TIMER_ONE_SHOT, 5);
  978.     }
  979.     return SUCCESS;
  980.   }
  982.   //added by Mahesh
  984.   event result_t TDMATimer.fired(){
  985.     call TDMATimer.start(TIMER_ONE_SHOT, slotMultiplier);
  986.     slotNum++;
  987.     atomic currentMAC = ZMAC;
  988.     atomic{
  989.       currentSlot = slotNum & (localFrameLength - 1);
  990.       globalSlot = slotNum & (globalFrameLength - 1);
  991. #ifdef ZMAC_TIMER
  992.       SODbg(DBG_USR2,"*************Timer fired with current slot = %u, own slot = %un", currentSlot, ownSlot);
  993. #endif 
  994.       if(HCLselect){
  995.         slots_since_ecnsend ++;
  996.         slots_since_ecnrecv ++;
  997.         slots_since_ecncheck++;
  998.         if((packetsSent > ECNMINPACKETS) && (slots_since_ecncheck >= ECNCHECKPERIOD)){
  999.           double currentLoss = (double)congBackOffs/packetsSent;
  1000.           avgLoss = ALPHA * (currentLoss) + (1 - ALPHA) * avgLoss;
  1001. #ifdef ZMAC_ECN
  1002.           SODbg(DBG_USR2,"#####################Congestion Statistics: %i / %i, %in", congBackOffs, packetsSent, (uint16_t) avgLoss);
  1003. #endif
  1004.           slots_since_ecncheck = 0;
  1005.           congBackOffs = 0;
  1006.           packetsSent = 0;
  1007.           if((avgLoss > ECNTHRESHOLD) && (slots_since_ecnsend >= ECNSENDPERIOD)){
  1008.             ecnMsgType *ecnMsgPtr = (ecnMsgType *) ecnMsgHdr.data;
  1009. #ifdef ZMAC_ECN
  1010.             SODbg(DBG_USR2,"Setting ECN flagn");
  1011. #endif
  1012.             // change by acw, go to ecn myself if sending ecn
  1013.             atomic enableHCL = TRUE;
  1014.             slots_since_ecnrecv = 0;
  1015.             // change by acw ends
  1017.             ecnMsgPtr->nextHop = nextHop;
  1018.             if(!pureHCL)
  1019.               ecnPending = TRUE;
  1020.           }
  1021.         }
  1022.         if((enableHCL) && (slots_since_ecnrecv >= ECNEXPIREPERIOD)){
  1023.           if(!pureHCL)
  1024.             enableHCL = FALSE;
  1025. #ifdef ZMAC_ECN
  1026.           SODbg(DBG_USR2,"ECN expired, into LCL againn");
  1027. #endif
  1028.         }
  1029.         
  1030. #ifdef ZMAC_ECN
  1031.         if(enableHCL)
  1032.           SODbg(DBG_USR2,"Current slot %i **********************n",currentSlot);
  1033. #endif
  1034. #ifdef ZMAC_ECN
  1035.         if(enableHCL && IsHCL(globalSlot) && ownSlot != currentSlot)
  1036.           SODbg(DBG_USR2,"***** ****** ****** ****** Current slot %i HCLn",currentSlot);
  1037. #endif
  1038.       }
  1040.       if(bTxPending){
  1041.         sMacDelay = getZMACBackoff(sMacDelay);
  1042. #ifdef ZMAC_BACKOFF
  1043.         SODbg(DBG_USR2,"TDMATimerFired: backoff %un", sMacDelay);
  1044. #endif
  1045.       }
  1046.     }
  1047.     return SUCCESS;
  1048.   }
  1049.  
  1050.   command result_t StdControl.stop() {
  1051.     atomic RadioState = DISABLED_STATE;
  1053.     call SquelchTimer.stop();
  1054.     call WakeupTimer.stop();
  1055.     call CC1000StdControl.stop();
  1056.     call SpiByteFifo.disableIntr(); // disable spi interrupt
  1057.     return SUCCESS;
  1058.   }
  1060.   command result_t StdControl.start() {
  1061.     uint8_t currentRadioState;
  1062.     atomic currentRadioState = RadioState;
  1064.     call SClock.SetRate(MAX_VAL,CLK_DIV_64);
  1065.     if (currentRadioState == DISABLED_STATE) {
  1066.       atomic {
  1067.         rxbufptr->length = 0;
  1068.         RadioState  = IDLE_STATE;
  1069.         bTxPending = bTxBusy = FALSE;
  1070.         sMacDelay = -1;
  1071.         if(SLEEPTIME > 0){
  1072.           sleeptime = SLEEPTIME;
  1073.           preamblelen = PREAMBLELEN;
  1074.         } else{
  1075.           lplpower = lplpowertx = 0;
  1076.           sleeptime = ((PRG_RDB(&CC1K_LPL_SleepTime[lplpower*2]) << 8) |
  1077.                        PRG_RDB(&CC1K_LPL_SleepTime[(lplpower*2)+1]));
  1078.           preamblelen = ((PRG_RDB(&CC1K_LPL_PreambleLength[lplpowertx*2]) << 8) |
  1079.                          PRG_RDB(&CC1K_LPL_PreambleLength[(lplpowertx*2)+1]));
  1080.         }
  1081. /*         sleeptime = ((PRG_RDB(&CC1K_LPL_SleepTime[lplpower*2]) << 8) | */
  1082. /*                      PRG_RDB(&CC1K_LPL_SleepTime[(lplpower*2)+1])); */
  1083. /*         preamblelen = ((PRG_RDB(&CC1K_LPL_PreambleLength[lplpowertx*2]) << 8) | */
  1084. /*                        PRG_RDB(&CC1K_LPL_PreambleLength[(lplpowertx*2)+1])); */
  1085.       }
  1086.       // all power on, captain!
  1087.       rxbufptr->length = 0;
  1088.       atomic RadioState = IDLE_STATE;
  1089.       call CC1000StdControl.start();
  1090.       call CC1000Control.BIASOn();
  1091.       call SpiByteFifo.rxMode(); // SPI to miso
  1092.       call CC1000Control.RxMode();
  1093.       if (iSquelchCount > CC1K_SquelchCount)
  1094.         call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  1095.       else
  1096.         call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  1097.       call SpiByteFifo.enableIntr(); // enable spi interrupt
  1098.       if (lplpower > 0) {
  1099.         // set a time to start sleeping after measuring the noise floor
  1100.         call WakeupTimer.start(TIMER_ONE_SHOT, CC1K_SquelchIntervalSlow);
  1101.       }
  1102.     }
  1103.     return SUCCESS;
  1104.   }
  1106.   command result_t Send.send(TOS_MsgPtr pMsg) {
  1107.     result_t Result = SUCCESS;
  1108.     uint8_t currentRadioState = 0;
  1109.    
  1110.     atomic {
  1111.       if (bTxBusy) {
  1112.         Result = FAIL;
  1113. #ifdef ZMAC_DEBUG
  1114.         //        SODbg(DBG_USR2, "Busy sending the message of type %u!n", txbufptr->type);
  1115. #endif
  1116.       } else {
  1117.         bTxBusy = TRUE;
  1118.         txbufptr = pMsg;
  1119.         txlength = pMsg->length + (MSG_DATA_SIZE - DATA_LENGTH - 2);
  1121.         if(bCCAEnable){ // initially back off [1,32] bytes (approx 2/3 packet)
  1122.           if(currentMAC == BMAC)
  1123.             sMacDelay = signal MacBackoff.initialBackoff(pMsg);
  1124.           else
  1125.             sMacDelay = getZMACBackoff(0);
  1126.         } else
  1127.           sMacDelay = 0;
  1128. #ifdef ZMAC_BACKOFF
  1129.         SODbg(DBG_USR2, "SendMSG(): Need to send type %u, myslot %u, current slot %u backoff %un",
  1130.               txbufptr->type, ownSlot, currentSlot, sMacDelay);
  1131. #endif
  1132.         bTxPending = TRUE;
  1133.       }
  1134.       currentRadioState = RadioState;
  1135.     }
  1137.     if (Result) {
  1138.       if (currentRadioState == POWER_DOWN_STATE) {       // if we're off, start the radio
  1139.         atomic RadioState = IDLE_STATE;         // disable wakeup timer
  1140.         call WakeupTimer.stop();
  1141.         call CC1000StdControl.start();
  1142.         call CC1000Control.BIASOn();
  1143.         call CC1000Control.RxMode();
  1144.         call SpiByteFifo.rxMode(); // SPI to miso
  1145.         call SpiByteFifo.enableIntr(); // enable spi interrupt
  1146.         if (iSquelchCount > CC1K_SquelchCount)
  1147.           call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  1148.         else
  1149.           call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  1150.         call WakeupTimer.start(TIMER_ONE_SHOT, CC1K_LPL_PACKET_TIME*2);
  1151.       }
  1152.     }
  1153.     return Result;
  1154.   }
  1155.   
  1156.   /**********************************************************
  1157.    * make a spibus interrupt handler
  1158.    * needs to handle interrupts for transmit delay
  1159.    * and then go into byte transmit mode with
  1160.    *   timer1 baudrate delay as interrupt handler
  1161.    * else SODbg(DBG_USR2,"Sending Packet ..");
  1162.    * needs to handle interrupts for byte read and detect preamble
  1163.    *  then handle reading a packet
  1164.    * PB - We can use this interrupt handler as a transmit scheduler
  1165.    * because the CC1000 continuously clocks in data, regarless
  1166.    * of whether it's good or not.  Thus, this routine will be called
  1167.    * on every 8 ticks of DCLK. 
  1168.    **********************************************************/
  1170.   async event result_t SpiByteFifo.dataReady(uint8_t data_in) {
  1171.     GTime loctime;
  1172.     signal RadioSendCoordinator.blockTimer();
  1173.     signal RadioReceiveCoordinator.blockTimer();
  1174.      
  1175.     if (bInvertRxData)
  1176.       data_in = ~data_in;
  1177. #ifdef ENABLE_UART_DEBUG
  1178.     UARTPutChar(RadioState);
  1179. #endif
  1180.     switch (RadioState) {
  1182.     case TX_STATE:
  1183.       {
  1184.         call SpiByteFifo.writeByte(NextTxByte);
  1185.         TxByteCnt++;
  1186.         switch (RadioTxState) {
  1187.           
  1188.         case TXSTATE_PREAMBLE:
  1189.           send_sum ++;
  1190.           if (!(TxByteCnt < preamblelen)||
  1191.               (txbufptr->strength == 0xffff && TxByteCnt >= PREAMBLE_LENGTH_TO_BASE)) {
  1192.             NextTxByte = SYNC_BYTE;
  1193.             RadioTxState = TXSTATE_SYNC;
  1194. #ifdef ZMAC_ECN
  1195.             SODbg(DBG_USR2,"Sent packet in slot %in",currentSlot);
  1196.             SODbg(DBG_USR2, "ishcl = %un", IsHCL(currentSlot));
  1197. #endif
  1198.           }
  1199.           break;
  1201.         case TXSTATE_SYNC:
  1202.           send_sum ++;
  1203.           NextTxByte = NSYNC_BYTE;
  1204.           RadioTxState = TXSTATE_DATA;
  1205.           TxByteCnt = -1;
  1206.           // for Time Sync services
  1207.           signal RadioSendCoordinator.startSymbol(8, 0, txbufptr);
  1208.           break;
  1210.         case TXSTATE_DATA:
  1211.           send_sum ++;
  1212.           if ((uint8_t)(TxByteCnt) < txlength){
  1213.             if((txbufptr->type == SYNCTYPE) && (TxByteCnt == 5)){ // 5 = offset of timestamp
  1214.               syncMsgType *syncMsgPtr = (syncMsgType *) txbufptr->data;
  1215.               call SClock.getTime(&loctime);
  1216.               AddTime(&loctime, &loctime, &constOffset);
  1217.               syncMsgPtr->mticks = loctime.mticks;
  1218.               syncMsgPtr->sticks = loctime.sticks;
  1219.             }
  1220.             NextTxByte = ((uint8_t *)txbufptr)[(TxByteCnt)];
  1221.             usRunningCRC = crcByte(usRunningCRC,NextTxByte);
  1222.             signal RadioSendCoordinator.byte(txbufptr, (uint8_t)TxByteCnt); // Time Sync
  1223.           }
  1224.           else {
  1225.             NextTxByte = (uint8_t)(usRunningCRC);
  1226.             RadioTxState = TXSTATE_CRC;
  1227.           }
  1228.           break;
  1230.         case TXSTATE_CRC:
  1231.           send_sum ++;
  1232.           NextTxByte = (uint8_t)(usRunningCRC>>8);
  1233.           RadioTxState = TXSTATE_FLUSH;
  1234.           TxByteCnt = 0;
  1235.           break;
  1237.         case TXSTATE_FLUSH:
  1238.           send_sum ++;
  1239.           if (TxByteCnt > 3) {
  1240.             TxByteCnt = 0;
  1241. #ifdef ZMAC_DEBUG
  1242.             // SODbg(DBG_USR2,"Came heren");
  1243. #endif
  1244.             if (bAckEnable)
  1245.               RadioTxState = TXSTATE_WAIT_FOR_ACK;         
  1246.             else {
  1247. #ifdef ZMAC_DEBUG
  1248.               // SODbg(DBG_USR2,"came inside: current MAC: %i ackenabled :%i,ecnPending: %i ecnforward %i ecnSENT %in",currentMAC,bAckEnable,ecnPending,ecnforward,sentECN);
  1249. #endif
  1250.               packetsSent ++;
  1251.               call SpiByteFifo.rxMode();
  1252.               call CC1000Control.RxMode();
  1253.               RadioTxState = TXSTATE_DONE;
  1254.             }
  1255.           }
  1256.           break;
  1258.         case TXSTATE_WAIT_FOR_ACK:
  1259.           if(TxByteCnt == 1){
  1260.             send_sum ++;
  1261.             call SpiByteFifo.rxMode();
  1262.             call CC1000Control.RxMode();
  1263.             break;
  1264.           }
  1265.           receive_sum ++;
  1266.           if (TxByteCnt > 3) {
  1267.             RadioTxState = TXSTATE_READ_ACK;
  1268.             TxByteCnt = 0;
  1269.             search_word = 0;
  1270.           }
  1271.           break;
  1273.         case TXSTATE_READ_ACK:
  1274.           {
  1275.             uint8_t i;
  1276.             receive_sum ++;
  1277.             for(i = 0; i < 8; i ++){
  1278.               search_word <<= 1;
  1279.               if(data_in & 0x80) search_word |=  0x1;
  1280.               data_in <<= 1;
  1281.               if (search_word == 0xba83){
  1282.                 txbufptr->ack = 1;
  1283.                 RadioTxState = TXSTATE_DONE;
  1284. #ifdef ZMAC_DEBUG
  1285.                 //                SODbg(DBG_USR2,"received ackn");
  1286. #endif
  1287.                 return SUCCESS;
  1288.               }
  1289.             }
  1290.           }
  1291.           if(TxByteCnt >= MAX_ACK_WAIT){   
  1292.             txbufptr->ack = 0;  
  1293. #ifdef ZMAC_DEBUG
  1294.             //       SODbg(DBG_USR2,"did not receive ack %i %i %in",lostacks,packetsSent,avgLoss * 100);
  1295. #endif
  1296.             RadioTxState = TXSTATE_DONE;
  1297.           }
  1298.           break;
  1300.         case TXSTATE_DONE:
  1301.         default:
  1302.           bTxPending = FALSE;
  1303.           if((txbufptr->type == ECNTYPE) || (txbufptr->type == SYNCTYPE)){
  1304. #ifdef ZMAC_ECN
  1305.             ecnForwardMsgType *ecnForwardMsgPtr = (ecnForwardMsgType *) txbufptr->data;
  1306.             if(txbufptr->type == ECNTYPE && ecnForwardMsgPtr->hopCount == 1)
  1307.               SODbg(DBG_USR2,"Successfully forwarded ECNn");
  1308. #endif
  1309.             bAckEnable = ackOrig;
  1310.           }
  1311. #ifdef ZMAC_BACKOFF
  1312.           SODbg(DBG_USR2, "Sent one packet of type %u, myslot %u, current slot %u!n", txbufptr->type,
  1313.                 ownSlot, currentSlot);
  1314. #endif
  1315.           if(post PacketSent()) {
  1316.             // If the post operation succeeds, goto Idle
  1317.             // otherwise, we'll try again.
  1318. #ifdef ZMAC_DEBUG
  1319.             //  SODbg(DBG_USR2,"Packet type %in",txbufptr->type);
  1320. #endif
  1321.             RadioState = IDLE_STATE;
  1322.             pktsLastSync++;
  1323.             RSSIInitState = RadioState;
  1324.             call RSSIADC.getData();
  1325.           }
  1326.           break;
  1327.         }
  1328.       }
  1329.       break;
  1331.     case DISABLED_STATE:
  1332.       break;
  1334.     case IDLE_STATE: 
  1335.       {
  1336.         receive_sum ++;
  1337.         if (((data_in == (0xaa)) || (data_in == (0x55)))) {
  1338.           PreambleCount++;
  1339.           if (PreambleCount > CC1K_ValidPrecursor) {
  1340.             PreambleCount = SOFCount = 0;
  1341.             RxBitOffset = RxByteCnt = 0;
  1342.             usRunningCRC = 0;
  1343.             rxlength = MSG_DATA_SIZE-2;
  1344.             RadioState = SYNC_STATE;
  1345.           }
  1346.         } else {
  1347.           if ((currentMAC == BMAC) || (enableHCL == FALSE) || (!IsHCL(currentSlot))) {
  1348.             if((bTxPending) && (--sMacDelay <= 0)){
  1349.               RadioState = PRETX_STATE;
  1350.               RSSIInitState = PRETX_STATE;
  1351.               bRSSIValid = FALSE;
  1352.               iRSSIcount = 0;
  1353.               PreambleCount = 0;
  1354.               call RSSIADC.getData();
  1355.             }
  1356.           } else{
  1357. #ifdef ZMAC_ECN
  1358.             SODbg(DBG_USR2, "&&&&&&&&&&&&&&&&&&&&& ishcl = %un", IsHCL(currentSlot));
  1359. #endif
  1360.           }
  1361.         }
  1362.       }
  1363.       break;
  1365.     case PRETX_STATE:
  1366.       {
  1367.         receive_sum ++;
  1368.         if (((data_in == (0xaa)) || (data_in == (0x55)))) {
  1369.           // Back to the penalty box.
  1370.           sMacDelay = signal MacBackoff.congestionBackoff(txbufptr);
  1371. #ifdef ZMAC_BACKOFF
  1372.           SODbg(DBG_USR2,"SpiDataReady: detected preamble - backoff %un", sMacDelay);
  1373. #endif
  1374.           RadioState = IDLE_STATE;
  1375.         }
  1376.       }
  1377.       break;
  1379.     case SYNC_STATE:
  1380.       {
  1381.         // draw in the preamble bytes and look for a sync byte
  1382.         // save the data in a short with last byte received as msbyte
  1383.         //    and current byte received as the lsbyte.
  1384.         // use a bit shift compare to find the byte boundary for the sync byte
  1385.         // retain the shift value and use it to collect all of the packet data
  1386.         // check for data inversion, and restore proper polarity 
  1387.         // XXX-PB: Don't do this.
  1388.         uint8_t i;
  1390.         receive_sum ++;
  1391.         if ((data_in == 0xaa) || (data_in == 0x55)) {
  1392.           // It is actually possible to have the LAST BIT of the incoming
  1393.           // data be part of the Sync Byte.  SO, we need to store that
  1394.           // However, the next byte should definitely not have this pattern.
  1395.           // XXX-PB: Do we need to check for excessive preamble?
  1396.           RxShiftBuf.MSB = data_in;
  1397.         }
  1398.         else {
  1399.           // TODO: Modify to be tolerant of bad bits in the preamble...
  1400.           uint16_t usTmp;
  1401.           switch (SOFCount) {
  1402.           case 0:
  1403.             RxShiftBuf.LSB = data_in;
  1404.             break;
  1405.   
  1406.           case 1:
  1407.           case 2: 
  1408.           case 3: 
  1409.           case 4: 
  1410.           case 5: 
  1411.             // bit shift the data in with previous sample to find sync
  1412.             usTmp = RxShiftBuf.W;
  1413.             RxShiftBuf.W <<= 8;
  1414.             RxShiftBuf.LSB = data_in;
  1416.             for(i=0;i<8;i++) {
  1417.               usTmp <<= 1;
  1418.               if(data_in & 0x80)
  1419.                 usTmp  |=  0x1;
  1420.               data_in <<= 1;
  1421.               // check for sync bytes
  1422.               if (usTmp == SYNC_WORD) {
  1423.                 if (rxbufptr->length !=0) {
  1424.                   call Leds.redToggle();
  1425.                   RadioState = IDLE_STATE;
  1426.                 }
  1427.                 else {
  1428.                   RadioState = RX_STATE;
  1429.                   RSSIInitState = RX_STATE;
  1430.                   call RSSIADC.getData();
  1431.                   RxBitOffset = 7-i;
  1432.                   // For time sync services
  1433.                   signal RadioReceiveCoordinator.startSymbol(8, RxBitOffset, rxbufptr); 
  1434.                 }
  1435.                 break;
  1436.               }
  1437.             }
  1438.             break;
  1440.           default:
  1441.             // We didn't find it after a reasonable number of tries, so....
  1442.             RadioState = IDLE_STATE;  // Ensures we wait till the end of the transmission
  1443.             break;
  1444.           }
  1445.           SOFCount++;
  1446.         }
  1447.       }
  1448.       break;
  1449.       //  collect the data and shift into double buffer
  1450.       //  shift out data by correct offset
  1451.       //  invert the data if necessary
  1452.       //  stop after the correct packet length is read
  1453.       //  return notification to upper levels
  1454.       //  go back to idle state
  1455.     case RX_STATE:
  1456.       {
  1457.         char Byte;
  1458.         receive_sum ++;
  1460.         RxShiftBuf.W <<=8;
  1461.         RxShiftBuf.LSB = data_in;
  1463.         Byte = (RxShiftBuf.W >> RxBitOffset);
  1464.         ((char*)rxbufptr)[(int)RxByteCnt] = Byte;
  1465.         RxByteCnt++;
  1467.         signal RadioReceiveCoordinator.byte(rxbufptr, (uint8_t)RxByteCnt);
  1469.         if (RxByteCnt < rxlength) {
  1470.           usRunningCRC = crcByte(usRunningCRC,Byte);
  1472.           if (RxByteCnt == (offsetof(struct TOS_Msg,length) + 
  1473.                             sizeof(((struct TOS_Msg *)0)->length))) {
  1474.             rxlength = rxbufptr->length;
  1475.             if (rxlength > TOSH_DATA_LENGTH) {
  1476.               // The packet's screwed up, so just dump it
  1477.               rxbufptr->length = 0;
  1478.               RadioState = IDLE_STATE;  // Waits till end of transmission
  1479.               return SUCCESS;
  1480.             }
  1481.             //Add in the header size
  1482.             rxlength += offsetof(struct TOS_Msg,data);
  1483.           }
  1484.         }
  1485.         else if (RxByteCnt == rxlength) {
  1486.           if(rxbufptr->type == SYNCTYPE) // got all bytes of time stamp !
  1487.             getTimeDiff();
  1488.           usRunningCRC = crcByte(usRunningCRC,Byte);
  1489.           // Shift index ahead to the crc field.
  1490.           RxByteCnt = offsetof(struct TOS_Msg,crc);
  1491.         }
  1492.         else if (RxByteCnt >= MSG_DATA_SIZE) { 
  1494.           // Packet filtering based on bad CRC's is done at higher layers.
  1495.           // So sayeth the TOS weenies.
  1496.           if (rxbufptr->crc == usRunningCRC) {
  1497.             if(rxbufptr->type == SYNCTYPE)
  1498.               post adjustTime();
  1499.             rxbufptr->crc = 1;
  1500.             
  1501.             if(bAckEnable && (rxbufptr->addr == TOS_LOCAL_ADDRESS)){
  1503.               RadioState = SENDING_ACK; 
  1504.               call CC1000Control.TxMode();
  1505.               call SpiByteFifo.txMode();
  1506.               call SpiByteFifo.writeByte(0xaa);
  1507.               RxByteCnt = 0;
  1508.               return SUCCESS; 
  1509.             }
  1511.           } else {
  1512.             rxbufptr->crc = 0;
  1513.           }
  1515.           call SpiByteFifo.disableIntr();
  1516.   
  1517.           RadioState = IDLE_STATE; //DISABLED_STATE;
  1518.           if((currentMAC == ZMAC) && (bTxPending)){ //Ajit - reset timer when time slot boundary
  1519.             sMacDelay = getZMACBackoff(sMacDelay);
  1520. #ifdef ZMAC_BACKOFF
  1521.             SODbg(DBG_USR2,"JustAfterReceive: backoff %u mySlot %u currentSlot %un", sMacDelay,
  1522.                   ownSlot, currentSlot);
  1523. #endif
  1524.           }
  1525.           rxbufptr->strength = usRSSIVal;
  1526.           if (!(post PacketRcvd())) {
  1527.             // If there are insufficient resources to process the incoming packet
  1528.             // we drop it
  1529.             rxbufptr->length = 0;
  1530.             RadioState = IDLE_STATE;
  1531.             call SpiByteFifo.enableIntr();
  1532.           }
  1533.           RSSIInitState = RadioState;
  1534.           call RSSIADC.getData();
  1535.         }
  1536.       }
  1537.       break;
  1539.     case SENDING_ACK:
  1540.       {
  1541.         send_sum ++;
  1542.         RxByteCnt++;
  1543.         if (RxByteCnt >= ACK_LENGTH) { 
  1544.           call CC1000Control.RxMode();
  1545.           call SpiByteFifo.rxMode();
  1546.           call SpiByteFifo.disableIntr();
  1547.           RadioState = IDLE_STATE; //DISABLED_STATE;
  1548.           rxbufptr->strength = usRSSIVal;
  1549.           if (!(post PacketRcvd())) {
  1550.             rxbufptr->length = 0;
  1551.             RadioState = IDLE_STATE;
  1552.             call SpiByteFifo.enableIntr();
  1553.           }
  1554.         }else if(RxByteCnt >= ACK_LENGTH - sizeof(ack_code)){
  1555.           call SpiByteFifo.writeByte(ack_code[RxByteCnt + sizeof(ack_code) - ACK_LENGTH]);
  1556.         }
  1557.       }
  1558.       break;
  1560.     default:
  1561.       break;
  1562.     }
  1564.     if(pulse_check_sum > CHECK_MA_COUNT){
  1565.       power_sum ++;
  1566.       sp_sum++;
  1567.       pulse_check_sum -= CHECK_MA_COUNT;
  1568.     }
  1569.     if(send_sum > SEND_MA_COUNT){
  1570.       power_sum ++;
  1571.       tx_sum++;
  1572.       send_sum -= SEND_MA_COUNT;
  1573.     }
  1574.     if(receive_sum > RECEIVE_MA_COUNT){
  1575.       power_sum ++;
  1576.       rx_sum++;
  1577.       receive_sum -= RECEIVE_MA_COUNT;
  1578.     }
  1579.     return SUCCESS;
  1580.   }
  1582.   task void IdleTimerTask(){
  1583.     if (iSquelchCount > CC1K_SquelchCount)
  1584.       call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  1585.     else
  1586.       call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  1587.     call WakeupTimer.start(TIMER_ONE_SHOT, TIME_AFTER_CHECK);
  1588.     /*if(pulse_check_sum > CHECK_MA_COUNT){
  1589.       power_sum ++;
  1590.       pulse_check_sum -= CHECK_MA_COUNT;
  1591.       }
  1592.       if(send_sum > SEND_MA_COUNT){
  1593.       power_sum ++;
  1594.       send_sum -= SEND_MA_COUNT;
  1595.       }
  1596.       if(receive_sum > RECEIVE_MA_COUNT){
  1597.       power_sum ++;
  1598.       receive_sum -= RECEIVE_MA_COUNT;
  1599.       }*/
  1600.   }
  1602.   task void SleepTimerTask(){
  1603.     call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  1604.   }
  1606.   async event result_t RSSIADC.dataReady(uint16_t data) { 
  1607.     atomic{
  1608.       uint8_t currentRadioState;
  1609.       // TOSH_CLR_PW3_PIN();
  1610.       currentRadioState = RadioState;
  1611.       // find the maximum RSSI value over CC1K_MAX_RSSI_SAMPLES
  1612.       switch(currentRadioState) {
  1613.       case IDLE_STATE:
  1614.         if (RSSIInitState == IDLE_STATE) {
  1615.           atomic usTempSquelch = data;
  1616.           post adjustSquelch();
  1617.         }
  1618.         RSSIInitState = NULL_STATE;
  1619.         break;
  1620.           
  1621.       case RX_STATE:
  1622.         if (RSSIInitState == RX_STATE) {
  1623.           atomic usRSSIVal = data;
  1624.         }
  1625.         RSSIInitState = NULL_STATE;
  1626.         break;
  1627.         
  1628.       case PRETX_STATE:
  1629.         iRSSIcount++;
  1630.         
  1631.         // if the channel is clear or CCA is disabled, GO GO GO!
  1632.         if (((data > (usSquelchVal + CC1K_SquelchBuffer)) ||
  1633.              (!bCCAEnable)) && (RSSIInitState == PRETX_STATE)) { 
  1634.           call SpiByteFifo.writeByte(0xaa);
  1635.           call CC1000Control.TxMode();
  1636.           call SpiByteFifo.txMode();
  1637.           
  1638.           usRSSIVal = data;
  1639.           iRSSIcount = CC1K_MaxRSSISamples;
  1640.           bRSSIValid = TRUE;
  1641.           TxByteCnt = 0;
  1642.           usRunningCRC = 0;
  1643.           RadioState = TX_STATE;
  1644.           RadioTxState = TXSTATE_PREAMBLE;
  1645.           NextTxByte = 0xaa;
  1646.           RSSIInitState = NULL_STATE;
  1647.         }
  1648.         else {
  1649.           RSSIInitState = NULL_STATE;
  1650.           if (iRSSIcount == CC1K_MaxRSSISamples) {
  1651.             sMacDelay = signal MacBackoff.congestionBackoff(txbufptr);
  1652. #ifdef ZMAC_BACKOFF
  1653.             SODbg(DBG_USR2,"adcDataReady: channel busy, backoff %un", sMacDelay);
  1654. #endif
  1655.             RadioState = IDLE_STATE;
  1656.           }
  1657.           else {
  1658.             RSSIInitState = currentRadioState;
  1659.             call RSSIADC.getData();
  1660.           }
  1661.         }
  1662.         break;
  1663.         
  1664.       case PULSE_CHECK_STATE:
  1665.         atomic{
  1666.           uint8_t done = 0;
  1667.           uint16_t threshold = call GetSquelch();
  1668.           threshold = threshold - (call GetSquelch() >> 2);
  1669.           if(data > threshold){
  1670.             // adjust the noise floor level
  1671.             atomic usTempSquelch = data;
  1672.             post adjustSquelch();
  1673.             
  1674.           }else if(pulse_check_count > 5){
  1675.             //go to the idle state since no outliers were found
  1676.             call CC1000Control.RxMode();
  1677.             RadioState = IDLE_STATE;
  1678.             call SpiByteFifo.rxMode();     // SPI to miso
  1679.             call SpiByteFifo.enableIntr(); // enable spi interrupt
  1680.             post IdleTimerTask();
  1681.             done = 1;
  1682.             
  1683.           }else {
  1684.             call CC1000Control.RxMode();
  1685.             if(call RSSIADC.getData()){
  1686.               TOSH_uwait(80);
  1687.               pulse_check_count ++;
  1688.               done = 1;
  1689.             }
  1690.             pulse_check_sum ++;
  1691.             call CC1000StdControl.stop();
  1692.           }
  1693.             
  1694.           if (bTxPending) { // bug fixed by Dr. Rhee
  1695.             //go to the idle state since no outliers were found
  1696.             call CC1000Control.RxMode();
  1697.             RadioState = IDLE_STATE;
  1698.             call SpiByteFifo.rxMode();     // SPI to miso
  1699.             call SpiByteFifo.enableIntr(); // enable spi interrupt
  1700.             post IdleTimerTask();
  1701.             done = 1;
  1702.           }
  1704.           if(done == 0){
  1705.             post SleepTimerTask();
  1706.             RadioState = POWER_DOWN_STATE;
  1707.             call SpiByteFifo.disableIntr();
  1708.           }
  1709.         }
  1710.         //go to the power down state
  1711.         break;
  1713.       default:
  1714.       }
  1715.     }
  1716.     return SUCCESS;
  1717.   }
  1719.   // XXX:JP- for testing the mac layer squlech value
  1720.   async command uint16_t GetSquelch() {
  1721.     return usSquelchVal;
  1722.   }
  1723.   // XXX:JP- for testing the mac layer power consumption
  1724.   async command uint16_t GetPower() {
  1725.     return power_sum;
  1726.   }
  1727.   async command uint16_t GetDataSent() {
  1728.     return dataSent;
  1729.   }
  1730.   async command result_t ResetDataSent() {
  1731.     dataSent = 0;
  1732.     return SUCCESS;
  1733.   }
  1734.   async command uint16_t GetPower_tx() {
  1735.     return tx_sum;
  1736.   }
  1737.   async command uint16_t GetPower_rx() {
  1738.     return rx_sum;
  1739.   }
  1740.   async command uint16_t GetPower_sp() {
  1741.     return sp_sum;
  1742.   }
  1744.   async command result_t ResetPower() {
  1745.     power_sum = 0;
  1746.     pulse_check_sum = 0;
  1747.     send_sum = 0;
  1748.     receive_sum = 0;
  1749.     sp_sum = 0;
  1750.     tx_sum = 0;
  1751.     rx_sum = 0;
  1752.     return SUCCESS;
  1753.   }
  1755.   async command result_t MacControl.enableAck() {
  1756.     atomic bAckEnable = TRUE;
  1757.     return SUCCESS;
  1758.   }
  1760.   async command result_t MacControl.disableAck() {
  1761.     atomic bAckEnable = FALSE;
  1762.     return SUCCESS;
  1763.   }
  1765.   async command result_t MacControl.enableCCA() {
  1766.     atomic bCCAEnable = TRUE;
  1767.     return SUCCESS;
  1768.   }
  1770.   async command result_t MacControl.disableCCA() {
  1771.     atomic bCCAEnable = FALSE; 
  1772.     return SUCCESS;
  1773.   }
  1775.   // ***Not yet implemented
  1776.   async command TOS_MsgPtr MacControl.HaltTx() {
  1777.     return 0;
  1778.   }
  1780.   // Default events for radio send/receive coordinators do nothing.
  1781.   // Be very careful using these, you'll break the stack.
  1782.   default async event void RadioSendCoordinator.startSymbol(uint8_t bitsPerBlock, uint8_t offset,
  1783.                                                             TOS_MsgPtr msgBuff) { }
  1784.   default async event void RadioSendCoordinator.byte(TOS_MsgPtr msg, uint8_t byteCount) { }
  1785.   default async event void RadioSendCoordinator.blockTimer() { }
  1787.   default async event void RadioReceiveCoordinator.startSymbol(uint8_t bitsPerBlock, uint8_t offset,
  1788.                                                                TOS_MsgPtr msgBuff) { }
  1789.   default async event void RadioReceiveCoordinator.byte(TOS_MsgPtr msg, uint8_t byteCount) { }
  1790.   default async event void RadioReceiveCoordinator.blockTimer() { }
  1792.   default async event int16_t MacBackoff.initialBackoff(TOS_MsgPtr m){
  1793.     return (call Random.rand() & 0x1F) + 1;
  1794.   }
  1796.   default async event int16_t MacBackoff.congestionBackoff(TOS_MsgPtr m){
  1797.     congBackOffs++;
  1798.     return (call Random.rand() & 0xF) + 1;
  1799.   }
  1801.   /**************SClock Interface********/
  1802.   async event result_t SClock.syncDone(){
  1803.     if(needTimeSync){
  1804.       GTime loctime;
  1805.       uint32_t globalTimeStamp, slotOffset;
  1806.       call SClock.getTime(&loctime);
  1807.       globalTimeStamp = (uint32_t)(loctime.mticks * 568.889 + loctime.sticks * 0.00868056); //in ms
  1808.       slotOffset = (uint32_t) (1.024 * (slotSize - (globalTimeStamp % slotSize))); // in timer units .976562 = 1000/1024
  1809.       slotNum = (uint32_t) (globalTimeStamp/slotSize);
  1810.       currentSlot = slotNum & (localFrameLength - 1);
  1811.       globalSlot = slotNum & (globalFrameLength - 1);
  1813.       if(currentMAC == ZMAC)
  1814.         call TDMATimer.start(TIMER_ONE_SHOT, slotOffset);
  1815.       needTimeSync = FALSE;
  1816.     }
  1817.     return SUCCESS;
  1818.   }
  1819.   async event result_t SClock.fire(uint16_t mticks){ return SUCCESS; }  
  1820. }