CC1000Const.h
上传用户:joranyuan
上传日期:2022-06-23
资源大小:3306k
文件大小:17k
源码类别:

网络

开发平台:

Others

  1. // $Id: CC1000Const.h,v 1.1.1.1 2005/04/22 04:26:45 acwarrie Exp $
  2. /* -*- Mode: C; c-basic-indent: 2; indent-tabs-mode: nil -*- */ 
  3. /* tab:4
  4.  *  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.  By
  5.  *  downloading, copying, installing or using the software you agree to
  6.  *  this license.  If you do not agree to this license, do not download,
  7.  *  install, copy or use the software.
  8.  *
  9.  *  Intel Open Source License 
  10.  *
  11.  *  Copyright (c) 2002 Intel Corporation 
  12.  *  All rights reserved. 
  13.  *  Redistribution and use in source and binary forms, with or without
  14.  *  modification, are permitted provided that the following conditions are
  15.  *  met:
  16.  * 
  17.  * Redistributions of source code must retain the above copyright
  18.  *  notice, this list of conditions and the following disclaimer.
  19.  * Redistributions in binary form must reproduce the above copyright
  20.  *  notice, this list of conditions and the following disclaimer in the
  21.  *  documentation and/or other materials provided with the distribution.
  22.  *      Neither the name of the Intel Corporation nor the names of its
  23.  *  contributors may be used to endorse or promote products derived from
  24.  *  this software without specific prior written permission.
  25.  *  
  26.  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  27.  *  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  28.  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  29.  *  PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE INTEL OR ITS
  30.  *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  31.  *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  32.  *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  33.  *  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  34.  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  35.  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  36.  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  37.  * 
  38.  * 
  39.  */
  40. /*
  41.  *
  42.  * Authors: Phil Buonadonna
  43.  * Date last modified:  1/10/03
  44.  *
  45.  */
  46. /**
  47.  * @author Phil Buonadonna
  48.  */
  49. #ifndef _CC1KCONST_H
  50. #define _CC1KCONST_H
  51. #include <avr/pgmspace.h>
  52. /* Constants defined for CC1K */
  53. /* Register addresses */
  54. #define CC1K_MAIN            0x00
  55. #define CC1K_FREQ_2A         0x01
  56. #define CC1K_FREQ_1A         0x02
  57. #define CC1K_FREQ_0A         0x03
  58. #define CC1K_FREQ_2B         0x04
  59. #define CC1K_FREQ_1B         0x05
  60. #define CC1K_FREQ_0B         0x06
  61. #define CC1K_FSEP1           0x07
  62. #define CC1K_FSEP0           0x08
  63. #define CC1K_CURRENT         0x09
  64. #define CC1K_FRONT_END       0x0A //10
  65. #define CC1K_PA_POW          0x0B //11
  66. #define CC1K_PLL             0x0C //12
  67. #define CC1K_LOCK            0x0D //13
  68. #define CC1K_CAL             0x0E //14
  69. #define CC1K_MODEM2          0x0F //15
  70. #define CC1K_MODEM1          0x10 //16
  71. #define CC1K_MODEM0          0x11 //17
  72. #define CC1K_MATCH           0x12 //18
  73. #define CC1K_FSCTRL          0x13 //19
  74. #define CC1K_FSHAPE7         0x14 //20
  75. #define CC1K_FSHAPE6         0x15 //21
  76. #define CC1K_FSHAPE5         0x16 //22
  77. #define CC1K_FSHAPE4         0x17 //23
  78. #define CC1K_FSHAPE3         0x18 //24
  79. #define CC1K_FSHAPE2         0x19 //25
  80. #define CC1K_FSHAPE1         0x1A //26
  81. #define CC1K_FSDELAY         0x1B //27
  82. #define CC1K_PRESCALER       0x1C //28
  83. #define CC1K_TEST6           0x40 //64
  84. #define CC1K_TEST5           0x41 //66
  85. #define CC1K_TEST4           0x42 //67
  86. #define CC1K_TEST3           0x43 //68
  87. #define CC1K_TEST2           0x44 //69
  88. #define CC1K_TEST1           0x45 //70
  89. #define CC1K_TEST0           0x46 //71
  90. // MAIN Register Bit Posititions
  91. #define CC1K_RXTX 7
  92. #define CC1K_F_REG 6
  93. #define CC1K_RX_PD 5
  94. #define CC1K_TX_PD 4
  95. #define CC1K_FS_PD 3
  96. #define CC1K_CORE_PD 2
  97. #define CC1K_BIAS_PD 1
  98. #define CC1K_RESET_N 0
  99. // CURRENT Register Bit Positions
  100. #define CC1K_VCO_CURRENT 4
  101. #define CC1K_LO_DRIVE 2
  102. #define CC1K_PA_DRIVE 0
  103. // FRONT_END Register Bit Positions
  104. #define CC1K_BUF_CURRENT 5
  105. #define CC1K_LNA_CURRENT 3
  106. #define CC1K_IF_RSSI 1
  107. #define CC1K_XOSC_BYPASS 0
  108. // PA_POW Register Bit Positions
  109. #define CC1K_PA_HIGHPOWER 4
  110. #define CC1K_PA_LOWPOWER 0
  111. // PLL Register Bit Positions
  112. #define CC1K_EXT_FILTER 7
  113. #define CC1K_REFDIV 3
  114. #define CC1K_ALARM_DISABLE 2
  115. #define CC1K_ALARM_H 1
  116. #define CC1K_ALARM_L 0
  117. // LOCK Register Bit Positions
  118. #define CC1K_LOCK_SELECT 4
  119. #define CC1K_PLL_LOCK_ACCURACY 3
  120. #define CC1K_PLL_LOCK_LENGTH 2
  121. #define CC1K_LOCK_INSTANT 1
  122. #define CC1K_LOCK_CONTINUOUS 0
  123. // CAL Register Bit Positions
  124. #define CC1K_CAL_START 7
  125. #define CC1K_CAL_DUAL 6
  126. #define CC1K_CAL_WAIT 5
  127. #define CC1K_CAL_CURRENT 4
  128. #define CC1K_CAL_COMPLETE 3
  129. #define CC1K_CAL_ITERATE 0
  130. // MODEM2 Register Bit Positions
  131. #define CC1K_PEAKDETECT 7
  132. #define CC1K_PEAK_LEVEL_OFFSET 0
  133. // MODEM1 Register Bit Positions
  134. #define CC1K_MLIMIT 5
  135. #define CC1K_LOCK_AVG_IN 4
  136. #define CC1K_LOCK_AVG_MODE 3
  137. #define CC1K_SETTLING 1
  138. #define CC1K_MODEM_RESET_N 0
  139. // MODEM0 Register Bit Positions
  140. #define CC1K_BAUDRATE 4
  141. #define CC1K_DATA_FORMAT 2
  142. #define CC1K_XOSC_FREQ 0
  143. // MATCH Register Bit Positions
  144. #define CC1K_RX_MATCH 4
  145. #define CC1K_TX_MATCH 0
  146. // FSCTLR Register Bit Positions
  147. #define CC1K_DITHER1 3
  148. #define CC1K_DITHER0 2
  149. #define CC1K_SHAPE 1
  150. #define CC1K_FS_RESET_N 0
  151. // PRESCALER Register Bit Positions
  152. #define CC1K_PRE_SWING 6
  153. #define CC1K_PRE_CURRENT 4
  154. #define CC1K_IF_INPUT 3
  155. #define CC1K_IF_FRONT 2
  156. // TEST6 Register Bit Positions
  157. #define CC1K_LOOPFILTER_TP1 7
  158. #define CC1K_LOOPFILTER_TP2 6
  159. #define CC1K_CHP_OVERRIDE 5
  160. #define CC1K_CHP_CO 0
  161. // TEST5 Register Bit Positions
  162. #define CC1K_CHP_DISABLE 5
  163. #define CC1K_VCO_OVERRIDE 4
  164. #define CC1K_VCO_AO 0
  165. // TEST3 Register Bit Positions
  166. #define CC1K_BREAK_LOOP 4
  167. #define CC1K_CAL_DAC_OPEN 0
  168. /* 
  169.  * CC1K Register Parameters Table
  170.  *
  171.  * This table follows the same format order as the CC1K register 
  172.  * set EXCEPT for the last entry in the table which is the 
  173.  * CURRENT register value for TX mode.
  174.  *  
  175.  * NOTE: To save RAM space, this table resides in program memory (flash). 
  176.  * This has two important implications:
  177.  * 1) You can't write to it (duh!)
  178.  * 2) You must read it using the PRG_RDB(addr) macro. IT CANNOT BE ACCESSED AS AN ORDINARY C ARRAY.  
  179.  * 
  180.  * Add/remove individual entries below to suit your RF tastes.
  181.  * 
  182.  */
  183. #define CC1K_433_002_MHZ 0x00
  184. #define CC1K_915_998_MHZ 0x01
  185. #define CC1K_434_845_MHZ        0x02
  186. #define CC1K_914_077_MHZ        0x03
  187. #define CC1K_315_178_MHZ        0x04
  188. #ifdef CC1K_DEFAULT_FREQ
  189. #define CC1K_DEF_PRESET (CC1K_DEFAULT_FREQ)
  190. #endif
  191. #ifdef CC1K_MANUAL_FREQ
  192. #define CC1K_DEF_FREQ (CC1K_MANUAL_FREQ)
  193. #endif
  194. #ifndef CC1K_DEF_PRESET
  195. #define CC1K_DEF_PRESET (CC1K_433_002_MHZ)
  196. #endif 
  197. //#define CC1K_SquelchInit        0x02F8 // 0.90V using the bandgap reference
  198. #define CC1K_SquelchInit        0x120
  199. #define CC1K_SquelchTableSize   9     
  200. #define CC1K_MaxRSSISamples     5
  201. #define CC1K_Settling           1
  202. #define CC1K_ValidPrecursor     2
  203. #define CC1K_SquelchIntervalFast 128
  204. #define CC1K_SquelchIntervalSlow 2560
  205. #define CC1K_SquelchCount       30
  206. #define CC1K_SquelchBuffer      16
  207. #define CC1K_LPL_STATES         9
  208. #define CC1K_LPL_PACKET_TIME    16
  209. typedef struct syncMsgType{
  210.   uint16_t mticks;
  211.   uint16_t sticks;
  212.   uint8_t trust;
  213.   uint16_t sender;
  214. } syncMsgType;
  215. static const prog_uchar CC1K_LPL_PreambleLength[CC1K_LPL_STATES*2] = {
  216.     0, 6,       // Always on, 6 byte preamble
  217.     0x0, 48,    // 10ms check interval
  218.     0x0, 60,    // 25ms 
  219.     0x0, 144,   // 50ms 
  220.     0x1, 0x0f,  // 100ms
  221.     0x1, 0xf8,  // 200ms
  222.     0x3, 0xd9,  // 400ms
  223.     0x7, 0x9b,  // 800ms
  224.     0xf, 0x06,  // 1600ms
  225. };
  226. static const prog_uchar CC1K_LPL_SleepTime[CC1K_LPL_STATES*2] = {
  227.     0, 0,       //0
  228.     0x0, 10,    // 10ms
  229.     0x0, 25,    // 25ms
  230.     0x0, 50,    // 50ms
  231.     0x0, 100,   // 100ms
  232.     0x0, 200,   // 200ms
  233.     0x1, 0x90,  // 400ms
  234.     0x3, 0x20,  // 800ms
  235.     0x6, 0x40,  // 1600ms
  236. };
  237. static const prog_uchar CC1K_LPL_SleepPreamble[CC1K_LPL_STATES] = {
  238.     0, 
  239.     8,
  240.     8,
  241.     8, 
  242.     8,
  243.     8,
  244.     8,
  245.     8
  246. };
  247. static const prog_uchar CC1K_Params[6][31] = {
  248.   // (0) 433.002 MHz channel, 19.2 Kbps data, Manchester Encoding, High Side LO
  249.   { // MAIN   0x00
  250.     0x31,
  251.     // FREQ2A,FREQ1A,FREQ0A  0x01-0x03
  252.     0x58,0x00,0x00,
  253.     // FREQ2B,FREQ1B,FREQ0B  0x04-0x06
  254.     0x57,0xf6,0x85,    //XBOW
  255.     // FSEP1, FSEP0     0x07-0x08
  256.     0X03,0x55,
  257.     // CURRENT (RX MODE VALUE)   0x09 (also see below)
  258.     ((4<<CC1K_VCO_CURRENT) | (1<<CC1K_LO_DRIVE)),
  259.     // FRONT_END  0x0a
  260.     ((1<<CC1K_IF_RSSI)),
  261.     // PA_POW  0x0b
  262.     ((0x0<<CC1K_PA_HIGHPOWER) | (0xf<<CC1K_PA_LOWPOWER)), 
  263.     // PLL  0x0c
  264.     ((12<<CC1K_REFDIV)),
  265.     // LOCK  0x0d
  266.     ((0xe<<CC1K_LOCK_SELECT)),
  267.     // CAL  0x0e
  268.     ((1<<CC1K_CAL_WAIT) | (6<<CC1K_CAL_ITERATE)),
  269.     // MODEM2  0x0f
  270.     ((0<<CC1K_PEAKDETECT) | (28<<CC1K_PEAK_LEVEL_OFFSET)),
  271.     // MODEM1  0x10
  272.     ((3<<CC1K_MLIMIT) | (1<<CC1K_LOCK_AVG_MODE) | (CC1K_Settling<<CC1K_SETTLING) | (1<<CC1K_MODEM_RESET_N)), 
  273.     // MODEM0  0x11
  274.     ((5<<CC1K_BAUDRATE) | (1<<CC1K_DATA_FORMAT) | (1<<CC1K_XOSC_FREQ)),
  275.     // MATCH  0x12
  276.     ((0x7<<CC1K_RX_MATCH) | (0x0<<CC1K_TX_MATCH)),
  277.     // FSCTRL 0x13
  278.     ((1<<CC1K_FS_RESET_N)),
  279.     // FSHAPE7 - FSHAPE1   0x14-0x1a
  280.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  281.     // FSDELAY   0x1b
  282.     0x00,
  283.     // PRESCALER    0x1c
  284.     0x00,
  285.     // CURRENT (TX MODE VALUE)  0x1d
  286.     ((8<<CC1K_VCO_CURRENT) | (1<<CC1K_PA_DRIVE)),
  287.     // High side LO  0x1e (i.e. do we need to invert the data?)
  288.     TRUE
  289.   },
  290.   // (1) 915.9988 MHz channel, 19.2 Kbps data, Manchester Encoding, High Side LO
  291.   { // MAIN   0x00 
  292.     0x31,
  293.     // FREQ2A,FREQ1A,FREQ0A  0x01-0x03
  294.     0x7c,0x00,0x00,
  295.     // FREQ2B,FREQ1B,FREQ0B  0x04-0x06
  296.     0x7b,0xf9,0xae,
  297.     // FSEP1, FSEP0     0x07-0x8
  298.     0x02,0x38,
  299.     // CURRENT (RX MODE VALUE)   0x09 (also see below)
  300.     ((8<<CC1K_VCO_CURRENT) | (3<<CC1K_LO_DRIVE)),
  301.     //0x8C,
  302.     // FRONT_END  0x0a
  303.     ((1<<CC1K_BUF_CURRENT) | (2<<CC1K_LNA_CURRENT) | (1<<CC1K_IF_RSSI)),
  304.     //0x32,
  305.     // PA_POW  0x0b
  306.     ((0x8<<CC1K_PA_HIGHPOWER) | (0x0<<CC1K_PA_LOWPOWER)), 
  307.     //0xff,
  308.     // PLL  0xc
  309.     ((8<<CC1K_REFDIV)),
  310.     //0x40,
  311.     // LOCK  0xd
  312.     ((0x1<<CC1K_LOCK_SELECT)),
  313.     //0x10,
  314.     // CAL  0xe
  315.     ((1<<CC1K_CAL_WAIT) | (6<<CC1K_CAL_ITERATE)),
  316.     //0x26,
  317.     // MODEM2  0xf
  318.     ((1<<CC1K_PEAKDETECT) | (33<<CC1K_PEAK_LEVEL_OFFSET)),
  319.     //0xA1,
  320.     // MODEM1  0x10
  321.     ((3<<CC1K_MLIMIT) | (1<<CC1K_LOCK_AVG_MODE) | (CC1K_Settling<<CC1K_SETTLING) | (1<<CC1K_MODEM_RESET_N)), 
  322.     //0x6f, 
  323.     // MODEM0  0x11
  324.     ((5<<CC1K_BAUDRATE) | (1<<CC1K_DATA_FORMAT) | (1<<CC1K_XOSC_FREQ)),
  325.     //0x55,
  326.     // MATCH 0x12
  327.     ((0x1<<CC1K_RX_MATCH) | (0x0<<CC1K_TX_MATCH)),
  328.     //0x10,
  329.     // FSCTRL  0x13
  330.     ((1<<CC1K_FS_RESET_N)),
  331.     //0x01,
  332.     // FSHAPE7 - FSHAPE1   0x14..0x1a
  333.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  334.     // FSDELAY   0x1b
  335.     0x00,
  336.     // PRESCALER    0x1c
  337.     0x00,
  338.     // CURRENT (TX MODE VALUE)  0x1d
  339.     ((15<<CC1K_VCO_CURRENT) | (3<<CC1K_PA_DRIVE)),
  340.     //0xf3,
  341.     // High side LO  0x1e (i.e. do we need to invert the data?)
  342.     TRUE
  343.   },
  344.   // (2) 434.845200 MHz channel, 19.2 Kbps data, Manchester Encoding, High Side LO
  345.   { // MAIN   0x00
  346.     0x31,
  347.     // FREQ2A,FREQ1A,FREQ0A  0x01-0x03
  348.     0x51,0x00,0x00,
  349.     // FREQ2B,FREQ1B,FREQ0B  0x04-0x06
  350.     0x50,0xf7,0x4F,    //XBOW
  351.     // FSEP1, FSEP0     0x07-0x08
  352.     0X03,0x0E,
  353.     // CURRENT (RX MODE VALUE)   0x09 (also see below)
  354.     ((4<<CC1K_VCO_CURRENT) | (1<<CC1K_LO_DRIVE)),
  355.     // FRONT_END  0x0a
  356.     ((1<<CC1K_IF_RSSI)),
  357.     // PA_POW  0x0b
  358.     ((0x0<<CC1K_PA_HIGHPOWER) | (0xf<<CC1K_PA_LOWPOWER)), 
  359.     // PLL  0x0c
  360.     ((11<<CC1K_REFDIV)),
  361.     // LOCK  0x0d
  362.     ((0xe<<CC1K_LOCK_SELECT)),
  363.     // CAL  0x0e
  364.     ((1<<CC1K_CAL_WAIT) | (6<<CC1K_CAL_ITERATE)),
  365.     // MODEM2  0x0f
  366.     ((1<<CC1K_PEAKDETECT) | (33<<CC1K_PEAK_LEVEL_OFFSET)),
  367.     // MODEM1  0x10
  368.     ((3<<CC1K_MLIMIT) | (1<<CC1K_LOCK_AVG_MODE) | (CC1K_Settling<<CC1K_SETTLING) | (1<<CC1K_MODEM_RESET_N)), 
  369.     // MODEM0  0x11
  370.     ((5<<CC1K_BAUDRATE) | (1<<CC1K_DATA_FORMAT) | (1<<CC1K_XOSC_FREQ)),
  371.     // MATCH  0x12
  372.     ((0x7<<CC1K_RX_MATCH) | (0x0<<CC1K_TX_MATCH)),
  373.     // FSCTRL 0x13
  374.     ((1<<CC1K_FS_RESET_N)),
  375.     // FSHAPE7 - FSHAPE1   0x14-0x1a
  376.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  377.     // FSDELAY   0x1b
  378.     0x00,
  379.     // PRESCALER    0x1c
  380.     0x00,
  381.     // CURRENT (TX MODE VALUE)  0x1d
  382.     ((8<<CC1K_VCO_CURRENT) | (1<<CC1K_PA_DRIVE)),
  383.     // High side LO  0x1e (i.e. do we need to invert the data?)
  384.     TRUE
  385.   },
  386.  
  387.   // (3) 914.077 MHz channel, 19.2 Kbps data, Manchester Encoding, High Side LO
  388.   { // MAIN   0x00 
  389.     0x31,
  390.     // FREQ2A,FREQ1A,FREQ0A  0x01-0x03
  391.     0x5c,0xe0,0x00,
  392.     // FREQ2B,FREQ1B,FREQ0B  0x04-0x06
  393.     0x5c,0xdb,0x42,
  394.     // FSEP1, FSEP0     0x07-0x8
  395.     0x01,0xAA,
  396.     // CURRENT (RX MODE VALUE)   0x09 (also see below)
  397.     ((8<<CC1K_VCO_CURRENT) | (3<<CC1K_LO_DRIVE)),
  398.     //0x8C,
  399.     // FRONT_END  0x0a
  400.     ((1<<CC1K_BUF_CURRENT) | (2<<CC1K_LNA_CURRENT) | (1<<CC1K_IF_RSSI)),
  401.     //0x32,
  402.     // PA_POW  0x0b
  403.     ((0x8<<CC1K_PA_HIGHPOWER) | (0x0<<CC1K_PA_LOWPOWER)), 
  404.     //0xff,
  405.     // PLL  0xc
  406.     ((6<<CC1K_REFDIV)),
  407.     //0x40,
  408.     // LOCK  0xd
  409.     ((0x1<<CC1K_LOCK_SELECT)),
  410.     //0x10,
  411.     // CAL  0xe
  412.     ((1<<CC1K_CAL_WAIT) | (6<<CC1K_CAL_ITERATE)),
  413.     //0x26,
  414.     // MODEM2  0xf
  415.     ((1<<CC1K_PEAKDETECT) | (33<<CC1K_PEAK_LEVEL_OFFSET)),
  416.     //0xA1,
  417.     // MODEM1  0x10
  418.     ((3<<CC1K_MLIMIT) | (1<<CC1K_LOCK_AVG_MODE) | (CC1K_Settling<<CC1K_SETTLING) | (1<<CC1K_MODEM_RESET_N)), 
  419.     //0x6f, 
  420.     // MODEM0  0x11
  421.     ((5<<CC1K_BAUDRATE) | (1<<CC1K_DATA_FORMAT) | (1<<CC1K_XOSC_FREQ)),
  422.     //0x55,
  423.     // MATCH 0x12
  424.     ((0x1<<CC1K_RX_MATCH) | (0x0<<CC1K_TX_MATCH)),
  425.     //0x10,
  426.     // FSCTRL  0x13
  427.     ((1<<CC1K_FS_RESET_N)),
  428.     //0x01,
  429.     // FSHAPE7 - FSHAPE1   0x14..0x1a
  430.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  431.     // FSDELAY   0x1b
  432.     0x00,
  433.     // PRESCALER    0x1c
  434.     0x00,
  435.     // CURRENT (TX MODE VALUE)  0x1d
  436.     ((15<<CC1K_VCO_CURRENT) | (3<<CC1K_PA_DRIVE)),
  437.     //0xf3,
  438.     // High side LO  0x1e (i.e. do we need to invert the data?)
  439.     TRUE 
  440.   },
  441.   // (4) 315.178985 MHz channel, 38.4 Kbps data, Manchester Encoding, High Side LO
  442.   { // MAIN   0x00
  443.     0x31,
  444.     // FREQ2A,FREQ1A,FREQ0A  0x01-0x03
  445.     0x45,0x60,0x00,
  446.     // FREQ2B,FREQ1B,FREQ0B  0x04-0x06
  447.     0x45,0x55,0xBB,
  448.     // FSEP1, FSEP0     0x07-0x08
  449.     0X03,0x9C,
  450.     // CURRENT (RX MODE VALUE)   0x09 (also see below)
  451.     ((8<<CC1K_VCO_CURRENT) | (0<<CC1K_LO_DRIVE)),
  452.     // FRONT_END  0x0a
  453.     ((1<<CC1K_IF_RSSI)),
  454.     // PA_POW  0x0b
  455.     ((0x0<<CC1K_PA_HIGHPOWER) | (0xf<<CC1K_PA_LOWPOWER)), 
  456.     // PLL  0x0c
  457.     ((13<<CC1K_REFDIV)),
  458.     // LOCK  0x0d
  459.     ((0xe<<CC1K_LOCK_SELECT)),
  460.     // CAL  0x0e
  461.     ((1<<CC1K_CAL_WAIT) | (6<<CC1K_CAL_ITERATE)),
  462.     // MODEM2  0x0f
  463.     ((1<<CC1K_PEAKDETECT) | (33<<CC1K_PEAK_LEVEL_OFFSET)),
  464.     // MODEM1  0x10
  465.     ((3<<CC1K_MLIMIT) | (1<<CC1K_LOCK_AVG_MODE) | (CC1K_Settling<<CC1K_SETTLING) | (1<<CC1K_MODEM_RESET_N)), 
  466.     // MODEM0  0x11
  467.     ((5<<CC1K_BAUDRATE) | (1<<CC1K_DATA_FORMAT) | (0<<CC1K_XOSC_FREQ)),
  468.     // MATCH  0x12
  469.     ((0x7<<CC1K_RX_MATCH) | (0x0<<CC1K_TX_MATCH)),
  470.     // FSCTRL 0x13
  471.     ((1<<CC1K_FS_RESET_N)),
  472.     // FSHAPE7 - FSHAPE1   0x14-0x1a
  473.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  474.     // FSDELAY   0x1b
  475.     0x00,
  476.     // PRESCALER    0x1c
  477.     0x00,
  478.     // CURRENT (TX MODE VALUE)  0x1d
  479.     ((8<<CC1K_VCO_CURRENT) | (1<<CC1K_PA_DRIVE)),
  480.     // High side LO  0x1e (i.e. do we need to invert the data?)
  481.     TRUE
  482.   },
  483.   // (5) Spare
  484.   { // MAIN   0x00
  485.     0x31,
  486.     // FREQ2A,FREQ1A,FREQ0A  0x01-0x03
  487.     0x58,0x00,0x00,
  488.     // FREQ2B,FREQ1B,FREQ0B  0x04-0x06
  489.     0x57,0xf6,0x85,    //XBOW
  490.     // FSEP1, FSEP0     0x07-0x08
  491.     0X03,0x55,
  492.     // CURRENT (RX MODE VALUE)   0x09 (also see below)
  493.     ((8<<CC1K_VCO_CURRENT) | (4<<CC1K_LO_DRIVE)),
  494.     // FRONT_END  0x0a
  495.     ((1<<CC1K_IF_RSSI)),
  496.     // PA_POW  0x0b
  497.     ((0x0<<CC1K_PA_HIGHPOWER) | (0xf<<CC1K_PA_LOWPOWER)), 
  498.     // PLL  0x0c
  499.     ((12<<CC1K_REFDIV)),
  500.     // LOCK  0x0d
  501.     ((0xe<<CC1K_LOCK_SELECT)),
  502.     // CAL  0x0e
  503.     ((1<<CC1K_CAL_WAIT) | (6<<CC1K_CAL_ITERATE)),
  504.     // MODEM2  0x0f
  505.     ((1<<CC1K_PEAKDETECT) | (33<<CC1K_PEAK_LEVEL_OFFSET)),
  506.     // MODEM1  0x10
  507.     ((3<<CC1K_MLIMIT) | (1<<CC1K_LOCK_AVG_MODE) | (CC1K_Settling<<CC1K_SETTLING) | (1<<CC1K_MODEM_RESET_N)),    // MODEM0  0x11
  508.     ((5<<CC1K_BAUDRATE) | (1<<CC1K_DATA_FORMAT) | (1<<CC1K_XOSC_FREQ)),
  509.     // MATCH  0x12
  510.     ((0x7<<CC1K_RX_MATCH) | (0x0<<CC1K_TX_MATCH)),
  511.     // FSCTRL 0x13
  512.     ((1<<CC1K_FS_RESET_N)),
  513.     // FSHAPE7 - FSHAPE1   0x14-0x1a
  514.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  515.     // FSDELAY   0x1b
  516.     0x00,
  517.     // PRESCALER    0x1c
  518.     0x00,
  519.     // CURRENT (TX MODE VALUE)  0x1d
  520.     ((8<<CC1K_VCO_CURRENT) | (1<<CC1K_PA_DRIVE)),
  521.     // High side LO  0x1e (i.e. do we need to invert the data?)
  522.     TRUE
  523.   },
  524. };
  525. #endif /* _CC1KCONST_H */