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

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

网络

开发平台：

Others

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