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

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

网络

开发平台：

Others

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