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

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

网络

开发平台：

Others

CC1000RadioIntM-HCLOpt.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.   //  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.           SODbg(DBG_USR2,"Going into ECNn");
  480.           if(recvEcnMsgPtr->senderAddress == nextHop){  //check forwarding node's address
  481.             //suppress ECN
  482. #ifdef ZMAC_ECN
  483.             SODbg(DBG_USR2,"Suppressed own ECNn");
  484. #endif
  485.             atomic ecnPending = FALSE;
  486.             slots_since_ecnsend = 0;
  487.             slots_since_ecnrecv = 0;
  488.           }
  489.         }
  490.       } else if((pBuf->type != SYNCTYPE) && (pBuf->type != ECNTYPE)){
  491. #ifdef ZMAC_ECN
  492.         //        SODbg(DBG_USR2,"Received packet of type %u, crc = %un", pBuf->type, pBuf->crc);
  493. #endif
  494.         pBuf = signal Receive.receive((TOS_MsgPtr)pBuf);
  495.       }
  496.       
  497.       if (pBuf)
  498.         rxbufptr = pBuf;
  499.       rxbufptr->length = 0;
  500.     }
  501.     call SpiByteFifo.enableIntr();
  502.   }
  503.   
  504.   task void PacketSent() {
  505.     TOS_MsgPtr pBuf; //store buf on stack 
  506.     atomic {
  507.       txbufptr->time = 0;
  508.       pBuf = txbufptr;
  509.     }
  510.       
  511.     if ((txbufptr->type != ECNTYPE) && (txbufptr->type != SYNCTYPE)){
  512.       if(txbufptr->type == AM_MULTIHOP)
  513.         dataSent++;
  514.       signal Send.sendDone((TOS_MsgPtr)pBuf, SUCCESS);
  515.     } else if(txbufptr->type == SYNCTYPE){
  516. #ifdef ZMAC_DEBUG
  517.       //      SODbg(DBG_USR2, "Sent one sync message $$$$$$$$$n");
  518. #endif
  519.     } else if(txbufptr->type == ECNTYPE){
  520. #ifdef ZMAC_DEBUG
  521.       //      SODbg(DBG_USR2, "Sent one ecn message $$$$$$$$$n");
  522. #endif
  523.     }
  524.       
  525.     atomic bTxBusy = FALSE;
  526.     if(pktsLastSync > SYNC_PERIOD){
  527.       atomic{
  528.         ackOrig = bAckEnable;
  529.         bAckEnable = FALSE;
  530.       }
  531.       call Send.send(&syncMsgHdr);
  532.       pktsLastSync = 0;
  533.     } else if((currentMAC == ZMAC) && (ecnforward == TRUE)){
  534.       atomic{
  535.         ackOrig = bAckEnable;
  536.         bAckEnable = FALSE;
  537.       }
  538.       call Send.send(&ecnForwardMsgHdr);
  539.       atomic ecnforward = FALSE;
  540. #ifdef ZMAC_ECN
  541.       SODbg(DBG_USR2,"Forwarded ECNn");
  542. #endif
  543.     } else if((currentMAC == ZMAC) && (ecnPending == TRUE)){
  544.       atomic{
  545.         ackOrig = bAckEnable;
  546.         bAckEnable = FALSE;
  547.       }
  548.       call Send.send(&ecnMsgHdr);
  549.       atomic ecnPending = FALSE;
  550.       atomic slots_since_ecnsend = 0;
  551. #ifdef ZMAC_ECN
  552.       SODbg(DBG_USR2,"Sent own ECNn");
  553. #endif
  554.     }
  555.   }
  557.   ///**********************************************************
  558.   //* Exported interface functions
  559.   //**********************************************************/
  560.   command void SetDrand.setParent(uint8_t id){ nextHop = id; }
  561.   command result_t SetDrand.Set(nodeInfo *mInfo, uint8_t nHop, nodeInfo *nInfo, uint16_t sSize){
  562.     uint32_t slotOffset = 0, globalTimeStamp = 0;
  563.     GTime loctime;
  564.     uint8_t i = 0;
  566.     slotSize = sSize;
  567.     nextHop = nHop;
  569.     if(0){
  570.       /*       localFrameLength = myInfo->frame; */
  571.       /*       ownSlot = myInfo->slot; */
  572.       /*       nbrInfo = nInfo; */
  573.       /*       for(i = 0; (i < MAX_NBR) && (nbrInfo[i].nodeID != 0xFF); i++) */
  574.       /*         if(nbrInfo[i].bitMap & TWO_HOP) */
  575.       /*           Blacklist(nbrInfo[i].slot, nbrInfo[i].frame); */
  576.     } else{ // USE THIS ONLY FOR TESTING
  577.       for(i = 0 ; i<MAX_NBR ; i++){ // initialize the nbr table
  578.         nbrInfo[i].nodeID = 0xFF;
  579.         nbrInfo[i].slot = 0xFF;
  580.         nbrInfo[i].frame = 0xFF;
  581.         nbrInfo[i].bitMap = 0x0;
  582.       }
  583. #include "nbrTable.h"
  584.       /*       slotSize = sSize; */
  585.       /*       localFrameLength = 8; */
  586.       /*       nextHop = nHop; */
  587.       /*       switch(TOS_LOCAL_ADDRESS){ */
  588.       /*       case 1: */
  589.       /*         ownSlot = 6; */
  590.       /*         break; */
  591.       /*       case 10: */
  592.       /*         ownSlot = 4; */
  593.       /*         break; */
  594.       /*       case 11: */
  595.       /*         ownSlot = 0; */
  596.       /*         break; */
  597.       /*       case 13: */
  598.       /*         ownSlot = 1; */
  599.       /*         break; */
  600.       /*       case 2: */
  601.       /*         ownSlot = 1; */
  602.       /*         break; */
  603.       /*       case 20: */
  604.       /*         ownSlot = 1; */
  605.       /*         break; */
  606.       /*       case 21: */
  607.       /*         ownSlot = 2; */
  608.       /*         break; */
  609.       /*       case 22: */
  610.       /*         ownSlot = 7; */
  611.       /*         break; */
  612.       /*       case 24: */
  613.       /*         ownSlot = 0; */
  614.       /*         break; */
  615.       /*       case 0: */
  616.       /*         ownSlot = 5; */
  617.       /*         break; */
  618.       /*       case 8: */
  619.       /*         ownSlot = 2; */
  620.       /*         break; */
  621.       /*       case 9: */
  622.       /*         ownSlot = 3; */
  623.       /*         break; */
  624.       /*       } */
  625.     }
  627.     localFrameSize = localFrameLength * slotSize;
  628.     globalFrameSize = globalFrameLength * slotSize;
  629.     slotMultiplier = (uint16_t) (slotSize * 1.024);
  631.     call SClock.getTime(&loctime);
  632.     globalTimeStamp = (uint32_t)(loctime.mticks * 568.889 + loctime.sticks * 0.00868056); //in ms
  633.     slotOffset = (uint32_t) (1.024 * (slotSize - (globalTimeStamp % slotSize))); // in timer units .976562 = 1000/1024
  634.     slotNum = (uint32_t) (globalTimeStamp/slotSize);
  635.     currentSlot = slotNum & (localFrameLength - 1);
  636.     globalSlot = slotNum & (globalFrameLength - 1);
  637.     
  638.     call TDMATimer.start(TIMER_ONE_SHOT, slotOffset);
  639. #ifdef ZMAC_TIMER
  640.     // SODbg(DBG_USR2,"Started timer slotsize - offset is %in",slotSize - slotOffset);
  641. #endif
  642.     return SUCCESS; 
  643.   }
  645.   command result_t StdControl.init() {
  646.     char i;
  647.     ecnMsgType *ecnMsgPtr = (ecnMsgType *) ecnMsgHdr.data;
  648.     atomic {
  649.       RadioState = DISABLED_STATE;
  650.       RadioTxState = TXSTATE_PREAMBLE;
  651.       rxbufptr = &RxBuf;
  652.       rxbufptr->length = 0;
  653.       rxlength = MSG_DATA_SIZE-2;
  654.       RxBitOffset = 0;
  655.       iSquelchCount = 0;
  656.       
  657.       PreambleCount = 0;
  658.       RSSISampleFreq = 0;
  659.       RxShiftBuf.W = 0;
  660.       iRSSIcount = 0;
  661.       bTxPending = FALSE;
  662.       bTxBusy = FALSE;
  663.       bRSSIValid = FALSE;
  664.       bAckEnable = FALSE; // to test for ECN only
  665.       bCCAEnable = TRUE;
  666.       CC1K_PulseLevel = 300;
  667.       sMacDelay = -1;
  668.       usRSSIVal = -1;
  669.       usSquelchIndex = 0;
  670.       pulse_check_count = 0;
  671.       lplpower =  0;//0x87;
  672.       RSSIInitState = NULL_STATE;
  673.       //      if(TOS_LOCAL_ADDRESS == 0) lplpower = 0;
  674.       //      lplpowertx = 7;
  675.       usSquelchVal = CC1K_SquelchInit;
  677.       currentMAC = BMAC;
  678.       congBackOffs = 0;
  679.       packetsSent = 0;
  680.       pktsLastSync = 0;
  681.       avgLoss = 0.0;
  682.       curHCLlist = 0;
  683.       globalFrameLength = GLOBAL_FRAME_LENGTH;
  685.       localFrameLength = GLOBAL_FRAME_LENGTH;
  686.       slotSize = 50;
  687.       localFrameSize = localFrameLength * slotSize;
  688.       globalFrameSize = globalFrameLength * slotSize;
  690.       ackOrig = bAckEnable;
  691.       ecnPending = FALSE;
  692.       ecnforward = FALSE;
  694.       enableHCL = FALSE; // ecn flag, set if currently ecn is going on ...
  695.       pureHCL = FALSE;
  696.       HCLselect = SELECTHCL;
  697.       needTimeSync = FALSE;
  699.       slots_since_ecnsend = 0;
  700.       slots_since_ecnrecv = 0;
  701.       slots_since_ecncheck = 0;
  703.       ecnMsgHdr.type = ECNTYPE;  //set ecnMsg headers
  704.       ecnMsgHdr.addr = TOS_BCAST_ADDR; //ECN Indicator;
  705.       ecnMsgHdr.length = sizeof(ecnMsgType);
  706.       ecnMsgHdr.group = 125;
  707.       ecnMsgHdr.crc = 0;
  709.       ecnForwardMsgHdr.type = ECNTYPE;
  710.       ecnForwardMsgHdr.addr = TOS_BCAST_ADDR; 
  711.       ecnForwardMsgHdr.length = sizeof(ecnMsgType);
  712.       ecnForwardMsgHdr.group = 125;
  713.       ecnForwardMsgHdr.crc = 0;
  715.       syncMsgHdr.type = SYNCTYPE;  //set syncMsg headers
  716.       syncMsgHdr.addr = TOS_BCAST_ADDR; //SYNC Indicator;
  717.       syncMsgHdr.length = sizeof(syncMsgType);
  718.       syncMsgHdr.group = 125;
  719.       syncMsgHdr.crc = 0;
  720.       
  721.       ecnMsgPtr->hopCount = 0; //hopcount
  722.       ecnMsgPtr->nextHop = nextHop; //parent node
  723.       ecnMsgPtr->senderAddress = TOS_LOCAL_ADDRESS;
  724.     }
  726.     for (i = 0; i < CC1K_SquelchTableSize; i++)
  727.       usSquelchTable[(int)i] = CC1K_SquelchInit;
  729.     call SpiByteFifo.initSlave(); // set spi bus to slave mode
  730.    
  731.     call CC1000StdControl.init();
  732.     call CC1000Control.SelectLock(0x9); // Select MANCHESTER VIOLATION
  733.     bInvertRxData = call CC1000Control.GetLOStatus();
  735.     call ADCControl.bindPort(TOS_ADC_CC_RSSI_PORT,TOSH_ACTUAL_CC_RSSI_PORT);
  736.     call ADCControl.init();
  737.     
  738.     call Random.init();
  739.     call TimerControl.init();
  741. #ifdef ZMAC_DEBUG
  742.     init_debug();
  743. #endif
  744.     LocalAddr = TOS_LOCAL_ADDRESS;
  746.     return SUCCESS;
  747.   }
  748.   
  749.   /**
  750.    * Get the current Low Power Listening transmit mode
  751.    * @return mode number (see SetListeningMode)
  752.    */
  753.   async command uint8_t LowPowerListening.GetTransmitMode() {
  754.     return lplpowertx;
  755.   }
  756.   // legacy support
  757.   async command uint8_t GetTransmitMode() {
  758.     return call LowPowerListening.GetTransmitMode();
  759.   }
  761.   /**
  762.    * Set the transmit mode.  This allows for hybrid schemes where
  763.    * the transmit mode is different than the receive mode.
  764.    * Use SetListeningMode first, then change the mode with SetTransmitMode.
  765.    *
  766.    * @param mode mode number (see SetListeningMode)
  767.    * @return SUCCESS if the mode was successfully changed
  768.    */
  769.   async command result_t LowPowerListening.SetTransmitMode(uint8_t power) {
  770.     if ((power >= CC1K_LPL_STATES) || (power == lplpowertx))
  771.       return FAIL;
  773.     // check if the radio is currently doing something
  774.     if ((!bTxPending) && ((RadioState == POWER_DOWN_STATE) || 
  775.                           (RadioState == IDLE_STATE) ||
  776.                           (RadioState == DISABLED_STATE))) {
  778.       atomic {
  779.         lplpowertx = power;
  780.         preamblelen = ((PRG_RDB(&CC1K_LPL_PreambleLength[lplpowertx*2]) << 8)
  781.                        | PRG_RDB(&CC1K_LPL_PreambleLength[(lplpowertx*2)+1]));
  782.       }
  783.       return SUCCESS;
  784.     }
  785.     return FAIL;
  786.   }
  787.   // legacy support
  788.   async command result_t SetTransmitMode(uint8_t power) {
  789.     return call LowPowerListening.SetTransmitMode(power);
  790.   }
  792.   /**
  793.    * Set the current Low Power Listening mode.
  794.    * Setting the LPL mode sets both the check interval and preamble length.
  795.    *
  796.    * Modes include:
  797.    *  0 = Radio full on
  798.    *  1 = 10ms check interval
  799.    *  2 = 25ms check interval
  800.    *  3 = 50ms check interval
  801.    *  4 = 100ms check interval (recommended)
  802.    *  5 = 200ms check interval
  803.    *  6 = 400ms check interval
  804.    *  7 = 800ms check interval
  805.    *  8 = 1600ms check interval
  806.    *
  807.    * @param mode the mode number
  808.    * @return SUCCESS if the mode was successfully changed
  809.    */
  810.   async command result_t LowPowerListening.SetListeningMode(uint8_t power) {
  811.     // valid low power listening values are 0 to 8
  812.     // 0 is "always on" and 8 is lowest duty cycle
  813.     if ((power >= CC1K_LPL_STATES) || (power == lplpower))
  814.       return FAIL;
  816.     // check if the radio is currently doing something
  817.     if ((!bTxPending) && ((RadioState == POWER_DOWN_STATE) || 
  818.                           (RadioState == IDLE_STATE) ||
  819.                           (RadioState == DISABLED_STATE))) {
  821.       // change receiving function in CC1000Radio
  822.       call WakeupTimer.stop();
  823.       atomic {
  824.         if (lplpower == lplpowertx) {
  825.           lplpowertx = power;
  826.         }
  827.         lplpower = power;
  828.       }
  830.       // if successful, change power here
  831.       if (RadioState == IDLE_STATE) {
  832.         RadioState = DISABLED_STATE;
  833.         call StdControl.stop();
  834.         call StdControl.start();
  835.       }
  836.       if (RadioState == POWER_DOWN_STATE) {
  837.         RadioState = DISABLED_STATE;
  838.         call StdControl.start();
  839.         call PowerManagement.adjustPower();
  840.       }
  841.     }
  842.     else {
  843.       return FAIL;
  844.     }
  845.     return SUCCESS;
  846.   }
  847.   // legacy support
  848.   async command result_t SetListeningMode(uint8_t power) {
  849.     return call SetListeningMode(power);
  850.   }
  852.   /**
  853.    * Gets the state of low power listening on the chipcon radio.
  854.    * @return Current low power listening state value
  855.    */
  856.   async command uint8_t LowPowerListening.GetListeningMode() {
  857.     return lplpower;
  858.   }
  859.   // legacy support
  860.   async command uint8_t GetListeningMode() {
  861.     return call LowPowerListening.GetListeningMode();
  862.   } 
  864.   /**
  865.    * Set the preamble length of outgoing packets
  866.    *
  867.    * @param bytes length of the preamble in bytes
  868.    * @return SUCCESS if the preamble length was successfully changed
  869.    */
  870.   async command result_t LowPowerListening.SetPreambleLength(uint16_t bytes) {
  871.     result_t result = FAIL;
  872.     atomic {
  873.       if (RadioState != TX_STATE) {
  874.         preamblelen = bytes;
  875.         result = SUCCESS;
  876.       }
  877.     }
  878.     return result;
  879.   }
  881.   /**
  882.    * Get the preamble length of outgoing packets
  883.    *
  884.    * @return length of the preamble in bytes
  885.    */
  886.   async command uint16_t LowPowerListening.GetPreambleLength() {
  887.     return preamblelen;
  888.   }
  890.   /**
  891.    * Set the check interval (time between waking up and sampling
  892.    * the radio for activity in low power listening)
  893.    *
  894.    * @param ms check interval in milliseconds
  895.    * @return SUCCESS if the check interval was successfully changed
  896.    */
  897.   async command result_t LowPowerListening.SetCheckInterval(uint16_t ms) {
  898.     // sleep time will go into effect after the next wakeup time
  899.     atomic sleeptime = ms;
  900.     return SUCCESS;
  901.   }
  903.   /**
  904.    * Get the check interval currently used by low power listening
  905.    *
  906.    * @return length of the check interval in milliseconds
  907.    */
  908.   async command uint16_t LowPowerListening.GetCheckInterval() {
  909.     return sleeptime;
  910.   }
  913.   event result_t SquelchTimer.fired() {
  914.     char currentRadioState;
  915.     atomic currentRadioState = RadioState;
  917.     if (currentRadioState == IDLE_STATE) {
  918.       atomic RSSIInitState = currentRadioState;
  919.       call RSSIADC.getData();
  920.     }
  921.     return SUCCESS;
  922.   }
  924.   event result_t WakeupTimer.fired() {
  925.     uint8_t currentRadioState;
  927.     if (lplpower == 0)
  928.       return SUCCESS;
  929.     
  930.     atomic currentRadioState = RadioState;
  931.     switch(currentRadioState) {
  933.     case IDLE_STATE:
  934.       if (!bTxPending || (enableHCL && IsHCL(currentSlot))) { // changed here for hcl optimization
  935.         atomic {
  936.           RadioState = POWER_DOWN_STATE;
  937.           call SpiByteFifo.disableIntr();
  938.         }
  939.         call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  940.         call SquelchTimer.stop();
  941.         call CC1000StdControl.stop();
  942.       } else {
  943.         call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  944.       }
  945.       break;
  947.     case POWER_DOWN_STATE:
  948.       atomic RadioState = PULSE_CHECK_STATE;
  949.       pulse_check_count = 0;
  950.       call CC1000StdControl.start();
  951.       call CC1000Control.BIASOn();
  952.       call WakeupTimer.start(TIMER_ONE_SHOT, 1);
  953.       return SUCCESS;
  954.       break;
  956.     case PULSE_CHECK_STATE:
  957.       call CC1000Control.RxMode();
  958.       if(!(call RSSIADC.getData())){
  959.         call WakeupTimer.start(TIMER_ONE_SHOT, TIME_BETWEEN_CHECKS);
  960.         atomic RadioState = POWER_DOWN_STATE;
  961.       }
  962.       else {
  963.         TOSH_uwait(80);
  964.       }
  965.       call CC1000StdControl.stop();
  966.       pulse_check_sum ++;
  967.       break;
  969.     default:
  970.       call WakeupTimer.start(TIMER_ONE_SHOT, 5);
  971.     }
  972.     return SUCCESS;
  973.   }
  975.   task void IdleTimerTask(){
  976.     if (iSquelchCount > CC1K_SquelchCount)
  977.       call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  978.     else
  979.       call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  980.     call WakeupTimer.start(TIMER_ONE_SHOT, TIME_AFTER_CHECK);
  981.     /*if(pulse_check_sum > CHECK_MA_COUNT){
  982.       power_sum ++;
  983.       pulse_check_sum -= CHECK_MA_COUNT;
  984.       }
  985.       if(send_sum > SEND_MA_COUNT){
  986.       power_sum ++;
  987.       send_sum -= SEND_MA_COUNT;
  988.       }
  989.       if(receive_sum > RECEIVE_MA_COUNT){
  990.       power_sum ++;
  991.       receive_sum -= RECEIVE_MA_COUNT;
  992.       }*/
  993.   }
  995.   //added by Mahesh
  997.   event result_t TDMATimer.fired(){
  998.     call TDMATimer.start(TIMER_ONE_SHOT, slotMultiplier);
  999.     slotNum++;
  1000.     atomic currentMAC = ZMAC;
  1001.     atomic{
  1002.       currentSlot = slotNum & (localFrameLength - 1);
  1003.       globalSlot = slotNum & (globalFrameLength - 1);
  1004. #ifdef ZMAC_TIMER
  1005.       SODbg(DBG_USR2,"*************Timer fired with current slot = %u, own slot = %un", currentSlot, ownSlot);
  1006. #endif 
  1007.       if(HCLselect){
  1008.         slots_since_ecnsend ++;
  1009.         slots_since_ecnrecv ++;
  1010.         slots_since_ecncheck++;
  1011.         if((packetsSent > ECNMINPACKETS) && (slots_since_ecncheck >= ECNCHECKPERIOD)){
  1012.           double currentLoss = (double)congBackOffs/packetsSent;
  1013.           avgLoss = ALPHA * (currentLoss) + (1 - ALPHA) * avgLoss;
  1014. #ifdef ZMAC_ECN
  1015.           SODbg(DBG_USR2,"#####################Congestion Statistics: %i / %i, %in", congBackOffs, packetsSent, (uint16_t) avgLoss);
  1016. #endif
  1017.           slots_since_ecncheck = 0;
  1018.           congBackOffs = 0;
  1019.           packetsSent = 0;
  1020.           if((avgLoss > ECNTHRESHOLD) && (slots_since_ecnsend >= ECNSENDPERIOD)){
  1021.             ecnMsgType *ecnMsgPtr = (ecnMsgType *) ecnMsgHdr.data;
  1022. #ifdef ZMAC_ECN
  1023.             SODbg(DBG_USR2,"Setting ECN flagn");
  1024. #endif
  1025.             // change by acw, go to ecn myself if sending ecn
  1026.             atomic enableHCL = TRUE;
  1027.             slots_since_ecnrecv = 0;
  1028.             // change by acw ends
  1030.             ecnMsgPtr->nextHop = nextHop;
  1031.             if(!pureHCL)
  1032.               ecnPending = TRUE;
  1033.           }
  1034.         }
  1035.         if((enableHCL) && (slots_since_ecnrecv >= ECNEXPIREPERIOD)){
  1036.           if(!pureHCL)
  1037.             enableHCL = FALSE;
  1038. #ifdef ZMAC_ECN
  1039.           SODbg(DBG_USR2,"ECN expired, into LCL againn");
  1040. #endif
  1041.         }
  1042.         
  1043. #ifdef ZMAC_ECN
  1044.         if(enableHCL)
  1045.           SODbg(DBG_USR2,"Current slot %i **********************n",currentSlot);
  1046. #endif
  1047. #ifdef ZMAC_ECN
  1048.         if(enableHCL && IsHCL(globalSlot) && ownSlot != currentSlot)
  1049.           SODbg(DBG_USR2,"***** ****** ****** ****** Current slot %i HCLn",currentSlot);
  1050. #endif
  1051.       }
  1052.       // changed here for hcl optimization
  1053.       if((RadioState == POWER_DOWN_STATE) || (RadioState == DISABLED_STATE)){
  1054.         if (bTxPending && (!enableHCL || !IsHCL(currentSlot))) { // bug fixed by Dr. Rhee
  1055.           call CC1000Control.RxMode();
  1056.           RadioState = IDLE_STATE;
  1057.           call SpiByteFifo.rxMode();     // SPI to miso
  1058.           call SpiByteFifo.enableIntr(); // enable spi interrupt
  1059.           post IdleTimerTask();
  1060.         }
  1061.       }
  1063.       if(bTxPending){
  1064.         sMacDelay = getZMACBackoff(sMacDelay);
  1065. #ifdef ZMAC_BACKOFF
  1066.         SODbg(DBG_USR2,"TDMATimerFired: backoff %un", sMacDelay);
  1067. #endif
  1068.       }
  1069.     }
  1070.     return SUCCESS;
  1071.   }
  1072.  
  1073.   command result_t StdControl.stop() {
  1074.     atomic RadioState = DISABLED_STATE;
  1076.     call SquelchTimer.stop();
  1077.     call WakeupTimer.stop();
  1078.     call CC1000StdControl.stop();
  1079.     call SpiByteFifo.disableIntr(); // disable spi interrupt
  1080.     return SUCCESS;
  1081.   }
  1083.   command result_t StdControl.start() {
  1084.     uint8_t currentRadioState;
  1085.     atomic currentRadioState = RadioState;
  1087.     call SClock.SetRate(MAX_VAL,CLK_DIV_64);
  1088.     if (currentRadioState == DISABLED_STATE) {
  1089.       atomic {
  1090.         rxbufptr->length = 0;
  1091.         RadioState  = IDLE_STATE;
  1092.         bTxPending = bTxBusy = FALSE;
  1093.         sMacDelay = -1;
  1094.         if(SLEEPTIME > 0){
  1095.           sleeptime = SLEEPTIME;
  1096.           preamblelen = PREAMBLELEN;
  1097.         } else{
  1098.           lplpower = lplpowertx = 0;
  1099.           sleeptime = ((PRG_RDB(&CC1K_LPL_SleepTime[lplpower*2]) << 8) |
  1100.                        PRG_RDB(&CC1K_LPL_SleepTime[(lplpower*2)+1]));
  1101.           preamblelen = ((PRG_RDB(&CC1K_LPL_PreambleLength[lplpowertx*2]) << 8) |
  1102.                          PRG_RDB(&CC1K_LPL_PreambleLength[(lplpowertx*2)+1]));
  1103.         }
  1104. /*         sleeptime = ((PRG_RDB(&CC1K_LPL_SleepTime[lplpower*2]) << 8) | */
  1105. /*                      PRG_RDB(&CC1K_LPL_SleepTime[(lplpower*2)+1])); */
  1106. /*         preamblelen = ((PRG_RDB(&CC1K_LPL_PreambleLength[lplpowertx*2]) << 8) | */
  1107. /*                        PRG_RDB(&CC1K_LPL_PreambleLength[(lplpowertx*2)+1])); */
  1108.       }
  1109.       // all power on, captain!
  1110.       rxbufptr->length = 0;
  1111.       atomic RadioState = IDLE_STATE;
  1112.       call CC1000StdControl.start();
  1113.       call CC1000Control.BIASOn();
  1114.       call SpiByteFifo.rxMode(); // SPI to miso
  1115.       call CC1000Control.RxMode();
  1116.       if (iSquelchCount > CC1K_SquelchCount)
  1117.         call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  1118.       else
  1119.         call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  1120.       call SpiByteFifo.enableIntr(); // enable spi interrupt
  1121.       if (lplpower > 0) {
  1122.         // set a time to start sleeping after measuring the noise floor
  1123.         call WakeupTimer.start(TIMER_ONE_SHOT, CC1K_SquelchIntervalSlow);
  1124.       }
  1125.     }
  1126.     return SUCCESS;
  1127.   }
  1129.   command result_t Send.send(TOS_MsgPtr pMsg) {
  1130.     result_t Result = SUCCESS;
  1131.     uint8_t currentRadioState = 0;
  1132.    
  1133.     atomic {
  1134.       if (bTxBusy) {
  1135.         Result = FAIL;
  1136. #ifdef ZMAC_DEBUG
  1137.         //        SODbg(DBG_USR2, "Busy sending the message of type %u!n", txbufptr->type);
  1138. #endif
  1139.       } else {
  1140.         bTxBusy = TRUE;
  1141.         txbufptr = pMsg;
  1142.         txlength = pMsg->length + (MSG_DATA_SIZE - DATA_LENGTH - 2);
  1144.         if(bCCAEnable){ // initially back off [1,32] bytes (approx 2/3 packet)
  1145.           if(currentMAC == BMAC)
  1146.             sMacDelay = signal MacBackoff.initialBackoff(pMsg);
  1147.           else
  1148.             sMacDelay = getZMACBackoff(0);
  1149.         } else
  1150.           sMacDelay = 0;
  1151. #ifdef ZMAC_BACKOFF
  1152.         SODbg(DBG_USR2, "SendMSG(): Need to send type %u, myslot %u, current slot %u backoff %un",
  1153.               txbufptr->type, ownSlot, currentSlot, sMacDelay);
  1154. #endif
  1155.         bTxPending = TRUE;
  1156.       }
  1157.       currentRadioState = RadioState;
  1158.     }
  1160.     if (Result) {
  1161.       if (currentRadioState == POWER_DOWN_STATE){ //{ && (!enableHCL || !IsHCL(currentSlot))) {       // if we're off, start the radio
  1162.         atomic RadioState = IDLE_STATE;         // disable wakeup timer
  1163.         call WakeupTimer.stop();
  1164.         call CC1000StdControl.start();
  1165.         call CC1000Control.BIASOn();
  1166.         call CC1000Control.RxMode();
  1167.         call SpiByteFifo.rxMode(); // SPI to miso
  1168.         call SpiByteFifo.enableIntr(); // enable spi interrupt
  1169.         if (iSquelchCount > CC1K_SquelchCount)
  1170.           call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  1171.         else
  1172.           call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  1173.         call WakeupTimer.start(TIMER_ONE_SHOT, CC1K_LPL_PACKET_TIME*2);
  1174.       }
  1175.     }
  1176.     return Result;
  1177.   }
  1178.   
  1179.   /**********************************************************
  1180.    * make a spibus interrupt handler
  1181.    * needs to handle interrupts for transmit delay
  1182.    * and then go into byte transmit mode with
  1183.    *   timer1 baudrate delay as interrupt handler
  1184.    * else SODbg(DBG_USR2,"Sending Packet ..");
  1185.    * needs to handle interrupts for byte read and detect preamble
  1186.    *  then handle reading a packet
  1187.    * PB - We can use this interrupt handler as a transmit scheduler
  1188.    * because the CC1000 continuously clocks in data, regarless
  1189.    * of whether it's good or not.  Thus, this routine will be called
  1190.    * on every 8 ticks of DCLK. 
  1191.    **********************************************************/
  1193.   async event result_t SpiByteFifo.dataReady(uint8_t data_in) {
  1194.     GTime loctime;
  1195.     signal RadioSendCoordinator.blockTimer();
  1196.     signal RadioReceiveCoordinator.blockTimer();
  1197.      
  1198.     if (bInvertRxData)
  1199.       data_in = ~data_in;
  1200. #ifdef ENABLE_UART_DEBUG
  1201.     UARTPutChar(RadioState);
  1202. #endif
  1203.     switch (RadioState) {
  1205.     case TX_STATE:
  1206.       {
  1207.         call SpiByteFifo.writeByte(NextTxByte);
  1208.         TxByteCnt++;
  1209.         switch (RadioTxState) {
  1210.           
  1211.         case TXSTATE_PREAMBLE:
  1212.           send_sum ++;
  1213.           if (!(TxByteCnt < preamblelen)||
  1214.               (txbufptr->strength == 0xffff && TxByteCnt >= PREAMBLE_LENGTH_TO_BASE)) {
  1215.             NextTxByte = SYNC_BYTE;
  1216.             RadioTxState = TXSTATE_SYNC;
  1217. #ifdef ZMAC_ECN
  1218.             SODbg(DBG_USR2,"Sent packet in slot %in",currentSlot);
  1219.             SODbg(DBG_USR2, "ishcl = %un", IsHCL(currentSlot));
  1220. #endif
  1221.           }
  1222.           break;
  1224.         case TXSTATE_SYNC:
  1225.           send_sum ++;
  1226.           NextTxByte = NSYNC_BYTE;
  1227.           RadioTxState = TXSTATE_DATA;
  1228.           TxByteCnt = -1;
  1229.           if(txbufptr->type == SYNCTYPE){ // allow sync messages
  1230.             syncMsgType *syncMsgPtr = (syncMsgType *) txbufptr->data;
  1231.             call SClock.getTime(&loctime);
  1232.             syncMsgPtr->mticks = loctime.mticks;
  1233.             syncMsgPtr->sticks = loctime.sticks;
  1234.             syncMsgPtr->trust = TRUST_FACTOR;
  1235.             syncMsgPtr->sender = TOS_LOCAL_ADDRESS;
  1236.           }
  1237.           // for Time Sync services
  1238.           signal RadioSendCoordinator.startSymbol(8, 0, txbufptr);
  1239.           break;
  1241.         case TXSTATE_DATA:
  1242.           send_sum ++;
  1243.           if ((uint8_t)(TxByteCnt) < txlength){
  1244.             if((txbufptr->type == SYNCTYPE) && (TxByteCnt == 5)){ // 5 = offset of timestamp
  1245.               syncMsgType *syncMsgPtr = (syncMsgType *) txbufptr->data;
  1246.               call SClock.getTime(&loctime);
  1247.               AddTime(&loctime, &loctime, &constOffset);
  1248.               syncMsgPtr->mticks = loctime.mticks;
  1249.               syncMsgPtr->sticks = loctime.sticks;
  1250.             }
  1251.             NextTxByte = ((uint8_t *)txbufptr)[(TxByteCnt)];
  1252.             usRunningCRC = crcByte(usRunningCRC,NextTxByte);
  1253.             signal RadioSendCoordinator.byte(txbufptr, (uint8_t)TxByteCnt); // Time Sync
  1254.           }
  1255.           else {
  1256.             NextTxByte = (uint8_t)(usRunningCRC);
  1257.             RadioTxState = TXSTATE_CRC;
  1258.           }
  1259.           break;
  1261.         case TXSTATE_CRC:
  1262.           send_sum ++;
  1263.           NextTxByte = (uint8_t)(usRunningCRC>>8);
  1264.           RadioTxState = TXSTATE_FLUSH;
  1265.           TxByteCnt = 0;
  1266.           break;
  1268.         case TXSTATE_FLUSH:
  1269.           send_sum ++;
  1270.           if (TxByteCnt > 3) {
  1271.             TxByteCnt = 0;
  1272. #ifdef ZMAC_DEBUG
  1273.             // SODbg(DBG_USR2,"Came heren");
  1274. #endif
  1275.             if (bAckEnable)
  1276.               RadioTxState = TXSTATE_WAIT_FOR_ACK;         
  1277.             else {
  1278. #ifdef ZMAC_DEBUG
  1279.               // SODbg(DBG_USR2,"came inside: current MAC: %i ackenabled :%i,ecnPending: %i ecnforward %i ecnSENT %in",currentMAC,bAckEnable,ecnPending,ecnforward,sentECN);
  1280. #endif
  1281.               packetsSent ++;
  1282.               call SpiByteFifo.rxMode();
  1283.               call CC1000Control.RxMode();
  1284.               RadioTxState = TXSTATE_DONE;
  1285.             }
  1286.           }
  1287.           break;
  1289.         case TXSTATE_WAIT_FOR_ACK:
  1290.           if(TxByteCnt == 1){
  1291.             send_sum ++;
  1292.             call SpiByteFifo.rxMode();
  1293.             call CC1000Control.RxMode();
  1294.             break;
  1295.           }
  1296.           receive_sum ++;
  1297.           if (TxByteCnt > 3) {
  1298.             RadioTxState = TXSTATE_READ_ACK;
  1299.             TxByteCnt = 0;
  1300.             search_word = 0;
  1301.           }
  1302.           break;
  1304.         case TXSTATE_READ_ACK:
  1305.           {
  1306.             uint8_t i;
  1307.             receive_sum ++;
  1308.             for(i = 0; i < 8; i ++){
  1309.               search_word <<= 1;
  1310.               if(data_in & 0x80) search_word |=  0x1;
  1311.               data_in <<= 1;
  1312.               if (search_word == 0xba83){
  1313.                 txbufptr->ack = 1;
  1314.                 RadioTxState = TXSTATE_DONE;
  1315. #ifdef ZMAC_DEBUG
  1316.                 //                SODbg(DBG_USR2,"received ackn");
  1317. #endif
  1318.                 return SUCCESS;
  1319.               }
  1320.             }
  1321.           }
  1322.           if(TxByteCnt >= MAX_ACK_WAIT){   
  1323.             txbufptr->ack = 0;  
  1324. #ifdef ZMAC_DEBUG
  1325.             //       SODbg(DBG_USR2,"did not receive ack %i %i %in",lostacks,packetsSent,avgLoss * 100);
  1326. #endif
  1327.             RadioTxState = TXSTATE_DONE;
  1328.           }
  1329.           break;
  1331.         case TXSTATE_DONE:
  1332.         default:
  1333.           bTxPending = FALSE;
  1334.           if((txbufptr->type == ECNTYPE) || (txbufptr->type == SYNCTYPE)){
  1335. #ifdef ZMAC_ECN
  1336.             ecnForwardMsgType *ecnForwardMsgPtr = (ecnForwardMsgType *) txbufptr->data;
  1337.             if(txbufptr->type == ECNTYPE && ecnForwardMsgPtr->hopCount == 1)
  1338.               SODbg(DBG_USR2,"Successfully forwarded ECNn");
  1339. #endif
  1340.             bAckEnable = ackOrig;
  1341.           }
  1342. #ifdef ZMAC_BACKOFF
  1343.           SODbg(DBG_USR2, "Sent one packet of type %u, myslot %u, current slot %u!n", txbufptr->type,
  1344.                 ownSlot, currentSlot);
  1345. #endif
  1346.           if(post PacketSent()) {
  1347.             // If the post operation succeeds, goto Idle
  1348.             // otherwise, we'll try again.
  1349. #ifdef ZMAC_DEBUG
  1350.             //  SODbg(DBG_USR2,"Packet type %in",txbufptr->type);
  1351. #endif
  1352.             RadioState = IDLE_STATE;
  1353.             pktsLastSync++;
  1354.             RSSIInitState = RadioState;
  1355.             call RSSIADC.getData();
  1356.           }
  1357.           break;
  1358.         }
  1359.       }
  1360.       break;
  1362.     case DISABLED_STATE:
  1363.       break;
  1365.     case IDLE_STATE: 
  1366.       {
  1367.         receive_sum ++;
  1368.         if (((data_in == (0xaa)) || (data_in == (0x55)))) {
  1369.           PreambleCount++;
  1370.           if (PreambleCount > CC1K_ValidPrecursor) {
  1371.             PreambleCount = SOFCount = 0;
  1372.             RxBitOffset = RxByteCnt = 0;
  1373.             usRunningCRC = 0;
  1374.             rxlength = MSG_DATA_SIZE-2;
  1375.             RadioState = SYNC_STATE;
  1376.           }
  1377.         } else {
  1378.           if ((currentMAC == BMAC) || (enableHCL == FALSE) || (!IsHCL(currentSlot))) {
  1379.             if((bTxPending) && (--sMacDelay <= 0)){
  1380.               RadioState = PRETX_STATE;
  1381.               RSSIInitState = PRETX_STATE;
  1382.               bRSSIValid = FALSE;
  1383.               iRSSIcount = 0;
  1384.               PreambleCount = 0;
  1385.               call RSSIADC.getData();
  1386.             }
  1387.           } else{
  1388. #ifdef ZMAC_ECN
  1389.             SODbg(DBG_USR2, "&&&&&&&&&&&&&&&&&&&&& ishcl = %un", IsHCL(currentSlot));
  1390. #endif
  1391.           }
  1392.         }
  1393.       }
  1394.       break;
  1396.     case PRETX_STATE:
  1397.       {
  1398.         receive_sum ++;
  1399.         if (((data_in == (0xaa)) || (data_in == (0x55)))) {
  1400.           // Back to the penalty box.
  1401.           sMacDelay = signal MacBackoff.congestionBackoff(txbufptr);
  1402. #ifdef ZMAC_BACKOFF
  1403.           SODbg(DBG_USR2,"SpiDataReady: detected preamble - backoff %un", sMacDelay);
  1404. #endif
  1405.           RadioState = IDLE_STATE;
  1406.         }
  1407.       }
  1408.       break;
  1410.     case SYNC_STATE:
  1411.       {
  1412.         // draw in the preamble bytes and look for a sync byte
  1413.         // save the data in a short with last byte received as msbyte
  1414.         //    and current byte received as the lsbyte.
  1415.         // use a bit shift compare to find the byte boundary for the sync byte
  1416.         // retain the shift value and use it to collect all of the packet data
  1417.         // check for data inversion, and restore proper polarity 
  1418.         // XXX-PB: Don't do this.
  1419.         uint8_t i;
  1421.         receive_sum ++;
  1422.         if ((data_in == 0xaa) || (data_in == 0x55)) {
  1423.           // It is actually possible to have the LAST BIT of the incoming
  1424.           // data be part of the Sync Byte.  SO, we need to store that
  1425.           // However, the next byte should definitely not have this pattern.
  1426.           // XXX-PB: Do we need to check for excessive preamble?
  1427.           RxShiftBuf.MSB = data_in;
  1428.         }
  1429.         else {
  1430.           // TODO: Modify to be tolerant of bad bits in the preamble...
  1431.           uint16_t usTmp;
  1432.           switch (SOFCount) {
  1433.           case 0:
  1434.             RxShiftBuf.LSB = data_in;
  1435.             break;
  1436.   
  1437.           case 1:
  1438.           case 2: 
  1439.           case 3: 
  1440.           case 4: 
  1441.           case 5: 
  1442.             // bit shift the data in with previous sample to find sync
  1443.             usTmp = RxShiftBuf.W;
  1444.             RxShiftBuf.W <<= 8;
  1445.             RxShiftBuf.LSB = data_in;
  1447.             for(i=0;i<8;i++) {
  1448.               usTmp <<= 1;
  1449.               if(data_in & 0x80)
  1450.                 usTmp  |=  0x1;
  1451.               data_in <<= 1;
  1452.               // check for sync bytes
  1453.               if (usTmp == SYNC_WORD) {
  1454.                 if (rxbufptr->length !=0) {
  1455.                   call Leds.redToggle();
  1456.                   RadioState = IDLE_STATE;
  1457.                 }
  1458.                 else {
  1459.                   RadioState = RX_STATE;
  1460.                   RSSIInitState = RX_STATE;
  1461.                   call RSSIADC.getData();
  1462.                   RxBitOffset = 7-i;
  1463.                   // For time sync services
  1464.                   signal RadioReceiveCoordinator.startSymbol(8, RxBitOffset, rxbufptr); 
  1465.                 }
  1466.                 break;
  1467.               }
  1468.             }
  1469.             break;
  1471.           default:
  1472.             // We didn't find it after a reasonable number of tries, so....
  1473.             RadioState = IDLE_STATE;  // Ensures we wait till the end of the transmission
  1474.             break;
  1475.           }
  1476.           SOFCount++;
  1477.         }
  1478.       }
  1479.       break;
  1480.       //  collect the data and shift into double buffer
  1481.       //  shift out data by correct offset
  1482.       //  invert the data if necessary
  1483.       //  stop after the correct packet length is read
  1484.       //  return notification to upper levels
  1485.       //  go back to idle state
  1486.     case RX_STATE:
  1487.       {
  1488.         char Byte;
  1489.         receive_sum ++;
  1491.         RxShiftBuf.W <<=8;
  1492.         RxShiftBuf.LSB = data_in;
  1494.         Byte = (RxShiftBuf.W >> RxBitOffset);
  1495.         ((char*)rxbufptr)[(int)RxByteCnt] = Byte;
  1496.         RxByteCnt++;
  1498.         signal RadioReceiveCoordinator.byte(rxbufptr, (uint8_t)RxByteCnt);
  1500.         if (RxByteCnt < rxlength) {
  1501.           usRunningCRC = crcByte(usRunningCRC,Byte);
  1503.           if (RxByteCnt == (offsetof(struct TOS_Msg,length) + 
  1504.                             sizeof(((struct TOS_Msg *)0)->length))) {
  1505.             rxlength = rxbufptr->length;
  1506.             if (rxlength > TOSH_DATA_LENGTH) {
  1507.               // The packet's screwed up, so just dump it
  1508.               rxbufptr->length = 0;
  1509.               RadioState = IDLE_STATE;  // Waits till end of transmission
  1510.               return SUCCESS;
  1511.             }
  1512.             //Add in the header size
  1513.             rxlength += offsetof(struct TOS_Msg,data);
  1514.           }
  1515.         }
  1516.         else if (RxByteCnt == rxlength) {
  1517.           if(rxbufptr->type == SYNCTYPE) // got all bytes of time stamp !
  1518.             getTimeDiff();
  1519.           usRunningCRC = crcByte(usRunningCRC,Byte);
  1520.           // Shift index ahead to the crc field.
  1521.           RxByteCnt = offsetof(struct TOS_Msg,crc);
  1522.         }
  1523.         else if (RxByteCnt >= MSG_DATA_SIZE) { 
  1525.           // Packet filtering based on bad CRC's is done at higher layers.
  1526.           // So sayeth the TOS weenies.
  1527.           if (rxbufptr->crc == usRunningCRC) {
  1528.             if(rxbufptr->type == SYNCTYPE)
  1529.               post adjustTime();
  1530.             rxbufptr->crc = 1;
  1531.             
  1532.             if(bAckEnable && (rxbufptr->addr == TOS_LOCAL_ADDRESS)){
  1534.               RadioState = SENDING_ACK; 
  1535.               call CC1000Control.TxMode();
  1536.               call SpiByteFifo.txMode();
  1537.               call SpiByteFifo.writeByte(0xaa);
  1538.               RxByteCnt = 0;
  1539.               return SUCCESS; 
  1540.             }
  1542.           } else {
  1543.             rxbufptr->crc = 0;
  1544.           }
  1546.           call SpiByteFifo.disableIntr();
  1547.   
  1548.           RadioState = IDLE_STATE; //DISABLED_STATE;
  1549.           if((currentMAC == ZMAC) && (bTxPending)){ //Ajit - reset timer when time slot boundary
  1550.             sMacDelay = getZMACBackoff(sMacDelay);
  1551. #ifdef ZMAC_BACKOFF
  1552.             SODbg(DBG_USR2,"JustAfterReceive: backoff %u mySlot %u currentSlot %un", sMacDelay,
  1553.                   ownSlot, currentSlot);
  1554. #endif
  1555.           }
  1556.           rxbufptr->strength = usRSSIVal;
  1557.           if (!(post PacketRcvd())) {
  1558.             // If there are insufficient resources to process the incoming packet
  1559.             // we drop it
  1560.             rxbufptr->length = 0;
  1561.             RadioState = IDLE_STATE;
  1562.             call SpiByteFifo.enableIntr();
  1563.           }
  1564.           RSSIInitState = RadioState;
  1565.           call RSSIADC.getData();
  1566.         }
  1567.       }
  1568.       break;
  1570.     case SENDING_ACK:
  1571.       {
  1572.         send_sum ++;
  1573.         RxByteCnt++;
  1574.         if (RxByteCnt >= ACK_LENGTH) { 
  1575.           call CC1000Control.RxMode();
  1576.           call SpiByteFifo.rxMode();
  1577.           call SpiByteFifo.disableIntr();
  1578.           RadioState = IDLE_STATE; //DISABLED_STATE;
  1579.           rxbufptr->strength = usRSSIVal;
  1580.           if (!(post PacketRcvd())) {
  1581.             rxbufptr->length = 0;
  1582.             RadioState = IDLE_STATE;
  1583.             call SpiByteFifo.enableIntr();
  1584.           }
  1585.         }else if(RxByteCnt >= ACK_LENGTH - sizeof(ack_code)){
  1586.           call SpiByteFifo.writeByte(ack_code[RxByteCnt + sizeof(ack_code) - ACK_LENGTH]);
  1587.         }
  1588.       }
  1589.       break;
  1591.     default:
  1592.       break;
  1593.     }
  1595.     if(pulse_check_sum > CHECK_MA_COUNT){
  1596.       power_sum ++;
  1597.       sp_sum++;
  1598.       pulse_check_sum -= CHECK_MA_COUNT;
  1599.     }
  1600.     if(send_sum > SEND_MA_COUNT){
  1601.       power_sum ++;
  1602.       tx_sum++;
  1603.       send_sum -= SEND_MA_COUNT;
  1604.     }
  1605.     if(receive_sum > RECEIVE_MA_COUNT){
  1606.       power_sum ++;
  1607.       rx_sum++;
  1608.       receive_sum -= RECEIVE_MA_COUNT;
  1609.     }
  1610.     return SUCCESS;
  1611.   }
  1613.   task void SleepTimerTask(){
  1614.     call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  1615.   }
  1617.   async event result_t RSSIADC.dataReady(uint16_t data) { 
  1618.     atomic{
  1619.       uint8_t currentRadioState;
  1620.       // TOSH_CLR_PW3_PIN();
  1621.       currentRadioState = RadioState;
  1622.       // find the maximum RSSI value over CC1K_MAX_RSSI_SAMPLES
  1623.       switch(currentRadioState) {
  1624.       case IDLE_STATE:
  1625.         if (RSSIInitState == IDLE_STATE) {
  1626.           atomic usTempSquelch = data;
  1627.           post adjustSquelch();
  1628.         }
  1629.         RSSIInitState = NULL_STATE;
  1630.         break;
  1631.           
  1632.       case RX_STATE:
  1633.         if (RSSIInitState == RX_STATE) {
  1634.           atomic usRSSIVal = data;
  1635.         }
  1636.         RSSIInitState = NULL_STATE;
  1637.         break;
  1638.         
  1639.       case PRETX_STATE:
  1640.         iRSSIcount++;
  1641.         
  1642.         // if the channel is clear or CCA is disabled, GO GO GO!
  1643.         if (((data > (usSquelchVal + CC1K_SquelchBuffer)) ||
  1644.              (!bCCAEnable)) && (RSSIInitState == PRETX_STATE)) { 
  1645.           call SpiByteFifo.writeByte(0xaa);
  1646.           call CC1000Control.TxMode();
  1647.           call SpiByteFifo.txMode();
  1648.           
  1649.           usRSSIVal = data;
  1650.           iRSSIcount = CC1K_MaxRSSISamples;
  1651.           bRSSIValid = TRUE;
  1652.           TxByteCnt = 0;
  1653.           usRunningCRC = 0;
  1654.           RadioState = TX_STATE;
  1655.           RadioTxState = TXSTATE_PREAMBLE;
  1656.           NextTxByte = 0xaa;
  1657.           RSSIInitState = NULL_STATE;
  1658.         }
  1659.         else {
  1660.           RSSIInitState = NULL_STATE;
  1661.           if (iRSSIcount == CC1K_MaxRSSISamples) {
  1662.             sMacDelay = signal MacBackoff.congestionBackoff(txbufptr);
  1663. #ifdef ZMAC_BACKOFF
  1664.             SODbg(DBG_USR2,"adcDataReady: channel busy, backoff %un", sMacDelay);
  1665. #endif
  1666.             RadioState = IDLE_STATE;
  1667.           }
  1668.           else {
  1669.             RSSIInitState = currentRadioState;
  1670.             call RSSIADC.getData();
  1671.           }
  1672.         }
  1673.         break;
  1674.         
  1675.       case PULSE_CHECK_STATE:
  1676.         atomic{
  1677.           uint8_t done = 0;
  1678.           uint16_t threshold = call GetSquelch();
  1679.           threshold = threshold - (call GetSquelch() >> 2);
  1680.           if(data > threshold){
  1681.             // adjust the noise floor level
  1682.             atomic usTempSquelch = data;
  1683.             post adjustSquelch();
  1684.             
  1685.           }else if(pulse_check_count > 5){
  1686.             //go to the idle state since no outliers were found
  1687.             call CC1000Control.RxMode();
  1688.             RadioState = IDLE_STATE;
  1689.             call SpiByteFifo.rxMode();     // SPI to miso
  1690.             call SpiByteFifo.enableIntr(); // enable spi interrupt
  1691.             post IdleTimerTask();
  1692.             done = 1;
  1693.             
  1694.           }else {
  1695.             call CC1000Control.RxMode();
  1696.             if(call RSSIADC.getData()){
  1697.               TOSH_uwait(80);
  1698.               pulse_check_count ++;
  1699.               done = 1;
  1700.             }
  1701.             pulse_check_sum ++;
  1702.             call CC1000StdControl.stop();
  1703.           }
  1704.           // changed here for hcl optimization
  1705.           if (bTxPending && (!enableHCL || !IsHCL(currentSlot))) { // bug fixed by Dr. Rhee
  1706.             //go to the idle state since no outliers were found
  1707.             call CC1000Control.RxMode();
  1708.             RadioState = IDLE_STATE;
  1709.             call SpiByteFifo.rxMode();     // SPI to miso
  1710.             call SpiByteFifo.enableIntr(); // enable spi interrupt
  1711.             post IdleTimerTask();
  1712.             done = 1;
  1713.           }
  1715.           if(done == 0){
  1716.             post SleepTimerTask();
  1717.             RadioState = POWER_DOWN_STATE;
  1718.             call SpiByteFifo.disableIntr();
  1719.           }
  1720.         }
  1721.         //go to the power down state
  1722.         break;
  1724.       default:
  1725.       }
  1726.     }
  1727.     return SUCCESS;
  1728.   }
  1730.   // XXX:JP- for testing the mac layer squlech value
  1731.   async command uint16_t GetSquelch() {
  1732.     return usSquelchVal;
  1733.   }
  1734.   // XXX:JP- for testing the mac layer power consumption
  1735.   async command uint16_t GetPower() {
  1736.     return power_sum;
  1737.   }
  1738.   async command uint16_t GetDataSent() {
  1739.     return dataSent;
  1740.   }
  1741.   async command result_t ResetDataSent() {
  1742.     dataSent = 0;
  1743.     return SUCCESS;
  1744.   }
  1745.   async command uint16_t GetPower_tx() {
  1746.     return tx_sum;
  1747.   }
  1748.   async command uint16_t GetPower_rx() {
  1749.     return rx_sum;
  1750.   }
  1751.   async command uint16_t GetPower_sp() {
  1752.     return sp_sum;
  1753.   }
  1755.   async command result_t ResetPower() {
  1756.     power_sum = 0;
  1757.     pulse_check_sum = 0;
  1758.     send_sum = 0;
  1759.     receive_sum = 0;
  1760.     sp_sum = 0;
  1761.     tx_sum = 0;
  1762.     rx_sum = 0;
  1763.     return SUCCESS;
  1764.   }
  1766.   async command result_t MacControl.enableAck() {
  1767.     atomic bAckEnable = TRUE;
  1768.     return SUCCESS;
  1769.   }
  1771.   async command result_t MacControl.disableAck() {
  1772.     atomic bAckEnable = FALSE;
  1773.     return SUCCESS;
  1774.   }
  1776.   async command result_t MacControl.enableCCA() {
  1777.     atomic bCCAEnable = TRUE;
  1778.     return SUCCESS;
  1779.   }
  1781.   async command result_t MacControl.disableCCA() {
  1782.     atomic bCCAEnable = FALSE; 
  1783.     return SUCCESS;
  1784.   }
  1786.   // ***Not yet implemented
  1787.   async command TOS_MsgPtr MacControl.HaltTx() {
  1788.     return 0;
  1789.   }
  1791.   // Default events for radio send/receive coordinators do nothing.
  1792.   // Be very careful using these, you'll break the stack.
  1793.   default async event void RadioSendCoordinator.startSymbol(uint8_t bitsPerBlock, uint8_t offset,
  1794.                                                             TOS_MsgPtr msgBuff) { }
  1795.   default async event void RadioSendCoordinator.byte(TOS_MsgPtr msg, uint8_t byteCount) { }
  1796.   default async event void RadioSendCoordinator.blockTimer() { }
  1798.   default async event void RadioReceiveCoordinator.startSymbol(uint8_t bitsPerBlock, uint8_t offset,
  1799.                                                                TOS_MsgPtr msgBuff) { }
  1800.   default async event void RadioReceiveCoordinator.byte(TOS_MsgPtr msg, uint8_t byteCount) { }
  1801.   default async event void RadioReceiveCoordinator.blockTimer() { }
  1803.   default async event int16_t MacBackoff.initialBackoff(TOS_MsgPtr m){
  1804.     return (call Random.rand() & 0x1F) + 1;
  1805.   }
  1807.   default async event int16_t MacBackoff.congestionBackoff(TOS_MsgPtr m){
  1808.     congBackOffs++;
  1809.     return (call Random.rand() & 0xF) + 1;
  1810.   }
  1812.   /**************SClock Interface********/
  1813.   async event result_t SClock.syncDone(){
  1814.     if(needTimeSync){
  1815.       GTime loctime;
  1816.       uint32_t globalTimeStamp, slotOffset;
  1817.       call SClock.getTime(&loctime);
  1818.       globalTimeStamp = (uint32_t)(loctime.mticks * 568.889 + loctime.sticks * 0.00868056); //in ms
  1819.       slotOffset = (uint32_t) (1.024 * (slotSize - (globalTimeStamp % slotSize))); // in timer units .976562 = 1000/1024
  1820.       slotNum = (uint32_t) (globalTimeStamp/slotSize);
  1821.       currentSlot = slotNum & (localFrameLength - 1);
  1822.       globalSlot = slotNum & (globalFrameLength - 1);
  1824.       if(currentMAC == ZMAC)
  1825.         call TDMATimer.start(TIMER_ONE_SHOT, slotOffset);
  1826.       needTimeSync = FALSE;
  1827.     }
  1828.     return SUCCESS;
  1829.   }
  1830.   async event result_t SClock.fire(uint16_t mticks){ return SUCCESS; }  
  1831. }