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

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

网络

开发平台：

Others

CC1000RadioIntM.nc：源码内容
  1. // $Id: CC1000RadioIntM.nc,v 1.6 2005/08/16 19:18:47 acwarrie Exp $
  3. /* -*- Mode: C; c-basic-indent: 2; indent-tabs-mode: nil -*- */ 
  4. /* tab:4
  5.  *
  6.  *
  7.  * "Copyright (c) 2000-2002 The Regents of the University  of California.  
  8.  * All rights reserved.
  9.  *
  10.  * Permission to use, copy, modify, and distribute this software and its
  11.  * documentation for any purpose, without fee, and without written agreement is
  12.  * hereby granted, provided that the above copyright notice, the following
  13.  * two paragraphs and the author appear in all copies of this software.
  14.  * 
  15.  * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
  16.  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  17.  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
  18.  * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  19.  * 
  20.  * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  21.  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  22.  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  23.  * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
  24.  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."
  25.  *
  26.  */
  27. /* tab:4
  28.  *  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.  By
  29.  *  downloading, copying, installing or using the software you agree to
  30.  *  this license.  If you do not agree to this license, do not download,
  31.  *  install, copy or use the software.
  32.  *
  33.  *  Intel Open Source License 
  34.  *
  35.  *  Copyright (c) 2002 Intel Corporation 
  36.  *  All rights reserved. 
  37.  *  Redistribution and use in source and binary forms, with or without
  38.  *  modification, are permitted provided that the following conditions are
  39.  *  met:
  40.  * 
  41.  * Redistributions of source code must retain the above copyright
  42.  *  notice, this list of conditions and the following disclaimer.
  43.  * Redistributions in binary form must reproduce the above copyright
  44.  *  notice, this list of conditions and the following disclaimer in the
  45.  *  documentation and/or other materials provided with the distribution.
  46.  *      Neither the name of the Intel Corporation nor the names of its
  47.  *  contributors may be used to endorse or promote products derived from
  48.  *  this software without specific prior written permission.
  49.  *  
  50.  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  51.  *  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  52.  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  53.  *  PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE INTEL OR ITS
  54.  *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  55.  *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  56.  *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  57.  *  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  58.  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  59.  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  60.  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  61.  * 
  62.  * 
  63.  */
  65. /*  
  66.  *  Authors: Philip Buonadonna, Jaein Jeong, Joe Polastre
  67.  *  Date last modified: $Revision: 1.6 $
  68.  *
  69.  * This module provides the layer2 functionality for the mica2 radio.
  70.  * While the internal architecture of this module is not CC1000 specific,
  71.  * It does make some CC1000 specific calls via CC1000Control.
  72.  * 
  73.  */
  75. /**
  76.  * @author Philip Buonadonna
  77.  * @author Jaein Jeong
  78.  * @author Joe Polastre
  79.  */
  80.   
  81. includes crc;
  82. includes CC1000Const;
  84. module CC1000RadioIntM {
  85.   provides {
  86.     interface StdControl;
  87.     interface BareSendMsg as Send;
  88.     interface ReceiveMsg as Receive;
  89.     interface RadioCoordinator as RadioSendCoordinator;
  90.     interface RadioCoordinator as RadioReceiveCoordinator;
  91.     interface MacControl;
  92.     interface MacBackoff;
  93.     interface LowPowerListening;
  94.     // legacy commands supported, but should now use the
  95.     // Low Power Listening interface
  96.     async command result_t SetListeningMode(uint8_t power);
  97.     async command uint8_t GetListeningMode();
  98.     async command result_t SetTransmitMode(uint8_t power);
  99.     async command uint8_t GetTransmitMode();
  100.     // Used for debugging the noise floor (gets the current squelch value)
  101.     async command uint16_t GetSquelch();
  102.     // Used for debugging; gets an estimate of the power consumed by the radio
  103.     async command uint16_t GetPower();
  104.     async command uint16_t GetPower_tx();
  105.     async command uint16_t GetPower_rx();
  106.     async command uint16_t GetPower_sp();
  107.     async command uint16_t GetDataSent();
  108.     async command result_t ResetDataSent();
  109.     async command result_t ResetPower();
  110.   }
  111.   uses {
  112.     interface PowerManagement;
  113.     interface StdControl as CC1000StdControl;
  114.     interface CC1000Control;
  115.     interface Random;
  116.     interface ADCControl;
  117.     interface ADC as RSSIADC;
  118.     interface SpiByteFifo;
  119.     interface StdControl as TimerControl;
  120.     interface Timer as WakeupTimer;
  121.     interface Timer as SquelchTimer;
  122.     interface Leds;
  123.   }
  124. }
  125. implementation {
  126. #ifdef ZMAC_DEBUG
  127. #include "SODebug.h"
  128. #endif
  129.   enum {
  130.     NULL_STATE,
  131.     TX_STATE,
  132.     DISABLED_STATE,
  133.     IDLE_STATE,
  134.     PRETX_STATE,
  135.     SYNC_STATE,
  136.     RX_STATE,
  137.     SENDING_ACK,
  138.     POWER_DOWN_STATE,
  139.     PULSE_CHECK_STATE,
  140.   };
  142.   enum {
  143.     TXSTATE_WAIT,
  144.     TXSTATE_START,
  145.     TXSTATE_PREAMBLE,
  146.     TXSTATE_SYNC,
  147.     TXSTATE_DATA,
  148.     TXSTATE_CRC,
  149.     TXSTATE_FLUSH,
  150.     TXSTATE_WAIT_FOR_ACK,
  151.     TXSTATE_READ_ACK,
  152.     TXSTATE_DONE
  153.   };
  155.   enum {
  156.     SYNC_BYTE = 0x33,
  157.     NSYNC_BYTE = 0xcc,
  158.     SYNC_WORD = 0x33cc,
  159.     NSYNC_WORD = 0xcc33,
  160.     ACK_LENGTH = 16,
  161.     MAX_ACK_WAIT = 18,
  162.     TIME_BETWEEN_CHECKS = 50,
  163.     TIME_AFTER_CHECK = 30,
  164.     CHECK_MA_COUNT = 100, //8888,
  165.     SEND_MA_COUNT = 100, //7200,
  166.     PREAMBLE_LENGTH_TO_BASE = 8,
  167.     RECEIVE_MA_COUNT = 100, //9600
  168.   };
  170.   uint8_t ack_code[5] = {0xab, 0xba, 0x83, 0xaa, 0xaa};
  172.   uint8_t RadioState;
  173.   uint8_t RadioTxState;
  174.   norace uint8_t iRSSIcount;
  175.   uint8_t RSSIInitState;
  176.   uint8_t iSquelchCount;
  177.   uint16_t txlength;
  178.   uint16_t rxlength;
  179.   TOS_MsgPtr txbufptr;  // pointer to transmit buffer
  180.   TOS_MsgPtr rxbufptr;  // pointer to receive buffer
  181.   TOS_Msg RxBuf; // save received messages
  182.   uint8_t NextTxByte;
  184.   uint8_t lplpower;        //  low power listening mode
  185.   uint8_t lplpowertx;      //  low power listening transmit mode
  187.   uint16_t preamblelen;    //  current length of the preamble
  188.   uint16_t sleeptime;       //  current check interval (sleep time)
  189.  
  190.   uint16_t PreambleCount;   //  found a valid preamble
  191.   uint8_t SOFCount;
  193.   uint16_t search_word;
  195.   union {
  196.     uint16_t W;
  197.     struct {
  198.       uint8_t LSB;
  199.       uint8_t MSB;
  200.     };
  201.   } RxShiftBuf;
  203.   uint8_t RxBitOffset; // bit offset for spibus
  204.   uint16_t RxByteCnt; // received byte counter
  205.   uint16_t TxByteCnt;
  206.   uint16_t RSSISampleFreq; // in Bytes rcvd per sample
  207.   norace bool bInvertRxData; // data inverted
  208.   norace bool bTxPending;
  209.   bool bAckEnable;
  210.   bool bCCAEnable;
  211.   bool bTxBusy;
  212.   bool bRSSIValid;
  213.   uint16_t CC1K_PulseLevel;
  214.   uint16_t usRunningCRC; // Running CRC variable
  215.   uint16_t usRSSIVal;
  216.   uint16_t usSquelchVal;
  217.   uint16_t usTempSquelch;
  218.   uint8_t usSquelchIndex;
  219.   norace uint8_t pulse_check_count;
  220.   norace uint16_t pulse_check_sum;
  221.   norace uint16_t send_sum;
  222.   norace uint16_t receive_sum;
  223.   norace uint16_t power_sum;
  224.   norace uint16_t sp_sum;
  225.   norace uint16_t rx_sum;
  226.   norace uint16_t tx_sum;
  227.   norace uint16_t dataSent;
  229.   uint16_t usSquelchTable[CC1K_SquelchTableSize];
  231.   int16_t sMacDelay;    // MAC delay for the next transmission
  232.   // XXX-PB:
  233.   // Here's the deal, the mica (RFM) radio stacks used TOS_LOCAL_ADDRESS
  234.   // to determine if an L2 ack was reqd.  This stack doesn't do L2 acks
  235.   // and, thus doesn't need it.  HOWEVER, some set-mote-id versions
  236.   // break if this symbol is missing from the binary.
  237.   // Thus, I put this LocalAddr here and set it to TOS_LOCAL_ADDRESS
  238.   // to keep things happy for now.
  239.   volatile uint16_t LocalAddr;
  241.   ///**********************************************************
  242.   //* local function definitions
  243.   //**********************************************************/
  245.   /*
  246.     int sortByShort(const void *x, const void *y) {
  247.     uint16_t* x1 = (uint16_t*)x;
  248.     uint16_t* y1 = (uint16_t*)y;
  249.     if (x1[0] > y1[0]) return -1;
  250.     if (x1[0] == y1[0]) return 0;
  251.     if (x1[0] < y1[0]) return 1;
  252.     return 0; // shouldn't reach here becasue it covers all the cases
  253.     }
  254.   */
  256.   task void adjustSquelch() {
  257.     uint16_t tempArray[CC1K_SquelchTableSize];
  258.     char i,j,min; 
  259.     uint16_t min_value;
  260.     uint32_t tempsquelch;
  262.     atomic {
  263.       usSquelchTable[usSquelchIndex] = usTempSquelch;
  264.       usSquelchIndex++;
  265.       if (usSquelchIndex >= CC1K_SquelchTableSize)
  266.         usSquelchIndex = 0;
  267.       if (iSquelchCount <= CC1K_SquelchCount)
  268.         iSquelchCount++;  
  269.     }
  271.     for (i=0; i<CC1K_SquelchTableSize; i++) {
  272.       tempArray[(int)i] = usSquelchTable[(int)i];
  273.     }
  275.     min = 0;
  276.     //    for (j = 0; j < ((CC1K_SquelchTableSize) >> 1); j++) {
  277.     for (j = 0; j < 3; j++) {
  278.       for (i = 1; i < CC1K_SquelchTableSize; i++) {
  279.         if ((tempArray[(int)i] != 0xFFFF) && 
  280.             ((tempArray[(int)i] > tempArray[(int)min]) ||
  281.              (tempArray[(int)min] == 0xFFFF))) {
  282.           min = i;
  283.         }
  284.       }
  285.       min_value = tempArray[(int)min];
  286.       tempArray[(int)min] = 0xFFFF;
  287.     }
  289.     tempsquelch = ((uint32_t)(usSquelchVal << 5) + (uint32_t)(min_value << 1));
  290.     atomic usSquelchVal = (uint16_t)((tempsquelch / 34) & 0x0FFFF);
  292.     /*
  293.     // XXX: qsort actually causes ~600bits/sec lower bandwidth... why???
  294.     //
  295.     qsort (tempArray,CC1K_SquelchTableSize, sizeof(uint16_t),sortByShort);
  296.     min_value = tempArray[CC1K_SquelchTableSize >> 1];
  297.     atomic usSquelchVal = ((usSquelchVal << 5) + (min_value << 1)) / 34;
  298.     */
  301.   }
  303.   task void PacketRcvd() {
  304.     TOS_MsgPtr pBuf;
  306.     atomic {
  307.       rxbufptr->time = 0;
  308.       pBuf = rxbufptr;
  309.     }
  310. #ifdef ZMAC_DEBUG
  311.     SODbg(DBG_USR2, "Received packet of type %u and crc %un", pBuf->type, pBuf->crc);
  312. #endif
  313.     pBuf = signal Receive.receive((TOS_MsgPtr)pBuf);
  314.     atomic {
  315.       if (pBuf) 
  316.         rxbufptr = pBuf;
  317.       rxbufptr->length = 0;
  318.     }
  319.     call SpiByteFifo.enableIntr();
  320.   }
  321.   
  322.   task void PacketSent() {
  323.     TOS_MsgPtr pBuf; //store buf on stack 
  324.     atomic {
  325.       txbufptr->time = 0;
  326.       pBuf = txbufptr;
  327.     }
  328.     if(txbufptr->type == AM_MULTIHOP)
  329.       dataSent++;
  330.     signal Send.sendDone((TOS_MsgPtr)pBuf,SUCCESS);
  331.     atomic bTxBusy = FALSE;
  332.   }
  334.   ///**********************************************************
  335.   //* Exported interface functions
  336.   //**********************************************************/
  337.   
  338.   command result_t StdControl.init() {
  339.     char i;
  341.     atomic {
  342.       RadioState = DISABLED_STATE;
  343.       RadioTxState = TXSTATE_PREAMBLE;
  344.       rxbufptr = &RxBuf;
  345.       rxbufptr->length = 0;
  346.       rxlength = MSG_DATA_SIZE-2;
  347.       RxBitOffset = 0;
  348.       iSquelchCount = 0;
  349.       
  350.       PreambleCount = 0;
  351.       RSSISampleFreq = 0;
  352.       RxShiftBuf.W = 0;
  353.       iRSSIcount = 0;
  354.       bTxPending = FALSE;
  355.       bTxBusy = FALSE;
  356.       bRSSIValid = FALSE;
  357.       bAckEnable = FALSE;
  358.       bCCAEnable = TRUE;
  359.       CC1K_PulseLevel = 300;
  360.       sMacDelay = -1;
  361.       usRSSIVal = -1;
  362.       usSquelchIndex = 0;
  363.       pulse_check_count = 0;
  364.       lplpower =  0;//0x87;
  365.       RSSIInitState = NULL_STATE;
  366.       //      if(TOS_LOCAL_ADDRESS == 0) lplpower = 0;
  367.       //      lplpowertx = 7;
  368.       usSquelchVal = CC1K_SquelchInit;
  369.     }
  371.     for (i = 0; i < CC1K_SquelchTableSize; i++)
  372.       usSquelchTable[(int)i] = CC1K_SquelchInit;
  374.     call SpiByteFifo.initSlave(); // set spi bus to slave mode
  375.     call CC1000StdControl.init();
  376.     call CC1000Control.SelectLock(0x9); // Select MANCHESTER VIOLATION
  377.     bInvertRxData = call CC1000Control.GetLOStatus();
  379.     call ADCControl.bindPort(TOS_ADC_CC_RSSI_PORT,TOSH_ACTUAL_CC_RSSI_PORT);
  380.     call ADCControl.init();
  382.     call Random.init();
  383.     call TimerControl.init();
  385.     LocalAddr = TOS_LOCAL_ADDRESS;
  387. #ifdef ZMAC_DEBUG
  388.     init_debug();
  389. #endif
  390.     return SUCCESS;
  391.   }
  392.   
  393.   /**
  394.    * Get the current Low Power Listening transmit mode
  395.    * @return mode number (see SetListeningMode)
  396.    */
  397.   async command uint8_t LowPowerListening.GetTransmitMode() {
  398.     return lplpowertx;
  399.   }
  400.   // legacy support
  401.   async command uint8_t GetTransmitMode() {
  402.     return call LowPowerListening.GetTransmitMode();
  403.   }
  405.   /**
  406.    * Set the transmit mode.  This allows for hybrid schemes where
  407.    * the transmit mode is different than the receive mode.
  408.    * Use SetListeningMode first, then change the mode with SetTransmitMode.
  409.    *
  410.    * @param mode mode number (see SetListeningMode)
  411.    * @return SUCCESS if the mode was successfully changed
  412.    */
  413.   async command result_t LowPowerListening.SetTransmitMode(uint8_t power) {
  414.     if ((power >= CC1K_LPL_STATES) || (power == lplpowertx))
  415.       return FAIL;
  417.     // check if the radio is currently doing something
  418.     if ((!bTxPending) && ((RadioState == POWER_DOWN_STATE) || 
  419.                           (RadioState == IDLE_STATE) ||
  420.                           (RadioState == DISABLED_STATE))) {
  422.       atomic {
  423.         lplpowertx = power;
  424.         preamblelen = ((PRG_RDB(&CC1K_LPL_PreambleLength[lplpowertx*2]) << 8)
  425.                        | PRG_RDB(&CC1K_LPL_PreambleLength[(lplpowertx*2)+1]));
  426.       }
  427.       return SUCCESS;
  428.     }
  429.     return FAIL;
  430.   }
  431.   // legacy support
  432.   async command result_t SetTransmitMode(uint8_t power) {
  433.     return call LowPowerListening.SetTransmitMode(power);
  434.   }
  436.   /**
  437.    * Set the current Low Power Listening mode.
  438.    * Setting the LPL mode sets both the check interval and preamble length.
  439.    *
  440.    * Modes include:
  441.    *  0 = Radio full on
  442.    *  1 = 10ms check interval
  443.    *  2 = 25ms check interval
  444.    *  3 = 50ms check interval
  445.    *  4 = 100ms check interval (recommended)
  446.    *  5 = 200ms check interval
  447.    *  6 = 400ms check interval
  448.    *  7 = 800ms check interval
  449.    *  8 = 1600ms check interval
  450.    *
  451.    * @param mode the mode number
  452.    * @return SUCCESS if the mode was successfully changed
  453.    */
  454.   async command result_t LowPowerListening.SetListeningMode(uint8_t power) {
  455.     // valid low power listening values are 0 to 8
  456.     // 0 is "always on" and 8 is lowest duty cycle
  457.     if ((power >= CC1K_LPL_STATES) || (power == lplpower))
  458.       return FAIL;
  460.     // check if the radio is currently doing something
  461.     if ((!bTxPending) && ((RadioState == POWER_DOWN_STATE) || 
  462.                           (RadioState == IDLE_STATE) ||
  463.                           (RadioState == DISABLED_STATE))) {
  465.       // change receiving function in CC1000Radio
  466.       call WakeupTimer.stop();
  467.       atomic {
  468.         if (lplpower == lplpowertx) {
  469.           lplpowertx = power;
  470.         }
  471.         lplpower = power;
  472.       }
  474.       // if successful, change power here
  475.       if (RadioState == IDLE_STATE) {
  476.         RadioState = DISABLED_STATE;
  477.         call StdControl.stop();
  478.         call StdControl.start();
  479.       }
  480.       if (RadioState == POWER_DOWN_STATE) {
  481.         RadioState = DISABLED_STATE;
  482.         call StdControl.start();
  483.         call PowerManagement.adjustPower();
  484.       }
  485.     }
  486.     else {
  487.       return FAIL;
  488.     }
  489.     return SUCCESS;
  490.   }
  491.   // legacy support
  492.   async command result_t SetListeningMode(uint8_t power) {
  493.     return call SetListeningMode(power);
  494.   }
  496.   /**
  497.    * Gets the state of low power listening on the chipcon radio.
  498.    * @return Current low power listening state value
  499.    */
  500.   async command uint8_t LowPowerListening.GetListeningMode() {
  501.     return lplpower;
  502.   }
  503.   // legacy support
  504.   async command uint8_t GetListeningMode() {
  505.     return call LowPowerListening.GetListeningMode();
  506.   } 
  508.   /**
  509.    * Set the preamble length of outgoing packets
  510.    *
  511.    * @param bytes length of the preamble in bytes
  512.    * @return SUCCESS if the preamble length was successfully changed
  513.    */
  514.   async command result_t LowPowerListening.SetPreambleLength(uint16_t bytes) {
  515.     result_t result = FAIL;
  516.     atomic {
  517.       if (RadioState != TX_STATE) {
  518.         preamblelen = bytes;
  519.         result = SUCCESS;
  520.       }
  521.     }
  522.     return result;
  523.   }
  525.   /**
  526.    * Get the preamble length of outgoing packets
  527.    *
  528.    * @return length of the preamble in bytes
  529.    */
  530.   async command uint16_t LowPowerListening.GetPreambleLength() {
  531.     return preamblelen;
  532.   }
  534.   /**
  535.    * Set the check interval (time between waking up and sampling
  536.    * the radio for activity in low power listening)
  537.    *
  538.    * @param ms check interval in milliseconds
  539.    * @return SUCCESS if the check interval was successfully changed
  540.    */
  541.   async command result_t LowPowerListening.SetCheckInterval(uint16_t ms) {
  542.     // sleep time will go into effect after the next wakeup time
  543.     atomic sleeptime = ms;
  544.     return SUCCESS;
  545.   }
  547.   /**
  548.    * Get the check interval currently used by low power listening
  549.    *
  550.    * @return length of the check interval in milliseconds
  551.    */
  552.   async command uint16_t LowPowerListening.GetCheckInterval() {
  553.     return sleeptime;
  554.   }
  557.   event result_t SquelchTimer.fired() {
  558.     char currentRadioState;
  559.     atomic currentRadioState = RadioState;
  561.     if (currentRadioState == IDLE_STATE) {
  562.       atomic RSSIInitState = currentRadioState;
  563.       call RSSIADC.getData();
  564.     }
  565.     return SUCCESS;
  566.   }
  568.   event result_t WakeupTimer.fired() {
  569.     uint8_t currentRadioState;
  571.     if (lplpower == 0)
  572.       return SUCCESS;
  574.     atomic currentRadioState = RadioState;
  575.     switch(currentRadioState) {
  577.     case IDLE_STATE:
  578.       if (!bTxPending) {
  579.         atomic {
  580.           RadioState = POWER_DOWN_STATE;
  581.           call SpiByteFifo.disableIntr();
  582.         }
  583.         call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  584.         call SquelchTimer.stop();
  585.         call CC1000StdControl.stop();
  586.       } else {
  587.         call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  588.       }
  589.       break;
  591.     case POWER_DOWN_STATE:
  592.       atomic RadioState = PULSE_CHECK_STATE;
  593.       pulse_check_count = 0;
  594.       call CC1000StdControl.start();
  595.       call CC1000Control.BIASOn();
  596.       call WakeupTimer.start(TIMER_ONE_SHOT, 1);
  597.       return SUCCESS;
  598.       break;
  600.     case PULSE_CHECK_STATE:
  601.       call CC1000Control.RxMode();
  602.       if(!(call RSSIADC.getData())){
  603.         call WakeupTimer.start(TIMER_ONE_SHOT, TIME_BETWEEN_CHECKS);
  604.         atomic RadioState = POWER_DOWN_STATE;
  605.       }
  606.       else {
  607.         TOSH_uwait(80);
  608.       }
  609.       call CC1000StdControl.stop();
  610.       pulse_check_sum ++;
  611.       break;
  613.     default:
  614.       call WakeupTimer.start(TIMER_ONE_SHOT, 5);
  615.     }
  616.     return SUCCESS;
  617.   }
  619.   command result_t StdControl.stop() {
  620.     atomic RadioState = DISABLED_STATE;
  622.     call SquelchTimer.stop();
  623.     call WakeupTimer.stop();
  624.     call CC1000StdControl.stop();
  625.     call SpiByteFifo.disableIntr(); // disable spi interrupt
  626.     return SUCCESS;
  627.   }
  629.   command result_t StdControl.start() {
  630.     uint8_t currentRadioState;
  631.     atomic currentRadioState = RadioState;
  632.     if (currentRadioState == DISABLED_STATE) {
  633.       atomic {
  634.         rxbufptr->length = 0;
  635.         RadioState  = IDLE_STATE;
  636.         bTxPending = bTxBusy = FALSE;
  637.         sMacDelay = -1;
  638.         if(SLEEPTIME > 0){
  639.           sleeptime = SLEEPTIME;
  640.           preamblelen = PREAMBLELEN;
  641.         } else{
  642.           lplpower = lplpowertx = 0;
  643.           sleeptime = ((PRG_RDB(&CC1K_LPL_SleepTime[lplpower*2]) << 8) |
  644.                        PRG_RDB(&CC1K_LPL_SleepTime[(lplpower*2)+1]));
  645.           preamblelen = ((PRG_RDB(&CC1K_LPL_PreambleLength[lplpowertx*2]) << 8) |
  646.                          PRG_RDB(&CC1K_LPL_PreambleLength[(lplpowertx*2)+1]));
  647.         }
  648.       }
  649.       // all power on, captain!
  650.       rxbufptr->length = 0;
  651.       atomic RadioState = IDLE_STATE;
  652.       call CC1000StdControl.start();
  653.       call CC1000Control.BIASOn();
  654.       call SpiByteFifo.rxMode(); // SPI to miso
  655.       call CC1000Control.RxMode();
  656.       if (iSquelchCount > CC1K_SquelchCount)
  657.         call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  658.       else
  659.         call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  660.       call SpiByteFifo.enableIntr(); // enable spi interrupt
  661.       if (lplpower > 0) {
  662.         // set a time to start sleeping after measuring the noise floor
  663.         call WakeupTimer.start(TIMER_ONE_SHOT, CC1K_SquelchIntervalSlow);
  664.       }
  665.     }
  666.     return SUCCESS;
  667.   }
  669.   command result_t Send.send(TOS_MsgPtr pMsg) {
  670.     result_t Result = SUCCESS;
  671.     uint8_t currentRadioState = 0;
  672.     atomic {
  673.       if (bTxBusy) {
  674.         Result = FAIL;
  675.       }
  676.       else {
  677.         bTxBusy = TRUE;
  678.         txbufptr = pMsg;
  679.         txlength = pMsg->length + (MSG_DATA_SIZE - DATA_LENGTH - 2); 
  681.         // initially back off [1,32] bytes (approx 2/3 packet)
  682.         if (bCCAEnable)
  683.           sMacDelay = signal MacBackoff.initialBackoff(pMsg);
  684.         else
  685.           sMacDelay = 0;
  686.         bTxPending = TRUE;
  687.       }
  688.       currentRadioState = RadioState;
  689.     }
  691.     if (Result) {
  693.       // if we're off, start the radio
  694.       if (currentRadioState == POWER_DOWN_STATE) {
  695.         // disable wakeup timer
  696.         atomic RadioState = IDLE_STATE;
  697.         call WakeupTimer.stop();
  698.         call CC1000StdControl.start();
  699.         call CC1000Control.BIASOn();
  700.         call CC1000Control.RxMode();
  701.         call SpiByteFifo.rxMode(); // SPI to miso
  702.         call SpiByteFifo.enableIntr(); // enable spi interrupt
  703.         if (iSquelchCount > CC1K_SquelchCount)
  704.           call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  705.         else
  706.           call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  707.         call WakeupTimer.start(TIMER_ONE_SHOT, CC1K_LPL_PACKET_TIME*2);
  708.       }
  709.     }
  711.     return Result;
  712.   }
  713.   
  714.   /**********************************************************
  715.    * make a spibus interrupt handler
  716.    * needs to handle interrupts for transmit delay
  717.    * and then go into byte transmit mode with
  718.    *   timer1 baudrate delay as interrupt handler
  719.    * else
  720.    * needs to handle interrupts for byte read and detect preamble
  721.    *  then handle reading a packet
  722.    * PB - We can use this interrupt handler as a transmit scheduler
  723.    * because the CC1000 continuously clocks in data, regarless
  724.    * of whether it's good or not.  Thus, this routine will be called
  725.    * on every 8 ticks of DCLK. 
  726.    **********************************************************/
  728.   async event result_t SpiByteFifo.dataReady(uint8_t data_in) {
  729.     
  730.     signal RadioSendCoordinator.blockTimer();
  731.     signal RadioReceiveCoordinator.blockTimer();
  733.     if (bInvertRxData) 
  734.       data_in = ~data_in;
  735. #ifdef ENABLE_UART_DEBUG
  736.     UARTPutChar(RadioState);
  737. #endif
  738.     switch (RadioState) {
  740.     case TX_STATE:
  741.       {
  742.         call SpiByteFifo.writeByte(NextTxByte);
  743.         TxByteCnt++;
  744.         switch (RadioTxState) {
  746.         case TXSTATE_PREAMBLE:
  747.           send_sum ++;
  748.           if (!(TxByteCnt < preamblelen)||
  749.               (txbufptr->strength == 0xffff && TxByteCnt >= PREAMBLE_LENGTH_TO_BASE)) {
  750.             NextTxByte = SYNC_BYTE;
  751.             RadioTxState = TXSTATE_SYNC;
  752.           }
  753.           break;
  755.         case TXSTATE_SYNC:
  756.           send_sum ++;
  757.           NextTxByte = NSYNC_BYTE;
  758.           RadioTxState = TXSTATE_DATA;
  759.           TxByteCnt = -1;
  760.           // for Time Sync services
  761.           signal RadioSendCoordinator.startSymbol(8, 0, txbufptr); 
  762.           break;
  764.         case TXSTATE_DATA:
  765.           send_sum ++;
  766.           if ((uint8_t)(TxByteCnt) < txlength) {
  767.             NextTxByte = ((uint8_t *)txbufptr)[(TxByteCnt)];
  768.             usRunningCRC = crcByte(usRunningCRC,NextTxByte);
  769.             signal RadioSendCoordinator.byte(txbufptr, (uint8_t)TxByteCnt); // Time Sync
  770.           }
  771.           else {
  772.             NextTxByte = (uint8_t)(usRunningCRC);
  773.             RadioTxState = TXSTATE_CRC;
  774.           }
  775.           break;
  777.         case TXSTATE_CRC:
  778.           send_sum ++;
  779.           NextTxByte = (uint8_t)(usRunningCRC>>8);
  780.           RadioTxState = TXSTATE_FLUSH;
  781.           TxByteCnt = 0;
  782.           break;
  784.         case TXSTATE_FLUSH:
  785.           send_sum ++;
  786.           if (TxByteCnt > 3) {
  787.             TxByteCnt = 0;
  788.             if (bAckEnable) {
  789.               RadioTxState = TXSTATE_WAIT_FOR_ACK;
  790.             }
  791.             else {
  792.               call SpiByteFifo.rxMode();
  793.               call CC1000Control.RxMode();
  794.               RadioTxState = TXSTATE_DONE;
  795.             }
  796.           }
  797.           break;
  799.         case TXSTATE_WAIT_FOR_ACK:
  800.           if(TxByteCnt == 1){
  801.             send_sum ++;
  802.             call SpiByteFifo.rxMode();
  803.             call CC1000Control.RxMode();
  804.             break;
  805.           }
  806.           receive_sum ++;
  807.           if (TxByteCnt > 3) {
  808.             RadioTxState = TXSTATE_READ_ACK;
  809.             TxByteCnt = 0;
  810.             search_word = 0;
  811.           }
  812.           break;
  814.         case TXSTATE_READ_ACK:
  815.           {
  816.             uint8_t i;
  817.             receive_sum ++;
  818.             for(i = 0; i < 8; i ++){
  819.               search_word <<= 1;
  820.               if(data_in & 0x80) search_word |=  0x1;
  821.               data_in <<= 1;
  822.               if (search_word == 0xba83){
  823.                 txbufptr->ack = 1;
  824.                 RadioTxState = TXSTATE_DONE;
  825.                 return SUCCESS;
  827.               }
  828.             }
  829.           }
  830.           if(TxByteCnt >= MAX_ACK_WAIT){
  831.             txbufptr->ack = 0;
  832.             RadioTxState = TXSTATE_DONE;
  834.           }
  835.           break;
  837.         case TXSTATE_DONE:
  838.         default:
  839.           bTxPending = FALSE;
  840.           if (post PacketSent()) {
  841.             // If the post operation succeeds, goto Idle
  842.             // otherwise, we'll try again.
  843.             RadioState = IDLE_STATE;
  844.             RSSIInitState = RadioState;
  845.             call RSSIADC.getData();
  846.           }
  847.           break;
  848.         }
  849.       }
  850.       break;
  852.     case DISABLED_STATE:
  853.       break;
  855.     case IDLE_STATE: 
  856.       {
  857.         receive_sum ++;
  858.         if (((data_in == (0xaa)) || (data_in == (0x55)))) {
  859.           PreambleCount++;
  860.           if (PreambleCount > CC1K_ValidPrecursor) {
  861.             PreambleCount = SOFCount = 0;
  862.             RxBitOffset = RxByteCnt = 0;
  863.             usRunningCRC = 0;
  864.             rxlength = MSG_DATA_SIZE-2;
  865.             RadioState = SYNC_STATE;
  866.           }
  867.         }
  868.         else if (bTxPending && (--sMacDelay <= 0)) {
  869.           RadioState = PRETX_STATE;
  870.           RSSIInitState = PRETX_STATE;
  871.           bRSSIValid = FALSE;
  872.           iRSSIcount = 0;
  873.           PreambleCount = 0;
  874.           call RSSIADC.getData();
  875.         }
  876.       }
  877.       break;
  879.     case PRETX_STATE:
  880.       {
  881.         receive_sum ++;
  882.         if (((data_in == (0xaa)) || (data_in == (0x55)))) {
  883.           // Back to the penalty box.
  884.           sMacDelay = signal MacBackoff.congestionBackoff(txbufptr);
  885.           RadioState = IDLE_STATE;
  886.         }
  887.       }
  888.       break;
  890.     case SYNC_STATE:
  891.       {
  892.         // draw in the preamble bytes and look for a sync byte
  893.         // save the data in a short with last byte received as msbyte
  894.         //    and current byte received as the lsbyte.
  895.         // use a bit shift compare to find the byte boundary for the sync byte
  896.         // retain the shift value and use it to collect all of the packet data
  897.         // check for data inversion, and restore proper polarity 
  898.         // XXX-PB: Don't do this.
  899.         uint8_t i;
  901.         receive_sum ++;
  902.         if ((data_in == 0xaa) || (data_in == 0x55)) {
  903.           // It is actually possible to have the LAST BIT of the incoming
  904.           // data be part of the Sync Byte.  SO, we need to store that
  905.           // However, the next byte should definitely not have this pattern.
  906.           // XXX-PB: Do we need to check for excessive preamble?
  907.           RxShiftBuf.MSB = data_in;
  909.         }
  910.         else {
  911.           // TODO: Modify to be tolerant of bad bits in the preamble...
  912.           uint16_t usTmp;
  913.           switch (SOFCount) {
  914.           case 0:
  915.             RxShiftBuf.LSB = data_in;
  916.             break;
  917.   
  918.           case 1:
  919.           case 2: 
  920.           case 3: 
  921.           case 4: 
  922.           case 5: 
  923.             // bit shift the data in with previous sample to find sync
  924.             usTmp = RxShiftBuf.W;
  925.             RxShiftBuf.W <<= 8;
  926.             RxShiftBuf.LSB = data_in;
  928.             for(i=0;i<8;i++) {
  929.               usTmp <<= 1;
  930.               if(data_in & 0x80)
  931.                 usTmp  |=  0x1;
  932.               data_in <<= 1;
  933.               // check for sync bytes
  934.               if (usTmp == SYNC_WORD) {
  935.                 if (rxbufptr->length !=0) {
  936.                   call Leds.redToggle();
  937.                   RadioState = IDLE_STATE;
  938.                 }
  939.                 else {
  940.                   RadioState = RX_STATE;
  941.                   RSSIInitState = RX_STATE;
  942.                   call RSSIADC.getData();
  943.                   RxBitOffset = 7-i;
  944.                   // For time sync services
  945.                   signal RadioReceiveCoordinator.startSymbol(8, RxBitOffset, rxbufptr); 
  946.                 }
  947.                 break;
  948.               }
  949.             }
  950.             break;
  952.           default:
  953.             // We didn't find it after a reasonable number of tries, so....
  954.             RadioState = IDLE_STATE;  // Ensures we wait till the end of the transmission
  955.             break;
  956.           }
  957.           SOFCount++;
  958.         }
  960.       }
  961.       break;
  962.       //  collect the data and shift into double buffer
  963.       //  shift out data by correct offset
  964.       //  invert the data if necessary
  965.       //  stop after the correct packet length is read
  966.       //  return notification to upper levels
  967.       //  go back to idle state
  968.     case RX_STATE:
  969.       {
  970.         char Byte;
  971.         receive_sum ++;
  973.         RxShiftBuf.W <<=8;
  974.         RxShiftBuf.LSB = data_in;
  976.         Byte = (RxShiftBuf.W >> RxBitOffset);
  977.         ((char*)rxbufptr)[(int)RxByteCnt] = Byte;
  978.         RxByteCnt++;
  980.         signal RadioReceiveCoordinator.byte(rxbufptr, (uint8_t)RxByteCnt);
  982.         if (RxByteCnt < rxlength) {
  983.           usRunningCRC = crcByte(usRunningCRC,Byte);
  985.           if (RxByteCnt == (offsetof(struct TOS_Msg,length) + 
  986.                             sizeof(((struct TOS_Msg *)0)->length))) {
  987.             rxlength = rxbufptr->length;
  988.             if (rxlength > TOSH_DATA_LENGTH) {
  989.               // The packet's screwed up, so just dump it
  990.               rxbufptr->length = 0;
  991.               RadioState = IDLE_STATE;  // Waits till end of transmission
  992.               return SUCCESS;
  993.             }
  994.             //Add in the header size
  995.             rxlength += offsetof(struct TOS_Msg,data);
  996.           }
  997.         }
  998.         else if (RxByteCnt == rxlength) {
  999.           usRunningCRC = crcByte(usRunningCRC,Byte);
  1000.           // Shift index ahead to the crc field.
  1001.           RxByteCnt = offsetof(struct TOS_Msg,crc);
  1002.         }
  1003.         else if (RxByteCnt >= MSG_DATA_SIZE) { 
  1005.           // Packet filtering based on bad CRC's is done at higher layers.
  1006.           // So sayeth the TOS weenies.
  1007.           if (rxbufptr->crc == usRunningCRC) {
  1008.             rxbufptr->crc = 1;
  1010.             if(bAckEnable && (rxbufptr->addr == TOS_LOCAL_ADDRESS)){
  1012.               RadioState = SENDING_ACK; 
  1013.               call CC1000Control.TxMode();
  1014.               call SpiByteFifo.txMode();
  1015.               call SpiByteFifo.writeByte(0xaa);
  1016.               RxByteCnt = 0;
  1017.               return SUCCESS; 
  1018.             }
  1020.           } else {
  1021.             rxbufptr->crc = 0;
  1022.           }
  1024.           call SpiByteFifo.disableIntr();
  1025.   
  1026.           RadioState = IDLE_STATE; //DISABLED_STATE;
  1027.           rxbufptr->strength = usRSSIVal;
  1028.           if (!(post PacketRcvd())) {
  1029.             // If there are insufficient resources to process the incoming packet
  1030.             // we drop it
  1031.             rxbufptr->length = 0;
  1032.             RadioState = IDLE_STATE;
  1033.             call SpiByteFifo.enableIntr();
  1034.           }
  1035.           RSSIInitState = RadioState;
  1036.           call RSSIADC.getData();
  1037.         }
  1038.       }
  1039.       break;
  1041.     case SENDING_ACK:
  1042.       {
  1043.         send_sum ++;
  1044.         RxByteCnt++;
  1045.         if (RxByteCnt >= ACK_LENGTH) { 
  1046.           call CC1000Control.RxMode();
  1047.           call SpiByteFifo.rxMode();
  1048.           call SpiByteFifo.disableIntr();
  1049.           RadioState = IDLE_STATE; //DISABLED_STATE;
  1050.           rxbufptr->strength = usRSSIVal;
  1051.           if (!(post PacketRcvd())) {
  1052.             rxbufptr->length = 0;
  1053.             RadioState = IDLE_STATE;
  1054.             call SpiByteFifo.enableIntr();
  1055.           }
  1056.         }else if(RxByteCnt >= ACK_LENGTH - sizeof(ack_code)){
  1057.           call SpiByteFifo.writeByte(ack_code[RxByteCnt + sizeof(ack_code) - ACK_LENGTH]);
  1058.         }
  1059.       }
  1060.       break;
  1062.     default:
  1063.       break;
  1064.     }
  1066.     if(pulse_check_sum > CHECK_MA_COUNT){
  1067.       power_sum ++;
  1068.       sp_sum++;
  1069.       pulse_check_sum -= CHECK_MA_COUNT;
  1070.     }
  1071.     if(send_sum > SEND_MA_COUNT){
  1072.       power_sum ++;
  1073.       tx_sum++;
  1074.       send_sum -= SEND_MA_COUNT;
  1075.     }
  1076.     if(receive_sum > RECEIVE_MA_COUNT){
  1077.       power_sum ++;
  1078.       rx_sum++;
  1079.       receive_sum -= RECEIVE_MA_COUNT;
  1080.     }
  1081.     return SUCCESS;
  1082.   }
  1084.   task void IdleTimerTask(){
  1085.     if (iSquelchCount > CC1K_SquelchCount)
  1086.       call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalSlow);
  1087.     else
  1088.       call SquelchTimer.start(TIMER_REPEAT, CC1K_SquelchIntervalFast);
  1089.     call WakeupTimer.start(TIMER_ONE_SHOT, TIME_AFTER_CHECK);
  1090.     /*if(pulse_check_sum > CHECK_MA_COUNT){
  1091.       power_sum ++;
  1092.       pulse_check_sum -= CHECK_MA_COUNT;
  1093.       }
  1094.       if(send_sum > SEND_MA_COUNT){
  1095.       power_sum ++;
  1096.       send_sum -= SEND_MA_COUNT;
  1097.       }
  1098.       if(receive_sum > RECEIVE_MA_COUNT){
  1099.       power_sum ++;
  1100.       receive_sum -= RECEIVE_MA_COUNT;
  1101.       }*/
  1102.   }
  1104.   task void SleepTimerTask(){
  1105.     call WakeupTimer.start(TIMER_ONE_SHOT, sleeptime);
  1106.   }
  1108.   async event result_t RSSIADC.dataReady(uint16_t data) { 
  1109.     atomic
  1110.       {
  1111.         uint8_t currentRadioState;
  1113.         // TOSH_CLR_PW3_PIN();
  1115.         currentRadioState = RadioState;
  1116.         // find the maximum RSSI value over CC1K_MAX_RSSI_SAMPLES
  1117.         switch(currentRadioState) {
  1118.         case IDLE_STATE:
  1119.           if (RSSIInitState == IDLE_STATE) {
  1120.             atomic usTempSquelch = data;
  1121.             post adjustSquelch();
  1122.           }
  1123.           RSSIInitState = NULL_STATE;
  1124.           break;
  1126.         case RX_STATE:
  1127.           if (RSSIInitState == RX_STATE) {
  1128.             atomic usRSSIVal = data;
  1129.           }
  1130.           RSSIInitState = NULL_STATE;
  1131.           break;
  1133.         case PRETX_STATE:
  1134.           iRSSIcount++;
  1136.           // if the channel is clear or CCA is disabled, GO GO GO!
  1137.           if (((data > (usSquelchVal + CC1K_SquelchBuffer)) || (!bCCAEnable)) && (RSSIInitState == PRETX_STATE)) { 
  1138.             call SpiByteFifo.writeByte(0xaa);
  1139.             call CC1000Control.TxMode();
  1140.             call SpiByteFifo.txMode();
  1142.             usRSSIVal = data;
  1143.             iRSSIcount = CC1K_MaxRSSISamples;
  1144.             bRSSIValid = TRUE;
  1145.             TxByteCnt = 0;
  1146.             usRunningCRC = 0;
  1147.             RadioState = TX_STATE;
  1148.             RadioTxState = TXSTATE_PREAMBLE;
  1149.             NextTxByte = 0xaa;
  1150.             RSSIInitState = NULL_STATE;
  1151.           }
  1152.           else {
  1153.             RSSIInitState = NULL_STATE;
  1154.             if (iRSSIcount == CC1K_MaxRSSISamples) {
  1155.               sMacDelay = signal MacBackoff.congestionBackoff(txbufptr);
  1156.               RadioState = IDLE_STATE;
  1157.             }
  1158.             else {
  1159.               RSSIInitState = currentRadioState;
  1160.               call RSSIADC.getData();
  1161.             }
  1162.           }
  1163.           break;
  1165.         case PULSE_CHECK_STATE:
  1166.           atomic{
  1167.             uint8_t done = 0;
  1168.             uint16_t threshold = call GetSquelch();
  1169.             threshold = threshold - (call GetSquelch() >> 2);
  1170.             if(data > threshold){
  1171.               // adjust the noise floor level
  1172.               atomic usTempSquelch = data;
  1173.               post adjustSquelch();
  1175.             }else if(pulse_check_count > 5){
  1176.               //go to the idle state since no outliers were found
  1177.               call CC1000Control.RxMode();
  1178.               RadioState = IDLE_STATE;
  1179.               call SpiByteFifo.rxMode();     // SPI to miso
  1180.               call SpiByteFifo.enableIntr(); // enable spi interrupt
  1181.               post IdleTimerTask();
  1182.               done = 1;
  1184.             }else {
  1185.               call CC1000Control.RxMode();
  1186.               if(call RSSIADC.getData()){
  1187.                 TOSH_uwait(80);
  1188.                 pulse_check_count ++;
  1189.                 done = 1;
  1190.               }
  1191.               pulse_check_sum ++;
  1192.               call CC1000StdControl.stop();
  1193.             }
  1195.             if (bTxPending) { // bug fixed by Dr. Rhee
  1196.               //go to the idle state since no outliers were found
  1197.               call CC1000Control.RxMode();
  1198.               RadioState = IDLE_STATE;
  1199.               call SpiByteFifo.rxMode();     // SPI to miso
  1200.               call SpiByteFifo.enableIntr(); // enable spi interrupt
  1201.               post IdleTimerTask();
  1202.               done = 1;
  1203.             }
  1205.             if(done == 0){
  1206.               post SleepTimerTask();
  1207.               RadioState = POWER_DOWN_STATE;
  1208.               call SpiByteFifo.disableIntr();
  1209.             }
  1210.           }
  1211.           //go to the power down state
  1212.           break;
  1214.         default:
  1215.         }
  1216.       }
  1217.     return SUCCESS;
  1218.   }
  1220.   // XXX:JP- for testing the mac layer squlech value
  1221.   async command uint16_t GetSquelch() {
  1222.     return usSquelchVal;
  1223.   }
  1224.   // XXX:JP- for testing the mac layer power consumption
  1225.   async command uint16_t GetPower() {
  1226.     return power_sum;
  1227.   }
  1228.   async command uint16_t GetDataSent() {
  1229.     return dataSent;
  1230.   }
  1231.   async command result_t ResetDataSent() {
  1232.     dataSent = 0;
  1233.     return SUCCESS;
  1234.   }
  1235.   async command uint16_t GetPower_tx() {
  1236.     return tx_sum;
  1237.   }
  1238.   async command uint16_t GetPower_rx() {
  1239.     return rx_sum;
  1240.   }
  1241.   async command uint16_t GetPower_sp() {
  1242.     return sp_sum;
  1243.   }
  1244.   async command result_t ResetPower() {
  1245.     power_sum = 0;
  1246.     pulse_check_sum = 0;
  1247.     send_sum = 0;
  1248.     receive_sum = 0;
  1249.     sp_sum = 0;
  1250.     tx_sum = 0;
  1251.     rx_sum = 0;
  1252.     return SUCCESS;
  1253.   }
  1255.   async command result_t MacControl.enableAck() {
  1256.     atomic bAckEnable = TRUE;
  1257.     return SUCCESS;
  1258.   }
  1260.   async command result_t MacControl.disableAck() {
  1261.     atomic bAckEnable = FALSE;
  1262.     return SUCCESS;
  1263.   }
  1265.   async command result_t MacControl.enableCCA() {
  1266.     atomic bCCAEnable = TRUE;
  1267.     return SUCCESS;
  1268.   }
  1270.   async command result_t MacControl.disableCCA() {
  1271.     atomic bCCAEnable = TRUE; 
  1272.     return SUCCESS;
  1273.   }
  1275.   // ***Not yet implemented
  1276.   async command TOS_MsgPtr MacControl.HaltTx() {
  1277.     return 0;
  1278.   }
  1280.   // Default events for radio send/receive coordinators do nothing.
  1281.   // Be very careful using these, you'll break the stack.
  1282.   default async event void RadioSendCoordinator.startSymbol(uint8_t bitsPerBlock, uint8_t offset, TOS_MsgPtr msgBuff) { }
  1283.   default async event void RadioSendCoordinator.byte(TOS_MsgPtr msg, uint8_t byteCount) { }
  1284.   default async event void RadioSendCoordinator.blockTimer() { }
  1286.   default async event void RadioReceiveCoordinator.startSymbol(uint8_t bitsPerBlock, uint8_t offset, TOS_MsgPtr msgBuff) { }
  1287.   default async event void RadioReceiveCoordinator.byte(TOS_MsgPtr msg, uint8_t byteCount) { }
  1288.   default async event void RadioReceiveCoordinator.blockTimer() { }
  1290.   default async event int16_t MacBackoff.initialBackoff(TOS_MsgPtr m) { 
  1291.     return (call Random.rand() & 0x1F) + 1;
  1292.   }
  1294.   default async event int16_t MacBackoff.congestionBackoff(TOS_MsgPtr m) { 
  1295.     return (call Random.rand() & 0xF) + 1;
  1296.   }
  1298. }