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

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

网络

开发平台：

Others

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