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

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

网络

开发平台：

Others

CC1000RadioIntM.nc：源码内容
  1. // $Id: CC1000RadioIntM.nc,v 1.1.1.1 2005/04/22 04:26:45 acwarrie Exp $
  3. /* tab:4
  4.  * "Copyright (c) 2000-2003 The Regents of the University  of California.  
  5.  * All rights reserved.
  6.  *
  7.  * Permission to use, copy, modify, and distribute this software and its
  8.  * documentation for any purpose, without fee, and without written agreement is
  9.  * hereby granted, provided that the above copyright notice, the following
  10.  * two paragraphs and the author appear in all copies of this software.
  11.  * 
  12.  * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
  13.  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  14.  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
  15.  * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  16.  * 
  17.  * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  18.  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  19.  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  20.  * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
  21.  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."
  22.  *
  23.  * Copyright (c) 2002-2003 Intel Corporation
  24.  * All rights reserved.
  25.  *
  26.  * This file is distributed under the terms in the attached INTEL-LICENSE     
  27.  * file. If you do not find these files, copies can be found by writing to
  28.  * Intel Research Berkeley, 2150 Shattuck Avenue, Suite 1300, Berkeley, CA, 
  29.  * 94704.  Attention:  Intel License Inquiry.
  30.  */
  32. /*  
  33.  *  Authors: Philip Buonadonna, Jaein Jeong, Joe Polastre, Chris Karlof
  34.  *  Date last modified: $Revision: 1.1.1.1 $
  35.  *
  36.  * This module provides the layer2 functionality for the mica2 radio.
  37.  * While the internal architecture of this module is not CC1000 specific,
  38.  * It does make some CC1000 specific calls via CC1000Control.
  39.  *
  40.  *
  41.  * This makes use of TinySec. WARNING: Beware of using RadioCoordinators
  42.  * with this stack. Length and group byte are switched.
  43.  * 
  44.  * $Id: CC1000RadioIntM.nc,v 1.1.1.1 2005/04/22 04:26:45 acwarrie Exp $
  45.  */
  47. /**
  48.  * @author Philip Buonadonna
  49.  * @author Jaein Jeong
  50.  * @author Joe Polastre
  51.  * @author Chris Karlof
  52.  */
  53.   
  54. includes crc;
  55. includes CC1000Const;
  57. module CC1000RadioIntM {
  58.   provides {
  59.     interface StdControl;
  60.     interface BareSendMsg as Send;
  61.     interface ReceiveMsg as Receive;
  62.     command result_t EnableRSSI();
  63.     command result_t DisableRSSI();
  64.     command result_t SetListeningMode(uint8_t power);
  65.     command uint8_t GetListeningMode();
  66.     command result_t SetTransmitMode(uint8_t power);
  67.     command uint8_t GetTransmitMode();
  68.     command uint16_t GetSquelch();
  69.     interface RadioCoordinator as RadioSendCoordinator;
  70.     interface RadioCoordinator as RadioReceiveCoordinator;
  71.     interface TinySecRadio;
  72.   }
  73.   uses {
  74.     interface PowerManagement;
  75.     interface StdControl as CC1000StdControl;
  76.     interface CC1000Control;
  77.     interface Random;
  78.     interface ADCControl;
  79.     interface ADC as RSSIADC;
  80.     interface SpiByteFifo;
  81.     interface StdControl as TimerControl;
  82.     interface Timer as WakeupTimer;
  83.     interface Timer as SquelchTimer;
  84.     // TinySec
  85.     interface TinySec;
  86.     interface Leds;
  87.   }
  88. }
  89. implementation {
  90.   enum {
  91.     TX_STATE,
  92.     DISABLED_STATE,
  93.     IDLE_STATE,
  94.     PRETX_STATE,
  95.     SYNC_STATE,
  96.     HEADER_RX_STATE,
  97.     RX_STATE,
  98.     RX_STATE_TINYSEC,
  99.     SENDING_ACK,
  100.     POWER_DOWN_STATE,
  101.   };
  103.   enum {
  104.     TXSTATE_WAIT,
  105.     TXSTATE_START,
  106.     TXSTATE_PREAMBLE,
  107.     TXSTATE_SYNC,
  108.     TXSTATE_DATA,
  109.     TXSTATE_DATA_TINYSEC,
  110.     TXSTATE_CRC,
  111.     TXSTATE_FLUSH,
  112.     TXSTATE_WAIT_FOR_ACK,
  113.     TXSTATE_READ_ACK,
  114.     TXSTATE_DONE
  115.   };
  117.   enum {
  118.     SYNC_BYTE = 0x33,
  119.     NSYNC_BYTE = 0xcc,
  120.     SYNC_WORD = 0x33cc,
  121.     NSYNC_WORD = 0xcc33,
  122.     ACK_LENGTH = 16,
  123.     MAX_ACK_WAIT = 18
  124.   };
  126.   uint8_t ack_code[3] = {0xab, 0xba, 0x83};
  128.   uint8_t RadioState;
  129.   uint8_t RadioTxState;
  130.   norace uint8_t iRSSIcount;
  131.   uint8_t iSquelchCount;
  132.   uint16_t txlength;
  133.   uint16_t rxlength;
  134.   /**** TinySec ****/
  135.   TOS_Msg_TinySecCompat* txbufptr;  // pointer to transmit buffer
  136.   TOS_Msg_TinySecCompat* rxbufptr;  // pointer to receive buffer
  137.   TOS_Msg_TinySecCompat RxBuf; // save received messages
  138.   /**** TinySec ****/
  139.   uint8_t NextTxByte;
  141.   uint8_t lplpower;        //  low power listening mode
  142.   uint8_t lplpowertx;      //  low power listening transmit mode
  144.   uint16_t preamblelen;    //  current length of the preamble
  145.  
  146.   uint16_t PreambleCount;   //  found a valid preamble
  147.   uint8_t SOFCount;
  149.   uint16_t search_word;
  151.   union {
  152.     uint16_t W;
  153.     struct {
  154.       uint8_t LSB;
  155.       uint8_t MSB;
  156.     };
  157.   } RxShiftBuf;
  159.   uint8_t RxBitOffset; // bit offset for spibus
  160.   uint16_t RxByteCnt; // received byte counter
  161.   uint16_t TxByteCnt;
  162.   uint16_t RSSISampleFreq; // in Bytes rcvd per sample
  163.   norace bool bInvertRxData; // data inverted
  164.   bool bTxPending;
  165.   bool bTxBusy;
  166.   bool bRSSIValid;
  167.   uint16_t usRunningCRC; // Running CRC variable
  168.   norace uint16_t usRSSIVal; // suppress nesc warnings
  169.   uint16_t usSquelchVal;
  170.   uint16_t usTempSquelch;
  171.   uint8_t usSquelchIndex;
  173.   uint16_t usSquelchTable[CC1K_SquelchTableSize];
  175.   int16_t sMacDelay;    // MAC delay for the next transmission
  176.   // XXX-PB:
  177.   // Here's the deal, the mica (RFM) radio stacks used TOS_LOCAL_ADDRESS
  178.   // to determine if an L2 ack was reqd.  This stack doesn't do L2 acks
  179.   // and, thus doesn't need it.  HOWEVER, some set-mote-id versions
  180.   // break if this symbol is missing from the binary.
  181.   // Thus, I put this LocalAddr here and set it to TOS_LOCAL_ADDRESS
  182.   // to keep things happy for now.
  183.   volatile uint16_t LocalAddr;
  185.   ///**********************************************************
  186.   //* local function definitions
  187.   //**********************************************************/
  189. /*
  190.   int sortByShort(const void *x, const void *y) {
  191.     uint16_t* x1 = (uint16_t*)x;
  192.     uint16_t* y1 = (uint16_t*)y;
  193.     if (x1[0] > y1[0]) return -1;
  194.     if (x1[0] == y1[0]) return 0;
  195.     if (x1[0] < y1[0]) return 1;
  196.     return 0; // shouldn't reach here becasue it covers all the cases
  197.   }
  198. */
  200.   task void adjustSquelch() {
  201.     uint16_t tempArray[CC1K_SquelchTableSize];
  202.     char i,j,min; 
  203.     uint16_t min_value;
  205.     atomic {
  206.       usSquelchTable[usSquelchIndex] = usTempSquelch;
  207.       usSquelchIndex++;
  208.       if (usSquelchIndex >= CC1K_SquelchTableSize)
  209.         usSquelchIndex = 0;
  210.       if (iSquelchCount <= CC1K_SquelchCount)
  211.         iSquelchCount++;  
  212.     }
  214.     for (i=0; i<CC1K_SquelchTableSize; i++) {
  215.       tempArray[(int)i] = usSquelchTable[(int)i];
  216.     }
  218.     min = 0;
  219.     for (j = 0; j < ((CC1K_SquelchTableSize) >> 1); j++) {
  220.       for (i = 1; i < CC1K_SquelchTableSize; i++) {
  221.         if ((tempArray[(int)i] != 0xFFFF) && 
  222.             (tempArray[(int)i] < tempArray[(int)min])) {
  223.           min = i;
  224.         }
  225.       }
  226.       min_value = tempArray[(int)min];
  227.       tempArray[(int)min] = 0xFFFF;
  228.     }
  230.     atomic usSquelchVal = ((usSquelchVal << 4) + (min_value << 1)) / 18;
  232.     /*
  233.     // XXX: qsort actually causes ~600bits/sec lower bandwidth... why???
  234.     //
  235.     qsort (tempArray,CC1K_SquelchTableSize, sizeof(uint16_t),sortByShort);
  236.     min_value = tempArray[CC1K_SquelchTableSize >> 1];
  237.     atomic usSquelchVal = ((usSquelchVal << 4) + (min_value << 1)) / 18;
  238.     */
  241.   }
  243.   /**** TinySec ****/
  244.   void swapLengthAndGroup(TOS_Msg* buf) {
  245.     uint8_t tmp = buf->group;
  247.     ((TOS_Msg_TinySecCompat*) buf)->length = buf->length;
  248.     ((TOS_Msg_TinySecCompat*) buf)->group = tmp;
  250.   }
  251.   /**** TinySec ****/
  252.   
  253.   task void PacketRcvd() {
  254.     TOS_MsgPtr pBuf;
  256.     atomic {
  257.       rxbufptr->time = 0;
  258.       /**** TinySec ****/
  259.       pBuf = (TOS_MsgPtr) rxbufptr;
  260.       swapLengthAndGroup(pBuf);
  261.       /**** TinySec ****/
  262.       // EWMA to determin squelch values
  263.       usSquelchVal = (((5*pBuf->strength) + (3*usSquelchVal)) >> 3);
  264.     }
  265.     pBuf = signal Receive.receive((TOS_MsgPtr)pBuf);
  266.     atomic {
  267.       if (pBuf) 
  268. rxbufptr = (TOS_Msg_TinySecCompat*) pBuf;
  269.       rxbufptr->length = 0;
  270.     }
  271.     call SpiByteFifo.enableIntr();
  272.   }
  273.   
  274.   task void PacketSent() {
  275.     TOS_MsgPtr pBuf; //store buf on stack 
  276.     atomic {
  277.       txbufptr->time = 0;
  278.       pBuf = (TOS_Msg*) txbufptr;
  279.       /**** TinySec ****/
  280.       swapLengthAndGroup(pBuf);
  281.       /**** TinySec ****/
  282.     }
  283.     signal Send.sendDone((TOS_MsgPtr)pBuf,SUCCESS);
  284.     atomic bTxBusy = FALSE;
  285.   }
  287.   ///**********************************************************
  288.   //* Exported interface functions
  289.   //**********************************************************/
  290.   
  291.   command result_t StdControl.init() {
  292.     char i;
  294.     atomic {
  295.       RadioState = DISABLED_STATE;
  296.       RadioTxState = TXSTATE_PREAMBLE;
  297.       rxbufptr = &RxBuf;
  298.       rxbufptr->length = 0;
  299.       rxlength = TINYSEC_MSG_DATA_SIZE-TINYSEC_MAC_LENGTH;
  300.       RxBitOffset = 0;
  301.       iSquelchCount = 0;
  302.       
  303.       PreambleCount = 0;
  304.       RSSISampleFreq = 0;
  305.       RxShiftBuf.W = 0;
  306.       iRSSIcount = 0;
  307.       bTxPending = FALSE;
  308.       bTxBusy = FALSE;
  309.       bRSSIValid = FALSE;
  310.       sMacDelay = -1;
  311.       usRSSIVal = -1;
  312.       usSquelchIndex = 0;
  313.       lplpower = lplpowertx = 0;
  314.       usSquelchVal = CC1K_SquelchInit;
  315.     }
  317.     for (i = 0; i < CC1K_SquelchTableSize; i++)
  318.       usSquelchTable[(int)i] = CC1K_SquelchInit;
  320.     call SpiByteFifo.initSlave(); // set spi bus to slave mode
  321.     call CC1000StdControl.init();
  322.     call CC1000Control.SelectLock(0x9); // Select MANCHESTER VIOLATION
  323.     bInvertRxData = call CC1000Control.GetLOStatus();
  325.     call ADCControl.bindPort(TOS_ADC_CC_RSSI_PORT,TOSH_ACTUAL_CC_RSSI_PORT);
  326.     call ADCControl.init();
  328.     call Random.init();
  329.     call TimerControl.init();
  331.     LocalAddr = TOS_LOCAL_ADDRESS;
  333.     return SUCCESS;
  334.   }
  335.   
  337.   command result_t EnableRSSI() {
  339.     return SUCCESS;
  340.   }
  342.   command result_t DisableRSSI() {
  344.     return SUCCESS;
  345.   }
  347.   command uint8_t GetTransmitMode() {
  348.     return lplpowertx;
  349.   }
  351.   /**
  352.    * Set the state of low power transmit on the chipcon radio.
  353.    * The transmit mode of the sender *must* match the receiver in
  354.    * order for the receiver to successfully get the packet.
  355.    * <p>
  356.    * The default power up state is 0 (radio always on).
  357.    * See CC1000Const.h for low power duty cycles and bandwidth
  358.    */
  359.   command result_t SetTransmitMode(uint8_t power) {
  360.     if ((power >= CC1K_LPL_STATES) || (power == lplpowertx))
  361.       return FAIL;
  363.     // check if the radio is currently doing something
  364.     if ((!bTxPending) && ((RadioState == POWER_DOWN_STATE) || 
  365.   (RadioState == IDLE_STATE) ||
  366.   (RadioState == DISABLED_STATE))) {
  368.       atomic {
  369. lplpowertx = power;
  370. preamblelen = ((PRG_RDB(&CC1K_LPL_PreambleLength[lplpowertx*2]) << 8)
  371.                        | PRG_RDB(&CC1K_LPL_PreambleLength[(lplpowertx*2)+1]));
  372.       }
  373.       return SUCCESS;
  374.     }
  375.     return FAIL;
  376.   }
  378.   /**
  379.    * Set the state of low power listening on the chipcon radio.
  380.    * <p>
  381.    * The default power up state is 0 (radio always on).
  382.    * See CC1000Const.h for low power duty cycles and bandwidth
  383.    */
  384.   command result_t SetListeningMode(uint8_t power) {
  385.     // valid low power listening values are 0 to 3
  386.     // 0 is "always on" and 3 is lowest duty cycle
  387.     // 1 and 2 are in the middle
  388.     if ((power >= CC1K_LPL_STATES) || (power == lplpower))
  389.       return FAIL;
  391.     // check if the radio is currently doing something
  392.     if ((!bTxPending) && ((RadioState == POWER_DOWN_STATE) || 
  393.   (RadioState == IDLE_STATE) ||
  394.   (RadioState == DISABLED_STATE))) {
  396.       // change receiving function in CC1000Radio
  397.       call WakeupTimer.stop();
  398.       atomic {
  399. if (lplpower == lplpowertx) {
  400.   lplpowertx = power;
  401. }
  402. lplpower = power;
  403.       }
  405.       // if successful, change power here
  406.       if (RadioState == IDLE_STATE) {
  407. RadioState = DISABLED_STATE;
  408. call StdControl.stop();
  409. call StdControl.start();
  410.       }
  411.       if (RadioState == POWER_DOWN_STATE) {
  412. RadioState = DISABLED_STATE;
  413. call StdControl.start();
  414. call PowerManagement.adjustPower();
  415.       }
  416.     }
  417.     else {
  418.       return FAIL;
  419.     }
  420.     return SUCCESS;
  421.   }
  423.   /**
  424.    * Gets the state of low power listening on the chipcon radio.
  425.    * <p>
  426.    * @return Current low power listening state value
  427.    */
  428.   command uint8_t GetListeningMode() {
  429.     return lplpower;
  430.   } 
  432.   event result_t SquelchTimer.fired() {
  433.     char currentRadioState;
  434.     atomic currentRadioState = RadioState;
  436.     if (currentRadioState == IDLE_STATE)
  437.       call RSSIADC.getData();
  438.     return SUCCESS;
  439.   }
  441.   event result_t WakeupTimer.fired() {
  442.     uint16_t sleeptime;
  443.     bool tempTxPending;
  444.     uint8_t currentRadioState;
  446.     if (lplpower == 0)
  447.       return SUCCESS;
  449.     atomic {
  450.       currentRadioState = RadioState;
  451.       tempTxPending = bTxPending;
  452.     }
  453.     switch(currentRadioState) {
  454.     case IDLE_STATE:
  455.       sleeptime = ((PRG_RDB(&CC1K_LPL_SleepTime[lplpower*2]) << 8) |
  456.    PRG_RDB(&CC1K_LPL_SleepTime[(lplpower*2)+1]));
  457.       if (!tempTxPending) {
  458.         atomic RadioState = POWER_DOWN_STATE;
  459.         call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  460.         call SquelchTimer.stop();
  461.         call CC1000StdControl.stop();
  462. call SpiByteFifo.disableIntr();
  463.       }
  464.       else {
  465.         call WakeupTimer.start(TIMER_ONE_SHOT, CC1K_LPL_PACKET_TIME*2);
  466.       }
  467.       break;
  469.     case POWER_DOWN_STATE:
  470.       sleeptime = PRG_RDB(&CC1K_LPL_SleepPreamble[lplpower]);
  471.       atomic RadioState = IDLE_STATE;
  472.       call CC1000StdControl.start();
  473.       call CC1000Control.BIASOn();
  474.       call SpiByteFifo.rxMode(); // SPI to miso
  475.       call CC1000Control.RxMode();
  476.       call SpiByteFifo.enableIntr(); // enable spi interrupt
  477.       if (iSquelchCount > CC1K_SquelchCount)
  478.         call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  479.       else
  480.         call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  481.       call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  482.       break;
  484.     default:
  485.       call WakeupTimer.start(TIMER_ONE_SHOT, CC1K_LPL_PACKET_TIME*2);
  486.     }
  487.     return SUCCESS;
  488.   }
  490.   command result_t StdControl.stop() {
  491.     atomic RadioState = DISABLED_STATE;
  493.     call SquelchTimer.stop();
  494.     call WakeupTimer.stop();
  495.     call CC1000StdControl.stop();
  496.     call SpiByteFifo.disableIntr(); // disable spi interrupt
  497.     return SUCCESS;
  498.   }
  500.   command result_t StdControl.start() {
  501.     uint8_t currentRadioState;
  502.     atomic currentRadioState = RadioState;
  503.     if (currentRadioState == DISABLED_STATE) {
  504.       atomic {
  505.         rxbufptr->length = 0;
  506.         RadioState  = IDLE_STATE;
  507.         bTxPending = bTxBusy = FALSE;
  508.         sMacDelay = -1;
  509.         preamblelen = ((PRG_RDB(&CC1K_LPL_PreambleLength[lplpowertx*2]) << 8) |
  510.      PRG_RDB(&CC1K_LPL_PreambleLength[(lplpowertx*2)+1]));
  511.       }
  512.       if (lplpower == 0) {
  513.         // all power on, captain!
  514.         rxbufptr->length = 0;
  515.         atomic RadioState = IDLE_STATE;
  516.         call CC1000StdControl.start();
  517.         call CC1000Control.BIASOn();
  518.         call SpiByteFifo.rxMode(); // SPI to miso
  519.         call CC1000Control.RxMode();
  520.         if (iSquelchCount > CC1K_SquelchCount)
  521.           call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  522.         else
  523.           call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  524.         call SpiByteFifo.enableIntr(); // enable spi interrupt
  525.       }
  526.       else {
  527.         uint16_t sleeptime = ((PRG_RDB(&CC1K_LPL_SleepTime[lplpower*2]) << 8) |
  528.                       PRG_RDB(&CC1K_LPL_SleepTime[(lplpower*2)+1]));
  529.         atomic RadioState = POWER_DOWN_STATE;
  530.         call TimerControl.start();
  531.         call SquelchTimer.stop();
  532.         call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  533.       }
  534.     }
  535.     return SUCCESS;
  536.   }
  538.   /*** TinySec ****/
  539.   async event result_t TinySec.sendDone(result_t result) {
  540.     atomic {
  541.       TxByteCnt = 0;
  542.       RadioTxState = TXSTATE_FLUSH;
  543.     }
  544.     return result;
  545.   }
  547.   async event result_t TinySec.receiveInitDone(result_t result, uint16_t length,
  548.        bool ts_enabled) {
  549.     atomic {
  550.       rxlength = length;
  551.       if(result == SUCCESS) {
  552.         if(ts_enabled)
  553.           RadioState = RX_STATE_TINYSEC;
  554.         else
  555.           RadioState = RX_STATE;
  556.       } else {
  557.         rxbufptr->length = 0;
  558.         RadioState = IDLE_STATE;
  559.       }
  560.     }
  561.     return SUCCESS;
  562.   }
  564.   async event result_t TinySec.receiveDone(result_t result) {
  565.     rxbufptr->strength = usRSSIVal;
  566.     if(rxbufptr->crc == 1 &&
  567.        (rxbufptr->addr == TOS_LOCAL_ADDRESS
  568. || rxbufptr->addr == TOS_BCAST_ADDR)){
  569.       //call Leds.redToggle();
  570.       RadioState = SENDING_ACK; 
  571.       call CC1000Control.TxMode();
  572.       call SpiByteFifo.txMode();
  573.       call SpiByteFifo.writeByte(0xaa);
  574.       RxByteCnt = 0;
  575.       return SUCCESS; 
  576.     } else {
  577.       call SpiByteFifo.disableIntr();
  578.       RadioState = IDLE_STATE; //DISABLED_STATE;
  579.       if (!(post PacketRcvd())) {
  580. // If there are insufficient resources to process the incoming packet
  581. // we drop it
  582. rxbufptr->length = 0;
  583. RadioState = IDLE_STATE;
  584. call SpiByteFifo.enableIntr();
  585.       }
  586.     }
  587.     return SUCCESS;
  588.   }
  589.   /**** TinySec ****/
  590.   
  591.   command result_t Send.send(TOS_MsgPtr pMsg) {
  592.     result_t Result = SUCCESS;
  593.     uint8_t currentRadioState = 0;
  595.     atomic {
  596.       if (bTxBusy) {
  597. Result = FAIL;
  598.       }
  599.       else {
  600. bTxBusy = TRUE;
  601.         /**** TinySec ****/
  602.         // swap TOS_Msg into TOS_Msg_TinySecCompat
  603.         // don't reference pMsg after here
  604.         swapLengthAndGroup(pMsg);
  605. txbufptr = (TOS_Msg_TinySecCompat*) pMsg;
  606.         /**** TinySec ****/
  607.         // initially back off [1,32] bytes (approx 2/3 packet)
  608.         sMacDelay = (call Random.rand() & 0x1F) + 1;
  609. bTxPending = TRUE;
  610.         /****** TinySec *****/
  611. // bad form to call a command in atomic, but sendInit is short.
  612. // easiest way to lock txbufptr
  613. if(txbufptr->length & TINYSEC_ENABLED_BIT) {
  614.   txlength = call TinySec.sendInit(txbufptr);
  615. } else {
  616.   txlength = txbufptr->length + (MSG_DATA_SIZE - DATA_LENGTH - 2);
  617. }
  618.         /****** TinySec *****/
  619.       }
  620.       currentRadioState = RadioState;
  621.     }
  623.     if (Result) {
  625.       // if we're off, start the radio
  626.       if (currentRadioState == POWER_DOWN_STATE) {
  627.         // disable wakeup timer
  628.         call WakeupTimer.stop();
  629.         call CC1000StdControl.start();
  630.         call CC1000Control.BIASOn();
  631.         call CC1000Control.RxMode();
  632.         call SpiByteFifo.rxMode(); // SPI to miso
  633.         call SpiByteFifo.enableIntr(); // enable spi interrupt
  634.         if (iSquelchCount > CC1K_SquelchCount)
  635.           call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  636.         else
  637.           call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  638.         call WakeupTimer.start(TIMER_ONE_SHOT, CC1K_LPL_PACKET_TIME*2);
  639.         atomic RadioState = IDLE_STATE;
  640.       }
  641.     }
  643.     return Result;
  644.   }
  645.   
  646.   /**********************************************************
  647.    * make a spibus interrupt handler
  648.    * needs to handle interrupts for transmit delay
  649.    * and then go into byte transmit mode with
  650.    *   timer1 baudrate delay as interrupt handler
  651.    * else
  652.    * needs to handle interrupts for byte read and detect preamble
  653.    *  then handle reading a packet
  654.    * PB - We can use this interrupt handler as a transmit scheduler
  655.    * because the CC1000 continuously clocks in data, regarless
  656.    * of whether it's good or not.  Thus, this routine will be called
  657.    * on every 8 ticks of DCLK. 
  658.    **********************************************************/
  660.   async event result_t SpiByteFifo.dataReady(uint8_t data_in) {
  661.     
  662.     signal RadioSendCoordinator.blockTimer();
  663.     signal RadioReceiveCoordinator.blockTimer();
  665.     if (bInvertRxData) 
  666.       data_in = ~data_in;
  667. #ifdef ENABLE_UART_DEBUG
  668.     UARTPutChar(RadioState);
  669. #endif
  670.     switch (RadioState) {
  672.     case TX_STATE:
  673.       {
  674. call SpiByteFifo.writeByte(NextTxByte);
  675. TxByteCnt++;
  676. switch (RadioTxState) {
  678. case TXSTATE_PREAMBLE:
  679.   if (!(TxByteCnt < preamblelen)) {
  680.     NextTxByte = SYNC_BYTE;
  681.     RadioTxState = TXSTATE_SYNC;
  682.   }
  683.   break;
  685. case TXSTATE_SYNC:
  686.   NextTxByte = NSYNC_BYTE;
  687.           /**** TinySec ****/
  688.           if(txbufptr->length & TINYSEC_ENABLED_BIT)
  689.             RadioTxState = TXSTATE_DATA_TINYSEC;
  690.           else
  691.             RadioTxState = TXSTATE_DATA;
  692.           /**** TinySec ****/
  693.   TxByteCnt = -1;
  694.           // for Time Sync services
  695.   signal RadioSendCoordinator.startSymbol(8, 0,(TOS_MsgPtr) txbufptr); 
  696.   break;
  698. case TXSTATE_DATA:
  699.   if ((uint8_t)(TxByteCnt) < txlength) {
  700.     NextTxByte = ((uint8_t *)txbufptr)[(TxByteCnt)];
  701.     usRunningCRC = crcByte(usRunningCRC,NextTxByte);
  702.     signal RadioSendCoordinator.byte((TOS_MsgPtr) txbufptr,
  703.      (uint8_t)TxByteCnt); // Time Sync
  704.   }
  705.   else {
  706.     NextTxByte = (uint8_t)(usRunningCRC);
  707.     RadioTxState = TXSTATE_CRC;
  708.   }
  709.   break;
  711.           /**** TinySec ****/
  712. case TXSTATE_DATA_TINYSEC:
  713.           signal RadioSendCoordinator.byte((TOS_MsgPtr) txbufptr,
  714.    (uint8_t)TxByteCnt); // Time Sync
  715.           NextTxByte = signal TinySecRadio.getTransmitByte();
  716.   break;
  717.           /**** TinySec ****/
  718.                   
  719. case TXSTATE_CRC:
  720.   NextTxByte = (uint8_t)(usRunningCRC>>8);
  721.   RadioTxState = TXSTATE_FLUSH;
  722.   TxByteCnt = 0;
  723.   break;
  725. case TXSTATE_FLUSH:
  726.   if (TxByteCnt > 3) {
  727.     TxByteCnt = 0;
  728.     RadioTxState = TXSTATE_WAIT_FOR_ACK;
  729.   }
  730.   break;
  733.         case TXSTATE_WAIT_FOR_ACK:
  734.   if(TxByteCnt == 1){
  735. call SpiByteFifo.rxMode();
  736.         call CC1000Control.RxMode();
  737.   }
  738.   if (TxByteCnt > 3) {
  739.     RadioTxState = TXSTATE_READ_ACK;
  740.     TxByteCnt = 0;
  741.     search_word = 0;
  742.   }
  743.   break;
  745.         case TXSTATE_READ_ACK:
  746.   {
  747.      uint8_t i;
  748.      for(i = 0; i < 8; i ++){
  749. search_word <<= 1;
  750.          if(data_in & 0x80) search_word |=  0x1;
  751.          data_in <<= 1;
  752.          if (search_word == 0xba83){
  753.                  txbufptr->ack = 1;
  754.      RadioTxState = TXSTATE_DONE;
  755.                  return SUCCESS;
  757.          }
  758.              }
  759.      }
  760.   if(TxByteCnt == MAX_ACK_WAIT){
  761. txbufptr->ack = 0;
  762.      RadioTxState = TXSTATE_DONE;
  764.   }
  765.   break;
  767. case TXSTATE_DONE:
  768. default:
  769.           call RSSIADC.getData();
  770.   bTxPending = FALSE;
  771.   if (post PacketSent()) {
  772.     // If the post operation succeeds, goto Idle
  773.     // otherwise, we'll try again.
  774.     RadioState = IDLE_STATE;
  775.   }
  776.   break;
  777. }
  778.       }
  779.       break;
  781.     case DISABLED_STATE:
  782.       break;
  784.     case IDLE_STATE: 
  785.       {
  786. if (((data_in == (0xaa)) || (data_in == (0x55)))) {
  787.   PreambleCount++;
  788.   if (PreambleCount > CC1K_ValidPrecursor) {
  789.     PreambleCount = SOFCount = 0;
  790.     RxBitOffset = RxByteCnt = 0;
  791.     usRunningCRC = 0;
  792.     rxlength = MSG_DATA_SIZE-2;
  793.             /**** TinySec ****/
  794.             call TinySec.receiveInit(rxbufptr);
  795.             /**** TinySec ****/
  796.     RadioState = SYNC_STATE;
  797.   }
  798. }
  799. else if (bTxPending && (--sMacDelay <= 0)) {
  800.   bRSSIValid = FALSE;
  801.   RadioState = PRETX_STATE;
  802.           iRSSIcount = 0;
  803.   PreambleCount = 0;
  804.   call RSSIADC.getData();
  805. }
  806.       }
  807.       break;
  809.     case PRETX_STATE:
  810.       {
  811. if (((data_in == (0xaa)) || (data_in == (0x55)))) {
  812.   // Back to the penalty box.
  813.           sMacDelay = (call Random.rand() & 0xF) + 1;
  814.   RadioState = IDLE_STATE;
  815. }
  816. /*
  817. else if (bRSSIValid) {
  818.   if (usRSSIVal > (usSquelchVal + CC1K_SquelchBuffer)) { 
  819.     // ROCK AND ROLL!!!!!
  820.     call CC1000Control.TxMode();
  821.     call SpiByteFifo.txMode();
  822.     TxByteCnt = 0;
  823.     usRunningCRC = 0;
  824.     RadioState = TX_STATE;
  825.     RadioTxState = TXSTATE_PREAMBLE;
  826.     NextTxByte = 0xaa;
  827.     call SpiByteFifo.writeByte(0xaa);
  828.   }
  829.   else {
  830.     // Russin frussin freakin frick o frack
  831.             sMacDelay = (call Random.rand() & 0xF) + 1;
  833.     RadioState = IDLE_STATE;
  834.   }
  835. }
  836. */
  837.       }
  838.       break;
  840.     case SYNC_STATE:
  841.       {
  842. // draw in the preamble bytes and look for a sync byte
  843. // save the data in a short with last byte received as msbyte
  844. //    and current byte received as the lsbyte.
  845. // use a bit shift compare to find the byte boundary for the sync byte
  846. // retain the shift value and use it to collect all of the packet data
  847. // check for data inversion, and restore proper polarity 
  848.         // XXX-PB: Don't do this.
  849. uint8_t i;
  851. if ((data_in == 0xaa) || (data_in == 0x55)) {
  852.   // It is actually possible to have the LAST BIT of the incoming
  853.   // data be part of the Sync Byte.  SO, we need to store that
  854.   // However, the next byte should definitely not have this pattern.
  855.   // XXX-PB: Do we need to check for excessive preamble?
  856.   RxShiftBuf.MSB = data_in;
  858. }
  859. else {
  860.   // TODO: Modify to be tolerant of bad bits in the preamble...
  861.   uint16_t usTmp;
  862.   switch (SOFCount) {
  863.   case 0:
  864.     RxShiftBuf.LSB = data_in;
  865.     break;
  866.   
  867.   case 1:
  868.   case 2: 
  869.     // bit shift the data in with previous sample to find sync
  870.     usTmp = RxShiftBuf.W;
  871.     RxShiftBuf.W <<= 8;
  872.     RxShiftBuf.LSB = data_in;
  874.     for(i=0;i<8;i++) {
  875.       usTmp <<= 1;
  876.       if(data_in & 0x80)
  877. usTmp  |=  0x1;
  878.       data_in <<= 1;
  879.       // check for sync bytes
  880.       if (usTmp == SYNC_WORD) {
  881.                 if (rxbufptr->length !=0) {
  882.                   call Leds.redToggle();
  883.                   RadioState = IDLE_STATE;
  884.                 }
  885.                 else {
  886.                   RadioState = HEADER_RX_STATE;
  887.                   call RSSIADC.getData();
  888.                   RxBitOffset = 7-i;
  889.   // For time sync services
  890.                   signal RadioReceiveCoordinator.startSymbol(8, RxBitOffset,
  891.      (TOS_MsgPtr) rxbufptr);
  892.                 }
  893. break;
  894.       }
  895.     }
  896.     break;
  898.   default:
  899.     // We didn't find it after a reasonable number of tries, so....
  900.     RadioState = IDLE_STATE;  // Ensures we wait till the end of the transmission
  901.     break;
  902.   }
  903.   SOFCount++;
  904. }
  906.       }
  907.       break;
  909.       /**** TinySec ****/
  910.     case HEADER_RX_STATE:
  911.       {
  912.    char Byte;
  913.         
  914. RxShiftBuf.W <<=8;
  915. RxShiftBuf.LSB = data_in;
  916.         
  917. Byte = (RxShiftBuf.W >> RxBitOffset);
  918. ((char*)rxbufptr)[(int)RxByteCnt] = Byte;      
  919. RxByteCnt++;
  921. signal RadioReceiveCoordinator.byte((TOS_MsgPtr) rxbufptr,
  922.     (uint8_t)RxByteCnt-1);
  923.         
  924.         usRunningCRC = crcByte(usRunningCRC,Byte);
  925.         signal TinySecRadio.byteReceived(Byte);
  926.         
  927.       }
  928.       break;
  930.       
  931.     case RX_STATE_TINYSEC:
  932.       {
  933. char Byte;
  935. RxShiftBuf.W <<=8;
  936. RxShiftBuf.LSB = data_in;
  938. Byte = (RxShiftBuf.W >> RxBitOffset);
  940. RxByteCnt++;
  942. signal RadioReceiveCoordinator.byte((TOS_MsgPtr) rxbufptr,
  943.     (uint8_t)RxByteCnt-1);
  944.         signal TinySecRadio.byteReceived(Byte);   
  945.       }         
  946.       break;
  947.       /**** TinySec ****/
  948.       
  949.       
  950.       //  collect the data and shift into double buffer
  951.       //  shift out data by correct offset
  952.       //  invert the data if necessary
  953.       //  stop after the correct packet length is read
  954.       //  return notification to upper levels
  955.       //  go back to idle state
  956.     case RX_STATE:
  957.       {
  958. char Byte;
  960. RxShiftBuf.W <<=8;
  961. RxShiftBuf.LSB = data_in;
  963. Byte = (RxShiftBuf.W >> RxBitOffset);
  964. ((char*)rxbufptr)[(int)RxByteCnt] = Byte;
  965. RxByteCnt++;
  967. // Time Sync:  substract one to start counting from zero
  968. signal RadioReceiveCoordinator.byte((TOS_MsgPtr) rxbufptr,
  969.     (uint8_t)RxByteCnt-1);
  971. if (RxByteCnt < rxlength) {
  972.   usRunningCRC = crcByte(usRunningCRC,Byte);
  973. }
  974. else if (RxByteCnt == rxlength) {
  975.   usRunningCRC = crcByte(usRunningCRC,Byte);
  976.   // Shift index ahead to the crc field.
  977.   RxByteCnt = offsetof(struct TOS_Msg,crc);
  978. }
  979. else if (RxByteCnt >= MSG_DATA_SIZE) { 
  981.   // Packet filtering based on bad CRC's is done at higher layers.
  982.   // So sayeth the TOS weenies.
  983.   if (rxbufptr->crc == usRunningCRC) {
  984.     rxbufptr->crc = 1;
  985.     if(rxbufptr->addr == TOS_LOCAL_ADDRESS || rxbufptr->addr == TOS_BCAST_ADDR){
  987.     RadioState = SENDING_ACK; 
  988.     call CC1000Control.TxMode();
  989.     call SpiByteFifo.txMode();
  990.     call SpiByteFifo.writeByte(0xaa);
  991.     RxByteCnt = 0;
  992.     return SUCCESS; 
  993.        }
  994.   } else {
  995.     rxbufptr->crc = 0;
  996.   }
  998.   call SpiByteFifo.disableIntr();
  999.   
  1000.   RadioState = IDLE_STATE; //DISABLED_STATE;
  1001.   rxbufptr->strength = usRSSIVal;
  1002.   if (!(post PacketRcvd())) {
  1003.     // If there are insufficient resources to process the incoming packet
  1004.     // we drop it
  1005.             rxbufptr->length = 0;
  1006.     RadioState = IDLE_STATE;
  1007.     call SpiByteFifo.enableIntr();
  1008.   }
  1010. }
  1011.       }
  1012.       break;
  1013.     case SENDING_ACK:
  1014.       {
  1015. RxByteCnt++;
  1016. if (RxByteCnt >= ACK_LENGTH) { 
  1017.     call CC1000Control.RxMode();
  1018.     call SpiByteFifo.rxMode();
  1019.     call SpiByteFifo.disableIntr();
  1020.     RadioState = IDLE_STATE; //DISABLED_STATE;
  1021.     rxbufptr->strength = usRSSIVal;
  1022.     if (!(post PacketRcvd())) {
  1023.    rxbufptr->length = 0;
  1024.    RadioState = IDLE_STATE;
  1025.    call SpiByteFifo.enableIntr();
  1026.     }
  1027. }else if(RxByteCnt >= ACK_LENGTH - sizeof(ack_code) - 2){
  1028.     call SpiByteFifo.writeByte(ack_code[RxByteCnt + sizeof(ack_code) + 2- ACK_LENGTH]);
  1029.         }
  1030.       }
  1031.       break;
  1032.   
  1033.     default:
  1034.       break;
  1035.     }
  1037.   return SUCCESS;
  1038. }
  1040. async event result_t RSSIADC.dataReady(uint16_t data) {
  1041.   uint8_t currentRadioState;
  1043.   atomic currentRadioState = RadioState;
  1044.   // find the maximum RSSI value over CC1K_MAX_RSSI_SAMPLES
  1045.   switch(currentRadioState) {
  1046.   case PRETX_STATE:
  1047.     iRSSIcount++;
  1049.     // if the channel is clear, GO GO GO!
  1050.     if (data > (usSquelchVal + CC1K_SquelchBuffer)) { 
  1051.       call SpiByteFifo.writeByte(0xaa);
  1052.       call CC1000Control.TxMode();
  1053.       call SpiByteFifo.txMode();
  1054.       atomic {
  1055.         usRSSIVal = data;
  1056.         iRSSIcount = CC1K_MaxRSSISamples;
  1057.         bRSSIValid = TRUE;
  1058.         TxByteCnt = 0;
  1059.         usRunningCRC = 0;
  1060.         RadioState = TX_STATE;
  1061.         RadioTxState = TXSTATE_PREAMBLE;
  1062.         NextTxByte = 0xaa;
  1063. // start encrypting packet - re-enables interrupts
  1064. // check if encrypt enabled bit is set
  1065.         /**** TinySec ****/
  1066. if(txbufptr->length & TINYSEC_ENABLED_BIT) {
  1067.   call TinySec.send();
  1068. }
  1069.         /**** TinySec ****/
  1070.       }
  1071.       return SUCCESS;
  1072.     }
  1074.     if (iRSSIcount == 1)
  1075.       atomic usRSSIVal = data;
  1076.     else if (data > usRSSIVal)
  1077.       atomic usRSSIVal = data;
  1079.     if (iRSSIcount == CC1K_MaxRSSISamples) {
  1080.       atomic {
  1081.         bRSSIValid = TRUE;
  1082.         sMacDelay = (call Random.rand() & 0xF) + 1;
  1083.         RadioState = IDLE_STATE;
  1084.       }
  1085.     }
  1086.     else
  1087.       call RSSIADC.getData();
  1088.     break;
  1090.   case IDLE_STATE:
  1091.     atomic usTempSquelch = data;
  1092.     post adjustSquelch();
  1093.     break;
  1095.   case RX_STATE:
  1096.   case HEADER_RX_STATE:
  1097.   case RX_STATE_TINYSEC:
  1098.     atomic usRSSIVal = data;
  1099.     break;
  1100.  
  1101.   default:
  1102.   }
  1104.   return SUCCESS;
  1105. }
  1107.  // XXX:JP- for testing the mac layer squlech value
  1108.  command uint16_t GetSquelch() {
  1109.    return usSquelchVal;
  1110.  }
  1112. // Default events for radio send/receive coordinators do nothing.
  1113. // Be very careful using these, you'll break the stack.
  1114. default async event void RadioSendCoordinator.startSymbol(uint8_t bitsPerBlock, uint8_t offset, TOS_MsgPtr msgBuff) { }
  1115. default async event void RadioSendCoordinator.byte(TOS_MsgPtr msg, uint8_t byteCount) { }
  1116. default async event void RadioSendCoordinator.blockTimer() { }
  1118. default async event void RadioReceiveCoordinator.startSymbol(uint8_t bitsPerBlock, uint8_t offset, TOS_MsgPtr msgBuff) { }
  1119. default async event void RadioReceiveCoordinator.byte(TOS_MsgPtr msg, uint8_t byteCount) { }
  1120. default async event void RadioReceiveCoordinator.blockTimer() { }
  1121. }