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

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

网络

开发平台：

Others

CC1000ControlM.nc：源码内容
  1. /* tab:4
  2.  *
  3.  *
  4.  * "Copyright (c) 2000-2002 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.  */
  24. /* tab:4
  25.  *  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.  By
  26.  *  downloading, copying, installing or using the software you agree to
  27.  *  this license.  If you do not agree to this license, do not download,
  28.  *  install, copy or use the software.
  29.  *
  30.  *  Intel Open Source License 
  31.  *
  32.  *  Copyright (c) 2002 Intel Corporation 
  33.  *  All rights reserved. 
  34.  *  Redistribution and use in source and binary forms, with or without
  35.  *  modification, are permitted provided that the following conditions are
  36.  *  met:
  37.  * 
  38.  * Redistributions of source code must retain the above copyright
  39.  *  notice, this list of conditions and the following disclaimer.
  40.  * Redistributions in binary form must reproduce the above copyright
  41.  *  notice, this list of conditions and the following disclaimer in the
  42.  *  documentation and/or other materials provided with the distribution.
  43.  *      Neither the name of the Intel Corporation nor the names of its
  44.  *  contributors may be used to endorse or promote products derived from
  45.  *  this software without specific prior written permission.
  46.  *  
  47.  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  48.  *  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  49.  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  50.  *  PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE INTEL OR ITS
  51.  *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  52.  *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  53.  *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  54.  *  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  55.  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  56.  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  57.  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  58.  * 
  59.  * 
  60.  */
  61. /*
  62.  *
  63.  * Authors: Jaein Jeong, Phil Buonadonna
  64.  * Date last modified:  $Revision: 1.1.1.1 $
  65.  *
  66.  * This module provides the CONTROL functionality for the Chipcon1000 series radio.
  67.  * It exports both a standard control interface and a custom interface to control
  68.  * CC1000 operation.
  69.  */
  71. module CC1000ControlM {
  72.   provides {
  73.     interface StdControl;
  74.     interface CC1000Control;
  75.   }
  76.   uses {
  77.     interface HPLCC1000 as HPLChipcon;
  78.   }
  79. }
  80. implementation
  81. {
  82.   uint32_t gCurrentChannel;
  83.   norace uint8_t gCurrentParameters[31];
  85.   enum {
  86.     IF = 150000,
  87.     FREQ_MIN = 4194304,
  88.     FREQ_MAX = 16751615
  89.   };
  91.   const uint32_t FRefTbl[9] = {2457600,
  92.        2106514,
  93.        1843200,
  94.        1638400,
  95.        1474560,
  96.        1340509,
  97.        1228800,
  98.        1134277,
  99.        1053257};
  100.   
  101.   const uint16_t CorTbl[9] = {1213,
  102.       1416,
  103.       1618,
  104.       1820,
  105.       2022,
  106.       2224,
  107.       2427,
  108.       2629,
  109.       2831};
  110.   
  111.   const uint16_t FSepTbl[9] = {0x1AA,
  112.        0x1F1,
  113.        0x238,
  114.        0x280,
  115.        0x2C7,
  116.        0x30E,
  117.        0x355,
  118.        0x39C,
  119.        0x3E3};
  120.   
  121.   //
  122.   // PRIVATE Module functions
  123.   //
  125.   ///************************************************************/
  126.   ///* Function: chipcon_cal                                    */
  127.   ///* Description: places the chipcon radio in calibrate mode  */
  128.   ///*                                                          */
  129.   ///************************************************************/
  131.   result_t chipcon_cal()
  132.   {
  133.     //int i;
  134.     //int freq = tunefreq;
  136.     call HPLChipcon.write(CC1K_PA_POW,0x00);  // turn off rf amp
  137.     call HPLChipcon.write(CC1K_TEST4,0x3f);   // chip rate >= 38.4kb
  139.     // RX - configure main freq A
  140.     call HPLChipcon.write(CC1K_MAIN,
  141.   ((1<<CC1K_TX_PD) | (1<<CC1K_RESET_N)));
  142.     //TOSH_uwait(2000);
  144.     // start cal
  145.     call HPLChipcon.write(CC1K_CAL,
  146.   ((1<<CC1K_CAL_START) | 
  147.    (1<<CC1K_CAL_WAIT) | (6<<CC1K_CAL_ITERATE)));
  148. #if 0
  149.     for (i=0;i<34;i++)  // need 34 ms delay
  150.       TOSH_uwait(1000);
  151. #endif
  152.     while (((call HPLChipcon.read(CC1K_CAL)) & (1<<CC1K_CAL_COMPLETE)) == 0);
  154.     //exit cal mode
  155.     call HPLChipcon.write(CC1K_CAL,
  156.   ((1<<CC1K_CAL_WAIT) | (6<<CC1K_CAL_ITERATE)));
  159.     // TX - configure main freq B
  160.     call HPLChipcon.write(CC1K_MAIN,
  161.   ((1<<CC1K_RXTX) | (1<<CC1K_F_REG) | (1<<CC1K_RX_PD) | 
  162.    (1<<CC1K_RESET_N)));
  163.     // Set TX current
  164.     call HPLChipcon.write(CC1K_CURRENT,gCurrentParameters[29]);
  165.     call HPLChipcon.write(CC1K_PA_POW,0x00);
  166.     //TOSH_uwait(2000);
  168.     // start cal
  169.     call HPLChipcon.write(CC1K_CAL,
  170.   ((1<<CC1K_CAL_START) | 
  171.    (1<<CC1K_CAL_WAIT) | (6<<CC1K_CAL_ITERATE)));
  172. #if 0
  173.     for (i=0;i<28;i++)  // need 28 ms delay
  174.       TOSH_uwait(1000);
  175. #endif
  176.     while (((call HPLChipcon.read(CC1K_CAL)) & (1<<CC1K_CAL_COMPLETE)) == 0);
  178.     //exit cal mode
  179.     call HPLChipcon.write(CC1K_CAL,
  180.   ((1<<CC1K_CAL_WAIT) | (6<<CC1K_CAL_ITERATE)));
  181.     
  182.     //TOSH_uwait(200);
  184.     return SUCCESS;
  185.   }
  187.   void cc1000SetFreq() {
  188.     uint8_t i;
  189.     // FREQA, FREQB, FSEP, CURRENT(RX), FRONT_END, POWER, PLL
  190.     for (i = 1;i < 0x0d;i++) {
  191.       call HPLChipcon.write(i,gCurrentParameters[i]);
  192.     }
  194.     // MATCH
  195.     call HPLChipcon.write(CC1K_MATCH,gCurrentParameters[0x12]);
  197.     chipcon_cal();
  199.     return;
  201.   }
  203.   void cc1000SetModem() {
  204.     call HPLChipcon.write(CC1K_MODEM2,gCurrentParameters[0x0f]);
  205.     call HPLChipcon.write(CC1K_MODEM1,gCurrentParameters[0x10]);
  206.     call HPLChipcon.write(CC1K_MODEM0,gCurrentParameters[0x11]);
  208.     return;
  210.   }
  212.   /*
  213.    * cc1000ComputeFreq(uint32_t desiredFreq);
  214.    *
  215.    * Compute an achievable frequency and the necessary CC1K parameters from
  216.    * a given desired frequency (Hz). The function returns the actual achieved
  217.    * channel frequency in Hz.
  218.    *
  219.    * This routine assumes the following:
  220.    *  - Crystal Freq: 14.7456 MHz
  221.    *  - LO Injection: High
  222.    *  - Separation: 64 KHz
  223.    *  - IF: 150 KHz
  224.    * 
  225.    * Approximate costs for this function:
  226.    *  - ~870 bytes FLASH
  227.    *  - ~32 bytes RAM
  228.    *  - 9400 cycles
  229.    */
  230.   uint32_t cc1000ComputeFreq(uint32_t desiredFreq) {
  231.     uint32_t ActualChannel = 0;
  232.     uint32_t RXFreq = 0, TXFreq = 0;
  233.     int32_t Offset = 0x7fffffff;
  234.     uint16_t FSep = 0;
  235.     uint8_t RefDiv = 0;
  236.     uint8_t i;
  238.     for (i = 0; i < 9; i++) {
  240.       uint32_t NRef = ((desiredFreq + IF));
  241.       uint32_t FRef = FRefTbl[i];
  242.       uint32_t Channel = 0;
  243.       uint32_t RXCalc = 0, TXCalc = 0;
  244.       int32_t  diff;
  246.       NRef = ((desiredFreq + IF) << 2) / FRef;
  247.       if (NRef & 0x1) {
  248.   NRef++;
  249.       }
  251.       if (NRef & 0x2) {
  252. RXCalc = 16384 >> 1;
  253. Channel = FRef >> 1;
  254.       }
  256.       NRef >>= 2;
  258.       RXCalc += (NRef * 16384) - 8192;
  259.       if ((RXCalc < FREQ_MIN) || (RXCalc > FREQ_MAX)) 
  260. continue;
  261.     
  262.       TXCalc = RXCalc - CorTbl[i];
  263.       if ((TXCalc < FREQ_MIN) || (TXCalc > FREQ_MAX)) 
  264. continue;
  266.       Channel += (NRef * FRef);
  267.       Channel -= IF;
  269.       diff = Channel - desiredFreq;
  270.       if (diff < 0)
  271. diff = 0 - diff;
  273.       if (diff < Offset) {
  274. RXFreq = RXCalc;
  275. TXFreq = TXCalc;
  276. ActualChannel = Channel;
  277. FSep = FSepTbl[i];
  278. RefDiv = i + 6;
  279. Offset = diff;
  280.       }
  282.     }
  284.     if (RefDiv != 0) {
  285.       // FREQA
  286.       gCurrentParameters[0x3] = (uint8_t)((RXFreq) & 0xFF);  // LSB
  287.       gCurrentParameters[0x2] = (uint8_t)((RXFreq >> 8) & 0xFF);
  288.       gCurrentParameters[0x1] = (uint8_t)((RXFreq >> 16) & 0xFF);  // MSB
  289.       // FREQB
  290.       gCurrentParameters[0x6] = (uint8_t)((TXFreq) & 0xFF); // LSB
  291.       gCurrentParameters[0x5] = (uint8_t)((TXFreq >> 8) & 0xFF);
  292.       gCurrentParameters[0x4] = (uint8_t)((TXFreq >> 16) & 0xFF);  // MSB
  293.       // FSEP
  294.       gCurrentParameters[0x8] = (uint8_t)((FSep) & 0xFF);  // LSB
  295.       gCurrentParameters[0x7] = (uint8_t)((FSep >> 8) & 0xFF); //MSB
  297.       if (ActualChannel < 500000000) {
  298. if (ActualChannel < 400000000) {
  299. // CURRENT (RX)
  300.   gCurrentParameters[0x9] = ((8 << CC1K_VCO_CURRENT) | (1 << CC1K_LO_DRIVE));
  301. // CURRENT (TX)
  302.   gCurrentParameters[0x1d] = ((9 << CC1K_VCO_CURRENT) | (1 << CC1K_PA_DRIVE));
  303. }
  304. else {
  305. // CURRENT (RX)
  306.   gCurrentParameters[0x9] = ((4 << CC1K_VCO_CURRENT) | (1 << CC1K_LO_DRIVE));
  307. // CURRENT (TX)
  308.   gCurrentParameters[0x1d] = ((8 << CC1K_VCO_CURRENT) | (1 << CC1K_PA_DRIVE));
  309. }
  310. // FRONT_END
  311. gCurrentParameters[0xa] = (1 << CC1K_IF_RSSI); 
  312. // MATCH
  313. gCurrentParameters[0x12] = (7 << CC1K_RX_MATCH);
  314.       }
  315.       else {
  316. // CURRENT (RX)
  317.   gCurrentParameters[0x9] = ((8 << CC1K_VCO_CURRENT) | (3 << CC1K_LO_DRIVE));
  318. // CURRENT (TX)
  319.   gCurrentParameters[0x1d] = ((15 << CC1K_VCO_CURRENT) | (3 << CC1K_PA_DRIVE));
  321. // FRONT_END
  322. gCurrentParameters[0xa] = ((1<<CC1K_BUF_CURRENT) | (2<<CC1K_LNA_CURRENT) | 
  323.  (1<<CC1K_IF_RSSI));
  324. // MATCH
  325. gCurrentParameters[0x12] = (2 << CC1K_RX_MATCH);
  327.       }
  328.       // PLL
  329.       gCurrentParameters[0xc] = (RefDiv << CC1K_REFDIV);
  330.     }
  332.     gCurrentChannel = ActualChannel;
  333.     return ActualChannel;
  335.   }
  338.   //
  339.   // PUBLIC Module Functions
  340.   //
  342.   command result_t StdControl.init() {
  343.     outp (0x41,TCCR3B);
  344.     call HPLChipcon.init();
  346.     // wake up xtal and reset unit
  347.     call HPLChipcon.write(CC1K_MAIN,
  348.   ((1<<CC1K_RX_PD) | (1<<CC1K_TX_PD) | 
  349.    (1<<CC1K_FS_PD) | (1<<CC1K_BIAS_PD))); 
  350.     // clear reset.
  351.     call HPLChipcon.write(CC1K_MAIN,
  352.   ((1<<CC1K_RX_PD) | (1<<CC1K_TX_PD) | 
  353.    (1<<CC1K_FS_PD) | (1<<CC1K_BIAS_PD) |
  354.    (1<<CC1K_RESET_N))); 
  355.     // reset wait time
  356.     TOSH_uwait(2000);        
  358.     // Set default parameter values
  359.     // POWER 0dbm
  360.     gCurrentParameters[0xb] = ((8 << CC1K_PA_HIGHPOWER) | (0 << CC1K_PA_LOWPOWER)); 
  361.     call HPLChipcon.write(CC1K_PA_POW, gCurrentParameters[0xb]);
  363.     // LOCK Manchester Violation default
  364.     gCurrentParameters[0xd] = (9 << CC1K_LOCK_SELECT);
  365.     call HPLChipcon.write(CC1K_LOCK_SELECT, gCurrentParameters[0xd]);
  367.     // Default modem values = 19.2 Kbps (38.4 kBaud), Manchester encoded
  368.     // MODEM2
  369.     gCurrentParameters[0xf] = 0;
  370.     //call HPLChipcon.write(CC1K_MODEM2,gCurrentParameters[0xf]);
  371.     // MODEM1
  372.     gCurrentParameters[0x10] = ((3<<CC1K_MLIMIT) | (1<<CC1K_LOCK_AVG_MODE) | 
  373. (3<<CC1K_SETTLING) | (1<<CC1K_MODEM_RESET_N));
  374.     //call HPLChipcon.write(CC1K_MODEM1,gCurrentParameters[0x10]);
  375.     // MODEM0
  376.     gCurrentParameters[0x11] = ((5<<CC1K_BAUDRATE) | (1<<CC1K_DATA_FORMAT) | 
  377. (1<<CC1K_XOSC_FREQ));
  378.     //call HPLChipcon.write(CC1K_MODEM0,gCurrentParameters[0x11]);
  380.     cc1000SetModem();
  381.     // FSCTRL
  382.     gCurrentParameters[0x13] = (1 << CC1K_FS_RESET_N);
  383.     call HPLChipcon.write(CC1K_FSCTRL,gCurrentParameters[0x13]);
  385.     // HIGH Side LO
  386.     gCurrentParameters[0x1e] = TRUE;
  389.     // Program registers w/ default freq and calibrate
  390. #ifdef CC1K_DEF_FREQ
  391.     call CC1000Control.TuneManual(CC1K_DEF_FREQ);
  392. #else
  393.     call CC1000Control.TunePreset(CC1K_DEF_PRESET);     // go to default tune frequency
  394. #endif
  395.     return SUCCESS;
  396.   }
  400.   command result_t CC1000Control.TunePreset(uint8_t freq) {
  401.     int i;
  403.     for (i=1;i < 31 /*0x14*/;i++) {
  404.       //call HPLChipcon.write(i,PRG_RDB(&CC1K_Params[freq][i]));
  405.       gCurrentParameters[i] = PRG_RDB(&CC1K_Params[freq][i]);
  406.     }
  407.     cc1000SetFreq();
  409.     return SUCCESS;
  410.   }
  412.   command uint32_t CC1000Control.TuneManual(uint32_t DesiredFreq) {
  413.     uint32_t actualFreq;
  415.     actualFreq = cc1000ComputeFreq(DesiredFreq);
  417.     cc1000SetFreq();
  419.     return actualFreq;
  420.   }
  422.   async command result_t CC1000Control.TxMode() {
  423.     // MAIN register to TX mode
  424.     call HPLChipcon.write(CC1K_MAIN,
  425.   ((1<<CC1K_RXTX) | (1<<CC1K_F_REG) | (1<<CC1K_RX_PD) | 
  426.    (1<<CC1K_RESET_N)));
  427.     // Set the TX mode VCO Current
  428.     call HPLChipcon.write(CC1K_CURRENT,gCurrentParameters[29]);
  429.     TOSH_uwait(250);
  430.     call HPLChipcon.write(CC1K_PA_POW,gCurrentParameters[0xb] /*rfpower*/);
  431.     TOSH_uwait(20);
  432.     return SUCCESS;
  433.   }
  435.   async command result_t CC1000Control.RxMode() {
  436.     // MAIN register to RX mode
  437.     // Powerup Freqency Synthesizer and Receiver
  438.     call HPLChipcon.write(CC1K_CURRENT,gCurrentParameters[0x09]);
  439.     call HPLChipcon.write(CC1K_PA_POW,0x00); // turn off power amp
  440.     call HPLChipcon.write(CC1K_MAIN,
  441.   ((1<<CC1K_TX_PD) | (1<<CC1K_RESET_N)));
  442.     // Sex the RX mode VCO Current
  443.     TOSH_uwait(125);
  444.     return SUCCESS;
  445.   }
  447.   command result_t CC1000Control.BIASOff() {
  448.     // MAIN register to SLEEP mode
  449.     call HPLChipcon.write(CC1K_MAIN,
  450.   ((1<<CC1K_RX_PD) | (1<<CC1K_TX_PD) | 
  451.    (1<<CC1K_FS_PD) | (1<<CC1K_BIAS_PD) |
  452.    (1<<CC1K_RESET_N)));
  453.  
  454.     return SUCCESS;
  455.   }
  457.   command result_t CC1000Control.BIASOn() {
  458.     //call CC1000Control.RxMode();
  459.     call HPLChipcon.write(CC1K_MAIN,
  460.   ((1<<CC1K_RX_PD) | (1<<CC1K_TX_PD) | 
  461.    (1<<CC1K_FS_PD) | 
  462.    (1<<CC1K_RESET_N)));
  463.     
  464.     TOSH_uwait(200 /*500*/);
  465.     return SUCCESS;
  466.   }
  469.   command result_t StdControl.stop() {
  470.     // MAIN register to power down mode. Shut everything off
  471.     call HPLChipcon.write(CC1K_MAIN,
  472.   ((1<<CC1K_RX_PD) | (1<<CC1K_TX_PD) | 
  473.    (1<<CC1K_FS_PD) | (1<<CC1K_CORE_PD) | (1<<CC1K_BIAS_PD) |
  474.    (1<<CC1K_RESET_N)));
  476.     call HPLChipcon.write(CC1K_PA_POW,0x00);  // turn off rf amp
  477.     return SUCCESS;
  478.   }
  480.   command result_t StdControl.start() {
  481.     // wake up xtal osc
  482.     call HPLChipcon.write(CC1K_MAIN,
  483.   ((1<<CC1K_RX_PD) | (1<<CC1K_TX_PD) | 
  484.    (1<<CC1K_FS_PD) | (1<<CC1K_BIAS_PD) |
  485.    (1<<CC1K_RESET_N)));
  487.     //TOSH_uwait(2000);
  488. //    call CC1000Control.RxMode();
  490.     return SUCCESS;
  491.   }
  494.   command result_t CC1000Control.SetRFPower(uint8_t power) {
  495.     gCurrentParameters[0xb] = power;
  496.     //rfpower = power;
  497.     //call HPLChipcon.write(CC1K_PA_POW,rfpower); // Set power amp value
  498.     return SUCCESS;
  499.   }
  501.   command uint8_t CC1000Control.GetRFPower() {
  502.     return gCurrentParameters[0xb]; //rfpower;
  503.   }
  505.   command result_t CC1000Control.SelectLock(uint8_t Value) {
  506.     //LockVal = Value;
  507.     gCurrentParameters[0xd] = (Value << CC1K_LOCK_SELECT);
  508.     return call HPLChipcon.write(CC1K_LOCK,(Value << CC1K_LOCK_SELECT));
  509.   }
  511.   command uint8_t CC1000Control.GetLock() {
  512.     uint8_t retVal;
  513.     retVal = (uint8_t)call HPLChipcon.GetLOCK(); 
  514.     return retVal;
  515.   }
  517.   command bool CC1000Control.GetLOStatus() {
  519.     return gCurrentParameters[0x1e];
  521.   }
  523. }