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

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

网络

开发平台：

Others

CC1000RadioIntM.nc.~1.15.~：源码内容
  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.   //  nodeInfo *nbrInfo;
  145.   nodeInfo nbrInfo[MAX_NBR], myInfo; //CHANGE THIS, ONLY FOR TESTING !!!!!!!
  147.   GTime currentDiff, constOffset;
  148.   uint16_t currentSender;
  149.   uint8_t currentSign;
  150.   uint8_t currentMAC; // default must be BMAC and change to ZMAC after DRAND completes
  151.   uint16_t localFrameLength; // local frame length in slots
  152.   uint16_t globalFrameLength;
  153.   uint16_t slotSize; 
  154.   uint16_t nextHop;
  155.   uint16_t ownSlot;
  156.   uint16_t slots_since_ecnsend;
  157.   uint16_t slots_since_ecnrecv;
  158.   uint16_t slots_since_ecncheck;
  159.   uint16_t globalFrameSize;
  160.   uint16_t localFrameSize;
  161.   uint16_t globalSlot;
  162.   uint16_t currentSlot;
  163.   uint16_t slotMultiplier;
  164.   uint32_t slotNum;
  165.   uint16_t packetsSent;
  166.   uint16_t pktsLastSync;
  167.   bool needTimeSync;
  168.   uint16_t congBackOffs;
  169.   double avgLoss;
  170.   uint32_t curHCLlist;
  171.   bool HCLselect;
  172.   bool ackOrig;
  173.   bool ecnPending;
  174.   bool ecnforward;
  175.   bool enableHCL;
  176.   bool pureHCL;
  177.   TOS_Msg ecnMsgHdr;
  178.   TOS_Msg ecnForwardMsgHdr;
  179.   TOS_Msg syncMsgHdr;
  181.   union {
  182.     uint16_t W;
  183.     struct {
  184.       uint8_t LSB;
  185.       uint8_t MSB;
  186.     };
  187.   } RxShiftBuf;
  189.   uint8_t RxBitOffset; // bit offset for spibus
  190.   uint16_t RxByteCnt; // received byte counter
  191.   uint16_t TxByteCnt;
  192.   uint16_t RSSISampleFreq; // in Bytes rcvd per sample
  193.   norace bool bInvertRxData; // data inverted
  194.   norace bool bTxPending;
  195.   bool bAckEnable;
  196.   bool bCCAEnable;
  197.   bool bTxBusy;
  198.   bool bRSSIValid;
  199.   uint16_t CC1K_PulseLevel;
  200.   uint16_t usRunningCRC; // Running CRC variable
  201.   uint16_t usRSSIVal;
  202.   uint16_t usSquelchVal;
  203.   uint16_t usTempSquelch;
  204.   uint8_t usSquelchIndex;
  205.   norace uint8_t pulse_check_count;
  206.   norace uint16_t pulse_check_sum;
  207.   norace uint16_t send_sum;
  208.   norace uint16_t receive_sum;
  209.   norace uint16_t power_sum;
  210.   norace uint16_t sp_sum;
  211.   norace uint16_t rx_sum;
  212.   norace uint16_t tx_sum;
  213.   norace uint16_t dataSent;
  215.   uint16_t usSquelchTable[CC1K_SquelchTableSize];
  217.   int16_t sMacDelay;    // MAC delay for the next transmission
  218.   // XXX-PB:
  219.   // Here's the deal, the mica (RFM) radio stacks used TOS_LOCAL_ADDRESS
  220.   // to determine if an L2 ack was reqd.  This stack doesn't do L2 acks
  221.   // and, thus doesn't need it.  HOWEVER, some set-mote-id versions
  222.   // break if this symbol is missing from the binary.
  223.   // Thus, I put this LocalAddr here and set it to TOS_LOCAL_ADDRESS
  224.   // to keep things happy for now.
  225.   volatile uint16_t LocalAddr;
  227.   ///**********************************************************
  228.   //* local function definitions
  229.   //**********************************************************/
  231.   /*
  232.     int sortByShort(const void *x, const void *y) {
  233.     uint16_t* x1 = (uint16_t*)x;
  234.     uint16_t* y1 = (uint16_t*)y;
  235.     if (x1[0] > y1[0]) return -1;
  236.     if (x1[0] == y1[0]) return 0;
  237.     if (x1[0] < y1[0]) return 1;
  238.     return 0; // shouldn't reach here becasue it covers all the cases
  239.     }
  240.   */
  242.   uint16_t getOwnerBackoff(){
  243.     return (call Random.rand() & (T_O - 1)) + 1;
  244.   }
  246.   uint16_t getNonOwnerBackoff(){
  247.     return (call Random.rand() & (T_NO - 1)) + T_O + 1;
  248.   }
  250.   void DivTime2(GTime* B, GTime* A){
  251.     if (A->mticks % 2 == 1){
  252.       B->mticks = (A->mticks >> 1);
  253.       B->sticks = (A->sticks >> 1)  + ((MAX_VAL) >>1);
  254.     }
  255.     else{
  256.       B->mticks = (A->mticks >>1);
  257.       B->sticks = (A->sticks >>1);
  258.     }
  259.   }
  261.   void AddTime(GTime* C, GTime* A, GTime* B){
  262.     if ((MAX_VAL - B->sticks) < A->sticks){
  263.       C->sticks = A->sticks - (MAX_VAL - B->sticks);
  264.       C->mticks = A->mticks + B->mticks + 1;
  265.     }
  266.     else{
  267.       C->sticks = A->sticks + B->sticks;
  268.       C->mticks = A->mticks + B->mticks;
  269.     }
  270.   }
  272.   void SubTime(GTime* C, GTime* A, GTime* B){
  273.     if (B->sticks > A->sticks){
  274.       C->sticks = MAX_VAL - (B->sticks - A->sticks);
  275.       C->mticks = A->mticks - (B->mticks + 1);
  276.     }
  277.     else {
  278.       C->sticks = A->sticks -  B->sticks;
  279.       C->mticks = A->mticks -  B->mticks;
  280.     }
  281.   }
  283.   uint16_t getZMACBackoff(uint16_t residualBackoff){
  284.     if(residualBackoff > 0){
  285.       congBackOffs++;
  286.       if((currentSlot == ownSlot) && (residualBackoff >= T_O)){
  287.         return getOwnerBackoff();
  288.       } else if((currentSlot != ownSlot) && (residualBackoff < T_O)){
  289.         if((residualBackoff + T_O) < (T_O + T_NO))
  290.           return (residualBackoff + T_O);
  291.         else
  292.           return getNonOwnerBackoff();
  293.       } else
  294.         return residualBackoff;
  295.     } else{
  296.       if(currentSlot == ownSlot)
  297.         return getOwnerBackoff();
  298.       else
  299.         return getNonOwnerBackoff();
  300.     }
  301.   }
  303.   uint8_t ModSubTime(GTime* C, GTime* A, GTime* B){
  304.     uint8_t retval;
  305.     if (A->mticks > B->mticks) 
  306.       retval = POSITIVE;
  307.     else if (A->mticks < B->mticks) 
  308.       retval = NEGATIVE;
  309.     else{
  310.       if (A->sticks > B->sticks)
  311.         retval = POSITIVE;
  312.       else if (A->sticks < B->sticks)
  313.         retval = NEGATIVE;
  314.       else
  315.         retval = ZERO;
  316.     }
  317.     if (retval == POSITIVE) SubTime(C,A,B);
  318.     else if (retval == NEGATIVE) SubTime(C,B,A);
  319.     else {
  320.       C->sticks = 0;
  321.       C->mticks = 0;
  322.     }
  323.     return retval;
  324.   }
  326.   bool IsHCL(uint32_t gSlot){
  327.     uint32_t tempHCL = 0x1;
  328.     bool flag;
  329.     tempHCL = tempHCL << gSlot;
  330.     atomic{
  331.       if(tempHCL & curHCLlist)
  332.         flag = TRUE;
  333.       else
  334.         flag = FALSE;
  335.     }
  336.     return flag;
  337.   }
  339.   task void adjustSquelch() {
  340.     uint16_t tempArray[CC1K_SquelchTableSize];
  341.     char i,j,min; 
  342.     uint16_t min_value;
  343.     uint32_t tempsquelch;
  345.     atomic {
  346.       usSquelchTable[usSquelchIndex] = usTempSquelch;
  347.       usSquelchIndex++;
  348.       if (usSquelchIndex >= CC1K_SquelchTableSize)
  349.         usSquelchIndex = 0;
  350.       if (iSquelchCount <= CC1K_SquelchCount)
  351.         iSquelchCount++;  
  352.     }
  354.     for (i=0; i<CC1K_SquelchTableSize; i++) {
  355.       tempArray[(int)i] = usSquelchTable[(int)i];
  356.     }
  358.     min = 0;
  359.     //    for (j = 0; j < ((CC1K_SquelchTableSize) >> 1); j++) {
  360.     for (j = 0; j < 3; j++) {
  361.       for (i = 1; i < CC1K_SquelchTableSize; i++) {
  362.         if ((tempArray[(int)i] != 0xFFFF) && 
  363.             ((tempArray[(int)i] > tempArray[(int)min]) ||
  364.              (tempArray[(int)min] == 0xFFFF))) {
  365.           min = i;
  366.         }
  367.       }
  368.       min_value = tempArray[(int)min];
  369.       tempArray[(int)min] = 0xFFFF;
  370.     }
  372.     tempsquelch = ((uint32_t)(usSquelchVal << 5) + (uint32_t)(min_value << 1));
  373.     atomic usSquelchVal = (uint16_t)((tempsquelch / 34) & 0x0FFFF);
  375.     /*
  376.     // XXX: qsort actually causes ~600bits/sec lower bandwidth... why???
  377.     //
  378.     qsort (tempArray,CC1K_SquelchTableSize, sizeof(uint16_t),sortByShort);
  379.     min_value = tempArray[CC1K_SquelchTableSize >> 1];
  380.     atomic usSquelchVal = ((usSquelchVal << 5) + (min_value << 1)) / 34;
  381.     */
  382.   }
  384.   void getTimeDiff(){ // called as soon as time sync message is received, regardless of crc
  385.     atomic{
  386.       uint16_t i, trust;
  387.       GTime loctime, timeStamp;
  388.       syncMsgType* syncMsgPtr = (syncMsgType *) rxbufptr->data;
  389.       timeStamp.mticks = syncMsgPtr->mticks;
  390.       timeStamp.sticks = syncMsgPtr->sticks;
  391.       trust = syncMsgPtr->trust;
  392.       currentSender = syncMsgPtr->sender;
  393.       call SClock.getTime(&loctime);
  394.       currentSign = ModSubTime(&currentDiff, &timeStamp, &loctime);
  396.       if(trust < MIN_TRUST)
  397.         trust = MIN_TRUST;
  398.       if(trust < MAX_TRUST){
  399.         for(i = 0; i < trust; i++){
  400.           DivTime2(&currentDiff, &currentDiff);
  401.         }
  402.       }
  403.     }
  404.   }
  406.   void Blacklist(uint8_t slot, uint8_t fsize){
  407.     uint8_t black_slot;
  408.     atomic {
  409.       if(fsize <= globalFrameLength){
  410.         black_slot = slot;
  411.         while(black_slot < globalFrameLength){
  412.           uint32_t tempHCL2 = 0x1;
  413.           tempHCL2 = tempHCL2 << black_slot;
  414.           curHCLlist = curHCLlist | tempHCL2;
  415.           black_slot = black_slot + fsize;
  416.         }
  417.       }
  418.     }
  419.   }
  420.   
  421.   task void adjustTime(){
  422.     needTimeSync = TRUE;
  423.     call SClock.setTime(currentSign, &currentDiff);
  424. #ifdef ZMAC_TIME_SYNC
  425.     SODbg(DBG_USR2, "diff = %u, %u, from %un", currentDiff.mticks, currentDiff.sticks, currentSender);
  426. #endif
  427.   }
  429.   task void PacketRcvd(){
  430.     TOS_MsgPtr pBuf;
  431.     ecnForwardMsgType *recvEcnMsgPtr;
  432.     ecnForwardMsgType *ecnForwardMsgPtr;
  433.     atomic {
  434.       if(pktsLastSync > SYNC_PERIOD){
  435.         atomic{ 
  436.           ackOrig = bAckEnable;
  437.           bAckEnable = FALSE;
  438.         }
  439.         call Send.send(&syncMsgHdr);
  440.         pktsLastSync = 0;
  441.       }
  443.       pktsLastSync++;
  444.       rxbufptr->time = 0;
  445.       pBuf = rxbufptr;
  446.       recvEcnMsgPtr = (ecnForwardMsgType *) rxbufptr->data;
  447.       ecnForwardMsgPtr = (ecnForwardMsgType *) ecnForwardMsgHdr.data;
  449. #ifdef ZMAC_ECN
  450.       if((currentMAC == ZMAC) && (pBuf->type == ECNTYPE)){
  451.         SODbg(DBG_USR2,"Received %u hop ECN from %u, deciding whether significant..n",
  452.               recvEcnMsgPtr->hopCount, recvEcnMsgPtr->senderAddress);
  453.       }
  454. #endif
  456.       if((currentMAC == ZMAC) && (HCLselect) && (pBuf->type == ECNTYPE) && (pBuf->crc != 0) &&
  457.          (recvEcnMsgPtr->senderAddress != TOS_LOCAL_ADDRESS)){ //Message is an ECN
  458.         if((recvEcnMsgPtr->hopCount == 0) && (recvEcnMsgPtr->nextHop == TOS_LOCAL_ADDRESS)){
  459. #ifdef ZMAC_ECN
  460.           SODbg(DBG_USR2,"Received one-hop ECN from %un", recvEcnMsgPtr->senderAddress);
  461. #endif
  462.           ecnForwardMsgPtr->hopCount = 1;
  463.           ecnForwardMsgPtr->nextHop = nextHop;
  464.           ecnForwardMsgPtr->senderAddress = TOS_LOCAL_ADDRESS;
  465.           if(!bTxBusy){
  466.             ackOrig = bAckEnable;
  467.             bAckEnable = FALSE;
  468.             call Send.send(&ecnForwardMsgHdr);  //take care of case where we are not currently sending
  469. #ifdef ZMAC_ECN
  470.             SODbg(DBG_USR2,"Forwarded ECNn");
  471. #endif
  472.           } else
  473.             ecnforward = TRUE;
  474.         } else if(recvEcnMsgPtr->hopCount == 1){ //check if two-hop ECN
  475. #ifdef ZMAC_ECN
  476.           SODbg(DBG_USR2,"????????????????????? Received two hop ECN from %un", recvEcnMsgPtr->senderAddress);
  477. #endif
  478.           atomic enableHCL = TRUE;
  479.           if(recvEcnMsgPtr->senderAddress == nextHop){  //check forwarding node's address
  480.             //suppress ECN
  481. #ifdef ZMAC_ECN
  482.             SODbg(DBG_USR2,"Suppressed own ECNn");
  483. #endif
  484.             atomic ecnPending = FALSE;
  485.             slots_since_ecnsend = 0;
  486.             slots_since_ecnrecv = 0;
  487.           }
  488.         }
  489.       } else if((pBuf->type != SYNCTYPE) && (pBuf->type != ECNTYPE)){
  490. #ifdef ZMAC_ECN
  491.         //        SODbg(DBG_USR2,"Received packet of type %u, crc = %un", pBuf->type, pBuf->crc);
  492. #endif
  493.         pBuf = signal Receive.receive((TOS_MsgPtr)pBuf);
  494.       }
  495.       
  496.       if (pBuf)
  497.         rxbufptr = pBuf;
  498.       rxbufptr->length = 0;
  499.     }
  500.     call SpiByteFifo.enableIntr();
  501.   }
  502.   
  503.   task void PacketSent() {
  504.     TOS_MsgPtr pBuf; //store buf on stack 
  505.     atomic {
  506.       txbufptr->time = 0;
  507.       pBuf = txbufptr;
  508.     }
  509.       
  510.     if ((txbufptr->type != ECNTYPE) && (txbufptr->type != SYNCTYPE)){
  511.       if(txbufptr->type == AM_MULTIHOP)
  512.         dataSent++;
  513.       signal Send.sendDone((TOS_MsgPtr)pBuf, SUCCESS);
  514.     } else if(txbufptr->type == SYNCTYPE){
  515. #ifdef ZMAC_DEBUG
  516.       //      SODbg(DBG_USR2, "Sent one sync message $$$$$$$$$n");
  517. #endif
  518.     } else if(txbufptr->type == ECNTYPE){
  519. #ifdef ZMAC_DEBUG
  520.       //      SODbg(DBG_USR2, "Sent one ecn message $$$$$$$$$n");
  521. #endif
  522.     }
  523.       
  524.     atomic bTxBusy = FALSE;
  525.     if(pktsLastSync > SYNC_PERIOD){
  526.       atomic{
  527.         ackOrig = bAckEnable;
  528.         bAckEnable = FALSE;
  529.       }
  530.       call Send.send(&syncMsgHdr);
  531.       pktsLastSync = 0;
  532.     } else if((currentMAC == ZMAC) && (ecnforward == TRUE)){
  533.       atomic{
  534.         ackOrig = bAckEnable;
  535.         bAckEnable = FALSE;
  536.       }
  537.       call Send.send(&ecnForwardMsgHdr);
  538.       atomic ecnforward = FALSE;
  539. #ifdef ZMAC_ECN
  540.       SODbg(DBG_USR2,"Forwarded ECNn");
  541. #endif
  542.     } else if((currentMAC == ZMAC) && (ecnPending == TRUE)){
  543.       atomic{
  544.         ackOrig = bAckEnable;
  545.         bAckEnable = FALSE;
  546.       }
  547.       call Send.send(&ecnMsgHdr);
  548.       atomic ecnPending = FALSE;
  549.       atomic slots_since_ecnsend = 0;
  550. #ifdef ZMAC_ECN
  551.       SODbg(DBG_USR2,"Sent own ECNn");
  552. #endif
  553.     }
  554.   }
  556.   ///**********************************************************
  557.   //* Exported interface functions
  558.   //**********************************************************/
  559.   command void SetDrand.setParent(uint8_t id){ nextHop = id; }
  560.   command result_t SetDrand.Set(nodeInfo *mInfo, uint8_t nHop, nodeInfo *nInfo, uint16_t sSize){
  561.     uint32_t slotOffset = 0, globalTimeStamp = 0;
  562.     GTime loctime;
  563.     uint8_t i = 0;
  565.     slotSize = sSize;
  566.     nextHop = nHop;
  568.     if(0){
  569.       /*       localFrameLength = myInfo->frame; */
  570.       /*       ownSlot = myInfo->slot; */
  571.       /*       nbrInfo = nInfo; */
  572.       /*       for(i = 0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++) */
  573.       /*         if(nbrInfo[i].bitMap & TWO_HOP) */
  574.       /*           Blacklist(nbrInfo[i].slot, nbrInfo[i].frame); */
  575.     } else{ // USE THIS ONLY FOR TESTING
  576.       for(i = 0 ; i<MAX_NBR ; i++){ // initialize the nbr table
  577.         nbrInfo[i].nodeID = 0xFF;
  578.         nbrInfo[i].slot = 0xFF;
  579.         nbrInfo[i].frame = 0xFF;
  580.         nbrInfo[i].bitMap = 0x0;
  581.       }
  582. #include "nbrTable.h"
  583.       /*       slotSize = sSize; */
  584.       /*       localFrameLength = 8; */
  585.       /*       nextHop = nHop; */
  586.       /*       switch(TOS_LOCAL_ADDRESS){ */
  587.       /*       case 1: */
  588.       /*         ownSlot = 6; */
  589.       /*         break; */
  590.       /*       case 10: */
  591.       /*         ownSlot = 4; */
  592.       /*         break; */
  593.       /*       case 11: */
  594.       /*         ownSlot = 0; */
  595.       /*         break; */
  596.       /*       case 13: */
  597.       /*         ownSlot = 1; */
  598.       /*         break; */
  599.       /*       case 2: */
  600.       /*         ownSlot = 1; */
  601.       /*         break; */
  602.       /*       case 20: */
  603.       /*         ownSlot = 1; */
  604.       /*         break; */
  605.       /*       case 21: */
  606.       /*         ownSlot = 2; */
  607.       /*         break; */
  608.       /*       case 22: */
  609.       /*         ownSlot = 7; */
  610.       /*         break; */
  611.       /*       case 24: */
  612.       /*         ownSlot = 0; */
  613.       /*         break; */
  614.       /*       case 0: */
  615.       /*         ownSlot = 5; */
  616.       /*         break; */
  617.       /*       case 8: */
  618.       /*         ownSlot = 2; */
  619.       /*         break; */
  620.       /*       case 9: */
  621.       /*         ownSlot = 3; */
  622.       /*         break; */
  623.       /*       } */
  624.     }
  626.     localFrameSize = localFrameLength * slotSize;
  627.     globalFrameSize = globalFrameLength * slotSize;
  628.     slotMultiplier = (uint16_t) (slotSize * 1.024);
  630.     call SClock.getTime(&loctime);
  631.     globalTimeStamp = (uint32_t)(loctime.mticks * 568.889 + loctime.sticks * 0.00868056); //in ms
  632.     slotOffset = (uint32_t) (1.024 * (slotSize - (globalTimeStamp % slotSize))); // in timer units .976562 = 1000/1024
  633.     slotNum = (uint32_t) (globalTimeStamp/slotSize);
  634.     currentSlot = slotNum & (localFrameLength - 1);
  635.     globalSlot = slotNum & (globalFrameLength - 1);
  636.     
  637.     call TDMATimer.start(TIMER_ONE_SHOT, slotOffset);
  638. #ifdef ZMAC_TIMER
  639.     // SODbg(DBG_USR2,"Started timer slotsize - offset is %in",slotSize - slotOffset);
  640. #endif
  641.     return SUCCESS; 
  642.   }
  644.   command result_t StdControl.init() {
  645.     char i;
  646.     ecnMsgType *ecnMsgPtr = (ecnMsgType *) ecnMsgHdr.data;
  647.     atomic {
  648.       RadioState = DISABLED_STATE;
  649.       RadioTxState = TXSTATE_PREAMBLE;
  650.       rxbufptr = &RxBuf;
  651.       rxbufptr->length = 0;
  652.       rxlength = MSG_DATA_SIZE-2;
  653.       RxBitOffset = 0;
  654.       iSquelchCount = 0;
  655.       
  656.       PreambleCount = 0;
  657.       RSSISampleFreq = 0;
  658.       RxShiftBuf.W = 0;
  659.       iRSSIcount = 0;
  660.       bTxPending = FALSE;
  661.       bTxBusy = FALSE;
  662.       bRSSIValid = FALSE;
  663.       bAckEnable = FALSE; // to test for ECN only
  664.       bCCAEnable = TRUE;
  665.       CC1K_PulseLevel = 300;
  666.       sMacDelay = -1;
  667.       usRSSIVal = -1;
  668.       usSquelchIndex = 0;
  669.       pulse_check_count = 0;
  670.       lplpower =  0;//0x87;
  671.       RSSIInitState = NULL_STATE;
  672.       //      if(TOS_LOCAL_ADDRESS == 0) lplpower = 0;
  673.       //      lplpowertx = 7;
  674.       usSquelchVal = CC1K_SquelchInit;
  676.       currentMAC = BMAC;
  677.       congBackOffs = 0;
  678.       packetsSent = 0;
  679.       pktsLastSync = 0;
  680.       avgLoss = 0.0;
  681.       curHCLlist = 0;
  682.       globalFrameLength = GLOBAL_FRAME_LENGTH;
  684.       localFrameLength = GLOBAL_FRAME_LENGTH;
  685.       slotSize = 50;
  686.       localFrameSize = localFrameLength * slotSize;
  687.       globalFrameSize = globalFrameLength * slotSize;
  689.       ackOrig = bAckEnable;
  690.       ecnPending = FALSE;
  691.       ecnforward = FALSE;
  693.       enableHCL = FALSE; // ecn flag, set if currently ecn is going on ...
  694.       pureHCL = FALSE;
  695.       HCLselect = SELECTHCL;
  696.       needTimeSync = FALSE;
  698.       slots_since_ecnsend = 0;
  699.       slots_since_ecnrecv = 0;
  700.       slots_since_ecncheck = 0;
  702.       ecnMsgHdr.type = ECNTYPE;  //set ecnMsg headers
  703.       ecnMsgHdr.addr = TOS_BCAST_ADDR; //ECN Indicator;
  704.       ecnMsgHdr.length = sizeof(ecnMsgType);
  705.       ecnMsgHdr.group = 125;
  706.       ecnMsgHdr.crc = 0;
  708.       ecnForwardMsgHdr.type = ECNTYPE;
  709.       ecnForwardMsgHdr.addr = TOS_BCAST_ADDR; 
  710.       ecnForwardMsgHdr.length = sizeof(ecnMsgType);
  711.       ecnForwardMsgHdr.group = 125;
  712.       ecnForwardMsgHdr.crc = 0;
  714.       syncMsgHdr.type = SYNCTYPE;  //set syncMsg headers
  715.       syncMsgHdr.addr = TOS_BCAST_ADDR; //SYNC Indicator;
  716.       syncMsgHdr.length = sizeof(syncMsgType);
  717.       syncMsgHdr.group = 125;
  718.       syncMsgHdr.crc = 0;
  719.       
  720.       ecnMsgPtr->hopCount = 0; //hopcount
  721.       ecnMsgPtr->nextHop = nextHop; //parent node
  722.       ecnMsgPtr->senderAddress = TOS_LOCAL_ADDRESS;
  723.     }
  725.     for (i = 0; i < CC1K_SquelchTableSize; i++)
  726.       usSquelchTable[(int)i] = CC1K_SquelchInit;
  728.     call SpiByteFifo.initSlave(); // set spi bus to slave mode
  729.    
  730.     call CC1000StdControl.init();
  731.     call CC1000Control.SelectLock(0x9); // Select MANCHESTER VIOLATION
  732.     bInvertRxData = call CC1000Control.GetLOStatus();
  734.     call ADCControl.bindPort(TOS_ADC_CC_RSSI_PORT,TOSH_ACTUAL_CC_RSSI_PORT);
  735.     call ADCControl.init();
  736.     
  737.     call Random.init();
  738.     call TimerControl.init();
  740. #ifdef ZMAC_DEBUG
  741.     init_debug();
  742. #endif
  743.     LocalAddr = TOS_LOCAL_ADDRESS;
  745.     return SUCCESS;
  746.   }
  747.   
  748.   /**
  749.    * Get the current Low Power Listening transmit mode
  750.    * @return mode number (see SetListeningMode)
  751.    */
  752.   async command uint8_t LowPowerListening.GetTransmitMode() {
  753.     return lplpowertx;
  754.   }
  755.   // legacy support
  756.   async command uint8_t GetTransmitMode() {
  757.     return call LowPowerListening.GetTransmitMode();
  758.   }
  760.   /**
  761.    * Set the transmit mode.  This allows for hybrid schemes where
  762.    * the transmit mode is different than the receive mode.
  763.    * Use SetListeningMode first, then change the mode with SetTransmitMode.
  764.    *
  765.    * @param mode mode number (see SetListeningMode)
  766.    * @return SUCCESS if the mode was successfully changed
  767.    */
  768.   async command result_t LowPowerListening.SetTransmitMode(uint8_t power) {
  769.     if ((power >= CC1K_LPL_STATES) || (power == lplpowertx))
  770.       return FAIL;
  772.     // check if the radio is currently doing something
  773.     if ((!bTxPending) && ((RadioState == POWER_DOWN_STATE) || 
  774.                           (RadioState == IDLE_STATE) ||
  775.                           (RadioState == DISABLED_STATE))) {
  777.       atomic {
  778.         lplpowertx = power;
  779.         preamblelen = ((PRG_RDB(&CC1K_LPL_PreambleLength[lplpowertx*2]) << 8)
  780.                        | PRG_RDB(&CC1K_LPL_PreambleLength[(lplpowertx*2)+1]));
  781.       }
  782.       return SUCCESS;
  783.     }
  784.     return FAIL;
  785.   }
  786.   // legacy support
  787.   async command result_t SetTransmitMode(uint8_t power) {
  788.     return call LowPowerListening.SetTransmitMode(power);
  789.   }
  791.   /**
  792.    * Set the current Low Power Listening mode.
  793.    * Setting the LPL mode sets both the check interval and preamble length.
  794.    *
  795.    * Modes include:
  796.    *  0 = Radio full on
  797.    *  1 = 10ms check interval
  798.    *  2 = 25ms check interval
  799.    *  3 = 50ms check interval
  800.    *  4 = 100ms check interval (recommended)
  801.    *  5 = 200ms check interval
  802.    *  6 = 400ms check interval
  803.    *  7 = 800ms check interval
  804.    *  8 = 1600ms check interval
  805.    *
  806.    * @param mode the mode number
  807.    * @return SUCCESS if the mode was successfully changed
  808.    */
  809.   async command result_t LowPowerListening.SetListeningMode(uint8_t power) {
  810.     // valid low power listening values are 0 to 8
  811.     // 0 is "always on" and 8 is lowest duty cycle
  812.     if ((power >= CC1K_LPL_STATES) || (power == lplpower))
  813.       return FAIL;
  815.     // check if the radio is currently doing something
  816.     if ((!bTxPending) && ((RadioState == POWER_DOWN_STATE) || 
  817.                           (RadioState == IDLE_STATE) ||
  818.                           (RadioState == DISABLED_STATE))) {
  820.       // change receiving function in CC1000Radio
  821.       call WakeupTimer.stop();
  822.       atomic {
  823.         if (lplpower == lplpowertx) {
  824.           lplpowertx = power;
  825.         }
  826.         lplpower = power;
  827.       }
  829.       // if successful, change power here
  830.       if (RadioState == IDLE_STATE) {
  831.         RadioState = DISABLED_STATE;
  832.         call StdControl.stop();
  833.         call StdControl.start();
  834.       }
  835.       if (RadioState == POWER_DOWN_STATE) {
  836.         RadioState = DISABLED_STATE;
  837.         call StdControl.start();
  838.         call PowerManagement.adjustPower();
  839.       }
  840.     }
  841.     else {
  842.       return FAIL;
  843.     }
  844.     return SUCCESS;
  845.   }
  846.   // legacy support
  847.   async command result_t SetListeningMode(uint8_t power) {
  848.     return call SetListeningMode(power);
  849.   }
  851.   /**
  852.    * Gets the state of low power listening on the chipcon radio.
  853.    * @return Current low power listening state value
  854.    */
  855.   async command uint8_t LowPowerListening.GetListeningMode() {
  856.     return lplpower;
  857.   }
  858.   // legacy support
  859.   async command uint8_t GetListeningMode() {
  860.     return call LowPowerListening.GetListeningMode();
  861.   } 
  863.   /**
  864.    * Set the preamble length of outgoing packets
  865.    *
  866.    * @param bytes length of the preamble in bytes
  867.    * @return SUCCESS if the preamble length was successfully changed
  868.    */
  869.   async command result_t LowPowerListening.SetPreambleLength(uint16_t bytes) {
  870.     result_t result = FAIL;
  871.     atomic {
  872.       if (RadioState != TX_STATE) {
  873.         preamblelen = bytes;
  874.         result = SUCCESS;
  875.       }
  876.     }
  877.     return result;
  878.   }
  880.   /**
  881.    * Get the preamble length of outgoing packets
  882.    *
  883.    * @return length of the preamble in bytes
  884.    */
  885.   async command uint16_t LowPowerListening.GetPreambleLength() {
  886.     return preamblelen;
  887.   }
  889.   /**
  890.    * Set the check interval (time between waking up and sampling
  891.    * the radio for activity in low power listening)
  892.    *
  893.    * @param ms check interval in milliseconds
  894.    * @return SUCCESS if the check interval was successfully changed
  895.    */
  896.   async command result_t LowPowerListening.SetCheckInterval(uint16_t ms) {
  897.     // sleep time will go into effect after the next wakeup time
  898.     atomic sleeptime = ms;
  899.     return SUCCESS;
  900.   }
  902.   /**
  903.    * Get the check interval currently used by low power listening
  904.    *
  905.    * @return length of the check interval in milliseconds
  906.    */
  907.   async command uint16_t LowPowerListening.GetCheckInterval() {
  908.     return sleeptime;
  909.   }
  912.   event result_t SquelchTimer.fired() {
  913.     char currentRadioState;
  914.     atomic currentRadioState = RadioState;
  916.     if (currentRadioState == IDLE_STATE) {
  917.       atomic RSSIInitState = currentRadioState;
  918.       call RSSIADC.getData();
  919.     }
  920.     return SUCCESS;
  921.   }
  923.   event result_t WakeupTimer.fired() {
  924.     uint8_t currentRadioState;
  926.     if (lplpower == 0)
  927.       return SUCCESS;
  928.     
  929.     atomic currentRadioState = RadioState;
  930.     switch(currentRadioState) {
  932.     case IDLE_STATE:
  933.       if (!bTxPending) {
  934.         atomic {
  935.           RadioState = POWER_DOWN_STATE;
  936.           call SpiByteFifo.disableIntr();
  937.         }
  938.         call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  939.         call SquelchTimer.stop();
  940.         call CC1000StdControl.stop();
  941.       } else {
  942.         call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  943.       }
  944.       break;
  946.     case POWER_DOWN_STATE:
  947.       atomic RadioState = PULSE_CHECK_STATE;
  948.       pulse_check_count = 0;
  949.       call CC1000StdControl.start();
  950.       call CC1000Control.BIASOn();
  951.       call WakeupTimer.start(TIMER_ONE_SHOT, 1);
  952.       return SUCCESS;
  953.       break;
  955.     case PULSE_CHECK_STATE:
  956.       call CC1000Control.RxMode();
  957.       if(!(call RSSIADC.getData())){
  958.         call WakeupTimer.start(TIMER_ONE_SHOT, TIME_BETWEEN_CHECKS);
  959.         atomic RadioState = POWER_DOWN_STATE;
  960.       }
  961.       else {
  962.         TOSH_uwait(80);
  963.       }
  964.       call CC1000StdControl.stop();
  965.       pulse_check_sum ++;
  966.       break;
  968.     default:
  969.       call WakeupTimer.start(TIMER_ONE_SHOT, 5);
  970.     }
  971.     return SUCCESS;
  972.   }
  974.   //added by Mahesh
  976.   event result_t TDMATimer.fired(){
  977.     call TDMATimer.start(TIMER_ONE_SHOT, slotMultiplier);
  978.     slotNum++;
  979.     atomic currentMAC = ZMAC;
  980.     atomic{
  981.       currentSlot = slotNum & (localFrameLength - 1);
  982.       globalSlot = slotNum & (globalFrameLength - 1);
  983. #ifdef ZMAC_TIMER
  984.       SODbg(DBG_USR2,"*************Timer fired with current slot = %u, own slot = %un", currentSlot, ownSlot);
  985. #endif 
  986.       if(HCLselect){
  987.         slots_since_ecnsend ++;
  988.         slots_since_ecnrecv ++;
  989.         slots_since_ecncheck++;
  990.         if((packetsSent > ECNMINPACKETS) && (slots_since_ecncheck >= ECNCHECKPERIOD)){
  991.           double currentLoss = (double)congBackOffs/packetsSent;
  992.           avgLoss = ALPHA * (currentLoss) + (1 - ALPHA) * avgLoss;
  993. #ifdef ZMAC_ECN
  994.           SODbg(DBG_USR2,"#####################Congestion Statistics: %i / %i, %in", congBackOffs, packetsSent, (uint16_t) avgLoss);
  995. #endif
  996.           slots_since_ecncheck = 0;
  997.           congBackOffs = 0;
  998.           packetsSent = 0;
  999.           if((avgLoss > ECNTHRESHOLD) && (slots_since_ecnsend >= ECNSENDPERIOD)){
  1000.             ecnMsgType *ecnMsgPtr = (ecnMsgType *) ecnMsgHdr.data;
  1001. #ifdef ZMAC_ECN
  1002.             SODbg(DBG_USR2,"Setting ECN flagn");
  1003. #endif
  1004.             // change by acw, go to ecn myself if sending ecn
  1005.             atomic enableHCL = TRUE;
  1006.             slots_since_ecnrecv = 0;
  1007.             // change by acw ends
  1009.             ecnMsgPtr->nextHop = nextHop;
  1010.             if(!pureHCL)
  1011.               ecnPending = TRUE;
  1012.           }
  1013.         }
  1014.         if((enableHCL) && (slots_since_ecnrecv >= ECNEXPIREPERIOD)){
  1015.           if(!pureHCL)
  1016.             enableHCL = FALSE;
  1017. #ifdef ZMAC_ECN
  1018.           SODbg(DBG_USR2,"ECN expired, into LCL againn");
  1019. #endif
  1020.         }
  1021.         
  1022. #ifdef ZMAC_ECN
  1023.         if(enableHCL)
  1024.           SODbg(DBG_USR2,"Current slot %i **********************n",currentSlot);
  1025. #endif
  1026. #ifdef ZMAC_ECN
  1027.         if(enableHCL && IsHCL(globalSlot) && ownSlot != currentSlot)
  1028.           SODbg(DBG_USR2,"***** ****** ****** ****** Current slot %i HCLn",currentSlot);
  1029. #endif
  1030.       }
  1032.       if(bTxPending){
  1033.         sMacDelay = getZMACBackoff(sMacDelay);
  1034. #ifdef ZMAC_BACKOFF
  1035.         SODbg(DBG_USR2,"TDMATimerFired: backoff %un", sMacDelay);
  1036. #endif
  1037.       }
  1038.     }
  1039.     return SUCCESS;
  1040.   }
  1041.  
  1042.   command result_t StdControl.stop() {
  1043.     atomic RadioState = DISABLED_STATE;
  1045.     call SquelchTimer.stop();
  1046.     call WakeupTimer.stop();
  1047.     call CC1000StdControl.stop();
  1048.     call SpiByteFifo.disableIntr(); // disable spi interrupt
  1049.     return SUCCESS;
  1050.   }
  1052.   command result_t StdControl.start() {
  1053.     uint8_t currentRadioState;
  1054.     atomic currentRadioState = RadioState;
  1056.     call SClock.SetRate(MAX_VAL,CLK_DIV_64);
  1057.     if (currentRadioState == DISABLED_STATE) {
  1058.       atomic {
  1059.         rxbufptr->length = 0;
  1060.         RadioState  = IDLE_STATE;
  1061.         bTxPending = bTxBusy = FALSE;
  1062.         sMacDelay = -1;
  1063.         if(SLEEPTIME > 0){
  1064.           sleeptime = SLEEPTIME;
  1065.           preamblelen = PREAMBLELEN;
  1066.         } else{
  1067.           lplpower = lplpowertx = 0;
  1068.           sleeptime = ((PRG_RDB(&CC1K_LPL_SleepTime[lplpower*2]) << 8) |
  1069.                        PRG_RDB(&CC1K_LPL_SleepTime[(lplpower*2)+1]));
  1070.           preamblelen = ((PRG_RDB(&CC1K_LPL_PreambleLength[lplpowertx*2]) << 8) |
  1071.                          PRG_RDB(&CC1K_LPL_PreambleLength[(lplpowertx*2)+1]));
  1072.         }
  1073. /*         sleeptime = ((PRG_RDB(&CC1K_LPL_SleepTime[lplpower*2]) << 8) | */
  1074. /*                      PRG_RDB(&CC1K_LPL_SleepTime[(lplpower*2)+1])); */
  1075. /*         preamblelen = ((PRG_RDB(&CC1K_LPL_PreambleLength[lplpowertx*2]) << 8) | */
  1076. /*                        PRG_RDB(&CC1K_LPL_PreambleLength[(lplpowertx*2)+1])); */
  1077.       }
  1078.       // all power on, captain!
  1079.       rxbufptr->length = 0;
  1080.       atomic RadioState = IDLE_STATE;
  1081.       call CC1000StdControl.start();
  1082.       call CC1000Control.BIASOn();
  1083.       call SpiByteFifo.rxMode(); // SPI to miso
  1084.       call CC1000Control.RxMode();
  1085.       if (iSquelchCount > CC1K_SquelchCount)
  1086.         call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  1087.       else
  1088.         call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  1089.       call SpiByteFifo.enableIntr(); // enable spi interrupt
  1090.       if (lplpower > 0) {
  1091.         // set a time to start sleeping after measuring the noise floor
  1092.         call WakeupTimer.start(TIMER_ONE_SHOT, CC1K_SquelchIntervalSlow);
  1093.       }
  1094.     }
  1095.     return SUCCESS;
  1096.   }
  1098.   command result_t Send.send(TOS_MsgPtr pMsg) {
  1099.     result_t Result = SUCCESS;
  1100.     uint8_t currentRadioState = 0;
  1101.    
  1102.     atomic {
  1103.       if (bTxBusy) {
  1104.         Result = FAIL;
  1105. #ifdef ZMAC_DEBUG
  1106.         //        SODbg(DBG_USR2, "Busy sending the message of type %u!n", txbufptr->type);
  1107. #endif
  1108.       } else {
  1109.         bTxBusy = TRUE;
  1110.         txbufptr = pMsg;
  1111.         txlength = pMsg->length + (MSG_DATA_SIZE - DATA_LENGTH - 2);
  1113.         if(bCCAEnable){ // initially back off [1,32] bytes (approx 2/3 packet)
  1114.           if(currentMAC == BMAC)
  1115.             sMacDelay = signal MacBackoff.initialBackoff(pMsg);
  1116.           else
  1117.             sMacDelay = getZMACBackoff(0);
  1118.         } else
  1119.           sMacDelay = 0;
  1120. #ifdef ZMAC_BACKOFF
  1121.         SODbg(DBG_USR2, "SendMSG(): Need to send type %u, myslot %u, current slot %u backoff %un",
  1122.               txbufptr->type, ownSlot, currentSlot, sMacDelay);
  1123. #endif
  1124.         bTxPending = TRUE;
  1125.       }
  1126.       currentRadioState = RadioState;
  1127.     }
  1129.     if (Result) {
  1130.       if (currentRadioState == POWER_DOWN_STATE) {       // if we're off, start the radio
  1131.         atomic RadioState = IDLE_STATE;         // disable wakeup timer
  1132.         call WakeupTimer.stop();
  1133.         call CC1000StdControl.start();
  1134.         call CC1000Control.BIASOn();
  1135.         call CC1000Control.RxMode();
  1136.         call SpiByteFifo.rxMode(); // SPI to miso
  1137.         call SpiByteFifo.enableIntr(); // enable spi interrupt
  1138.         if (iSquelchCount > CC1K_SquelchCount)
  1139.           call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  1140.         else
  1141.           call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  1142.         call WakeupTimer.start(TIMER_ONE_SHOT, CC1K_LPL_PACKET_TIME*2);
  1143.       }
  1144.     }
  1145.     return Result;
  1146.   }
  1147.   
  1148.   /**********************************************************
  1149.    * make a spibus interrupt handler
  1150.    * needs to handle interrupts for transmit delay
  1151.    * and then go into byte transmit mode with
  1152.    *   timer1 baudrate delay as interrupt handler
  1153.    * else SODbg(DBG_USR2,"Sending Packet ..");
  1154.    * needs to handle interrupts for byte read and detect preamble
  1155.    *  then handle reading a packet
  1156.    * PB - We can use this interrupt handler as a transmit scheduler
  1157.    * because the CC1000 continuously clocks in data, regarless
  1158.    * of whether it's good or not.  Thus, this routine will be called
  1159.    * on every 8 ticks of DCLK. 
  1160.    **********************************************************/
  1162.   async event result_t SpiByteFifo.dataReady(uint8_t data_in) {
  1163.     GTime loctime;
  1164.     signal RadioSendCoordinator.blockTimer();
  1165.     signal RadioReceiveCoordinator.blockTimer();
  1166.      
  1167.     if (bInvertRxData)
  1168.       data_in = ~data_in;
  1169. #ifdef ENABLE_UART_DEBUG
  1170.     UARTPutChar(RadioState);
  1171. #endif
  1172.     switch (RadioState) {
  1174.     case TX_STATE:
  1175.       {
  1176.         call SpiByteFifo.writeByte(NextTxByte);
  1177.         TxByteCnt++;
  1178.         switch (RadioTxState) {
  1179.           
  1180.         case TXSTATE_PREAMBLE:
  1181.           send_sum ++;
  1182.           if (!(TxByteCnt < preamblelen)||
  1183.               (txbufptr->strength == 0xffff && TxByteCnt >= PREAMBLE_LENGTH_TO_BASE)) {
  1184.             NextTxByte = SYNC_BYTE;
  1185.             RadioTxState = TXSTATE_SYNC;
  1186. #ifdef ZMAC_ECN
  1187.             SODbg(DBG_USR2,"Sent packet in slot %in",currentSlot);
  1188.             SODbg(DBG_USR2, "ishcl = %un", IsHCL(currentSlot));
  1189. #endif
  1190.           }
  1191.           break;
  1193.         case TXSTATE_SYNC:
  1194.           send_sum ++;
  1195.           NextTxByte = NSYNC_BYTE;
  1196.           RadioTxState = TXSTATE_DATA;
  1197.           TxByteCnt = -1;
  1198.           if(txbufptr->type == SYNCTYPE){ // allow sync messages
  1199.             syncMsgType *syncMsgPtr = (syncMsgType *) txbufptr->data;
  1200.             call SClock.getTime(&loctime);
  1201.             syncMsgPtr->mticks = loctime.mticks;
  1202.             syncMsgPtr->sticks = loctime.sticks;
  1203.             syncMsgPtr->trust = TRUST_FACTOR;
  1204.             syncMsgPtr->sender = TOS_LOCAL_ADDRESS;
  1205.           }
  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. }