si4438 cca 侦听

/* set GPIO0 for RSSI interrupt / CCA */
txbuf[0] = CMD_GPIO_PIN_CFG;
txbuf[1] = 27; /* GPIO[0] = 27: CCA or 37: CCA_LATCH */
txbuf[2] = 0; /* GPIO[1] = DONOTHING */
txbuf[3] = 0; /* GPIO[2] = DONOTHING */
txbuf[4] = 0; /* GPIO[3] = DONOTHING */
txbuf[5] = 0; /* NIRQ = behavior not modified */
txbuf[6] = 0; /* SDO = behavior not modified*/
txbuf[7] = 0; /* GEN_CONFIG = GPIO outputs will have the highest drive strength*/
si446x_SendCommand(8, txbuf);
si446x_WaitForCTS();

/* set RSSI threshold */
txbuf[0] = CMD_SET_PROPERTY;
txbuf[1] = PROP_MODEM_GROUP;
txbuf[2] = 0x03; /* num of property */
txbuf[3] = PROP_MODEM_RSSI_THRESH;/* start address */
txbuf[4] = 30; /* MODEM_RSSI_THRESH: if < 30, CCA GPIO0 becomes low */
txbuf[5] = 0x0c; /* MODEM_RSSI_JUMP_THRESH: default */
txbuf[6] = 0x22; /* MODEM_RSSI_CONTROL: check thresh after latch, latch RSSI when sync word is detected */
si446x_SendCommand(5, txbuf);
si446x_WaitForCTS();

1. #include <reg51.h>
2. #include <string.h>
3. #include "radio.h"
4. #include"spi.h"
5. #include"uart.h"
6. #define  U8 unsigned char
7. #define SEND_OUT_MESSAGE_WITH_ACK      "NEED_ACK"
8. #define SEND_OUT_MESSAGE_NO_ACK        "NO_ACK"
9. #define SEND_OUT_ACK                   "ACK!"
10. #define SEND_OUT_MESSAGE_WITH_ACK_LEN   8
11. #define SEND_OUT_MESSAGE_NO_ACK_LEN     6
12. #define SEND_OUT_ACK_LEN                4
13. #define SNED_OUT_MSG_MAX_LEN            8       //It is the maxium length of the send out packet.
14. extern idata U8 ItStatus1,ItStatus2;
15. void delay_ms(unsigned int ms)
16. {
17. unsigned int i;
18. unsigned char j;
19. for(i=0;i<ms;i++)
20. {
21. for(j=0;j<200;j++);
22. for(j=0;j<102;j++);
23. }
24. }
25. void Init_Device(void)
26. {
27. //   Reset_Sources_Init();
28. //   PCA_Init();
29. //  Port_IO_Init();   // Oscillator_Init();
30. // Timer0_Init();
31. SPI_Init();
32. EA = 1; //Enable Gloable interruption.
33. //启动射频模块，模块的SDN引脚拉低后必须延时至少30ms，实际上可以直接把SDN引脚接地，这样就不用在程序中初始化了；
34. RF_SDN=0;
35. delay_ms(30);
36. delay_ms(30);
37. //        RF_SDN = 0;
38. //        DelayMs(30);
39. //        NSEL = 1;
40. //        SCLK = 0;
41. SpiWriteRegister(0x0B, 0xCA);
42. SpiWriteRegister(0x0C, 0xCA);
43. SpiWriteRegister(0x0D, 0xCA);
44. //1.Blink the LED to show that the initialization is finished.
45. //2.Wait for more than 16ms to wait for the radio chip to work correctly.
46. //        TurnOnAllLEDs();
47. //        DelayMs(20);
48. delay_ms(20);
49. //        TurnOffAllLEDs();
50. }
51. void main(void)
52. {
53. U8 length,temp8, *str, sendLen;
54. U8 payload[10];
55. //Initialize the MCU:
56. UART_Init();
57. Init_Device();
58. UART_Send_Str("MCU初始化完毕....\n");
59. //读取中断状态寄存器清除中断标志以便释放NIRQ引脚
60. //如果中断来了，那么NIRQ引脚会被拉低；如果这时候中断状态寄存器0x03和0x04被读取，那么NIRQ引脚会被释放恢复高电平
61. ItStatus1 = SpiReadRegister(0x03);                                                                                                        //read the Interrupt Status1 register
62. ItStatus2 = SpiReadRegister(0x04);                                                                                                        //read the Interrupt Status2 register
63. //SW reset，软件复位这个模块主控芯片
64. SpiWriteRegister(0x07, 0x80);                                                                                                                //write 0x80 to the Operating & Function Control1 register
65. //        DelayMs(20);
66. delay_ms(20);
67. delay_ms(20);
68. //wait for POR interrupt from the radio (while the nIRQ pin is high)
69. //wait for chip ready interrupt from the radio (while the nIRQ pin is high)
70. //等待软复位完成，当软复位完成后有中断发生。客户也可以在这里直接延时至少20ms而不用等待中断来；等待至少20ms后复位完成，这时候必须读中断状态寄存器释放中断引脚
71. while ( NIRQ == 1);
72. //read interrupt status registers to clear the interrupt flags and release NIRQ pin
73. ItStatus1 = SpiReadRegister(0x03);                                                                                                        //read the Interrupt Status1 register
74. ItStatus2 = SpiReadRegister(0x04);                                                                                                        //read the Interrupt Status2 register
75. //根据不同的射频参数初始化射频模块；
76. RF_init();
77. UART_Send_Str("RF芯片si4432初始化完毕....\n");
78. //Enable two interrupts:
79. // a) one which shows that a valid packet received: 'ipkval'
80. // b) second shows if the packet received with incorrect CRC: 'icrcerror'
81. //设置中断使能寄存器，这里设置为只有当有效的数据包被接收或者接收到的数据包数据CRC校验出错才来中断；具体设置参考0x05和0x06寄存器
82. SpiWriteRegister(0x05, 0x03);                                                                                                                        //write 0x03 to the Interrupt Enable 1 register
83. SpiWriteRegister(0x06, 0x00);                                                                                                                        //write 0x00 to the Interrupt Enable 2 register
84. //output dummy data.
85. PB1_TX = 1;
86. PB2_TX = 1;
87. str = SEND_OUT_MESSAGE_WITH_ACK;
88. sendLen = SEND_OUT_MESSAGE_WITH_ACK_LEN;
89. //设置模块处于接收状态，当没有按键按下的时候一直处于接收状态，等待接收数据
90. RFSetRxMode();
91. UART_Send_Str("模块处于接收状态....\n");
92. /*MAIN Loop*/
93. while(1)
94. {
95. //当按键被按下就有一个数据包被发出；
96. if(PB1_TX == 0)
97. {
98. while( PB1_TX == 0 );
99. UART_Send_Str("按键按下,开始发送....\n");
100. RFFIFOSendData(sendLen, str);
101. //after packet transmission set the interrupt enable bits according receiving mode
102. //Enable two interrupts:
103. // a) one which shows that a valid packet received: 'ipkval'
104. // b) second shows if the packet received with incorrect CRC: 'icrcerror'
105. //设置中断使能寄存器，这里设置为只有当有效的数据包被接收或者接收到的数据包数据CRC校验出错才来中断；具体设置参考0x05和0x06寄存器
106. SpiWriteRegister(0x05, 0x03);                                                                                                 //write 0x03 to the Interrupt Enable 1 register
107. SpiWriteRegister(0x06, 0x00);                                                                                                 //write 0x00 to the Interrupt Enable 2 register
108. //发射完毕后设置模块让它又工作在接收状态下；
109. RFSetRxMode();
110. UART_Send_Str("发送完毕，恢复到接收状态....\n");
111. }
112. //check whether interrupt occured
113. //查询中断是否到来，如果中断来了，根据我们前面中断使能寄存器的设置，说明有效数据包已经收到，或者收到的数据包CRC校验出错；
114. //如果客户采用中断触发的方式，那么服务程序必须包括这些内容。在中断服务程序中必须判断被使能的那些中断的状态位是否被置位，然后根据不同的
115. //状态位进行处理
116. if( NIRQ == 0 )
117. {
118. //设置模块处于空闲模式，处理收到的数据包，不继续接收数据
119. RFSetIdleMode();
120. UART_Send_Str("中断来了....\n");
121. /*CRC Error interrupt occured*/
122. //判断是否由于CRC校验出错引发的中断；在RFSetIdleMode中已经读出了中断状态寄存器的值
123. if( (ItStatus1 & 0x01) == 0x01 )
124. {
125. //reset the RX FIFO
126. //如果是CRC校验出错，那么接收FIFO复位；
127. SpiWriteRegister(0x08, 0x02);                                                                                                //write 0x02 to the Operating Function Control 2 register
128. SpiWriteRegister(0x08, 0x00);                                                                                                //write 0x00 to the Operating Function Control 2 register
129. //blink all LEDs to show the error
130. //闪灯提示，客户移植代码的时候这个闪灯操作根据不同客户不同操作
131. //        TurnOnAllLEDs();
132. //        DelayMs(2);
133. UART_Send_Str("CRC校验出错中断....\n");
134. //        TurnOffAllLEDs();
135. }
136. /*packet received interrupt occured*/
137. //判断是否是数据包已经被正确接收。
138. if( (ItStatus1 & 0x02) == 0x02 )
139. {
140. //Read the length of the received payload
141. //数据包已经被正确接收，读取收到的数据包长度
142. length = SpiReadRegister(0x4B);                                                                                        //read the Received Packet Length register
143. //根据长度判断相应的操作。客户可以不做这些，而直接从FIFO读出收到的数据；
144. //check whether the received payload is not longer than the allocated buffer in the MCU
145. if(length <= SNED_OUT_MSG_MAX_LEN)
146. {
147. //Get the reeived payload from the RX FIFO
148. //直接从FIFO中读取收到的数据。客户只要读出FIFO的数据就算收到数据。
149. for(temp8=0;temp8 < length;temp8++)
150. {
151. payload[temp8] = SpiReadRegister(0x7F);                                                //read the FIFO Access register
152. }
153. for(temp8=0;temp8 < length;temp8++)
154. {
155. UART_Send_Byte(payload[temp8]);        //向串口发送接收到的数据
156. }
157. UART_Send_Str("向串口发送接收到的数据....\n");
158. //check whether the acknowledgement packet received
159. //判断是否是预先设定的数据；一般应用情况客户可以不理会这个，这个判断只是我们demo板的应用。客户只要读出FIFO的数据就算收到数据；
160. if(( length == SEND_OUT_ACK_LEN ) || (length == SEND_OUT_MESSAGE_NO_ACK_LEN))
161. {
162. if((memcmp(&payload[0], SEND_OUT_ACK, SEND_OUT_ACK_LEN - 1) == 0 )
163. || (memcmp(&payload[0], SEND_OUT_MESSAGE_NO_ACK, SEND_OUT_MESSAGE_NO_ACK_LEN - 1) == 0))
164. {
165. //blink LED2 to show that ACK received
166. //        RxLEDOn();
167. //Show the Rx LED for about 10ms
168. UART_Send_Str("数据包已经被正确接收....\n");
169. //        DelayMs(2);
170. //        TurnOffAllLEDs();
171. }
172. }
173. //check whether an expected packet received, this should be acknowledged
174. //判断是否是需要发送回答信号的数据包。这个只是根据收到的数据做的不同操作，在客户那里可能是根据收到的数据做的特定的操作，例如控制某个开关
175. if( length == SEND_OUT_MESSAGE_WITH_ACK_LEN )
176. {
177. //必须发送应答信号，启动发送
178. if( memcmp(&payload[0], SEND_OUT_MESSAGE_WITH_ACK, SEND_OUT_MESSAGE_WITH_ACK_LEN - 1) == 0 )
179. {
180. //blink LED2 to show that the packet received
181. //RxLEDOn();
182. //Show the Rx LED for about 10ms
183. //        DelayMs(2);
184. UART_Send_Str("发送应答....\n");
185. //        TurnOffAllLEDs();
186. //发送应答信号。
187. /*send back an acknowledgement*/
188. RFFIFOSendData(SEND_OUT_ACK_LEN, SEND_OUT_ACK);
189. //after packet transmission set the interrupt enable bits according receiving mode
190. //Enable two interrupts:
191. // a) one which shows that a valid packet received: 'ipkval'
192. // b) second shows if the packet received with incorrect CRC: 'icrcerror'
193. SpiWriteRegister(0x05, 0x03);                                                                 //write 0x03 to the Interrupt Enable 1 register
194. SpiWriteRegister(0x06, 0x00);                                                                 //write 0x00 to the Interrupt Enable 2 register
195. //read interrupt status registers to release all pending interrupts
196. ItStatus1 = SpiReadRegister(0x03);                                                        //read the Interrupt Status1 register
197. ItStatus2 = SpiReadRegister(0x04);                                                        //read the Interrupt Status2 register
198. }
199. }
200. }
201. }
202. //reset the RX FIFO
203. SpiWriteRegister(0x08, 0x02);                                                                                                        //write 0x02 to the Operating Function Control 2 register
204. SpiWriteRegister(0x08, 0x00);                                                                                                        //write 0x00 to the Operating Function Control 2 register
205. RFSetRxMode();
206. }
207. }
208. }</pre>
209. <p>
210. </p>
211. <br>
212. <p>
213. <br>
214. </p>

 

 

jackwang

院士

2013-12-25 20:51:19    评分

2楼

没有使用贴代码功能？

评论

 

Snake0301

高工

2013-12-25 22:06:48    评分

3楼

修饰一下，帅多了、

评论

 

禅子

菜鸟

2013-12-27 11:44:02    评分

4楼

4432应该是兼容的吧？ Si4438与Si446x收发器产品引脚兼容以及软件兼容哦（是针对全球部署智能电表和智能电网产品而设计的sub-GHz ISM频段产品）。

评论

 

lili路亚

菜鸟

2014-01-02 14:34:25    评分

5楼

多谢版主帮修饰，确实好看多了！

回LS的： 并不完全兼容，下面是我请世强的杨工提供的采用Si4438的部分代码，大家可以参考下，完整的代码可以找深圳世强的FAE杨工要。大家可以对比研究下。

1. #include "compiler_defs.h"
2. #include "c8051f960_defs.h"
3. #include "hardware_defs.h"
4. #include "control_IO.h"
5. #include "spi.h"
6. #include "Si446x_B0_defs.h"
7. #include "ezrp_next_api.h"
8. #include "modem_params.h"
9. // Define capacitor bank value
10. #define CAP_BANK_VALUE    0x48    // Capacitor bank value for adjusting the XTAL frequency
11. // Note that it may varies on different test cards
12. /*------------------------------------------------------------------------*/
13. /*            GLOBAL variables                        */
14. /*------------------------------------------------------------------------*/
15. // Set up modem parameters database; data is retrieved from modem_params.h header file which is
16. // automatically generated by the WDS (Wireless Development Suite)
17. SEG_CODE U8 ModemTrx1[] = {7, MODEM_MOD_TYPE_7};
18. SEG_CODE U8 ModemTrx2[] = {5, MODEM_CLKGEN_BAND_5};
19. SEG_CODE U8 ModemTrx3[] = {11, SYNTH_PFDCP_CPFF_11};
20. SEG_CODE U8 ModemTrx4[] = {12, FREQ_CONTROL_INTE_12};
21. SEG_CODE U8 ModemRx1[] = {11, MODEM_MDM_CTRL_11};
22. SEG_CODE U8 ModemRx2[] = {14, MODEM_BCR_OSR_1_14};
23. SEG_CODE U8 ModemRx3[] = {12, MODEM_AFC_GEAR_12};
24. SEG_CODE U8 ModemRx4[] = {5, MODEM_AGC_CONTRL_5};
25. SEG_CODE U8 ModemRx4_1[] = {7, MODEM_AGC_WINDOW_SIZE_7};
26. SEG_CODE U8 ModemRx5[] = {9, MODEM_FSK4_GAIN1_9};
27. SEG_CODE U8 ModemRx6[] = {8, MODEM_OOK_PDTC_8};
28. SEG_CODE U8 ModemRx7[] = {8, MODEM_RAW_SEARCH_8};
29. SEG_CODE U8 ModemRx8[] = {6, MODEM_ANT_DIV_MODE_6};
30. SEG_CODE U8 ModemRx9[] = {13, MODEM_CHFLT_RX1_CHFLT_COE13_7_0_13};
31. SEG_CODE U8 ModemRx10[] = {13, MODEM_CHFLT_RX1_CHFLT_COE4_7_0_13};
32. SEG_CODE U8 ModemRx11[] = {13, MODEM_CHFLT_RX2_CHFLT_COE13_7_0_13};
33. SEG_CODE U8 ModemRx12[] = {13, MODEM_CHFLT_RX2_CHFLT_COE4_7_0_13};
34. /*------------------------------------------------------------------------*/
35. /*            LOCAL function prototypes                         */
36. /*------------------------------------------------------------------------*/
37. void MCU_Init(void);
38. /*------------------------------------------------------------------------*/
39. /*            MAIN function                             */
40. /*------------------------------------------------------------------------*/
41. void main(void)
42. {
43. SEGMENT_VARIABLE(wDelay, U16, SEG_XDATA);
44. SEGMENT_VARIABLE(bButtonNumber, U8, SEG_XDATA);
45. BIT fValidPacket;
46. //initialize the MCU peripherals
47. MCU_Init();
48. InitIO();
49. // Reset the radio
50. EZRP_PWRDN = 1;
51. // Wait ~300us (SDN pulse width)
52. for(wDelay=0; wDelay<330; wDelay++);
53. // Wake up the chip from SDN
54. EZRP_PWRDN = 0;
55. // Wait for POR (power on reset); ~5ms
56. for(wDelay=0; wDelay<5500; wDelay++);
57. // Start the radio
58. abApi_Write[0] = CMD_POWER_UP;          // Use API command to power up the radio IC
59. abApi_Write[1] = 0x01;              // Write global control registers
60. abApi_Write[2] = 0x00;              // Write global control registers
61. bApi_SendCommand(3,abApi_Write);        // Send command to the radio IC
62. // Wait for boot
63. if (vApi_WaitforCTS())                // Wait for CTS
64. {
65. while (1) {}    // Stop if radio power-up error
66. }
67. // Read ITs, clear pending ones
68. abApi_Write[0] = CMD_GET_INT_STATUS;      // Use interrupt status command
69. abApi_Write[1] = 0;               // Clear PH_CLR_PEND
70. abApi_Write[2] = 0;               // Clear MODEM_CLR_PEND
71. abApi_Write[3] = 0;               // Clear CHIP_CLR_PEND
72. bApi_SendCommand(4,abApi_Write);        // Send command to the radio IC
73. bApi_GetResponse(8, abApi_Read );         // Make sure that CTS is ready then get the response
74. // Set TRX parameters of the radio IC; data retrieved from the WDS-generated modem_params.h header file
75. bApi_SendCommand(ModemTrx1[0],&ModemTrx1[1]);       // Send API command to the radio IC
76. vApi_WaitforCTS();                    // Wait for CTS
77. bApi_SendCommand(ModemTrx2[0],&ModemTrx2[1]);
78. vApi_WaitforCTS();
79. bApi_SendCommand(ModemTrx3[0],&ModemTrx3[1]);
80. vApi_WaitforCTS();
81. bApi_SendCommand(ModemTrx4[0],&ModemTrx4[1]);
82. vApi_WaitforCTS();
83. // Set Rx parameters of the radio IC
84. bApi_SendCommand(ModemRx1[0],&ModemRx1[1]);       // Send API command to the radio IC
85. vApi_WaitforCTS();                    // Wait for CTS
86. bApi_SendCommand(ModemRx2[0],&ModemRx2[1]);
87. vApi_WaitforCTS();
88. bApi_SendCommand(ModemRx3[0],&ModemRx3[1]);
89. vApi_WaitforCTS();
90. bApi_SendCommand(ModemRx4[0],&ModemRx4[1]);
91. vApi_WaitforCTS();
92. bApi_SendCommand(ModemRx4_1[0],&ModemRx4_1[1]);
93. vApi_WaitforCTS();
94. bApi_SendCommand(ModemRx5[0],&ModemRx5[1]);
95. vApi_WaitforCTS();
96. bApi_SendCommand(ModemRx6[0],&ModemRx6[1]);
97. vApi_WaitforCTS();
98. bApi_SendCommand(ModemRx7[0],&ModemRx7[1]);
99. vApi_WaitforCTS();
100. bApi_SendCommand(ModemRx8[0],&ModemRx8[1]);
101. vApi_WaitforCTS();
102. bApi_SendCommand(ModemRx9[0],&ModemRx9[1]);
103. vApi_WaitforCTS();
104. bApi_SendCommand(ModemRx10[0],&ModemRx10[1]);
105. vApi_WaitforCTS();
106. bApi_SendCommand(ModemRx11[0],&ModemRx11[1]);
107. vApi_WaitforCTS();
108. bApi_SendCommand(ModemRx12[0],&ModemRx12[1]);
109. vApi_WaitforCTS();
110. // Enable packet received and CRC error interrupt only
111. abApi_Write[0] = CMD_SET_PROPERTY;      // Use property command
112. abApi_Write[1] = PROP_INT_CTL_GROUP;    // Select property group
113. abApi_Write[2] = 4;               // Number of properties to be written
114. abApi_Write[3] = PROP_INT_CTL_ENABLE;   // Specify property
115. abApi_Write[4] = 0x01;                   // INT_CTL: PH interrupt enabled
116. abApi_Write[5] = 0x18;              // INT_CTL_PH: PH PACKET_RX & CRC2_ERR interrupt enabled
117. abApi_Write[6] = 0x00;              // INT_CTL_MODEM: -
118. abApi_Write[7] = 0x00;              // INT_CTL_CHIP_EN: -
119. bApi_SendCommand(8,abApi_Write);        // Send API command to the radio IC
120. vApi_WaitforCTS();                // Wait for CTS
121. // Configure Fast response registers
122. abApi_Write[0] = CMD_SET_PROPERTY;        // Use property command
123. abApi_Write[1] = PROP_FRR_CTL_GROUP;      // Select property group
124. abApi_Write[2] = 4;               // Number of properties to be written
125. abApi_Write[3] = PROP_FRR_CTL_A_MODE;     // Specify property (1st)
126. abApi_Write[4] = 0x04;              // FRR A: PH IT pending
127. abApi_Write[5] = 0x06;              // FRR B: Modem IT pending
128. abApi_Write[6] = 0x0A;              // FRR C: Latched RSSI
129. abApi_Write[7] = 0x00;              // FRR D: disabled
130. bApi_SendCommand(8,abApi_Write);        // Send API command to the radio IC
131. vApi_WaitforCTS();                // Wait for CTS
132. //Set packet content
133. //Set preamble length
134. abApi_Write[0] = CMD_SET_PROPERTY;        // Use property command
135. abApi_Write[1] = PROP_PREAMBLE_GROUP;     // Select property group
136. abApi_Write[2] = 1;               // Number of properties to be written
137. abApi_Write[3] = PROP_PREAMBLE_CONFIG_STD_1;  // Specify property
138. abApi_Write[4] = 20;              // 20 bits preamble detection threshold
139. bApi_SendCommand(5,abApi_Write);        // Send API command to the radio IC
140. vApi_WaitforCTS();                // Wait for CTS
141. // Set preamble pattern
142. abApi_Write[0] = CMD_SET_PROPERTY;        // Use property command
143. abApi_Write[1] = PROP_PREAMBLE_GROUP;     // Select property group
144. abApi_Write[2] = 1;               // Number of properties to be written
145. abApi_Write[3] = PROP_PREAMBLE_CONFIG;      // Specify property
146. abApi_Write[4] = 0x31;              // Use `1010` pattern, length defined in bytes
147. bApi_SendCommand(5,abApi_Write);        // Send API command to the radio IC
148. vApi_WaitforCTS();                // Wait for CTS
149. // Set sync word
150. abApi_Write[0] = CMD_SET_PROPERTY;        // Use property command
151. abApi_Write[1] = PROP_SYNC_GROUP;       // Select property group
152. abApi_Write[2] = 3;               // Number of properties to be written
153. abApi_Write[3] = PROP_SYNC_CONFIG;        // Specify property
154. abApi_Write[4] = 0x01;              // SYNC_CONFIG: 2 bytes sync word
155. abApi_Write[5] = 0xB4;              // SYNC_BITS_31_24: 1st sync byte: 0x2D; NOTE: LSB transmitted first!
156. abApi_Write[6] = 0x2B;              // SYNC_BITS_23_16: 2nd sync byte: 0xD4; NOTE: LSB transmitted first!
157. bApi_SendCommand(7,abApi_Write);        // Send command to the radio IC
158. vApi_WaitforCTS();                // Wait for CTS
159. // General packet config (set bit order)
160. abApi_Write[0] = CMD_SET_PROPERTY;        // Use property command
161. abApi_Write[1] = PROP_PKT_GROUP;        // Select property group
162. abApi_Write[2] = 1;               // Number of properties to be written
163. abApi_Write[3] = PROP_PKT_CONFIG1;        // Specify property
164. abApi_Write[4] = 0x00;              // Payload data goes MSB first
165. bApi_SendCommand(5,abApi_Write);        // Send command to the radio IC
166. vApi_WaitforCTS();                // Wait for CTS
167. // Set RSSI latch to sync word
168. abApi_Write[0] = CMD_SET_PROPERTY;        // Use property command
169. abApi_Write[1] = PROP_MODEM_GROUP;        // Select property group
170. abApi_Write[2] = 1;               // Number of properties to be written
171. abApi_Write[3] = PROP_MODEM_RSSI_CONTROL;   // Specify property
172. abApi_Write[4] = 0x12;              // RSSI average over 4 bits, latch at sync detect
173. bApi_SendCommand(5,abApi_Write);        // Send API command to the radio IC
174. vApi_WaitforCTS();                // Wait for CTS
175. // Configure the GPIOs
176. abApi_Write[0] = CMD_GPIO_PIN_CFG;        // Use GPIO pin configuration command
177. #ifdef ONE_SMA_WITH_RF_SWITCH
178. // If RF switch is used
179. // Select Tx state to GPIO2, Rx state to GPIO0
180. abApi_Write[1] = 0x21;              // Configure GPIO0 as Rx state
181. abApi_Write[2] = 0x13;              // Configure GPIO1 as Tx data
182. abApi_Write[3] = 0x20;              // Configure GPIO2 as Tx state
183. abApi_Write[4] = 0x10;              // Configure GPIO3 as Tx data CLK
184. #else
185. abApi_Write[1] = 0x10;              // Configure GPIO0 as Tx data CLK
186. abApi_Write[2] = 0x13;              // Configure GPIO1 as Tx data
187. abApi_Write[3] = 0x20;              // Configure GPIO2 as Tx state
188. abApi_Write[4] = 0x21;              // Configure GPIO3 as Rx state
189. #endif
190. bApi_SendCommand(5,abApi_Write);        // Send command to the radio IC
191. vApi_WaitforCTS();
192. // Adjust XTAL clock frequency
193. abApi_Write[0] = CMD_SET_PROPERTY;        // Use property command
194. abApi_Write[1] = PROP_GLOBAL_GROUP;       // Select property group
195. abApi_Write[2] = 1;               // Number of properties to be written
196. abApi_Write[3] = PROP_GLOBAL_XO_TUNE;     // Specify property
197. abApi_Write[4] = CAP_BANK_VALUE;        // Set cap bank value to adjust XTAL clock frequency
198. bApi_SendCommand(5,abApi_Write);        // Send command to the radio IC
199. vApi_WaitforCTS();                // Wait for CTS
200. // Read ITs, clear pending ones
201. abApi_Write[0] = CMD_GET_INT_STATUS;  // Use interrupt status command
202. abApi_Write[1] = 0;           // Clear PH_CLR_PEND
203. abApi_Write[2] = 0;           // Clear MODEM_CLR_PEND
204. abApi_Write[3] = 0;           // Clear CHIP_CLR_PEND
205. bApi_SendCommand(4,abApi_Write);    // Send command to the radio IC
206. bApi_GetResponse(8,abApi_Read);     // Get the response
207. // Start Rx
208. abApi_Write[0] = CMD_START_RX;      // Use start Rx command
209. abApi_Write[1] = 0;           // Set channel number
210. abApi_Write[2] = 0x00;          // Start Rx immediately
211. abApi_Write[3] = 0x00;          // 8 bytes to receive
212. abApi_Write[4] = 0x08;          // 8 bytes to receive
213. abApi_Write[5] = 0x00;          // No change if Rx timeout
214. abApi_Write[6] = 0x03;          // Ready state after Rx
215. abApi_Write[7] = 0x03;          // Ready state if Rx invalid
216. bApi_SendCommand(8,abApi_Write);    // Send API command to the radio IC
217. vApi_WaitforCTS();            // Wait for CTS
218. // Turn off LEDs
219. ClearLed(1);
220. ClearLed(2);
221. ClearLed(3);
222. ClearLed(4);
223. while(1)
224. {
225. if(EZRP_NIRQ == 0)
226. {
227. // Read PH IT registers to see the cause for the IT
228. abApi_Write[0] = CMD_GET_PH_STATUS;   // Use packet handler status command
229. abApi_Write[1] = 0x00;          // Dummy byte for a proper CTS response
230. bApi_SendCommand(2,abApi_Write);    // Send command to the radio IC
231. bApi_GetResponse(1,abApi_Read);     // Make sure that CTS is ready then get the response
232. if((abApi_Read[0] & 0x10) == 0x10)    // Check if packet received
233. {// Packet received
234. // Get RSSI
235. bApi_GetFastResponseRegister(CMD_FAST_RESPONSE_REG_C,1,abApi_Read);
236. // Read the FIFO
237. bApi_ReadRxDataBuffer(8,abApi_Read);
238. fValidPacket = 0;
239. // Check the packet content
240. if ((abApi_Read[0]=='B') && (abApi_Read[1]=='U') && (abApi_Read[2]=='T') && (abApi_Read[3]=='T') && (abApi_Read[4]=='O') && (abApi_Read[5]=='N'))
241. {
242. bButtonNumber = abApi_Read[6] & 0x07; // Get button info
243. if((bButtonNumber > 0) && (bButtonNumber < 5))
244. {
245. SetLed(bButtonNumber);          // Turn on the appropriate LED
246. for(wDelay=0; wDelay<30000; wDelay++);  // Wait to show LED
247. ClearLed(bButtonNumber);        // Turn off the corresponding LED
248. fValidPacket = 1;
249. }
250. }
251. // Packet content is not what was expected
252. if(fValidPacket == 0)
253. {
254. SetLed(1);                // Blink all LEDs
255. SetLed(2);
256. SetLed(3);
257. SetLed(4);
258. for(wDelay=0; wDelay<30000; wDelay++);
259. ClearLed(1);
260. ClearLed(2);
261. ClearLed(3);
262. ClearLed(4);
263. }
264. }
265. // Read ITs, clear pending ones
266. abApi_Write[0] = CMD_GET_INT_STATUS;  // Use interrupt status command
267. abApi_Write[1] = 0;           // Clear PH_CLR_PEND
268. abApi_Write[2] = 0;           // Clear MODEM_CLR_PEND
269. abApi_Write[3] = 0;           // Clear CHIP_CLR_PEND
270. bApi_SendCommand(4,abApi_Write);    // Send command to the radio IC
271. bApi_GetResponse(8,abApi_Read);     // Get the response
272. // Start Rx
273. abApi_Write[0] = CMD_START_RX;      // Use start Rx command
274. abApi_Write[1] = 0;           // Set channel number
275. abApi_Write[2] = 0x00;          // Start Rx immediately
276. abApi_Write[3] = 0x00;          // 8 bytes to receive
277. abApi_Write[4] = 0x08;          // 8 bytes to receive
278. abApi_Write[5] = 0x00;          // No change if Rx timeout
279. abApi_Write[6] = 0x03;          // Ready state after Rx
280. abApi_Write[7] = 0x03;          // Ready if Rx invalid
281. bApi_SendCommand(8,abApi_Write);    // Send API command to the radio IC
282. vApi_WaitforCTS();            // Wait for CTS
283. }
284. }
285. }