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

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

网络

开发平台：

Others

CC1000RadioIntM.nc：源码内容
  1. includes crc;
  2. includes CC1000Const;
  3. includes NeighborInfo;
  5. module CC1000RadioIntM {
  6.   provides {
  7.     interface StdControl;
  8.     interface BareSendMsg as Send;
  9.     interface ReceiveMsg as Receive;
  10.     interface RadioCoordinator as RadioSendCoordinator;
  11.     interface RadioCoordinator as RadioReceiveCoordinator;
  12.     interface MacControl;
  13.     interface MacBackoff;
  14.     interface LowPowerListening;
  15.     interface SetDrand;
  16.     
  17.     // legacy commands supported, but should now use the
  18.     // Low Power Listening interface
  19.     async command result_t SetListeningMode(uint8_t power);
  20.     async command uint8_t GetListeningMode();
  21.     async command result_t SetTransmitMode(uint8_t power);
  22.     async command uint8_t GetTransmitMode();
  23.     // Used for debugging the noise floor (gets the current squelch value)
  24.     async command uint16_t GetSquelch();
  25.     // Used for debugging; gets an estimate of the power consumed by the radio
  26.     async command uint16_t GetPower();
  27.     async command result_t ResetPower();
  28.   }
  29.   uses {
  30.     interface SClock;
  31.     interface StdControl as SubControl;
  32.     interface PowerManagement;
  33.     interface StdControl as CC1000StdControl;
  34.     interface CC1000Control;
  35.     interface Random;
  36.     interface ADCControl;
  37.     interface ADC as RSSIADC;
  38.     interface SpiByteFifo;
  39.     interface StdControl as TimerControl;
  40.     interface Timer as WakeupTimer;
  41.     interface Timer as SquelchTimer;
  42.     interface Timer as TDMATimer;      
  43.     interface Leds;
  44.        
  45.   }
  46. }
  47. implementation {
  48. #include "SODebug.h"
  49. #define SINK 3
  50. #define MIN_TRUST 1
  51. #define MAX_TRUST 8
  52. #define AM_HELLO 31
  53. #define CSLOTS_PER_TDMA 125
  54. #define CSLOT_SIZE 0.4
  55. #define MAX_NEIGHBORS 20
  56. #define ECNCHECKPERIOD 16 
  57. #define ECNSENDPERIOD 96   //in terms of TDMA slots
  58. #define ECNEXPIREPERIOD 192  //in terms of TDMA slots
  59. #define ECNFORWARDPERIOD 1 //in terms of global frames
  60. #define ECNMINPACKETS 10
  61. #define HOPCOUNT 0
  62. #define NEXTHOP 1
  63. #define ECNTYPE 222
  64. #define SYNCTYPE 223
  65. #define SYNC_PERIOD 100
  66. #define TRUST_FACTOR 1
  67. #define SENDERADDRESS 2
  68.   //#define SELECTHCL 1
  69.   //#define SELECTNDC 0
  71.   //#define DEBUG
  73.   enum {
  74.     NULL_STATE,
  75.     TX_STATE,
  76.     DISABLED_STATE,
  77.     IDLE_STATE,
  78.     PRETX_STATE,
  79.     SYNC_STATE,
  80.     RX_STATE,
  81.     SENDING_ACK,
  82.     POWER_DOWN_STATE,
  83.     PULSE_CHECK_STATE,
  84.   };
  86.   enum {
  87.     TXSTATE_WAIT,
  88.     TXSTATE_START,
  89.     TXSTATE_PREAMBLE,
  90.     TXSTATE_SYNC,
  91.     TXSTATE_DATA,
  92.     TXSTATE_CRC,
  93.     TXSTATE_FLUSH,
  94.     TXSTATE_WAIT_FOR_ACK,
  95.     TXSTATE_READ_ACK,
  96.     TXSTATE_DONE
  97.   };
  99.   enum {
  100.     SYNC_BYTE = 0x33,
  101.     NSYNC_BYTE = 0xcc,
  102.     SYNC_WORD = 0x33cc,
  103.     NSYNC_WORD = 0xcc33,
  104.     ACK_LENGTH = 16,
  105.     MAX_ACK_WAIT = 18,
  106.     TIME_BETWEEN_CHECKS = 50,
  107.     TIME_AFTER_CHECK = 30,
  108.     CHECK_MA_COUNT = 8888,
  109.     SEND_MA_COUNT = 7200,
  110.     PREAMBLE_LENGTH_TO_BASE = 8,
  111.     RECEIVE_MA_COUNT = 9600
  113.   };
  115.   uint8_t ack_code[5] = {0xab, 0xba, 0x83, 0xaa, 0xaa};
  117.   uint8_t RadioState;
  118.   uint8_t RadioTxState;
  119.   norace uint8_t iRSSIcount;
  120.   uint8_t RSSIInitState;
  121.   uint8_t iSquelchCount;
  122.   uint16_t txlength;
  123.   uint16_t rxlength;
  124.   TOS_MsgPtr txbufptr;  // pointer to transmit buffer
  125.   TOS_MsgPtr rxbufptr;  // pointer to receive buffer
  126.   TOS_Msg retxbuf; //re-transmit buffer in case ECN preempts send 
  127.   TOS_Msg RxBuf; // save received messages
  128.   uint8_t NextTxByte;
  130.   uint8_t lplpower;        //  low power listening mode
  131.   uint8_t lplpowertx;      //  low power listening transmit mode
  133.   uint16_t preamblelen;    //  current length of the preamble
  134.   uint16_t sleeptime;       //  current check interval (sleep time)
  135.  
  136.   uint16_t PreambleCount;   //  found a valid preamble
  137.   uint8_t SOFCount;
  139.   uint16_t search_word, recvSync;
  140.   GTime currDiff;
  141.   uint8_t currSign;
  143.   //modified by Mahesh
  144.   enum {
  145.     BMAC,
  146.     HYMAC
  147.   };
  148.   enum{
  149.     T_O = 8,
  150.     T_NO = 32
  151.   };
  153.   enum{
  154.     MAX_VAL = 0xFFFF
  155.   };
  157.   enum{
  158.     POSITIVE = 1,
  159.     NEGATIVE = 2,
  160.     ZERO = 3
  161.   };
  162.   
  163.   /*struct neighborinfo
  164.     {
  165.     uint8_t id;
  166.     uint8_t owner;
  167.     uint8_t local_fsize;
  168.     }*/
  169.   struct neighborinfo twohopneighbors[MAX_NEIGHBORS];
  170.   
  171.   uint8_t current_mac = BMAC;    // select current MAC .. default must be BMAC and change to HYMAC after DRAND completes
  172.   uint16_t no_of_slots; // to be obtained from DRAND
  173.   uint16_t slot_size; 
  174.   uint16_t next_hop;
  175.   uint16_t own_slot;
  176.   uint16_t framesize;
  177.   uint16_t slots_since_ecnsend;
  178.   uint16_t slots_since_ecnrecv;
  179.   uint16_t slots_since_ecncheck;
  180.   uint8_t frames_since_forward;
  181.   uint16_t global_fsize;
  182.   uint32_t global_slot; 
  183.   uint16_t global_timestamp = 1000; //  DRAND passes on the latest value of the TPSN mticks value upon completion
  184.   uint16_t current_time = 0;    //number of interrupts since global timestamp
  185.   uint16_t current_slot = 0;
  186.   uint16_t next_slot = 1;
  187.   uint16_t packets_sent;
  188.   uint16_t pkts_last_sync = 0;
  189.   double current_loss;
  190.   uint16_t recvacks;
  191.   uint16_t congbackoffs;
  192.   uint16_t ecncheckfreq;
  193.   uint16_t ecnexpirefreq;
  194.   double ecnthreshold;
  195.   double avgloss;
  196.   uint32_t curHCLlist = 0;
  197.   uint32_t prevHCLlist = 0;
  198.   uint16_t ecnqueuesize;
  199.   uint8_t neighbors[MAX_NEIGHBORS];
  200.   uint8_t onehopneighborcount;
  201.   uint8_t twohopneighborcount;
  202.   uint16_t ecnfwdcount = 0;
  203.   uint16_t ecnsentcount = 0;
  204.   double alpha;
  205.   bool HCLselect;
  206.   bool ack_orig;
  207.   bool ecnpending;
  208.   bool ecnforward;
  209.   bool enableHCL;
  210.   bool enableNDC;
  211.   bool check_NDC;
  212.   bool wait_HCL;
  213.   bool pureHCL;
  214.   TOS_Msg ecnMsg;
  215.   TOS_Msg ecnForwardMsg;
  216.   TOS_Msg syncMsgHdr;
  217.   //ecnMsg.addr = TOS_BCAST_ADDR;
  218.   //ecnMsg.type = 33;
  219.   //ecnMsg.data[0] = 0;
  220.   /*****/
  222.   union {
  223.     uint16_t W;
  224.     struct {
  225.       uint8_t LSB;
  226.       uint8_t MSB;
  227.     };
  228.   } RxShiftBuf;
  230.   uint8_t RxBitOffset; // bit offset for spibus
  231.   uint16_t RxByteCnt; // received byte counter
  232.   uint16_t TxByteCnt;
  233.   uint16_t RSSISampleFreq; // in Bytes rcvd per sample
  234.   norace bool bInvertRxData; // data inverted
  235.   norace bool bTxPending;
  236.   bool bAckEnable;
  237.   bool bCCAEnable;
  238.   bool bTxBusy;
  239.   bool bRSSIValid;
  240.   uint16_t CC1K_PulseLevel;
  241.   uint16_t usRunningCRC; // Running CRC variable
  242.   uint16_t usRSSIVal;
  243.   uint16_t usSquelchVal;
  244.   uint16_t usTempSquelch;
  245.   uint8_t usSquelchIndex;
  246.   norace uint8_t pulse_check_count;
  247.   norace uint16_t pulse_check_sum;
  248.   norace uint16_t send_sum;
  249.   norace uint16_t receive_sum;
  250.   norace uint16_t power_sum;
  252.   uint16_t usSquelchTable[CC1K_SquelchTableSize];
  254.   int16_t sMacDelay;    // MAC delay for the next transmission
  255.   // XXX-PB:
  256.   // Here's the deal, the mica (RFM) radio stacks used TOS_LOCAL_ADDRESS
  257.   // to determine if an L2 ack was reqd.  This stack doesn't do L2 acks
  258.   // and, thus doesn't need it.  HOWEVER, some set-mote-id versions
  259.   // break if this symbol is missing from the binary.
  260.   // Thus, I put this LocalAddr here and set it to TOS_LOCAL_ADDRESS
  261.   // to keep things happy for now.
  262.   volatile uint16_t LocalAddr;
  264.   uint8_t receiveCount;
  266.   ///**********************************************************
  267.   //* local function definitions
  268.   //**********************************************************/
  270.   /*
  271.     int sortByShort(const void *x, const void *y) {
  272.     uint16_t* x1 = (uint16_t*)x;
  273.     uint16_t* y1 = (uint16_t*)y;
  274.     if (x1[0] > y1[0]) return -1;
  275.     if (x1[0] == y1[0]) return 0;
  276.     if (x1[0] < y1[0]) return 1;
  277.     return 0; // shouldn't reach here becasue it covers all the cases
  278.     }
  279.   */
  281.   void DivTime2(GTime* B, GTime* A){
  282.     if (A->mticks % 2 == 1){
  283.       B->mticks = (A->mticks >> 1);
  284.       B->sticks = (A->sticks >> 1)  + ((MAX_VAL) >>1);
  285.     }
  286.     else{
  287.       B->mticks = (A->mticks >>1);
  288.       B->sticks = (A->sticks >>1);
  289.     }
  290.   }
  292.   void AddTime(GTime* C, GTime* A, GTime* B){
  293.     if ((MAX_VAL - B->sticks) < A->sticks){
  294.       C->sticks = A->sticks - (MAX_VAL - B->sticks);
  295.       C->mticks = A->mticks + B->mticks + 1;
  296.     }
  297.     else{
  298.       C->sticks = A->sticks + B->sticks;
  299.       C->mticks = A->mticks + B->mticks;
  300.     }
  301.   }
  303.   void SubTime(GTime* C, GTime* A, GTime* B){
  304.     if (B->sticks > A->sticks){
  305.       C->sticks = MAX_VAL - (B->sticks - A->sticks);
  306.       C->mticks = A->mticks - (B->mticks + 1);
  307.     }
  308.     else {
  309.       C->sticks = A->sticks -  B->sticks;
  310.       C->mticks = A->mticks -  B->mticks;
  311.     }
  312.   }
  314.   uint8_t ModSubTime(GTime* C, GTime* A, GTime* B){
  315.     uint8_t retval;
  316.     if (A->mticks > B->mticks) 
  317.       retval = POSITIVE;
  318.     else if (A->mticks < B->mticks) 
  319.       retval = NEGATIVE;
  320.     else{
  321.       if (A->sticks > B->sticks)
  322.         retval = POSITIVE;
  323.       else if (A->sticks < B->sticks)
  324.         retval = NEGATIVE;
  325.       else
  326.         retval = ZERO;
  327.     }
  328.     if (retval == POSITIVE) SubTime(C,A,B);
  329.     else if (retval == NEGATIVE) SubTime(C,B,A);
  330.     else {
  331.       C->sticks = 0;
  332.       C->mticks = 0;
  333.     }
  334.     return retval;
  335.   }
  337.   bool IsHCL(uint32_t glo_slot) {
  338.     uint32_t value = 1;
  339.     uint32_t check = value<<glo_slot;
  340.     uint8_t flag = 0;
  341.     atomic
  342.       { 
  344.         if((check & curHCLlist) == check) 
  345.           flag = 1;
  346.    
  347.         else
  348.           flag = 0;
  349.       }
  350.     
  351.     //    SODbg(DBG_USR2,"flag:%i slot:%i check:%i list:%i",flag,glo_slot,check,curHCLlist); 
  352.     if(flag == 1)  
  353.       return(TRUE);
  354.     else
  355.       return(FALSE);
  356.   }
  358.   bool IsNDC(){
  359.     GTime loctime;
  360.     uint16_t slot_offset;
  362.     call SClock.getTime(&loctime);
  363.     global_timestamp = (uint16_t)(loctime.mticks * 568.8 + loctime.sticks * 0.00868); //in ms
  364.     //SODbg(DBG_USR2, "Current time is %un", global_timestamp);
  365.     if((enableNDC == TRUE) && (enableHCL == TRUE) && (IsHCL(next_slot))){
  367.       slot_offset = (uint16_t)(global_timestamp)%(slot_size);
  368.       slot_offset = (slot_size - slot_offset)/CSLOT_SIZE;
  369.       if((txlength + preamblelen + 2) > slot_offset)
  370.         return TRUE;
  371.       else
  372.         return FALSE;
  373.     } else{
  374.       return FALSE;
  375.     }
  376.   }
  378.   task void adjustSquelch() {
  379.     uint16_t tempArray[CC1K_SquelchTableSize];
  380.     char i,j,min; 
  381.     uint16_t min_value;
  382.     uint32_t tempsquelch;
  384.     atomic {
  385.       usSquelchTable[usSquelchIndex] = usTempSquelch;
  386.       usSquelchIndex++;
  387.       if (usSquelchIndex >= CC1K_SquelchTableSize)
  388.         usSquelchIndex = 0;
  389.       if (iSquelchCount <= CC1K_SquelchCount)
  390.         iSquelchCount++;  
  391.     }
  393.     for (i=0; i<CC1K_SquelchTableSize; i++) {
  394.       tempArray[(int)i] = usSquelchTable[(int)i];
  395.     }
  397.     min = 0;
  398.     //    for (j = 0; j < ((CC1K_SquelchTableSize) >> 1); j++) {
  399.     for (j = 0; j < 3; j++) {
  400.       for (i = 1; i < CC1K_SquelchTableSize; i++) {
  401.         if ((tempArray[(int)i] != 0xFFFF) && 
  402.             ((tempArray[(int)i] > tempArray[(int)min]) ||
  403.              (tempArray[(int)min] == 0xFFFF))) {
  404.           min = i;
  405.         }
  406.       }
  407.       min_value = tempArray[(int)min];
  408.       tempArray[(int)min] = 0xFFFF;
  409.     }
  411.     tempsquelch = ((uint32_t)(usSquelchVal << 5) + (uint32_t)(min_value << 1));
  412.     atomic usSquelchVal = (uint16_t)((tempsquelch / 34) & 0x0FFFF);
  414.     /*
  415.     // XXX: qsort actually causes ~600bits/sec lower bandwidth... why???
  416.     //
  417.     qsort (tempArray,CC1K_SquelchTableSize, sizeof(uint16_t),sortByShort);
  418.     min_value = tempArray[CC1K_SquelchTableSize >> 1];
  419.     atomic usSquelchVal = ((usSquelchVal << 5) + (min_value << 1)) / 34;
  420.     */
  423.   }
  425.   
  426.   void Blacklist(uint8_t ECN_slot,uint8_t ECN_fsize) 
  427.   {
  428.     uint8_t black_slot;    
  429.     //  SODbg(DBG_USR2,"%i  %i  %i",ECN_fsize,ECN_slot,no_of_slots);
  430.     // SODbg(DBG_USR2,"Curr list is %i",curHCLlist);
  432.     atomic {
  433.       if(ECN_fsize <= global_fsize) {
  434.         black_slot = ECN_slot;
  435.         while(black_slot < global_fsize) {
  436.           curHCLlist = curHCLlist | (1<<black_slot);
  437.           black_slot = black_slot + ECN_fsize;
  438.       
  439.           // SODbg(DBG_USR2,"Vector: %i",curHCLlist);
  440.         }
  441.         // SODbg(DBG_USR2,"list:%i",curHCLlist);
  442.       }
  443.      
  444.     }
  445.     
  446.   }
  448.   /*
  449.     void updateAverageDiff(GTime diff, uint8_t sign){ //EWMA of time diff
  450.     uint8_t newSign;
  451.     recvSync++;
  452.     if((currSign == POSITIVE && sign == POSITIVE) ||
  453.     (currSign == NEGATIVE && sign == NEGATIVE)){
  454.     AddTime(&currDiff, &diff, &currDiff);
  455.     SODbg(DBG_USR2, "currDiff = %u, currSign = %un", currDiff, currSign);
  456.     }else if((currSign == NEGATIVE && sign == POSITIVE) ||
  457.     (currSign == POSITIVE && sign == NEGATIVE)){
  458.     newSign = ModSubTime(&currDiff, &currDiff, &diff);
  459.     if(newSign == POSITIVE)
  460.     currSign = currSign; // no change in sign
  461.     else
  462.     currSign = sign; // else sign is same as new value
  463.     SODbg(DBG_USR2, "currDiff = %u, currSign = %un", currDiff, currSign);
  464.     }
  465.     }
  466.   */
  467.   void adjustTime(){
  468.     uint16_t sign, i, trust;
  469.     GTime loctime, timeStamp, diff, correctedTime;
  470.     struct syncMsgType* syncMsgPtr;
  472.     syncMsgPtr = (struct syncMsgType *) rxbufptr->data;
  473.     timeStamp.mticks = syncMsgPtr->mticks;
  474.     timeStamp.sticks = syncMsgPtr->sticks;
  475.     trust = syncMsgPtr->trust;
  476.     call SClock.getTime(&loctime);
  478. #ifdef DEBUG
  479.     SODbg(DBG_USR2, "*********************************************n");
  480.     SODbg(DBG_USR2, "From: %i R_STICKS = %u, R_MTICKS = %u, MY_STICKS = %u, MY_MTICKS = %un",
  481.           syncMsgPtr->sender, timeStamp.sticks, timeStamp.mticks, loctime.sticks, loctime.mticks);
  482. #endif
  484.     sign = ModSubTime(&diff, &timeStamp, &loctime);
  485. #ifdef DEBUG
  486.     if(diff.mticks == 0 && TOS_LOCAL_ADDRESS == SINK)
  487.       SODbg(DBG_USR2, "Converged !!!");
  488. #endif
  489.     // update difference average
  490.     //updateAverageDiff(diff, sign);
  491.     
  492.     if(trust < MIN_TRUST)
  493.       trust = MIN_TRUST;
  494.     if(trust < MAX_TRUST){
  495.       for(i = 0; i < trust; i++){
  496.         DivTime2(&diff, &diff);
  497.         //SODbg(DBG_USR2, "diff = %u, %u, %u n", diff.mticks, diff.sticks, trust);
  498.       }
  499.       call SClock.setTime(sign, &diff);
  500.       call SClock.getTime(&loctime);
  501.       //SODbg(DBG_USR2, "sign = %u, Adjusted Time MY_STICKS = %u, MY_MTICKS = %un",
  502.       //      sign, loctime.sticks, loctime.mticks);
  503.     }
  504.   }
  506.    
  507.   task void PacketRcvd() {
  508.     TOS_MsgPtr pBuf;
  509.     atomic {
  510.       receiveCount++;
  512.       if(pkts_last_sync > SYNC_PERIOD){
  513.         atomic{  
  514.           ack_orig = bAckEnable;
  515.           bAckEnable = FALSE;
  516.         }
  517.         call Send.send(&syncMsgHdr);
  518.         pkts_last_sync = 0;
  519.       }
  521.       pkts_last_sync++;
  522.       rxbufptr->time = 0;
  523.       pBuf = rxbufptr;
  524.     } 
  525.      
  526.     if(pBuf->addr == ECNTYPE)
  527.       {
  528. #ifdef DEBUG
  529.         SODbg(DBG_USR2,"Received %i hop ECN from %i, deciding whether significant..n", pBuf->data[HOPCOUNT],pBuf->data[SENDERADDRESS]);
  530. #endif
  531.       }
  533.     if(current_mac == HYMAC && pBuf->addr == ECNTYPE && pBuf->crc != 0 
  534.        && pBuf->data[SENDERADDRESS]!= TOS_LOCAL_ADDRESS) //Message is an ECN
  535.       {
  536.        
  537.         if((pBuf->data[HOPCOUNT] == 0) && (pBuf->data[NEXTHOP] == TOS_LOCAL_ADDRESS))          
  538.           {
  539. #ifdef DEBUG
  540.             SODbg(DBG_USR2,"Received one-hop ECN from %in",pBuf->data[SENDERADDRESS]);
  541. #endif
  543.             atomic 
  544.               {
  545.                 ecnForwardMsg.data[HOPCOUNT] = (uint8_t) (pBuf->data[HOPCOUNT] + 1);
  546.                 ecnForwardMsg.data[NEXTHOP] = (uint8_t) (next_hop);
  547.                 ecnForwardMsg.data[SENDERADDRESS] = (uint8_t) (TOS_LOCAL_ADDRESS);
  548.                 frames_since_forward = 0;
  549.                 if(!bTxBusy)
  550.                   {
  551.                     ack_orig = bAckEnable;
  552.                     bAckEnable = FALSE;
  553.                     call Send.send(&ecnForwardMsg);  //take care of case where we are not currently sending
  554. #ifdef DEBUG
  555.                     //  SODbg(DBG_USR2,"Forwarded ECNn");
  556. #endif
  557.                   } 
  558.                 else
  559.                   ecnforward = TRUE;
  560.               } 
  561.           }
  562.         else if(pBuf->data[HOPCOUNT] == 1) //check if two-hop ECN
  563.           {
  564.             //    SODbg(DBG_USR2,"Received two hop ECN from %in",pBuf->data[SENDERADDRESS]);
  565. #ifdef DEBUG
  566.             SODbg(DBG_USR2,"Received two hop ECN from %in",pBuf->data[SENDERADDRESS]);
  567. #endif      
  568.              
  569.             //Take action, blacklist given slot 
  570.             atomic enableHCL = TRUE;
  571.             if(pBuf->data[SENDERADDRESS] == next_hop)  //check forwarding node's address
  572.               {  
  573.                 //suppress ECN
  574. #ifdef DEBUG
  575.                 SODbg(DBG_USR2,"Suppressed own ECNn");
  576. #endif  
  577.                 
  578.                 atomic ecnpending = FALSE;
  579.                 slots_since_ecnsend = 0;
  580.                 slots_since_ecnrecv = 0;
  581.               }
  582.             //  Blacklist(pBuf->data[1],pBuf->data[3]);
  583.             
  584.           }  
  585.   
  586.       }  
  587.     else if(pBuf->addr != SYNCTYPE &&
  588.             (TOS_LOCAL_ADDRESS != SINK || (pBuf->type > 7) )) // SINK = 2
  589.       {
  590. #ifdef DEBUG
  591.         //      SODbg(DBG_USR2,"Received packet of type %un",pBuf->addr);
  592. #endif
  593.         pBuf = signal Receive.receive((TOS_MsgPtr)pBuf);
  594.       }
  595.       
  596.     atomic {
  597.       if (pBuf) 
  598.         rxbufptr = pBuf;
  599.       rxbufptr->length = 0;
  600.     }
  601.     call SpiByteFifo.enableIntr();
  602.   }
  603.   
  604.   task void PacketSent() 
  605.   {
  606.     TOS_MsgPtr pBuf; //store buf on stack 
  607.     atomic 
  608.       {
  609.         txbufptr->time = 0;
  610.         pBuf = txbufptr;
  611.       }
  612.       
  613.     if (txbufptr->addr != ECNTYPE && txbufptr->addr != SYNCTYPE)
  614.       signal Send.sendDone((TOS_MsgPtr)pBuf,SUCCESS);
  615.     atomic bTxBusy = FALSE;
  616.     if(pkts_last_sync > SYNC_PERIOD){
  617.       atomic 
  618.         {  
  619.           ack_orig = bAckEnable;
  620.           bAckEnable = FALSE;
  621.         }
  622.       call Send.send(&syncMsgHdr);
  623.       pkts_last_sync = 0;
  624.     }
  625.     
  626.     if(ecnforward == TRUE)
  627.       { 
  628.         atomic 
  629.           {  
  630.             ack_orig = bAckEnable;
  631.             bAckEnable = FALSE;
  632.           }
  633.         call Send.send(&ecnForwardMsg);
  634.         atomic ecnforward = FALSE;
  635. #ifdef DEBUG
  636.         //       SODbg(DBG_USR2,"Forwarded ECNn");
  637. #endif
  638.         
  639.       }
  640.     if(ecnpending == TRUE)
  641.       { 
  642.         atomic 
  643.           {
  644.             ack_orig = bAckEnable;
  645.             bAckEnable = FALSE;
  646.           }  
  647.         call Send.send(&ecnMsg);
  648.         atomic ecnpending = FALSE;
  649.         atomic slots_since_ecnsend = 0;
  650. #ifdef DEBUG
  651.         SODbg(DBG_USR2,"Sent own ECNn");
  652. #endif
  653.       } 
  654.   } 
  655.   
  656.        
  657.   ///**********************************************************
  658.   //* Exported interface functions
  659.   //**********************************************************/
  660.   /*
  661.     command uint16_t SetDrand.getDiffMticks(){
  662.     SODbg("Getting Mticks = %un", currDiff.mticks);
  663.     return currDiff.mticks/recvSync;
  664.     }
  666.     command uint16_t SetDrand.getDiffSticks(){
  667.     SODbg("Getting Mticks = %un", currDiff.sticks);
  668.     return currDiff.sticks/recvSync;
  669.     }
  670.   */
  671.   command result_t SetDrand.Set(uint16_t mval, uint16_t sval,uint8_t num_nodes,uint8_t hop,/*uint8_t n1count,uint8_t neighbors1hop[],*/uint8_t n2count,struct neighborinfo neighbors2hop[]) {
  672.     //  command result_t SetDrand.Set(uint16_t mval,uint16_t sval,uint8_t num_nodes){
  673.     uint16_t slot_offset = 0;
  674.     uint8_t i = 0;
  676.     if(num_nodes > 16)
  677.       no_of_slots = 32;
  678.     else if(num_nodes > 8)
  679.       no_of_slots = 16;
  680.     else if(num_nodes > 4)
  681.       no_of_slots = 8;
  682.     else if(num_nodes > 2)
  683.       no_of_slots = 4;
  684.     else
  685.       no_of_slots = 2;
  686.     
  687.     no_of_slots = num_nodes;
  689.     framesize = no_of_slots * slot_size;
  690.     //current_mac = HYMAC;
  691.     global_timestamp = (uint16_t)(mval * 568.8 + sval * 0.00868) ; //in ms
  692.     current_slot = (uint16_t)(global_timestamp % framesize)/(slot_size);
  693.     slot_offset = (uint16_t)(global_timestamp % framesize)%(slot_size);
  694.     global_slot = (uint16_t)(global_timestamp % (global_fsize * slot_size))/(slot_size); 
  695.     next_slot = ((global_slot + 1)%global_fsize);
  696.     
  697.       
  698.     next_hop = hop;
  699.     own_slot = TOS_LOCAL_ADDRESS;
  700.     // ecnMsg.data[1] = own_slot;
  701.       
  702.     /*       onehopneighborcount = n1count;
  703.              for(i=0;i<n1count;i++) 
  704.              neighbors[i] = neighbors1hop[i];*/
  706.     twohopneighborcount = n2count;
  707.     for(i=0;i<n2count;i++)
  708.       {
  709.         twohopneighbors[i] = neighbors2hop[i];  
  710.         Blacklist(twohopneighbors[i].owner,twohopneighbors[i].local_fsize);
  711.       } 
  712.   
  713.     call TDMATimer.start(TIMER_ONE_SHOT,slot_size - slot_offset);
  714. #ifdef DEBUG
  715.     // SODbg(DBG_USR2,"Started timer slotsize - offset is %in",slot_size - slot_offset);
  716. #endif
  717.     return SUCCESS; 
  718.   }
  720.   command result_t StdControl.init() {
  721.     char i;
  722.     // atomic  own_slot = TOS_LOCAL_ADDRESS;
  723.     atomic {
  724.       RadioState = DISABLED_STATE;
  725.       RadioTxState = TXSTATE_PREAMBLE;
  726.       rxbufptr = &RxBuf;
  727.       rxbufptr->length = 0;
  728.       rxlength = MSG_DATA_SIZE-2;
  729.       RxBitOffset = 0;
  730.       iSquelchCount = 0;
  731.       
  732.       PreambleCount = 0;
  733.       RSSISampleFreq = 0;
  734.       RxShiftBuf.W = 0;
  735.       iRSSIcount = 0;
  736.       bTxPending = FALSE;
  737.       bTxBusy = FALSE;
  738.       bRSSIValid = FALSE;
  739.       bAckEnable = FALSE; // to test for ECN only
  740.       bCCAEnable = TRUE;
  741.       CC1K_PulseLevel = 300;
  742.       sMacDelay = -1;
  743.       usRSSIVal = -1;
  744.       usSquelchIndex = 0;
  745.       pulse_check_count = 0;
  746.       lplpower =  0;//0x87;
  747.       RSSIInitState = NULL_STATE;
  748.       //      if(TOS_LOCAL_ADDRESS == 0) lplpower = 0;
  749.       //      lplpowertx = 7;
  750.       usSquelchVal = CC1K_SquelchInit;
  751.       receiveCount=0;
  754.       alpha = 0.25; 
  755.       recvacks = 0;
  756.       congbackoffs = 0;
  757.       packets_sent = 0;
  758.       current_loss = 0.0;
  759.       avgloss = 0.0;
  760.       ecnqueuesize = 0;
  761.       curHCLlist = 0;
  762.       prevHCLlist = 0;
  763.       global_fsize = 32;
  764.       ack_orig = bAckEnable;
  765.       ecnpending = FALSE;
  766.       ecnforward = FALSE;
  768.       enableHCL = FALSE; // changed to FALSE for LCL by Ajit
  770.       //enableNDC = SELECTNDC;
  771.       enableNDC = FALSE;
  773.       check_NDC = FALSE;
  774.       wait_HCL = FALSE;
  775.       pureHCL = FALSE;
  777.       //HCLselect = SELECTHCL; // changed to FALSE by Ajit for LCL
  778.       HCLselect = TRUE; // changed to FALSE by Ajit for LCL
  780.       no_of_slots = 4; //2;           //these must be set by Drand in SetDrand.Set
  781.       own_slot = TOS_LOCAL_ADDRESS;
  782.       slot_size = 50; //ms
  783.       framesize = no_of_slots * slot_size;
  784.       slots_since_ecnsend = 0;
  785.       slots_since_ecnrecv = 0;
  786.       slots_since_ecncheck = 0;
  787.       frames_since_forward = 0;
  788.       next_hop = TOS_LOCAL_ADDRESS + 1;
  790.      
  791.       //modified
  792.       ecnMsg.type = 31;  //set ecnMsg headers
  793.       ecnMsg.addr = ECNTYPE; //ECN Indicator;
  794.       ecnMsg.length = 3;
  795.       ecnMsg.group = 125;
  796.       ecnMsg.crc = 0;
  798.       ecnForwardMsg.type = 31; 
  799.       ecnForwardMsg.addr = ECNTYPE; 
  800.       ecnForwardMsg.length = 3;
  801.       ecnForwardMsg.group = 125;
  802.       ecnForwardMsg.crc = 0; 
  804.       ecnMsg.data[HOPCOUNT] = (uint8_t) 0; //hopcount
  805.       ecnMsg.data[NEXTHOP] = (uint8_t) next_hop; //parent node
  806.       ecnMsg.data[SENDERADDRESS] = (uint8_t) TOS_LOCAL_ADDRESS;
  807.       
  808.       ecncheckfreq = 10000; //these parameters must be specified by application
  809.       ecnexpirefreq = 500;  // write new interfaces to set these
  810.       ecnthreshold = 3.0;
  812.       syncMsgHdr.type = 31;  //set syncMsg headers
  813.       syncMsgHdr.addr = SYNCTYPE; //SYNC Indicator;
  814.       syncMsgHdr.length = 7;  // mticks, sticks, trust, sender
  815.       syncMsgHdr.group = 125;
  816.       syncMsgHdr.crc = 0;
  818.       currDiff.mticks = 0;
  819.       currDiff.sticks = 0;
  820.       currSign = POSITIVE;
  821.       recvSync = 0;
  822.     }
  824.     for (i = 0; i < CC1K_SquelchTableSize; i++)
  825.       usSquelchTable[(int)i] = CC1K_SquelchInit;
  827.     call SpiByteFifo.initSlave(); // set spi bus to slave mode
  828.    
  829.     call CC1000StdControl.init();
  830.     call CC1000Control.SelectLock(0x9); // Select MANCHESTER VIOLATION
  831.     bInvertRxData = call CC1000Control.GetLOStatus();
  833.     call ADCControl.bindPort(TOS_ADC_CC_RSSI_PORT,TOSH_ACTUAL_CC_RSSI_PORT);
  834.     call ADCControl.init();
  835.     
  836.     call Random.init();
  837.     call TimerControl.init();
  838.   
  839.     init_debug();
  841.     LocalAddr = TOS_LOCAL_ADDRESS;
  843.     return SUCCESS;
  844.   }
  845.   
  846.   //async command uint8_t LowPowerListening.GetReceiveCount() {
  847.   // return receiveCount;
  848.   //}
  849.   /**
  850.    * Get the current Low Power Listening transmit mode
  851.    * @return mode number (see SetListeningMode)
  852.    */
  853.   async command uint8_t LowPowerListening.GetTransmitMode() {
  854.     return lplpowertx;
  855.   }
  856.   // legacy support
  857.   async command uint8_t GetTransmitMode() {
  858.     return call LowPowerListening.GetTransmitMode();
  859.   }
  861.   /**
  862.    * Set the transmit mode.  This allows for hybrid schemes where
  863.    * the transmit mode is different than the receive mode.
  864.    * Use SetListeningMode first, then change the mode with SetTransmitMode.
  865.    *
  866.    * @param mode mode number (see SetListeningMode)
  867.    * @return SUCCESS if the mode was successfully changed
  868.    */
  869.   async command result_t LowPowerListening.SetTransmitMode(uint8_t power) {
  870.     if ((power >= CC1K_LPL_STATES) || (power == lplpowertx))
  871.       return FAIL;
  873.     // check if the radio is currently doing something
  874.     if ((!bTxPending) && ((RadioState == POWER_DOWN_STATE) || 
  875.                           (RadioState == IDLE_STATE) ||
  876.                           (RadioState == DISABLED_STATE))) {
  878.       atomic {
  879.         lplpowertx = power;
  880.         preamblelen = ((PRG_RDB(&CC1K_LPL_PreambleLength[lplpowertx*2]) << 8)
  881.                        | PRG_RDB(&CC1K_LPL_PreambleLength[(lplpowertx*2)+1]));
  882.       }
  883.       return SUCCESS;
  884.     }
  885.     return FAIL;
  886.   }
  887.   // legacy support
  888.   async command result_t SetTransmitMode(uint8_t power) {
  889.     return call LowPowerListening.SetTransmitMode(power);
  890.   }
  892.   /**
  893.    * Set the current Low Power Listening mode.
  894.    * Setting the LPL mode sets both the check interval and preamble length.
  895.    *
  896.    * Modes include:
  897.    *  0 = Radio full on
  898.    *  1 = 10ms check interval
  899.    *  2 = 25ms check interval
  900.    *  3 = 50ms check interval
  901.    *  4 = 100ms check interval (recommended)
  902.    *  5 = 200ms check interval
  903.    *  6 = 400ms check interval
  904.    *  7 = 800ms check interval
  905.    *  8 = 1600ms check interval
  906.    *
  907.    * @param mode the mode number
  908.    * @return SUCCESS if the mode was successfully changed
  909.    */
  910.   async command result_t LowPowerListening.SetListeningMode(uint8_t power) {
  911.     // valid low power listening values are 0 to 8
  912.     // 0 is "always on" and 8 is lowest duty cycle
  913.     if ((power >= CC1K_LPL_STATES) || (power == lplpower))
  914.       return FAIL;
  916.     // check if the radio is currently doing something
  917.     if ((!bTxPending) && ((RadioState == POWER_DOWN_STATE) || 
  918.                           (RadioState == IDLE_STATE) ||
  919.                           (RadioState == DISABLED_STATE))) {
  921.       // change receiving function in CC1000Radio
  922.       call WakeupTimer.stop();
  923.       atomic {
  924.         if (lplpower == lplpowertx) {
  925.           lplpowertx = power;
  926.         }
  927.         lplpower = power;
  928.       }
  930.       // if successful, change power here
  931.       if (RadioState == IDLE_STATE) {
  932.         RadioState = DISABLED_STATE;
  933.         call StdControl.stop();
  934.         call StdControl.start();
  935.       }
  936.       if (RadioState == POWER_DOWN_STATE) {
  937.         RadioState = DISABLED_STATE;
  938.         call StdControl.start();
  939.         call PowerManagement.adjustPower();
  940.       }
  941.     }
  942.     else {
  943.       return FAIL;
  944.     }
  945.     return SUCCESS;
  946.   }
  947.   // legacy support
  948.   async command result_t SetListeningMode(uint8_t power) {
  949.     return call SetListeningMode(power);
  950.   }
  952.   /**
  953.    * Gets the state of low power listening on the chipcon radio.
  954.    * @return Current low power listening state value
  955.    */
  956.   async command uint8_t LowPowerListening.GetListeningMode() {
  957.     return lplpower;
  958.   }
  959.   // legacy support
  960.   async command uint8_t GetListeningMode() {
  961.     return call LowPowerListening.GetListeningMode();
  962.   } 
  964.   /**
  965.    * Set the preamble length of outgoing packets
  966.    *
  967.    * @param bytes length of the preamble in bytes
  968.    * @return SUCCESS if the preamble length was successfully changed
  969.    */
  970.   async command result_t LowPowerListening.SetPreambleLength(uint16_t bytes) {
  971.     result_t result = FAIL;
  972.     atomic {
  973.       if (RadioState != TX_STATE) {
  974.         preamblelen = bytes;
  975.         result = SUCCESS;
  976.       }
  977.     }
  978.     return result;
  979.   }
  981.   /**
  982.    * Get the preamble length of outgoing packets
  983.    *
  984.    * @return length of the preamble in bytes
  985.    */
  986.   async command uint16_t LowPowerListening.GetPreambleLength() {
  987.     return preamblelen;
  988.   }
  990.   /**
  991.    * Set the check interval (time between waking up and sampling
  992.    * the radio for activity in low power listening)
  993.    *
  994.    * @param ms check interval in milliseconds
  995.    * @return SUCCESS if the check interval was successfully changed
  996.    */
  997.   async command result_t LowPowerListening.SetCheckInterval(uint16_t ms) {
  998.     // sleep time will go into effect after the next wakeup time
  999.     atomic sleeptime = ms;
  1000.     return SUCCESS;
  1001.   }
  1003.   /**
  1004.    * Get the check interval currently used by low power listening
  1005.    *
  1006.    * @return length of the check interval in milliseconds
  1007.    */
  1008.   async command uint16_t LowPowerListening.GetCheckInterval() {
  1009.     return sleeptime;
  1010.   }
  1013.   event result_t SquelchTimer.fired() {
  1014.     char currentRadioState;
  1015.     atomic currentRadioState = RadioState;
  1017.     if (currentRadioState == IDLE_STATE) {
  1018.       atomic RSSIInitState = currentRadioState;
  1019.       call RSSIADC.getData();
  1020.     }
  1021.     return SUCCESS;
  1022.   }
  1024.   event result_t WakeupTimer.fired() {
  1025.     uint8_t currentRadioState;
  1027.     if (lplpower == 0)
  1028.       return SUCCESS;
  1029.     
  1030.     atomic currentRadioState = RadioState;
  1031.     switch(currentRadioState) {
  1033.     case IDLE_STATE:
  1034.       if (!bTxPending) {
  1035.         atomic {
  1036.           RadioState = POWER_DOWN_STATE;
  1037.           call SpiByteFifo.disableIntr();
  1038.         }
  1039.         call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  1040.         call SquelchTimer.stop();
  1041.         call CC1000StdControl.stop();
  1042.       } else {
  1043.         call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  1044.       }
  1045.       break;
  1047.     case POWER_DOWN_STATE:
  1048.       atomic RadioState = PULSE_CHECK_STATE;
  1049.       pulse_check_count = 0;
  1050.       call CC1000StdControl.start();
  1051.       call CC1000Control.BIASOn();
  1052.       call WakeupTimer.start(TIMER_ONE_SHOT, 1);
  1053.       return SUCCESS;
  1054.       break;
  1056.     case PULSE_CHECK_STATE:
  1057.       call CC1000Control.RxMode();
  1058.       if(!(call RSSIADC.getData())){
  1059.         call WakeupTimer.start(TIMER_ONE_SHOT, TIME_BETWEEN_CHECKS);
  1060.         atomic RadioState = POWER_DOWN_STATE;
  1061.       }
  1062.       else {
  1063.         TOSH_uwait(80);
  1064.       }
  1065.       call CC1000StdControl.stop();
  1066.       pulse_check_sum ++;
  1067.       break;
  1069.     default:
  1070.       call WakeupTimer.start(TIMER_ONE_SHOT, 5);
  1071.     }
  1072.     return SUCCESS;
  1073.   }
  1075.   //added by Mahesh
  1077.   event result_t TDMATimer.fired() 
  1078.   { 
  1079. #ifdef DEBUG
  1080.     // SODbg(DBG_USR2,"Timer fired");
  1081. #endif 
  1082.     if(current_mac == BMAC)
  1083.       atomic current_mac = HYMAC;
  1085.    
  1086.     call TDMATimer.start(TIMER_ONE_SHOT,slot_size);
  1088.     atomic 
  1089.       {  
  1090.         current_slot = (current_slot + 1)%(no_of_slots);
  1091.         if(HCLselect)
  1092.           {  
  1093.             slots_since_ecnsend ++;
  1094.             slots_since_ecnrecv ++;
  1095.             slots_since_ecncheck++;
  1097.             if(packets_sent > ECNMINPACKETS && slots_since_ecncheck >= ECNCHECKPERIOD)
  1098.               {  
  1099.                 current_loss = (double)congbackoffs/packets_sent;
  1100.                 avgloss = alpha*(current_loss) + (1-alpha)*avgloss; 
  1101.                 slots_since_ecncheck = 0;
  1102. #ifdef DEBUG
  1103.                 SODbg(DBG_USR2,"Congestion Statistics: %i / %in",congbackoffs,packets_sent);
  1104. #endif
  1105.                 
  1106.                 if(avgloss > ecnthreshold && slots_since_ecnsend >= ECNSENDPERIOD) 
  1107.                   {
  1108. #ifdef DEBUG
  1109.                     SODbg(DBG_USR2,"Setting ECN flagn");
  1110. #endif
  1111.                     ecnMsg.data[NEXTHOP] = (uint8_t) next_hop;
  1112.                         
  1113.                     if(!pureHCL)
  1114.                       ecnpending = TRUE;     //remember to uncomment
  1115.                     
  1116.                     //                        frames_since_ecn = 0;
  1117.                   }   
  1118.                 congbackoffs = 0;
  1119.                 packets_sent = 0;
  1120.               }    
  1122.             if(enableHCL && slots_since_ecnrecv >= ECNEXPIREPERIOD)
  1123.               {
  1124.                 if(!pureHCL)
  1125.                   enableHCL = FALSE;       
  1126. #ifdef DEBUG
  1127.                 SODbg(DBG_USR2,"ECN expired, into LCL againn");
  1128. #endif
  1129.                 //            slots_since_ecnrecv = 0;
  1130.               }
  1133.             global_slot = (global_slot + 1)%(global_fsize);    
  1135. #ifdef DEBUG
  1136.             //            if(enableHCL)
  1137.             // SODbg(DBG_USR2,"Current slot %i **********************n",current_slot);
  1138. #endif    
  1139.         
  1140.             if(enableHCL && IsHCL(global_slot) && own_slot != current_slot)
  1141.               { 
  1142.                 wait_HCL = TRUE;
  1143. #ifdef DEBUG
  1144.                 SODbg(DBG_USR2,"Current slot %i HCLn",current_slot);
  1145. #endif    
  1146.               }
  1147.             else 
  1148.               wait_HCL = FALSE;
  1149.        
  1150.             next_slot = (global_slot + 1)%(global_fsize);
  1151. #ifdef DEBUG
  1152.             //  SODbg(DBG_USR2,"next slot %u owner slot %un",next_slot,own_slot);
  1153. #endif      
  1155.             /*
  1156.               if(enableHCL && enableNDC && IsHCL(next_slot) && !wait_HCL)
  1157.               check_NDC = TRUE;     
  1158.               else
  1159.               check_NDC= FALSE; 
  1160.             */
  1161.          
  1162.             if(current_slot == own_slot)
  1163.               {
  1164. #ifdef DEBUG
  1165.                 //                SODbg(DBG_USR2,"**********Owner Slot************* btxpending %i sMacDelay %in",bTxPending,sMacDelay);
  1166. #endif
  1168.                 sMacDelay = signal MacBackoff.congestionBackoff(txbufptr);
  1169.               }
  1170.             else{
  1171.               if(sMacDelay < 0)
  1172.                 sMacDelay = signal MacBackoff.congestionBackoff(txbufptr);
  1173.               else{
  1174.                 if(sMacDelay + T_O < (T_O + T_NO - 1))
  1175.                   sMacDelay = sMacDelay + T_O;
  1176.                 else
  1177.                   sMacDelay = T_O + T_NO - 1;
  1178.               }
  1179.             }
  1181.             if(global_slot == own_slot) //global frame boundary, take action
  1182.               // processing for ecn
  1183.               { 
  1184.                
  1185.                 frames_since_forward ++;
  1186.               }  
  1187.                 
  1188.              
  1189.                
  1190.             
  1191.               
  1192.           }
  1193.       }
  1194.     return SUCCESS;
  1195.   }
  1196.   
  1197.   
  1198.  
  1199.   command result_t StdControl.stop() {
  1200.     atomic RadioState = DISABLED_STATE;
  1202.     call SquelchTimer.stop();
  1203.     call WakeupTimer.stop();
  1204.     call CC1000StdControl.stop();
  1205.     call SpiByteFifo.disableIntr(); // disable spi interrupt
  1206.     return SUCCESS;
  1207.   }
  1209.   command result_t StdControl.start() {
  1210.     uint8_t currentRadioState;
  1211.     atomic currentRadioState = RadioState;
  1212.    
  1213.    
  1214.     
  1216.     if (currentRadioState == DISABLED_STATE) {
  1217.       atomic {
  1218.         rxbufptr->length = 0;
  1219.         RadioState  = IDLE_STATE;
  1220.         bTxPending = bTxBusy = FALSE;
  1221.         sMacDelay = -1;
  1222.         sleeptime = ((PRG_RDB(&CC1K_LPL_SleepTime[lplpower*2]) << 8) |
  1223.                      PRG_RDB(&CC1K_LPL_SleepTime[(lplpower*2)+1]));
  1224.         preamblelen = ((PRG_RDB(&CC1K_LPL_PreambleLength[lplpowertx*2]) << 8) |
  1225.                        PRG_RDB(&CC1K_LPL_PreambleLength[(lplpowertx*2)+1]));
  1226.       }
  1227.       // all power on, captain!
  1228.       rxbufptr->length = 0;
  1229.       atomic RadioState = IDLE_STATE;
  1230.       call CC1000StdControl.start();
  1231.       call CC1000Control.BIASOn();
  1232.       call SpiByteFifo.rxMode(); // SPI to miso
  1233.       call CC1000Control.RxMode();
  1234.       if (iSquelchCount > CC1K_SquelchCount)
  1235.         call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  1236.       else
  1237.         call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  1238.       call SpiByteFifo.enableIntr(); // enable spi interrupt
  1239.       if (lplpower > 0) {
  1240.         // set a time to start sleeping after measuring the noise floor
  1241.         call WakeupTimer.start(TIMER_ONE_SHOT, CC1K_SquelchIntervalSlow);
  1242.       }
  1243.     }
  1244.     return SUCCESS;
  1245.   }
  1247.   command result_t Send.send(TOS_MsgPtr pMsg) {
  1248.     result_t Result = SUCCESS;
  1249.     uint8_t currentRadioState = 0;
  1250.    
  1251.     atomic {
  1252.       if (bTxBusy) {
  1253.         Result = FAIL;
  1254.       }
  1255.       else {
  1256.         bTxBusy = TRUE;
  1257.     
  1258.         txbufptr = pMsg;
  1259.         txlength = pMsg->length + (MSG_DATA_SIZE - DATA_LENGTH - 2); 
  1260.       }
  1261.          
  1263.       // initially back off [1,32] bytes (approx 2/3 packet)
  1264.       if(bCCAEnable) 
  1265.         sMacDelay = signal MacBackoff.initialBackoff(pMsg);
  1266.       else
  1267.         sMacDelay = 0;
  1268.       bTxPending = TRUE;
  1269.       currentRadioState = RadioState;
  1270.     }
  1272.     if (Result) {
  1274.       // if we're off, start the radio
  1275.       if (currentRadioState == POWER_DOWN_STATE) {
  1276.         // disable wakeup timer
  1277.         atomic RadioState = IDLE_STATE;
  1278.         call WakeupTimer.stop();
  1279.         call CC1000StdControl.start();
  1280.         call CC1000Control.BIASOn();
  1281.         call CC1000Control.RxMode();
  1282.         call SpiByteFifo.rxMode(); // SPI to miso
  1283.         call SpiByteFifo.enableIntr(); // enable spi interrupt
  1284.         if (iSquelchCount > CC1K_SquelchCount)
  1285.           call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  1286.         else
  1287.           call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  1288.         call WakeupTimer.start(TIMER_ONE_SHOT, CC1K_LPL_PACKET_TIME*2);
  1289.       }
  1290.     }
  1291.     return Result;
  1292.   }
  1293.   
  1294.   /**********************************************************
  1295.    * make a spibus interrupt handler
  1296.    * needs to handle interrupts for transmit delay
  1297.    * and then go into byte transmit mode with
  1298.    *   timer1 baudrate delay as interrupt handler
  1299.    * else SODbg(DBG_USR2,"Sending Packet ..");
  1300.    * needs to handle interrupts for byte read and detect preamble
  1301.    *  then handle reading a packet
  1302.    * PB - We can use this interrupt handler as a transmit scheduler
  1303.    * because the CC1000 continuously clocks in data, regarless
  1304.    * of whether it's good or not.  Thus, this routine will be called
  1305.    * on every 8 ticks of DCLK. 
  1306.    **********************************************************/
  1308.   async event result_t SpiByteFifo.dataReady(uint8_t data_in) {
  1309.     GTime loctime;
  1311.     signal RadioSendCoordinator.blockTimer();
  1312.     signal RadioReceiveCoordinator.blockTimer();
  1313.      
  1314.     if (bInvertRxData) 
  1315.       data_in = ~data_in;
  1316. #ifdef ENABLE_UART_DEBUG
  1317.     UARTPutChar(RadioState);
  1318. #endif
  1319.     switch (RadioState) {
  1321.     case TX_STATE:
  1322.       {
  1323.         call SpiByteFifo.writeByte(NextTxByte);
  1324.         TxByteCnt++;
  1325.         switch (RadioTxState) {
  1327.         case TXSTATE_PREAMBLE:
  1328.           send_sum ++;
  1329.           if (!(TxByteCnt < preamblelen)||
  1330.               (txbufptr->strength == 0xffff && TxByteCnt >= PREAMBLE_LENGTH_TO_BASE)) {
  1331.             NextTxByte = SYNC_BYTE;
  1332.             RadioTxState = TXSTATE_SYNC;
  1333. #ifdef DEBUG
  1334.             //      SODbg(DBG_USR2,"Sent packet in slot %in",current_slot);
  1335.             //      SODbg(DBG_USR2, "ishcl = %u, isndc = %u n", IsHCL(current_slot),
  1336.             //       IsNDC());
  1337. #endif
  1338.           }
  1339.           break;
  1341.         case TXSTATE_SYNC:
  1342.           send_sum ++;
  1343.           NextTxByte = NSYNC_BYTE;
  1344.           RadioTxState = TXSTATE_DATA;
  1345.           TxByteCnt = -1;
  1346.           if(txbufptr->addr == SYNCTYPE){
  1347.             struct syncMsgType *syncMsgPtr = (struct syncMsgType *) txbufptr->data;
  1348.             call SClock.getTime(&loctime);
  1349.             syncMsgPtr->mticks = loctime.mticks;
  1350.             syncMsgPtr->sticks = loctime.sticks;
  1351.             syncMsgPtr->trust = TRUST_FACTOR;
  1352.             syncMsgPtr->sender = TOS_LOCAL_ADDRESS;
  1353.           }
  1354.           // for Time Sync services
  1355.           signal RadioSendCoordinator.startSymbol(8, 0, txbufptr); 
  1356.           break;
  1358.         case TXSTATE_DATA:
  1359.           send_sum ++;
  1360.           if ((uint8_t)(TxByteCnt) < txlength) {
  1361.             NextTxByte = ((uint8_t *)txbufptr)[(TxByteCnt)];
  1362.             usRunningCRC = crcByte(usRunningCRC,NextTxByte);
  1363.             signal RadioSendCoordinator.byte(txbufptr, (uint8_t)TxByteCnt); // Time Sync
  1364.           }
  1365.           else {
  1366.             NextTxByte = (uint8_t)(usRunningCRC);
  1367.             RadioTxState = TXSTATE_CRC;
  1368.           }
  1369.           break;
  1371.         case TXSTATE_CRC:
  1372.           send_sum ++;
  1373.           NextTxByte = (uint8_t)(usRunningCRC>>8);
  1374.           RadioTxState = TXSTATE_FLUSH;
  1375.           TxByteCnt = 0;
  1376.           break;
  1378.         case TXSTATE_FLUSH:
  1379.           send_sum ++;
  1380.           if (TxByteCnt > 3) {
  1381.             TxByteCnt = 0;
  1382. #ifdef DEBUG
  1383.             // SODbg(DBG_USR2,"Came heren");
  1384. #endif
  1385.             if (bAckEnable)                                    
  1386.               RadioTxState = TXSTATE_WAIT_FOR_ACK;         
  1387.              
  1388.             else {
  1389. #ifdef DEBUG
  1390.               // SODbg(DBG_USR2,"came inside: current MAC: %i ackenabled :%i,ecnpending: %i ecnforward %i ecnSENT %in",current_mac,bAckEnable,ecnpending,ecnforward,sentECN);
  1391. #endif
  1392.               packets_sent ++;
  1393.               call SpiByteFifo.rxMode();
  1394.               call CC1000Control.RxMode();
  1395.               RadioTxState = TXSTATE_DONE;
  1396.             }
  1397.           }
  1398.           break;
  1400.         case TXSTATE_WAIT_FOR_ACK:
  1401.           if(TxByteCnt == 1){
  1402.             // packets_sent ++;
  1403.             send_sum ++;
  1404.             call SpiByteFifo.rxMode();
  1405.             call CC1000Control.RxMode();
  1406.             break;
  1407.           }
  1408.           receive_sum ++;
  1409.           if (TxByteCnt > 3) {
  1410.             RadioTxState = TXSTATE_READ_ACK;
  1411.             TxByteCnt = 0;
  1412.             search_word = 0;
  1413.           }
  1414.           break;
  1416.         case TXSTATE_READ_ACK:
  1417.           {
  1418.             uint8_t i;
  1419.             receive_sum ++;
  1420.             for(i = 0; i < 8; i ++){
  1421.               search_word <<= 1;
  1422.               if(data_in & 0x80) search_word |=  0x1;
  1423.               data_in <<= 1;
  1424.               if (search_word == 0xba83){
  1425.                 txbufptr->ack = 1;
  1426.                 RadioTxState = TXSTATE_DONE;
  1427.                 //     recvacks++ ;
  1428. #ifdef DEBUG
  1429.                 SODbg(DBG_USR2,"received ackn");
  1430. #endif
  1431.                 return SUCCESS;
  1432.               }
  1433.             }
  1434.           }
  1435.           if(TxByteCnt >= MAX_ACK_WAIT){   
  1436.             txbufptr->ack = 0;  
  1437.             //    lostacks++;
  1438. #ifdef DEBUG
  1439.             //       SODbg(DBG_USR2,"did not receive ack %i %i %in",lostacks,packets_sent,avgloss * 100);
  1440. #endif
  1441.             
  1442.             /***/
  1443.             RadioTxState = TXSTATE_DONE;
  1445.           }
  1446.          
  1447.           break;
  1449.         case TXSTATE_DONE:
  1450.         default:
  1451.           bTxPending = FALSE;
  1452.         
  1453.           if(txbufptr->addr == ECNTYPE || txbufptr->addr == SYNCTYPE){
  1454.             if(txbufptr->addr == ECNTYPE && txbufptr->data[HOPCOUNT] == 1)
  1455.               { 
  1456. #ifdef DEBUG
  1457.                 SODbg(DBG_USR2,"Successfully forwarded ECNn");
  1458. #endif
  1459.               }            
  1460.             bAckEnable = ack_orig;
  1461.           }
  1462.           call SClock.getTime(&loctime);
  1463.           global_timestamp = (uint16_t)(loctime.mticks * 568.8 + loctime.sticks * 0.00868) ; //in ms
  1464.           //SODbg(DBG_USR2,"Sent Packet seqnum = %u at %un", txbufptr->data[1],
  1465.           //global_timestamp);
  1466.           if(post PacketSent()) {
  1467.             // If the post operation succeeds, goto Idle
  1468.             // otherwise, we'll try again.
  1469. #ifdef DEBUG
  1470.             //  SODbg(DBG_USR2,"Packet type %in",txbufptr->addr);
  1471. #endif
  1472.             RadioState = IDLE_STATE;
  1473.             pkts_last_sync++;
  1474.             RSSIInitState = RadioState;
  1475.             call RSSIADC.getData();
  1476.           }
  1477.           break;
  1478.         }
  1479.       }
  1480.       break;
  1482.     case DISABLED_STATE:
  1483.       break;
  1485.     case IDLE_STATE: 
  1486.       {
  1487.         receive_sum ++;
  1488.         if (((data_in == (0xaa)) || (data_in == (0x55)))) {
  1489.           PreambleCount++;
  1490.           if (PreambleCount > CC1K_ValidPrecursor) {
  1491.             PreambleCount = SOFCount = 0;
  1492.             RxBitOffset = RxByteCnt = 0;
  1493.             usRunningCRC = 0;
  1494.             rxlength = MSG_DATA_SIZE-2;
  1495.             RadioState = SYNC_STATE;
  1496.           }
  1497.         }
  1498.         else {
  1499.           if ((enableHCL == FALSE) || (!IsHCL(current_slot))) {
  1500.             --sMacDelay;
  1501.             if ((bTxPending && (sMacDelay <= 0)) && !IsNDC()) {
  1502.               RadioState = PRETX_STATE;
  1503.               RSSIInitState = PRETX_STATE;
  1504.               bRSSIValid = FALSE;
  1505.               iRSSIcount = 0;
  1506.               PreambleCount = 0;
  1507.               call RSSIADC.getData();
  1508.             }
  1509.           }
  1510.         }
  1511.       }
  1512.       break;
  1514.     case PRETX_STATE:
  1515.       {
  1516.         receive_sum ++;
  1517.         if (((data_in == (0xaa)) || (data_in == (0x55)))) {
  1518.           // Back to the penalty box.
  1519.           sMacDelay = signal MacBackoff.congestionBackoff(txbufptr);
  1520.           RadioState = IDLE_STATE;
  1521.         }
  1522.       }
  1523.       break;
  1525.     case SYNC_STATE:
  1526.       {
  1527.         // draw in the preamble bytes and look for a sync byte
  1528.         // save the data in a short with last byte received as msbyte
  1529.         //    and current byte received as the lsbyte.
  1530.         // use a bit shift compare to find the byte boundary for the sync byte
  1531.         // retain the shift value and use it to collect all of the packet data
  1532.         // check for data inversion, and restore proper polarity 
  1533.         // XXX-PB: Don't do this.
  1534.         uint8_t i;
  1536.         receive_sum ++;
  1537.         if ((data_in == 0xaa) || (data_in == 0x55)) {
  1538.           // It is actually possible to have the LAST BIT of the incoming
  1539.           // data be part of the Sync Byte.  SO, we need to store that
  1540.           // However, the next byte should definitely not have this pattern.
  1541.           // XXX-PB: Do we need to check for excessive preamble?
  1542.           RxShiftBuf.MSB = data_in;
  1544.         }
  1545.         else {
  1546.           // TODO: Modify to be tolerant of bad bits in the preamble...
  1547.           uint16_t usTmp;
  1548.           switch (SOFCount) {
  1549.           case 0:
  1550.             RxShiftBuf.LSB = data_in;
  1551.             break;
  1552.   
  1553.           case 1:
  1554.           case 2: 
  1555.           case 3: 
  1556.           case 4: 
  1557.           case 5: 
  1558.             // bit shift the data in with previous sample to find sync
  1559.             usTmp = RxShiftBuf.W;
  1560.             RxShiftBuf.W <<= 8;
  1561.             RxShiftBuf.LSB = data_in;
  1563.             for(i=0;i<8;i++) {
  1564.               usTmp <<= 1;
  1565.               if(data_in & 0x80)
  1566.                 usTmp  |=  0x1;
  1567.               data_in <<= 1;
  1568.               // check for sync bytes
  1569.               if (usTmp == SYNC_WORD) {
  1570.                 if (rxbufptr->length !=0) {
  1571.                   call Leds.redToggle();
  1572.                   RadioState = IDLE_STATE;
  1573.                 }
  1574.                 else {
  1575.                   RadioState = RX_STATE;
  1576.                   RSSIInitState = RX_STATE;
  1577.                   call RSSIADC.getData();
  1578.                   RxBitOffset = 7-i;
  1579.                   // For time sync services
  1580.                   signal RadioReceiveCoordinator.startSymbol(8, RxBitOffset, rxbufptr); 
  1581.                 }
  1582.                 break;
  1583.               }
  1584.             }
  1585.             break;
  1587.           default:
  1588.             // We didn't find it after a reasonable number of tries, so....
  1589.             RadioState = IDLE_STATE;  // Ensures we wait till the end of the transmission
  1590.             break;
  1591.           }
  1592.           SOFCount++;
  1593.         }
  1595.       }
  1596.       break;
  1597.       //  collect the data and shift into double buffer
  1598.       //  shift out data by correct offset
  1599.       //  invert the data if necessary
  1600.       //  stop after the correct packet length is read
  1601.       //  return notification to upper levels
  1602.       //  go back to idle state
  1603.     case RX_STATE:
  1604.       {
  1605.         char Byte;
  1606.         receive_sum ++;
  1608.         RxShiftBuf.W <<=8;
  1609.         RxShiftBuf.LSB = data_in;
  1611.         Byte = (RxShiftBuf.W >> RxBitOffset);
  1612.         ((char*)rxbufptr)[(int)RxByteCnt] = Byte;
  1613.         RxByteCnt++;
  1615.         signal RadioReceiveCoordinator.byte(rxbufptr, (uint8_t)RxByteCnt);
  1617.         if (RxByteCnt < rxlength) {
  1618.           usRunningCRC = crcByte(usRunningCRC,Byte);
  1620.           if (RxByteCnt == (offsetof(struct TOS_Msg,length) + 
  1621.                             sizeof(((struct TOS_Msg *)0)->length))) {
  1622.             rxlength = rxbufptr->length;
  1623.             if (rxlength > TOSH_DATA_LENGTH) {
  1624.               // The packet's screwed up, so just dump it
  1625.               rxbufptr->length = 0;
  1626.               RadioState = IDLE_STATE;  // Waits till end of transmission
  1627.               return SUCCESS;
  1628.             }
  1629.             //Add in the header size
  1630.             rxlength += offsetof(struct TOS_Msg,data);
  1631.           }
  1632.         }
  1633.         else if (RxByteCnt == rxlength) {
  1634.           usRunningCRC = crcByte(usRunningCRC,Byte);
  1635.           // Shift index ahead to the crc field.
  1636.           RxByteCnt = offsetof(struct TOS_Msg,crc);
  1637.         }
  1638.         else if (RxByteCnt >= MSG_DATA_SIZE) { 
  1640.           // Packet filtering based on bad CRC's is done at higher layers.
  1641.           // So sayeth the TOS weenies.
  1642.           if (rxbufptr->crc == usRunningCRC) {
  1643.             if(rxbufptr->addr == SYNCTYPE){
  1644.               adjustTime();
  1645.             }
  1646.             rxbufptr->crc = 1;
  1647.             
  1648.             if(bAckEnable && (rxbufptr->addr == TOS_LOCAL_ADDRESS)){
  1650.               RadioState = SENDING_ACK; 
  1651.               call CC1000Control.TxMode();
  1652.               call SpiByteFifo.txMode();
  1653.               call SpiByteFifo.writeByte(0xaa);
  1654.               RxByteCnt = 0;
  1655.               return SUCCESS; 
  1656.             }
  1658.           } else {
  1659.             rxbufptr->crc = 0;
  1660.           }
  1662.           call SpiByteFifo.disableIntr();
  1663.   
  1664.           RadioState = IDLE_STATE; //DISABLED_STATE;
  1665.           if(bTxPending == TRUE){ // changes by Ajit
  1666.             if(current_slot == own_slot)
  1667.               sMacDelay = signal MacBackoff.congestionBackoff(rxbufptr);
  1668.             else{
  1669.               if(sMacDelay + T_O < (T_O + T_NO - 1))
  1670.                 sMacDelay = sMacDelay + T_O;
  1671.               else
  1672.                 sMacDelay = T_O + T_NO - 1;
  1673.             }
  1674.             // reset timer when time slot boundary
  1675.           }
  1676.           rxbufptr->strength = usRSSIVal;
  1677.           call SClock.getTime(&loctime);
  1678.           global_timestamp = (uint16_t)(loctime.mticks * 568.8 + loctime.sticks * 0.00868) ; //in ms
  1679.           /*
  1680.             if(rxbufptr->addr != SYNCTYPE)
  1681.             SODbg(DBG_USR2,"Received Packet from %u seqnum = %u at %un", rxbufptr->data[0],
  1682.             rxbufptr->data[1], global_timestamp);
  1683.           */
  1684.           if (!(post PacketRcvd())) {
  1685.             // If there are insufficient resources to process the incoming packet
  1686.             // we drop it
  1687.             rxbufptr->length = 0;
  1688.             RadioState = IDLE_STATE;
  1689.             call SpiByteFifo.enableIntr();
  1690.           }
  1691.           RSSIInitState = RadioState;
  1692.           call RSSIADC.getData();
  1693.         }
  1694.       }
  1695.       break;
  1697.     case SENDING_ACK:
  1698.       {
  1699.         send_sum ++;
  1700.         RxByteCnt++;
  1701.         if (RxByteCnt >= ACK_LENGTH) { 
  1702.           call CC1000Control.RxMode();
  1703.           call SpiByteFifo.rxMode();
  1704.           call SpiByteFifo.disableIntr();
  1705.           RadioState = IDLE_STATE; //DISABLED_STATE;
  1706.           rxbufptr->strength = usRSSIVal;
  1707.           if (!(post PacketRcvd())) {
  1708.             rxbufptr->length = 0;
  1709.             RadioState = IDLE_STATE;
  1710.             call SpiByteFifo.enableIntr();
  1711.           }
  1712.         }else if(RxByteCnt >= ACK_LENGTH - sizeof(ack_code)){
  1713.           call SpiByteFifo.writeByte(ack_code[RxByteCnt + sizeof(ack_code) - ACK_LENGTH]);
  1714.         }
  1715.       }
  1716.       break;
  1718.     default:
  1719.       break;
  1720.     }
  1722.     if(pulse_check_sum > CHECK_MA_COUNT){
  1723.       power_sum ++;
  1724.       pulse_check_sum -= CHECK_MA_COUNT;
  1725.     }
  1726.     if(send_sum > SEND_MA_COUNT){
  1727.       power_sum ++;
  1728.       send_sum -= SEND_MA_COUNT;
  1729.     }
  1730.     if(receive_sum > RECEIVE_MA_COUNT){
  1731.       power_sum ++;
  1732.       receive_sum -= RECEIVE_MA_COUNT;
  1733.     }
  1734.     return SUCCESS;
  1735.   }
  1737.   task void IdleTimerTask(){
  1738.     if (iSquelchCount > CC1K_SquelchCount)
  1739.       call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  1740.     else
  1741.       call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  1742.     call WakeupTimer.start(TIMER_ONE_SHOT, TIME_AFTER_CHECK);
  1743.     /*if(pulse_check_sum > CHECK_MA_COUNT){
  1744.       power_sum ++;
  1745.       pulse_check_sum -= CHECK_MA_COUNT;
  1746.       }
  1747.       if(send_sum > SEND_MA_COUNT){
  1748.       power_sum ++;
  1749.       send_sum -= SEND_MA_COUNT;
  1750.       }
  1751.       if(receive_sum > RECEIVE_MA_COUNT){
  1752.       power_sum ++;
  1753.       receive_sum -= RECEIVE_MA_COUNT;
  1754.       }*/
  1755.   }
  1757.   task void SleepTimerTask(){
  1758.     call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  1759.   }
  1761.   async event result_t RSSIADC.dataReady(uint16_t data) { 
  1762.     atomic
  1763.       {
  1764.         uint8_t currentRadioState;
  1766.         // TOSH_CLR_PW3_PIN();
  1768.         currentRadioState = RadioState;
  1769.         // find the maximum RSSI value over CC1K_MAX_RSSI_SAMPLES
  1770.         switch(currentRadioState) {
  1771.         case IDLE_STATE:
  1772.           if (RSSIInitState == IDLE_STATE) {
  1773.             atomic usTempSquelch = data;
  1774.             post adjustSquelch();
  1775.           }
  1776.           RSSIInitState = NULL_STATE;
  1777.           break;
  1779.         case RX_STATE:
  1780.           if (RSSIInitState == RX_STATE) {
  1781.             atomic usRSSIVal = data;
  1782.           }
  1783.           RSSIInitState = NULL_STATE;
  1784.           break;
  1786.         case PRETX_STATE:
  1787.           iRSSIcount++;
  1789.           // if the channel is clear or CCA is disabled, GO GO GO!
  1790.           if (((data > (usSquelchVal + CC1K_SquelchBuffer)) || (!bCCAEnable)) && (RSSIInitState == PRETX_STATE)) { 
  1791.             call SpiByteFifo.writeByte(0xaa);
  1792.             call CC1000Control.TxMode();
  1793.             call SpiByteFifo.txMode();
  1795.             usRSSIVal = data;
  1796.             iRSSIcount = CC1K_MaxRSSISamples;
  1797.             bRSSIValid = TRUE;
  1798.             TxByteCnt = 0;
  1799.             usRunningCRC = 0;
  1800.             RadioState = TX_STATE;
  1801.             RadioTxState = TXSTATE_PREAMBLE;
  1802.             NextTxByte = 0xaa;
  1803.             RSSIInitState = NULL_STATE;
  1804.           }
  1805.           else {
  1806.             RSSIInitState = NULL_STATE;
  1807.             if (iRSSIcount == CC1K_MaxRSSISamples) {
  1808.               sMacDelay = signal MacBackoff.congestionBackoff(txbufptr);
  1809.               RadioState = IDLE_STATE;
  1810.             }
  1811.             else {
  1812.               RSSIInitState = currentRadioState;
  1813.               call RSSIADC.getData();
  1814.             }
  1815.           }
  1816.           break;
  1818.         case PULSE_CHECK_STATE:
  1819.           atomic{
  1820.             uint8_t done = 0;
  1821.             uint16_t threshold = call GetSquelch();
  1822.             threshold = threshold - (call GetSquelch() >> 2);
  1823.             if(data > threshold){
  1824.               // adjust the noise floor level
  1825.               atomic usTempSquelch = data;
  1826.               post adjustSquelch();
  1828.             }else if(pulse_check_count > 5){
  1829.               //go to the idle state since no outliers were found
  1830.               call CC1000Control.RxMode();
  1831.               RadioState = IDLE_STATE;
  1832.               call SpiByteFifo.rxMode();     // SPI to miso
  1833.               call SpiByteFifo.enableIntr(); // enable spi interrupt
  1834.               post IdleTimerTask();
  1835.               done = 1;
  1837.             }else {
  1838.               call CC1000Control.RxMode();
  1839.               if(call RSSIADC.getData()){
  1840.                 TOSH_uwait(80);
  1841.                 pulse_check_count ++;
  1842.                 done = 1;
  1843.               }
  1844.               pulse_check_sum ++;
  1845.               call CC1000StdControl.stop();
  1846.             }
  1847.             
  1848.             if (bTxPending) { // bug fixed by Dr. Rhee
  1849.               //go to the idle state since no outliers were found
  1850.               call CC1000Control.RxMode();
  1851.               RadioState = IDLE_STATE;
  1852.               call SpiByteFifo.rxMode();     // SPI to miso
  1853.               call SpiByteFifo.enableIntr(); // enable spi interrupt
  1854.               post IdleTimerTask();
  1855.               done = 1;
  1856.             }
  1858.             if(done == 0){
  1859.               post SleepTimerTask();
  1860.               RadioState = POWER_DOWN_STATE;
  1861.               call SpiByteFifo.disableIntr();
  1862.             }
  1863.           }
  1864.           //go to the power down state
  1865.           break;
  1867.         default:
  1868.         }
  1869.       }
  1870.     return SUCCESS;
  1871.   }
  1873.   // XXX:JP- for testing the mac layer squlech value
  1874.   async command uint16_t GetSquelch() {
  1875.     return usSquelchVal;
  1876.   }
  1877.   // XXX:JP- for testing the mac layer power consumption
  1878.   async command uint16_t GetPower() {
  1879.     return power_sum;
  1880.   }
  1882.   async command result_t ResetPower() {
  1883.     power_sum = 0;
  1884.     pulse_check_sum = 0;
  1885.     send_sum = 0;
  1886.     receive_sum = 0;
  1887.   }
  1889.   async command result_t MacControl.enableAck() {
  1890.     atomic bAckEnable = TRUE;
  1891.     return SUCCESS;
  1892.   }
  1894.   async command result_t MacControl.disableAck() {
  1895.     atomic bAckEnable = FALSE;
  1896.     return SUCCESS;
  1897.   }
  1899.   async command result_t MacControl.enableCCA() {
  1900.     atomic bCCAEnable = TRUE;
  1901.     return SUCCESS;
  1902.   }
  1904.   async command result_t MacControl.disableCCA() {
  1905.     atomic bCCAEnable = FALSE; 
  1906.     return SUCCESS;
  1907.   }
  1909.   // ***Not yet implemented
  1910.   async command TOS_MsgPtr MacControl.HaltTx() {
  1911.     return 0;
  1912.   }
  1914.   // Default events for radio send/receive coordinators do nothing.
  1915.   // Be very careful using these, you'll break the stack.
  1916.   default async event void RadioSendCoordinator.startSymbol(uint8_t bitsPerBlock, uint8_t offset, TOS_MsgPtr msgBuff) { }
  1917.   default async event void RadioSendCoordinator.byte(TOS_MsgPtr msg, uint8_t byteCount) { }
  1918.   default async event void RadioSendCoordinator.blockTimer() { }
  1920.   default async event void RadioReceiveCoordinator.startSymbol(uint8_t bitsPerBlock, uint8_t offset, TOS_MsgPtr msgBuff) { }
  1921.   default async event void RadioReceiveCoordinator.byte(TOS_MsgPtr msg, uint8_t byteCount) { }
  1922.   default async event void RadioReceiveCoordinator.blockTimer() { }
  1924.  
  1926.   default async event int16_t MacBackoff.initialBackoff(TOS_MsgPtr m) { 
  1927.     uint16_t backoff;
  1928.     if(current_mac == HYMAC) 
  1929.       {
  1930.         /*
  1931.         //    SODbg(DBG_USR2,"current slot is %i own slot %i",current_slot,own_slot);    
  1932.         if(wait_HCL)
  1933.         {
  1934.         call SClock.getTime(&loctime);      
  1935.         global_timestamp = (uint16_t)(loctime.mticks * 568.8 + loctime.sticks * 0.00868) ; //in ms
  1936.         slot_offset = (uint16_t)(global_timestamp % framesize)%(slot_size);
  1937.         slot_offset = (slot_size - slot_offset)/CSLOT_SIZE;
  1939.         if(next_slot == own_slot) 
  1940.         return (call Random.rand() & (T_O - 1)) + 1 + slot_offset;
  1941.         else
  1942.         return (call Random.rand() & (T_NO-1)) + T_O + 1 + slot_offset;
  1943.         }
  1945.         else 
  1946.         {
  1947.         */
  1948.         if(current_slot == own_slot) 
  1949.           backoff = (call Random.rand() & (T_O - 1)) + 1;
  1950.         else  
  1951.           backoff = (call Random.rand() & (T_NO - 1)) + 1 + T_O;
  1952.         /*
  1953.           if(check_NDC)
  1954.           {
  1955.           call SClock.getTime(&loctime);      
  1956.           global_timestamp = (uint16_t)(loctime.mticks * 568.8 + loctime.sticks * 0.00868) ; //in ms
  1957.           slot_offset = (uint16_t)(global_timestamp % framesize)%(slot_size);
  1958.           slot_offset = (slot_size - slot_offset)/CSLOT_SIZE;
  1959.           if((txlength + preamblelen + 2) > slot_offset-backoff)
  1960.           backoff = slot_offset + slot_size * CSLOTS_PER_TDMA; 
  1961.           }
  1962.         */
  1963.         return(backoff);
  1965.         //}
  1966.       }
  1967.     else                                         //use 0 initial backoff for optimal BMAC performance
  1968.       return (call Random.rand() & 0x1F) + 1;
  1969.   }
  1971.   default async event int16_t MacBackoff.congestionBackoff(TOS_MsgPtr m) { 
  1972.     uint16_t backoff;
  1973.     if(current_mac == HYMAC)
  1974.       {
  1975.         congbackoffs++;
  1976.         //    SODbg(DBG_USR2,"current slot is %i own slot %i",current_slot,own_slot);    
  1977.         /*
  1978.           if(wait_HCL)
  1979.           {
  1980.           call SClock.getTime(&loctime);      
  1981.           global_timestamp = (uint16_t)(loctime.mticks * 568.8 + loctime.sticks * 0.00868) ; //in ms
  1982.           slot_offset = (uint16_t)(global_timestamp % framesize)%(slot_size);
  1983.           slot_offset = (slot_size - slot_offset)/CSLOT_SIZE;
  1985.           if(next_slot == own_slot)
  1986.           return (call Random.rand() & (T_O - 1)) + 1 + slot_offset;
  1987.           else
  1988.           return (call Random.rand() & (T_NO - 1)) + T_O + 1 + slot_offset;
  1989.           }
  1990.           else 
  1991.           {
  1992.         */
  1993.         if(current_slot == own_slot) 
  1994.           backoff = (call Random.rand() & (T_O - 1)) + 1;
  1995.         else  
  1996.           backoff = (call Random.rand() & (T_NO - 1)) + 1 + T_O;
  1997.         
  1998.         /*
  1999.           if(IsHCL(next_slot))
  2000.           {
  2001.           call SClock.getTime(&loctime);
  2002.           global_timestamp = (uint16_t)(loctime.mticks * 568.8 + loctime.sticks * 0.00868) ; //in ms
  2003.           slot_offset = (uint16_t)(global_timestamp)%(slot_size);
  2004.           slot_offset = (slot_size - slot_offset)/CSLOT_SIZE;
  2005.           if((txlength + preamblelen + 2) > slot_offset)
  2006.           backoff = slot_offset + slot_size * CSLOTS_PER_TDMA; 
  2007.           }
  2008.         */
  2009.         return(backoff);
  2011.             
  2012.         //}
  2013.       }
  2014.     else
  2015.       return (call Random.rand() & 0xF) + 1;
  2016.   }
  2018.   /**************SClock Interface********/
  2019.   async event result_t SClock.syncDone() 
  2020.   {
  2021.     return SUCCESS;
  2022.   }
  2024.   async event result_t SClock.fire(uint16_t mticks)
  2025.   {
  2026.     return SUCCESS;
  2027.   }  
  2028. }