Contiki 3.x
radioeng.c
Go to the documentation of this file.
1 /**
2  * Copyright (c) 2014, Analog Devices, Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted (subject to the limitations in the
6  * disclaimer below) provided that the following conditions are met:
7  *
8  * - Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *
11  * - Redistributions in binary form must reproduce the above copyright
12  * notice, this list of conditions and the following disclaimer in the
13  * documentation and/or other materials provided with the
14  * distribution.
15  *
16  * - Neither the name of Analog Devices, Inc. nor the names of its
17  * contributors may be used to endorse or promote products derived
18  * from this software without specific prior written permission.
19  *
20  * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
21  * GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
22  * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
23  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
24  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
25  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
26  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
29  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
30  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
31  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
32  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33  */
34 /**
35  @file radioeng.c
36  @brief Radio Interface Engine Functions
37  @version v1.0
38  @author PAD CSE group, Analog Devices Inc
39  @date May 08th 2013
40 **/
41 
42 #include "aducrf101-include.h"
43 
44 // 1.0 of the Engine
45 #define RIE_ENGINE_MAJOR_VERSION 1UL
46 #define RIE_ENGINE_MINOR_VERSION 0UL
47 
48 
49 #define RADIO_SPI_CLK_FREQ 4000000 // 4 MHz SPI CLK for radio interface
50 #define SYSTEM_UCLK 16000000 // 16 MHz UCLK
51 // Default Radio Parameters
52 #define DEFAULT_CHNL_FREQ 915000000
53 #define FREQ_CNVRT_VAL 0.00252061538
54 // Defines for radio memory mapped areas
55 #define PACKETRAM_START 0x10
56 #define PACKETRAM_LEN 240
57 #define BBRAM_START 0x100
58 #define PR_var_tx_mode_ADR 0x00D
59 
60 // PrF Table 35
61 #define PARAM_TX_NORMAL_PACKET 0
62 #define PARAM_TX_PREAMBLE_FOREVER 2
63 #define PARAM_TX_CARRIER_FOREVER 3
64 
65 #define gpio_configure_sport_mode_0 0xA0
66 #define gpio_configure_default 0x00
67 #define MCR_pa_level_mcr_Adr 0x307
68 #define MCR_rssi_readback_Adr 0x312
69 #define MCR_gpio_configure_Adr 0x3fa
70 #define MCR_ext_uc_clk_divide_Adr 0x32e
71 #define MCR_interrupt_source_0_Adr 0x336
72 #define MCR_interrupt_source_1_Adr 0x337
73 
74 // Macros for manual GPIO checking of Radio MISO pin P2.0 (SPI0)
75 #define RADIO_MISO_IN GP2IN_IN0_BBA
76 // Macros for manual GPIO control of P2.3 (Radio SPI CS) (SPI0)
77 #define RADIO_CSN_DEASSERT (pADI_GP2->GPSET = GP2SET_SET3)
78 #define RADIO_CSN_ASSERT (pADI_GP2->GPCLR = GP2CLR_CLR3)
79 // Macros for Sending\Receiving single bytes via SPI
80 #define SEND_SPI(x) pADI_SPI0->SPITX = x
81 #define WAIT_SPI_RX while((pADI_SPI0->SPISTA & SPISTA_RXFSTA_MSK) == 0x0);
82 #define READ_SPI pADI_SPI0->SPIRX
83 
84 // Bit Manipulation Macros
85 #define MSKSET_VAL(byte,numbits,offset,value) ((byte & ~(((0x1 << numbits)-1) << offset)) | value)
86 
87 
88 
89 /*************************************************************************/
90 /* Local Types */
91 /*************************************************************************/
92 /*************************************************************************/
93 /* Radio Command Codes */
94 /*************************************************************************/
95 typedef enum
96 {
97  CMD_SYNC = 0xA2, // Synchronizatio
98  CMD_PHY_OFF = 0xB0, // Transition to state PHY_OFF
99  CMD_PHY_ON = 0xB1, // transition to state PHY_ON
100  CMD_PHY_RX = 0xB2, // transition to state PHY_RX
101  CMD_PHY_TX = 0xB5, // transition to state PHY_TX
102  CMD_PHY_SLEEP = 0xBA, // transition to state PHY_SLEEP
103  CMD_CONFIG_DEV = 0xBB, // Apply Radio Configuration
104  CMD_GET_RSSI = 0xBC, // Performs an RSSI measurement
105  CMD_HW_RESET = 0xC8, // Power Down radio
106  SPI_MEM_WR = 0x18, // Sequential SPI Write
107  SPI_MEM_RD = 0x38, // Sequential SPI Read
108  SPI_NOP = 0xFF // No operation
109 } Radio_CmdCodes;
110 /*************************************************************************/
111 /* Firmware States */
112 /*************************************************************************/
113 typedef enum
114 {
115  FW_INIT = 0x0F, // Radio Starting Up
116  FW_BUSY = 0x00, // Radio not completed current operation
117  FW_RSSI = 0x05, // Performing CMD_GET_RSSI
118  FW_OFF = 0x11, // Radio is OFF
119  FW_ON = 0x12, // Radio is ON
120  FW_RX = 0x13, // Radio is in receive mode
121  FW_TX = 0x14, // Radio is in transmit mode
122 
123 } RadioState;
124 /*************************************************************************/
125 /* Status Byte Masks */
126 /*************************************************************************/
127 #define STATUS_BYTE_FW_STATE (0x1F << 0)
128 #define STATUS_BYTE_CMD_READY (0x1 << 5)
129 #define STATUS_BYTE_IRQ_STATUS (0x1 << 6)
130 #define STATUS_BYTE_SPI_READY (0x1 << 7)
131 /*************************************************************************/
132 /* SPI Memory Access Defs */
133 /*************************************************************************/
134 #define SPI_MEMCMD_BYTE0_ADR_MSK (0x3 << 0)
135 #define SPI_MEMCMD_BYTE0_CMD_BITOFFSET 3
136 #define SPI_MEMCMD_BYTE0_CMD_MSK (0x1F << SPI_MEMCMD_BYTE0_CMD_BITOFFSET)
137 /*************************************************************************/
138 /* Radio Configuration Structure */
139 /*************************************************************************/
140 /**
141  \internal Hide from Doxegen
142  \var TyRadioConfiguration
143  **/
144 typedef struct
145 {
146  RIE_U8 interrupt_mask_0_r; // 0x100
147  RIE_U8 cfg_101_r; // 0x101
148  RIE_U8 cfg_102_r; // 0x102
149  RIE_U8 cfg_103_r; // 0x103
150  RIE_U8 cfg_104_r; // 0x104
151  RIE_U8 cfg_105_r; // 0x105
152  RIE_U8 cfg_106_r; // 0x106
153  RIE_U8 cfg_107_r; // 0x107
154  RIE_U8 cfg_108_r; // 0x108
155  RIE_U8 channel_freq_0_r; // 0x109
156  RIE_U8 channel_freq_1_r; // 0x10A
157  RIE_U8 channel_freq_2_r; // 0x10B
158  RIE_U8 cfg_10C_r; // 0x10C
159  RIE_U8 cfg_10D_r; // 0x10D
160  RIE_U8 cfg_10E_r; // 0x10E
161  RIE_U8 cfg_10F_r; // 0x10F
162  RIE_U8 cfg_110_r; // 0x110
163  RIE_U8 cfg_111_r; // 0x111
164  RIE_U8 cfg_112_r; // 0x112
165  RIE_U8 cfg_113_r; // 0x113
166  RIE_U8 radio_cfg_8_r; // 0x114
167  RIE_U8 radio_cfg_9_r; // 0x115
168  RIE_U8 cfg_116_r; // 0x116
169  RIE_U8 cfg_117_r; // 0x117
170  RIE_U8 image_reject_cal_phase_r; // 0x118
171  RIE_U8 image_reject_cal_amplitude_r; // 0x119
172  RIE_U8 cfg_11A_r; // 0x11A
173  RIE_U8 cfg_11B_r; // 0x11B
174  RIE_U8 symbol_mode_r; // 0x11C
175  RIE_U8 cfg_11D_r; // 0x11D
176  RIE_U8 cfg_11E_r; // 0x11E
177  RIE_U8 cfg_11F_r; // 0x11F
178  RIE_U8 cfg_120_r; // 0x120
179  RIE_U8 cfg_121_r; // 0x121
180  RIE_U8 cfg_122_r; // 0x122
181  RIE_U8 cfg_123_r; // 0x123
182  RIE_U8 tx_base_adr_r; // 0x124
183  RIE_U8 rx_base_adr_r; // 0x125
184  RIE_U8 packet_length_control_r; // 0x126
185  RIE_U8 packet_length_max_r; // 0x127
186  RIE_U8 cfg_128_r; // 0x128
187  RIE_U8 cfg_129_r; // 0x129
188  RIE_U8 cfg_12A_r; // 0x12A
189  RIE_U8 cfg_12B_r; // 0x12B
190  RIE_U8 cfg_12C_r; // 0x12C
191  RIE_U8 cfg_12D_r; // 0x12D
192  RIE_U8 cfg_12E_r; // 0x12E
193  RIE_U8 cfg_12F_r; // 0x12F
194  RIE_U8 cfg_130_r; // 0x130
195  RIE_U8 cfg_131_r; // 0x131
196  RIE_U8 cfg_132_r; // 0x132
197  RIE_U8 cfg_133_r; // 0x133
198  RIE_U8 cfg_134_r; // 0x134
199  RIE_U8 cfg_135_r; // 0x135
200  RIE_U8 cfg_136_r; // 0x136
201  RIE_U8 cfg_137_r; // 0x137
202  RIE_U8 cfg_138_r; // 0x138
203  RIE_U8 cfg_139_r; // 0x139
204  RIE_U8 cfg_13A_r; // 0x13A
205  RIE_U8 cfg_13B_r; // 0x13B
206  RIE_U8 cfg_13C_r; // 0x13C
207  RIE_U8 cfg_13D_r; // 0x13D
208  RIE_U8 cfg_13E_r; // 0x13E
209  RIE_U8 cfg_13F_r; // 0x13F
210 } TyRadioConfiguration;
211 /*************************************************************************/
212 /* Radio Configuration Constants */
213 /*************************************************************************/
214 #define interrupt_mask_0_interrupt_tx_eof (0x1 << 4)
215 #define interrupt_mask_0_interrupt_crc_correct (0x1 << 2)
216 
217 #define packet_length_control_length_offset_offset (0)
218 #define packet_length_control_length_offset_minus0 (0x4 << packet_length_control_length_offset_offset)
219 #define packet_length_control_data_mode_offset (3)
220 #define packet_length_control_data_mode_packet (0x0 << packet_length_control_data_mode_offset)
221 #define packet_length_control_crc_en_yes (0x1 << 5)
222 #define packet_length_control_packet_len_variable (0x0 << 6)
223 #define packet_length_control_packet_len_fixed (0x1 << 6)
224 #define packet_length_control_data_byte_lsb (0x0 << 7)
225 
226 #define symbol_mode_symbol_length_8_bit (0 << 0)
227 #define symbol_mode_data_whitening_disabled (0 << 3)
228 #define symbol_mode_data_whitening_enabled (1 << 3)
229 #define symbol_mode_eight_ten_enc_disabled (0 << 4 )
230 #define symbol_mode_prog_crc_en_disabled (0 << 5)
231 #define symbol_mode_manchester_enc_enabled (1 << 6)
232 
233 #define radio_cfg_8_pa_single_diff_sel_single_ended (0x0 << 7)
234 #define radio_cfg_8_pa_single_diff_sel_differential (0x1 << 7)
235 #define radio_cfg_8_pa_power_numbits (4)
236 #define radio_cfg_8_pa_power_offset (3)
237 #define radio_cfg_8_pa_power_setting_63 (0xF << radio_cfg_8_pa_power_offset)
238 #define radio_cfg_8_pa_ramp_numbits (3)
239 #define radio_cfg_8_pa_ramp_offset (0)
240 #define radio_cfg_8_pa_ramp_16 (0x5 << radio_cfg_8_pa_ramp_offset)
241 
242 #define radio_cfg_9_demod_scheme_offset (0)
243 #define radio_cfg_9_demod_scheme_FSK (0x0 << radio_cfg_9_demod_scheme_offset)
244 #define radio_cfg_9_mod_scheme_numbits (3)
245 #define radio_cfg_9_mod_scheme_offset (3)
246 #define radio_cfg_9_mod_scheme_2_level_FSK (0x0 << radio_cfg_9_mod_scheme_offset)
247 #define radio_cfg_9_mod_scheme_2_level_GFSK (0x1 << radio_cfg_9_mod_scheme_offset)
248 #define radio_cfg_9_ifbw_numbits (2)
249 #define radio_cfg_9_ifbw_offset (6)
250 #define radio_cfg_9_ifbw_100kHz (0x0 << radio_cfg_9_ifbw_offset)
251 #define radio_cfg_9_ifbw_150kHz (0x1 << radio_cfg_9_ifbw_offset)
252 #define radio_cfg_9_ifbw_200kHz (0x2 << radio_cfg_9_ifbw_offset)
253 #define radio_cfg_9_ifbw_300kHz (0x3 << radio_cfg_9_ifbw_offset)
254 
255 /*************************************************************************/
256 /* Local Variables */
257 /*************************************************************************/
258 static TyRadioConfiguration RadioConfiguration;
259 static RIE_BOOL bRadioConfigurationChanged = RIE_FALSE;
260 static RIE_BOOL bTestModeEnabled = RIE_FALSE;
261 static RIE_U32 DataRate = 38400;
262 static volatile RIE_BOOL bPacketTx = RIE_FALSE;
263 static volatile RIE_BOOL bPacketRx = RIE_FALSE;
264 
265 const RIE_U8 DR_38_4kbps_Dev20kHz_Configuration[] =
266 {
267  0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x33,0x00,0x76,0x62,0x21,
268 
269 // 0 1 2 3 4 5 6 7 8 9 A B
270  0x80,0x01,0xC8,0x20,0x0E,0x00,0x00,0x00,0xFD,0x00,0x0B,0x37,
271  0x16,0x07,
272 
273  0x40,0x0C,0x00,0x0C,0x00,0x00,
274  0x10,0x00,0xC3,0x36,0x10,0x10,0x24,0xF0,0x2A,0x00,0x2F,0x19,0x5E,0x46,0x5F,0x78,
275  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
276 };
277 
278 
279 const RIE_U8 DR_300_0kbps_Dev75_0kHz_Configuration[] =
280 {
281  0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x33,0x00,0x76,0x62,0x21,
282 
283 // 0 1 2 3 4 5 6 7 8 9 A B
284  0xB8,0x2B,0xEE,0x0B,0x70,0x00,0x03,0x00,0xFD,0xC0,0x0B,0x37,
285  0x16,0x07,
286 
287  0x40,0x0C,0x00,0x0C,0x00,0x00,
288  0x10,0x00,0xC3,0x36,0x10,0x10,0x24,0xF0,0x2A,0x00,0x2F,0x19,0x5E,0x46,0x5F,0x78,
289  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
290 };
291 
292 
293 
294 const RIE_U8 DR_1_0kbps_Dev10_0kHz_Configuration[] =
295 {
296  0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x33,0x00,0x76,0x62,0x21,
297 // 0 1 2 3 4 5 6 7 8 9 A B
298  0x0A,0x00,0x64,0x41,0x01,0x00,0x02,0x00,0xFD,0x00,0x0B,0x37,
299  0x16,0x07,
300 
301  0x40,0x0C,0x00,0x0C,0x00,0x00,
302  0x10,0x00,0xC3,0x36,0x10,0x10,0x24,0xF0,0x2A,0x00,0x2F,0x19,0x5E,0x46,0x5F,0x78,
303  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
304 };
305 
306 /*************************************************************************/
307 /* Local Functions */
308 /*************************************************************************/
309 static RIE_Responses RadioSPIXferByte (RIE_U8 ucByte,
310  RIE_U8 * pData);
311 static RIE_Responses RadioSendCommandBytes (RIE_U8 * pCmdBytes,
312  RIE_U8 NumBytes);
313 static RIE_Responses RadioSendCommandNoWait (Radio_CmdCodes CmdCode);
314 static RIE_Responses RadioSendCommandWait (Radio_CmdCodes CmdCode);
315 static RIE_Responses RadioMMapRead (RIE_U32 ulAdr,
316  RIE_U32 ulLen,
317  RIE_U8 * pData);
318 static RIE_Responses RadioMMapWrite (RIE_U32 ulAdr,
319  RIE_U32 ulLen,
320  RIE_U8 * pData);
321 static RIE_Responses RadioReadState (RadioState * pState);
322 static RIE_Responses RadioWaitOnState (RadioState FinalState);
323 static RIE_Responses RadioWaitForPowerUp (void);
324 static RIE_Responses RadioSyncComms (void);
325 static RIE_Responses SetRadioConfiguration (RIE_BaseConfigs BaseConfig);
326 static RIE_Responses RadioCommitRadioConfig (void);
327 static RIE_Responses RadioConfigure (void);
328 static RIE_Responses RadioToOnMode (void);
329 static RIE_Responses RadioToOffMode (void);
330 static RIE_Responses RadioWaitOnCmdLdr (void);
331 /*************************************************************************/
332 /* Functions Implementations - Start */
333 /*************************************************************************/
334 
335 /**
336  @fn RIE_Responses RadioGetAPIVersion(RIE_U32 *pVersion)
337  @brief Return the Radio Interface Engine API Version
338  @param pVersion :{}
339  pVersion Storage for Radio Interface Engine API version.
340  @code
341  RIE_U32 Version;
342  Response = RadioGetAPIVersion(&Version);
343  @endcode
344  @return RIE_Responses Error code.
345 **/
346 
347 RIE_Responses RadioGetAPIVersion(RIE_U32 *pVersion)
348 {
349  RIE_Responses Response = RIE_Success;
350 
351  if (pVersion)
352  *pVersion = RIE_ENGINE_MINOR_VERSION | (RIE_ENGINE_MAJOR_VERSION << 8);
353  return Response;
354 }
355 
356 
357 /**
358  @fn RIE_U32 RadioSwitchConfig(RIE_BaseConfigs BaseConfig)
359  @brief Change the Radio to using specified configuration.
360  @param BaseConfig :{DR_1_0kbps_Dev10_0kHz, DR_38_4kbps_Dev20kHz, DR_300_0kbps_Dev75_0kHz}
361  - DR_1_0kbps_Dev10_0kHz Base configuration of 1 kbps datarate, 10.0 kHz frequency deviation.
362  - DR_38_4kbps_Dev20kHz Base configuration of 38.4 kbps datarate, 20 kHz frequency deviation.
363  - DR_300_0kbps_Dev75_0kHz Base configuration of 300 kbps datarate, 75 kHz frequency deviation.
364  @pre
365  RadioInit() must be called before this function is called.
366  @return RIE_Responses Error code.
367 **/
368 
369 RIE_Responses RadioSwitchConfig(RIE_BaseConfigs BaseConfig)
370 {
371  RIE_Responses Response = RIE_Success;
372  if(Response == RIE_Success)
373  Response = RadioToOffMode();
374  if(Response == RIE_Success)
375  Response = SetRadioConfiguration(BaseConfig);
376  if(Response == RIE_Success)
377  Response = RadioCommitRadioConfig();
378  if(Response == RIE_Success)
379  Response = RadioToOnMode();
380  return Response;
381 }
382 
383 
384 /**
385  @fn RIE_U32 RadioInit(RIE_BaseConfigs BaseConfig)
386  @brief Initialise the Radio, using specified configuration.
387  @param BaseConfig :{DR_1_0kbps_Dev10_0kHz , DR_38_4kbps_Dev20kHz ,DR_300_0kbps_Dev75_0kHz }
388  - DR_1_0kbps_Dev10_0kHz Base configuration of 1 kbps datarate, 10.0 kHz frequency deviation.
389  - DR_38_4kbps_Dev20kHz Base configuration of 38.4 kbps datarate, 20 kHz frequency deviation.
390  - DR_300_0kbps_Dev75_0kHz Base configuration of 300 kbps datarate, 75 kHz frequency deviation.
391  @note
392  This must be called before any other function is called.
393  @return RIE_Responses Error code.
394 **/
395 
396 RIE_Responses RadioInit(RIE_BaseConfigs BaseConfig)
397 {
398  RIE_Responses Response = RIE_Success;
399 
400  // Disable the radio interrupt until we have initialised the radio
401  NVIC_DisableIRQ(UHFTRX_IRQn);
402 
403  // Initialise GPIO Port 2 for Radio Use
404  pADI_GP2->GPCON = GP2CON_CON0_SPI0MISO | GP2CON_CON1_SPI0SCLK |
405  GP2CON_CON2_SPI0MOSI | GP2CON_CON3_GPIO |
406  GP2CON_CON4_IRQ8 | GP2CON_CON5_GPIO |
407  GP2CON_CON6_GPIO | GP2CON_CON7_GPIOIRQ7;
408 
409  pADI_GP2->GPOEN = GP2OEN_OEN0_IN | GP2OEN_OEN1_IN |
410  GP2OEN_OEN2_IN | GP2OEN_OEN3_OUT |
411  GP2OEN_OEN4_IN | GP2OEN_OEN5_IN |
412  GP2OEN_OEN6_IN | GP2OEN_OEN7_IN;
413 
414  // Disable the PULL-Up on P2.4 which is connected to the radio
415  GP2PUL_PUL4_BBA = 0x0;
416 
417  // Configure the SPI Interface to the Radio and flush it
418  pADI_SPI0->SPIDIV = ((SYSTEM_UCLK/RADIO_SPI_CLK_FREQ)/2)-0x1;
419  pADI_SPI0->SPICON = SPICON_MASEN | // Master mode
420  SPICON_TIM | // Interrupt on transmit
421  SPICON_TFLUSH | // Flush FIFO
422  SPICON_RFLUSH | // Flush FIFO
423  SPICON_ENABLE;
424  pADI_SPI0->SPICON = SPICON_MASEN | // Master mode
425  SPICON_TIM | // Interrupt on transmit
426  SPICON_ENABLE;
427 
428  // Initialise the chip select line to starting position
429  RADIO_CSN_DEASSERT;
430 
431 
432  // Power it down and up again to return to a known state
433  // which will be PHY_OFF.
434  // This will clear any pre-existing radio interrupt before
435  // we enable the Cortex interrupt handling of it
436  if(Response == RIE_Success)
437  Response = RadioPowerOff();
438  // Configure a "high level" radio interrupt ...
439  pADI_INTERRUPT->EI2CFG = EI2CFG_IRQ8MDE_HIGHLEVEL | EI2CFG_IRQ8EN;
440  // ... and set it up in the NVIC so that our interrupt handler is called
441  // when the radio wants our attention. Clear any pre-existing condition
442  // before enabling the interrupt.
443  pADI_INTERRUPT->EICLR = EICLR_IRQ8;
444  NVIC_ClearPendingIRQ(UHFTRX_IRQn);
445  NVIC_SetPriority (UHFTRX_IRQn,0x0);
446  NVIC_EnableIRQ (UHFTRX_IRQn);
447 
448  if(Response == RIE_Success)
449  Response = RadioWaitForPowerUp();
450  if(Response == RIE_Success)
451  Response = RadioSyncComms();
452  if(Response == RIE_Success)
453  Response = RadioToOffMode();
454  if(Response == RIE_Success)
455  Response = SetRadioConfiguration(BaseConfig);
456  if(Response == RIE_Success)
457  Response = RadioCommitRadioConfig();
458  if(Response == RIE_Success)
459  Response = RadioToOnMode();
460  return Response;
461 }
462 
463 /**
464  @fn RIE_U32 RadioDeInit(void)
465  @brief Deinitialise the Radio, and power it down.
466  @note
467  This can be called independently of all other functions to power down
468  the radio
469  @return RIE_Responses Error code.
470 **/
471 
472 RIE_Responses RadioDeInit(void)
473 {
474  RIE_Responses Response = RIE_Success;
475 
476  // Disable the radio interrupt
477  NVIC_DisableIRQ(UHFTRX_IRQn);
478 
479  // Initialise GPIO Port 2 for Radio Use
480  pADI_GP2->GPCON = GP2CON_CON0_SPI0MISO | GP2CON_CON1_SPI0SCLK |
481  GP2CON_CON2_SPI0MOSI | GP2CON_CON3_GPIO |
482  GP2CON_CON4_IRQ8 | GP2CON_CON5_GPIO |
483  GP2CON_CON6_GPIO | GP2CON_CON7_GPIOIRQ7;
484 
485  pADI_GP2->GPOEN = GP2OEN_OEN0_IN | GP2OEN_OEN1_IN |
486  GP2OEN_OEN2_IN | GP2OEN_OEN3_OUT |
487  GP2OEN_OEN4_IN | GP2OEN_OEN5_IN |
488  GP2OEN_OEN6_IN | GP2OEN_OEN7_IN;
489 
490  // Enable the pull-up as we are powering down the radion
491  GP2PUL_PUL4_BBA = 0x1;
492 
493  // Configure the SPI Interface to the Radio and flush it
494  pADI_SPI0->SPIDIV = ((SYSTEM_UCLK/RADIO_SPI_CLK_FREQ)/2)-0x1;
495  pADI_SPI0->SPICON = SPICON_MASEN | // Master mode
496  SPICON_TIM | // Interrupt on transmit
497  SPICON_TFLUSH | // Flush FIFO
498  SPICON_RFLUSH | // Flush FIFO
499  SPICON_ENABLE;
500  pADI_SPI0->SPICON = SPICON_MASEN | // Master mode
501  SPICON_TIM | // Interrupt on transmit
502  SPICON_ENABLE;
503 
504  // Initialise the chip select line to starting position
505  RADIO_CSN_DEASSERT;
506 
507  // Power it down
508  Response = RadioSendCommandNoWait(CMD_HW_RESET);
509 
510  return Response;
511 }
512 
513 /**
514  @fn RIE_Responses RadioPowerOff(void)
515  @brief Shutdown the radio and place it in its lowest power sleep mode.
516  @pre
517  RadioInit() must be called before this function is called.
518  @return RIE_Response Error code.
519 **/
520 
521 RIE_Responses RadioPowerOff(void)
522 {
523  volatile RIE_U32 ulDelay;
524  RIE_Responses Response = RIE_Success;
525 
526  Response = RadioSendCommandNoWait(CMD_HW_RESET);
527 
528  // Delay for approximately 1 ms
529  ulDelay = 0x1000;
530  while (ulDelay--);
531 
532  return Response;
533 }
534 
535 /**
536  @fn RIE_Responses RadioTerminateRadioOp(void)
537  @brief Terminate a currently running radio RX or TX operation.
538  @pre RadioInit() must be called before this function is called.
539  @code
540  if (RIE_Response == RIE_Success)
541  RIE_Response = RadioRxPacketFixedLen(12);
542  // Delay for a while waiting for a packet
543  if (RIE_Response == RIE_Success)
544  {
545  // Abort the waiting
546  RIE_Response = RadioTerminateRadioOp();
547  }
548  @endcode
549  @return RIE_Responses Error code
550 **/
551 RIE_Responses RadioTerminateRadioOp (void)
552 {
553  RIE_Responses Response = RIE_Success;
554 
555  Response = RadioToOnMode();
556 
557  return Response;
558 }
559 
560 /**
561  @fn RIE_Responses RadioSetFrequency(RIE_U32 Frequency)
562  @brief Set frequency for radio communications
563  @param Frequency :{431000000-928000000}
564  - This must be within the available bands of the radio:
565  - 431000000Hz to 464000000Hz and
566  - 862000000Hz to 928000000Hz.
567  @pre RadioInit() must be called before this function is called.
568  @code
569  if (RIE_Response == RIE_Success)
570  RIE_Response = RadioSetFrequency(915000000);
571  @endcode
572  @return RIE_Responses Error code
573 **/
574 RIE_Responses RadioSetFrequency(RIE_U32 Frequency)
575 {
576  RIE_Responses Response = RIE_Success;
577  RIE_U32 EncodedFrequency;
578 
579  bRadioConfigurationChanged = RIE_TRUE;
580 
581  EncodedFrequency = (RIE_U32)(Frequency * FREQ_CNVRT_VAL);
582  RadioConfiguration.channel_freq_0_r = (EncodedFrequency >> 0) & 0xFF;
583  RadioConfiguration.channel_freq_1_r = (EncodedFrequency >> 8) & 0xFF;
584  RadioConfiguration.channel_freq_2_r = (EncodedFrequency >> 16)& 0xFF;
585  if (Frequency >= 862000000)
586  {
587  RadioConfiguration.image_reject_cal_amplitude_r = 0x07;
588  RadioConfiguration.image_reject_cal_phase_r = 0x16;
589  }
590  else
591  {
592  RadioConfiguration.image_reject_cal_amplitude_r = 0x03;
593  RadioConfiguration.image_reject_cal_phase_r = 0x08;
594  }
595  return Response;
596 }
597 
598 /**
599  @fn RIE_Responses RadioSetModulationType(RIE_ModulationTypes ModulationType)
600  @brief Set the Radio Transmitter Modulation Type. Can be FSK_Modulation or GFSK_Modulation.
601  @param ModulationType :{DR_1_0kbps_Dev10_0kHz , DR_38_4kbps_Dev20kHz ,DR_300_0kbps_Dev75_0kHz }
602  - DR_1_0kbps_Dev10_0kHz Base configuration of 1 kbps datarate, 10.0 kHz frequency deviation.
603  - DR_38_4kbps_Dev20kHz Base configuration of 38.4 kbps datarate, 20 kHz frequency deviation.
604  - DR_300_0kbps_Dev75_0kHz Base configuration of 300 kbps datarate, 75 kHz frequency deviation.
605  @pre RadioInit() must be called before this function is called.
606  @code
607  Response = RadioSetModulationType(GFSK_Modulation);
608  @endcode
609  @note FSK_Modulation is used by default.
610  @return RIE_Responses Error code
611 **/
612 RIE_Responses RadioSetModulationType(RIE_ModulationTypes ModulationType)
613 {
614  RIE_Responses Response = RIE_Success;
615  RIE_U8 ucNewCode;
616  RIE_U8 ucNewRegVal = RadioConfiguration.radio_cfg_9_r;
617 
618  switch (ModulationType)
619  {
620  case FSK_Modulation:
621  ucNewCode = radio_cfg_9_mod_scheme_2_level_FSK;
622  break;
623  case GFSK_Modulation:
624  ucNewCode = radio_cfg_9_mod_scheme_2_level_GFSK;
625  break;
626  default:
627  Response = RIE_UnsupportedRadioConfig;
628  break;
629  }
630  if(Response == RIE_Success)
631  {
632  ucNewRegVal = MSKSET_VAL(RadioConfiguration.radio_cfg_9_r,
633  radio_cfg_9_mod_scheme_numbits,
634  radio_cfg_9_mod_scheme_offset,
635  ucNewCode);
636  if (ucNewRegVal != RadioConfiguration.radio_cfg_9_r )
637  {
638  bRadioConfigurationChanged = RIE_TRUE;
639  RadioConfiguration.radio_cfg_9_r = ucNewRegVal;
640  }
641 
642  }
643  return Response;
644 }
645 
646 /**
647  @fn RIE_Responses RadioPayldManchesterEncode(RIE_BOOL bEnable)
648  @brief Enable or Disable Manchester Encoding of payload data.
649 
650  Manchester encoding can be used to ensure a dc-free (zero mean)
651  transmission.
652 
653  A Binary 0 is mapped to 10, and a Binary 1 is mapped to 01.
654 
655  Manchester encoding and decoding are applied to the payload data
656  and the CRC.
657 
658  @param bEnable :{RIE_FALSE,RIE_TRUE}
659  - RIE_TRUE if Manchester Encoding is to be enabled.
660  - RIE_FALSE if disabled.
661 
662  @pre RadioInit() must be called before this function is called.
663  @code
664  Response = RadioPayldManchesterEncode(RIE_TRUE);
665 
666  @endcode
667  @note Manchester Encoding is disabled by default.
668  @return RIE_Responses Error code
669 **/
670 RIE_Responses RadioPayldManchesterEncode(RIE_BOOL bEnable)
671 {
672  RIE_Responses Response = RIE_Success;
673  RIE_U8 ucNewRegVal = RadioConfiguration.symbol_mode_r;
674 
675  switch (bEnable)
676  {
677  case RIE_FALSE:
678  ucNewRegVal &= ~symbol_mode_manchester_enc_enabled;
679  break;
680  case RIE_TRUE:
681  ucNewRegVal |= symbol_mode_manchester_enc_enabled;
682  break;
683  default:
684  Response = RIE_UnsupportedRadioConfig;
685  break;
686  }
687  if(Response == RIE_Success)
688  {
689  if (ucNewRegVal != RadioConfiguration.symbol_mode_r )
690  {
691  bRadioConfigurationChanged = RIE_TRUE;
692  RadioConfiguration.symbol_mode_r = ucNewRegVal;
693  }
694  }
695  return Response;
696 }
697 /**
698  @fn RIE_Responses RadioPayldDataWhitening(RIE_BOOL bEnable)
699  @brief Enable or Disable Data Whitening of payload data.
700 
701  Data whitening can be employed to avoid long runs of 1s or 0s
702  in the transmitted data stream.
703 
704  This ensures sufficient bit transitions in the packet, which
705  aids in receiver clock and data recovery because the encoding
706  breaks up long runs of 1s or 0s in the transmit packet.
707 
708  The data, excluding the preamble and sync word, is automatically
709  whitened before transmission by XORing the data with an 8-bit
710  pseudorandom sequence.
711 
712  At the receiver, the data is XORed with the same pseudorandom
713  sequence, thereby reversing the whitening.
714 
715  The linear feedback shift register polynomial used is x7 + x1 + 1.
716 
717  @param bEnable :{RIE_FALSE, RIE_TRUE}
718  - RIE_TRUE if Manchester Encoding is to be enabled.
719  - RIE_FALSE if disabled.
720 
721  @pre RadioInit() must be called before this function is called.
722  @code
723  Response = RadioPayldDataWhitening(RIE_TRUE);
724 
725  @endcode
726  @note Data Whitening is disabled by default.
727  @return RIE_Responses Error code
728 **/
729 RIE_Responses RadioPayldDataWhitening(RIE_BOOL bEnable)
730 {
731  RIE_Responses Response = RIE_Success;
732  RIE_U8 ucNewRegVal = RadioConfiguration.symbol_mode_r;
733 
734  switch (bEnable)
735  {
736  case RIE_FALSE:
737  ucNewRegVal &= ~symbol_mode_data_whitening_enabled;
738  break;
739  case RIE_TRUE:
740  ucNewRegVal |= symbol_mode_data_whitening_enabled;
741  break;
742  default:
743  Response = RIE_UnsupportedRadioConfig;
744  break;
745  }
746  if(Response == RIE_Success)
747  {
748  if (ucNewRegVal != RadioConfiguration.symbol_mode_r )
749  {
750  bRadioConfigurationChanged = RIE_TRUE;
751  RadioConfiguration.symbol_mode_r = ucNewRegVal;
752  }
753  }
754  return Response;
755 }
756 
757 /**
758  @fn RIE_Responses RadioTxPacketFixedLen(RIE_U8 Len, RIE_U8 *pData)
759  @brief Transmit a fixed length packet.
760  @param Len :{1-240} Length of packet to be transmitted.
761  @param pData :{} Data bytes to be transmitted.
762  @pre RadioInit() must be called before this function is called.
763  @code
764  if (RIE_Response == RIE_Success)
765  RIE_Response = RadioTxSetPA(DifferentialPA,PowerLevel15);
766  if (RIE_Response == RIE_Success)
767  RIE_Response = RadioTxPacketFixedLen(12, "HELLO WORLD");
768  while (!RadioTxPacketComplete());
769  @endcode
770  @return RIE_Responses Error code
771 **/
772 RIE_Responses RadioTxPacketFixedLen(RIE_U8 Len, RIE_U8 *pData)
773 {
774  RIE_Responses Response = RIE_Success;
775 
776  bPacketTx = RIE_FALSE;
777  if (Len > PACKETRAM_LEN)
778  Response = RIE_InvalidParamter;
779  if (Response == RIE_Success)
780  Response = RadioToOnMode();
781  if (Response == RIE_Success)
782  Response = RadioMMapWrite(PACKETRAM_START, Len, pData);
783  if (Response == RIE_Success)
784  {
785  RadioConfiguration.packet_length_max_r = Len;
786  RadioConfiguration.packet_length_control_r |= packet_length_control_packet_len_fixed;
787  }
788  if(Response == RIE_Success)
789  Response = RadioCommitRadioConfig();
790  if (Response == RIE_Success)
791  Response = RadioToOnMode();
792  if (Response == RIE_Success)
793  Response = RadioSendCommandWait(CMD_PHY_TX);
794 
795  return Response;
796 }
797 
798 /**
799  @fn RIE_Responses RadioTxPacketVariableLen(RIE_U8 Len, RIE_U8 *pData)
800  @brief Transmit a Variable length packet.
801  @param Len :{1-240} Length of packet to be transmitted.
802  @param pData :{} Data bytes to be transmitted.
803  @pre RadioInit() must be called before this function is called.
804  @code
805  if (RIE_Response == RIE_Success)
806  RIE_Response = RadioTxSetPA(DifferentialPA,PowerLevel15);
807  if (RIE_Response == RIE_Success)
808  RIE_Response = RadioTxPacketVariableLen(12, "HELLO WORLD");
809  while (!RadioTxPacketComplete());
810  @endcode
811  @return RIE_Responses Error code
812 **/
813 RIE_Responses RadioTxPacketVariableLen(RIE_U8 Len, RIE_U8 *pData)
814 {
815  RIE_Responses Response = RIE_Success;
816 
817  bPacketTx = RIE_FALSE;
818 
819  Len += 0x1;
820  if (Len > PACKETRAM_LEN)
821  Response = RIE_InvalidParamter;
822  if (Response == RIE_Success)
823  Response = RadioToOnMode();
824  if (Response == RIE_Success)
825  Response = RadioMMapWrite(PACKETRAM_START, 0x1, &Len);
826  if (Response == RIE_Success)
827  Response = RadioMMapWrite(PACKETRAM_START+0x1, Len-1, pData);
828  if (Response == RIE_Success)
829  {
830  RadioConfiguration.packet_length_max_r = PACKETRAM_LEN;
831  RadioConfiguration.packet_length_control_r &= ~packet_length_control_packet_len_fixed;
832  }
833  if(Response == RIE_Success)
834  Response = RadioCommitRadioConfig();
835  if (Response == RIE_Success)
836  Response = RadioToOnMode();
837  if (Response == RIE_Success)
838  Response = RadioSendCommandWait(CMD_PHY_TX);
839 
840  return Response;
841 }
842 
843 
844 /**
845  @fn RIE_BOOL RadioTxPacketComplete(void)
846  @brief Checks if a packet has finished transmitting
847  @pre RadioInit() must be called before this function is called.
848  @pre RadioRxPacketFixedLen() or equivalent should be called first.
849  @code
850  if (RIE_Response == RIE_Success)
851  RIE_Response = RadioTxSetPA(DifferentialPA,PowerLevel15);
852  if (RIE_Response == RIE_Success)
853  RIE_Response = RadioTxPacketFixedLen(12, "HELLO WORLD");
854  while (!RadioTxPacketComplete());
855  @endcode
856  @return RIE_BOOL RIE_TRUE if packet has finished transmitting, else RIE_FALSE
857 **/
858 RIE_BOOL RadioTxPacketComplete (void)
859 {
860  return bPacketTx;
861 }
862 
863 /**
864  @fn RIE_Responses RadioTxSetPA(RIE_PATypes PAType,RIE_PAPowerLevel Power)
865  @brief Set PA Type and the Transmit Power Level for Radio Transmission.
866  @param PAType :{DifferentialPA, SingleEndedPA} Select Single Ended or Differential PA Type
867  @param Power :{PowerLevel0 ,PowerLevel1 ,PowerLevel2 ,PowerLevel3,
868  PowerLevel4 ,PowerLevel5 ,PowerLevel6 ,PowerLevel7,
869  PowerLevel8 ,PowerLevel9 ,PowerLevel10,PowerLevel11,
870  PowerLevel12,PowerLevel13,PowerLevel14,PowerLevel15}
871  @pre RadioInit() must be called before this function is called.
872  @code
873  Response = RadioTxSetPA(SingleEndedPA,PowerLevel8);
874  @endcode
875  @note Differential PA is enabled by default.
876  @note Max TX Power is used by default.
877  @return RIE_Responses Error code
878 **/
879 RIE_Responses RadioTxSetPA(RIE_PATypes PAType,RIE_PAPowerLevel Power)
880 {
881  RIE_Responses Response = RIE_Success;
882  RIE_U8 ucNewRegVal = 0x0;
883  unsigned long pa_level_mcr,pa_ramp, codes_per_bit,min_codes_per_bit;
884 
885  switch (PAType)
886  {
887  case DifferentialPA:
888  ucNewRegVal |= radio_cfg_8_pa_single_diff_sel_differential;
889  break;
890  case SingleEndedPA:
891  ucNewRegVal |= radio_cfg_8_pa_single_diff_sel_single_ended;
892  break;
893  default:
894  Response = RIE_UnsupportedRadioConfig;
895  break;
896  }
897  if(Response == RIE_Success)
898  {
899  switch (Power)
900  {
901  case PowerLevel0 :
902  case PowerLevel1 :
903  case PowerLevel2 :
904  case PowerLevel3 :
905  case PowerLevel4 :
906  case PowerLevel5 :
907  case PowerLevel6 :
908  case PowerLevel7 :
909  case PowerLevel8 :
910  case PowerLevel9 :
911  case PowerLevel10:
912  case PowerLevel11:
913  case PowerLevel12:
914  case PowerLevel13:
915  case PowerLevel14:
916  case PowerLevel15:
917  ucNewRegVal |= ((RIE_U8)Power << radio_cfg_8_pa_power_offset);
918  // Calculate the minimum allowable codes per bit
919  pa_level_mcr = (((RIE_U8)Power)* 4) + 0x3;
920  min_codes_per_bit = (pa_level_mcr * 2500)/(DataRate/100);
921  pa_ramp = 0x1;
922  codes_per_bit = 256;
923  while (codes_per_bit > min_codes_per_bit)
924  {
925  pa_ramp++;
926  codes_per_bit = 512 >> pa_ramp;
927  if (pa_ramp >= 7)
928  break; // This is the maximum
929  }
930  ucNewRegVal |= ((RIE_U8)pa_ramp << radio_cfg_8_pa_ramp_offset);
931  break;
932  default:
933  Response = RIE_UnsupportedRadioConfig;
934  break;
935  }
936  }
937 
938  if(Response == RIE_Success)
939  {
940  if (ucNewRegVal != RadioConfiguration.radio_cfg_8_r )
941  {
942  bRadioConfigurationChanged = RIE_TRUE;
943  RadioConfiguration.radio_cfg_8_r = ucNewRegVal;
944  }
945  }
946  return Response;
947 }
948 /**
949  @fn RIE_Responses RadioTxCarrier(void)
950  @brief Transmit a carrier tone
951  using the current radio configuration.
952  @pre RadioInit() must be called before this function is called.
953  @code
954  Response = RadioTxCarrier();
955  @endcode
956  @note Terminate this mode by calling RadioTerminateRadioOp();
957  @return RIE_Responses Error code
958 **/
959 RIE_Responses RadioTxCarrier (void)
960 {
961  RIE_Responses Response = RIE_Success;
962  RIE_U8 ParamTX = PARAM_TX_CARRIER_FOREVER;
963 
964  if(Response == RIE_Success)
965  Response = RadioCommitRadioConfig();
966  bTestModeEnabled = RIE_TRUE;
967  if (Response == RIE_Success)
968  Response = RadioToOnMode();
969  // Mode needs to be set, before entry to PHY_TX
970  if (Response == RIE_Success)
971  Response = RadioMMapWrite(PR_var_tx_mode_ADR,sizeof(ParamTX),&ParamTX);
972  if (Response == RIE_Success)
973  Response = RadioSendCommandWait(CMD_PHY_TX);
974  return Response;
975 }
976 /**
977  @fn RIE_Responses RadioTxPreamble(void)
978  @brief Transmit a pre-amble (alternating ones and zeros)
979  using the current radio configuration.
980  @pre RadioInit() must be called before this function is called.
981  @code
982  Response = RadioTxPreamble();
983  @endcode
984  @note Terminate this mode by calling RadioTerminateRadioOp();
985  @return RIE_Responses Error code
986 **/
987 RIE_Responses RadioTxPreamble (void)
988 {
989  RIE_Responses Response = RIE_Success;
990  RIE_U8 ParamTX = PARAM_TX_PREAMBLE_FOREVER;
991 
992  if(Response == RIE_Success)
993  Response = RadioCommitRadioConfig();
994  if (Response == RIE_Success)
995  Response = RadioToOnMode();
996  bTestModeEnabled = RIE_TRUE;
997  // Mode needs to be set, before entry to PHY_TX
998  if (Response == RIE_Success)
999  Response = RadioMMapWrite(PR_var_tx_mode_ADR,sizeof(ParamTX),&ParamTX);
1000  if (Response == RIE_Success)
1001  Response = RadioSendCommandWait(CMD_PHY_TX);
1002  return Response;
1003 }
1004 
1005 /**
1006  @fn RIE_Responses RadioRxPacketFixedLen(RIE_U8 Len)
1007  @brief Enter receive mode and wait for a packet to be received.
1008 
1009  Radio will stay in Receive Mode until
1010  1) A packet is received.
1011  2) User manually exits Receive Mode with a call to RadioTerminateRadioOp()
1012 
1013  @param Len :{1-240} Fixed Length of packet to be received.
1014  @pre RadioInit() must be called before this function is called.
1015  @return RIE_Responses Error code
1016 **/
1017 RIE_Responses RadioRxPacketFixedLen(RIE_U8 Len)
1018 {
1019  RIE_Responses Response = RIE_Success;
1020 
1021  bPacketRx = RIE_FALSE;
1022  if (Len > PACKETRAM_LEN)
1023  Response = RIE_InvalidParamter;
1024 
1025  if (Response == RIE_Success)
1026  {
1027  RadioConfiguration.packet_length_max_r = Len;
1028  RadioConfiguration.packet_length_control_r |= packet_length_control_packet_len_fixed;
1029  }
1030  if(Response == RIE_Success)
1031  Response = RadioCommitRadioConfig();
1032  if (Response == RIE_Success)
1033  Response = RadioToOnMode();
1034  if (Response == RIE_Success)
1035  Response = RadioSendCommandWait(CMD_PHY_RX);
1036  return Response;
1037 }
1038 
1039 /**
1040  @fn RIE_Responses RadioRxPacketVariableLen(void)
1041  @brief Enter receive mode and wait for a packet to be received.
1042 
1043  Radio will stay in Receive Mode until
1044  1) A packet is received.
1045  2) User manually exits Receive Mode with a call to RadioTerminateRadioOp()
1046 
1047  @pre RadioInit() must be called before this function is called.
1048  @return RIE_Responses Error code
1049 **/
1050 RIE_Responses RadioRxPacketVariableLen(void)
1051 {
1052  RIE_Responses Response = RIE_Success;
1053 
1054  bPacketRx = RIE_FALSE;
1055 
1056  if (Response == RIE_Success)
1057  {
1058  RadioConfiguration.packet_length_max_r = PACKETRAM_LEN;
1059  RadioConfiguration.packet_length_control_r &= ~packet_length_control_packet_len_fixed;
1060  }
1061  if(Response == RIE_Success)
1062  Response = RadioCommitRadioConfig();
1063  if (Response == RIE_Success)
1064  Response = RadioToOnMode();
1065  if (Response == RIE_Success)
1066  Response = RadioSendCommandWait(CMD_PHY_RX);
1067  return Response;
1068 }
1069 
1070 /**
1071  @fn RIE_BOOL RadioRxPacketAvailable(void)
1072  @brief Checks if a packet has been received.
1073  @pre RadioInit() must be called before this function is called.
1074  @pre RadioRxPacketFixedLen() or equivalent should be called first.
1075  @code
1076  if (RIE_Response == RIE_Success)
1077  RIE_Response = RadioRxPacketFixedLen(12);
1078  if (RIE_Response == RIE_Success)
1079  {
1080  while (!RadioRxPacketAvailable());
1081  }
1082  if (RIE_Response == RIE_Success)
1083  {
1084  unsigned char Buffer[0x20];
1085  RIE_U8 PktLen;
1086  RIE_S8 RSSI;
1087  RIE_Response = RadioRxPacketRead(sizeof(Buffer),&PktLen,Buffer,&RSSI);
1088  }
1089  @endcode
1090  @return RIE_BOOL RIE_TRUE if packet received, else RIE_FALSE
1091 **/
1092 RIE_BOOL RadioRxPacketAvailable(void)
1093 {
1094  return bPacketRx;
1095 
1096 }
1097 
1098 /**
1099  @fn RIE_Responses RadioRxPacketRead(RIE_U8 BufferLen,RIE_U8 *pPktLen,RIE_U8 *pData,RIE_S8 *pRSSIdBm)
1100  @brief Read the packet that was received by the radio.
1101  @param BufferLen :{1-240} Size of passed in buffer
1102  @param pPktLen :{1-240} Storage for size of actual received packet
1103  @param pData :{} Received Packet will be stored here.
1104  @param pRSSIdBm :{} RSSI of received packet in dBm.
1105  @pre RadioInit() must be called before this function is called.
1106  @pre RadioRxPacketFixedLen() or equivalent should be called first.
1107  @code
1108  if (RIE_Response == RIE_Success)
1109  RIE_Response = RadioRxPacketFixedLen(12);
1110  if (RIE_Response == RIE_Success)
1111  {
1112  while (!RadioRxPacketAvailable());
1113  }
1114  if (RIE_Response == RIE_Success)
1115  {
1116  unsigned char Buffer[0x20];
1117  RIE_U8 PktLen;
1118  RIE_S8 RSSI;
1119  RIE_Response = RadioRxPacketRead(sizeof(Buffer),&PktLen,Buffer,&RSSI);
1120  }
1121  @endcode
1122  @note Check for the presence of a packet by calling RadioRxPacketAvailable();
1123  @return RIE_Responses Error code
1124 **/
1125 RIE_Responses RadioRxPacketRead(RIE_U8 BufferLen,RIE_U8 *pPktLen,RIE_U8 *pData,RIE_S8 *pRSSIdBm)
1126 {
1127  RIE_Responses Response = RIE_Success;
1128 
1129  if (RadioRxPacketAvailable())
1130  {
1131  RIE_U8 RdLen;
1132  if(RadioConfiguration.packet_length_control_r & packet_length_control_packet_len_fixed)
1133  {
1134  if (pPktLen)
1135  *pPktLen = RadioConfiguration.packet_length_max_r;
1136  RdLen = RadioConfiguration.packet_length_max_r;
1137  if (RdLen > BufferLen)
1138  RdLen = BufferLen;
1139  if (Response == RIE_Success)
1140  Response = RadioMMapRead(PACKETRAM_START,RdLen, pData);
1141  }
1142  else
1143  {
1144  if (Response == RIE_Success)
1145  Response = RadioMMapRead(PACKETRAM_START,0x1, &RdLen);
1146  RdLen -= 0x1;
1147  if (pPktLen)
1148  *pPktLen = RdLen;
1149  if (RdLen > BufferLen)
1150  RdLen = BufferLen;
1151  if (Response == RIE_Success)
1152  Response = RadioMMapRead(PACKETRAM_START+0x1,RdLen, pData);
1153  }
1154 
1155  if (pRSSIdBm)
1156  {
1157  if (Response == RIE_Success)
1158  Response = RadioMMapRead(MCR_rssi_readback_Adr,0x1, (RIE_U8 *)pRSSIdBm);
1159 
1160  *pRSSIdBm -= 107; // Convert to dBm
1161  }
1162 
1163  }
1164  else
1165  {
1166  if (pPktLen)
1167  *pPktLen = 0x0;
1168  }
1169 
1170  return Response;
1171 }
1172 
1173 /**
1174  @fn RIE_Responses RadioRxBERTestMode(void)
1175  @brief Enter receiver Bit Error Rate (BER) test mode where the
1176  clock and data appear on GPIO pins.
1177  Clock on P0.6 and Data on P2.6
1178  @pre RadioInit() must be called before this function is called.
1179  @code
1180  Response = RadioRxBERTestMode();
1181  @endcode
1182  @note Terminate this mode by calling RadioTerminateRadioOp();
1183  @return RIE_Responses Error code
1184 **/
1185 RIE_Responses RadioRxBERTestMode(void)
1186 {
1187  RIE_Responses Response = RIE_Success;
1188  RIE_U8 Data;
1189  // Enables internal radio signals on external pins
1190  // but overrides some of the standard GPIO muxed
1191  // functionality (UART?)
1192  pADI_MISC->RFTST = 0x7E1;
1193 
1194  if(Response == RIE_Success)
1195  Response = RadioCommitRadioConfig();
1196 
1197  bTestModeEnabled = RIE_TRUE;
1198  // Enable the RX signals on GPIO pins
1199  Data = gpio_configure_sport_mode_0;
1200  if (Response == RIE_Success)
1201  Response = RadioMMapWrite(MCR_gpio_configure_Adr, 0x1, (RIE_U8 *)&Data);
1202 
1203  // disable ext_uc_clk on GP5
1204  Data = 0;
1205  if (Response == RIE_Success)
1206  Response = RadioMMapWrite(MCR_ext_uc_clk_divide_Adr,
1207  0x1,
1208  (RIE_U8 *)&Data);
1209  if (Response == RIE_Success)
1210  Response = RadioSendCommandWait(CMD_PHY_RX);
1211  return Response;
1212 }
1213 
1214 /**
1215  @internal Hide from Doxegen
1216  @fn RIE_Responses RadioCommitRadioConfig(void)
1217  @brief Configures the radio if any changes were made
1218  since the last time.
1219  @return RIE_Responses Error code
1220 **/
1221 static RIE_Responses RadioCommitRadioConfig(void)
1222 {
1223  RIE_Responses Response = RIE_Success;
1224 
1225  if(bTestModeEnabled)
1226  {
1227  RIE_U8 Data;
1228  Data = gpio_configure_default;
1229  if (Response == RIE_Success)
1230  Response = RadioMMapWrite(MCR_gpio_configure_Adr, 0x1, (RIE_U8 *)&Data);
1231  Data = 4;
1232  if (Response == RIE_Success)
1233  Response = RadioMMapWrite(MCR_ext_uc_clk_divide_Adr,
1234  0x1,
1235  (RIE_U8 *)&Data);
1236 
1237  Data = PARAM_TX_NORMAL_PACKET;
1238  if (Response == RIE_Success)
1239  Response = RadioMMapWrite(PR_var_tx_mode_ADR,sizeof(Data),&Data);
1240  bTestModeEnabled = RIE_FALSE;
1241  }
1242  if (bRadioConfigurationChanged)
1243  {
1244  Response = RadioConfigure();
1245  if(Response == RIE_Success)
1246  bRadioConfigurationChanged = RIE_FALSE;
1247  }
1248  return Response;
1249 }
1250 /**
1251  @fn RIE_Responses RadioReadState(RadioState *pState)
1252  @brief Read the current state
1253  @param pState Pointer to return storage of state
1254  @return RIE_Responses Error code
1255 **/
1256 static RIE_Responses RadioReadState(RadioState *pState)
1257 {
1258  RIE_Responses Response = RIE_Success;
1259  RIE_U8 StatusByte;
1260 
1261  NVIC_DisableIRQ(UHFTRX_IRQn);
1262  RADIO_CSN_ASSERT;
1263  if (Response == RIE_Success)
1264  Response = RadioSPIXferByte(SPI_NOP,NULL);
1265  if (Response == RIE_Success)
1266  Response = RadioSPIXferByte(SPI_NOP,&StatusByte);
1267  RADIO_CSN_DEASSERT;
1268  NVIC_EnableIRQ (UHFTRX_IRQn);
1269  if ((Response == RIE_Success) && pState)
1270  *pState = (RadioState)(StatusByte & STATUS_BYTE_FW_STATE);
1271  return Response;
1272 }
1273 
1274 /**
1275  @fn RIE_Responses RadioWaitOnState(RadioState FinalState)
1276  @brief Wait for Final State to be reached
1277  @param FinalState State to wait on
1278  @return RIE_Responses Error code
1279 **/
1280 static RIE_Responses RadioWaitOnState(RadioState FinalState)
1281 {
1282  RIE_Responses Response = RIE_Success;
1283  RadioState CurrState;
1284  do
1285  {
1286  Response = RadioReadState(&CurrState);
1287  }
1288  while((Response == RIE_Success) && (CurrState != FinalState));
1289  return Response;
1290 }
1291 
1292 /**
1293  @fn RIE_Responses RadioWaitOnCmdLdr(void)
1294  @brief Wait for Final State to be reached
1295  @return RIE_Responses Error code
1296 **/
1297 static RIE_Responses RadioWaitOnCmdLdr(void)
1298 {
1299  RIE_Responses Response = RIE_Success;
1300  do
1301  {
1302  RIE_U8 StatusByte;
1303  NVIC_DisableIRQ(UHFTRX_IRQn);
1304  RADIO_CSN_ASSERT;
1305  if (Response == RIE_Success)
1306  Response = RadioSPIXferByte(SPI_NOP,NULL);
1307  if (Response == RIE_Success)
1308  Response = RadioSPIXferByte(SPI_NOP,&StatusByte);
1309  RADIO_CSN_DEASSERT;
1310  NVIC_EnableIRQ (UHFTRX_IRQn);
1311  if ((Response == RIE_Success))
1312  if(StatusByte & STATUS_BYTE_CMD_READY)
1313  break;
1314  }
1315  while((Response == RIE_Success));
1316  return Response;
1317 }
1318 
1319 /**
1320  @internal Hide from Doxegen
1321  @fn RIE_Responses RadioToOnMode(void)
1322  @brief Transition to On Mode
1323 
1324  Handle all possible states that the radio could be in
1325  and brings it back to PHY_ON state
1326  @param None
1327  @return RIE_Responses Error code
1328 **/
1329 static RIE_Responses RadioToOnMode(void)
1330 {
1331  RIE_Responses Response = RIE_Success;
1332  RadioState FwState;
1333 
1334  if (Response == RIE_Success)
1335  Response = RadioReadState(&FwState);
1336 
1337  while ((FwState != FW_ON) && (Response == RIE_Success))
1338  {
1339  switch (FwState)
1340  {
1341  case FW_BUSY:
1342  break;
1343  case FW_TX:
1344  if(Response == RIE_Success)
1345  Response = RadioSendCommandNoWait(CMD_PHY_ON);
1346  if (Response == RIE_Success)
1347  Response = RadioWaitOnState (FW_ON);
1348  break;
1349  case FW_RX:
1350  if(Response == RIE_Success)
1351  Response = RadioSendCommandNoWait(CMD_PHY_ON);
1352  if (Response == RIE_Success)
1353  Response = RadioWaitOnState (FW_ON);
1354  break;
1355  default:
1356  if(Response == RIE_Success)
1357  Response = RadioSendCommandNoWait(CMD_PHY_ON);
1358  if (Response == RIE_Success)
1359  Response = RadioWaitOnState (FW_ON);
1360  break;
1361  }
1362  if (Response == RIE_Success)
1363  Response = RadioReadState(&FwState);
1364  }
1365  return Response;
1366 }
1367 /**
1368  @internal Hide from Doxegen
1369  @fn RIE_Responses RadioToOffMode(void)
1370  @brief Transition to Off Mode
1371 
1372  Handle all possible states that the radio could be in
1373  and bring it back to PHY_OFF state.
1374 
1375  @param None
1376  @return RIE_Responses Error code
1377 **/
1378 static RIE_Responses RadioToOffMode(void)
1379 {
1380  RIE_Responses Response = RIE_Success;
1381  RadioState FwState;
1382 
1383  if (Response == RIE_Success)
1384  Response = RadioReadState(&FwState);
1385 
1386  while ((FwState != FW_OFF) && (Response == RIE_Success))
1387  {
1388  switch (FwState)
1389  {
1390  case FW_BUSY:
1391  break;
1392  case FW_TX:
1393  if(Response == RIE_Success)
1394  Response = RadioSendCommandNoWait(CMD_PHY_ON);
1395  if (Response == RIE_Success)
1396  Response = RadioWaitOnState (FW_ON);
1397  break;
1398  case FW_RX:
1399  if(Response == RIE_Success)
1400  Response = RadioSendCommandNoWait(CMD_PHY_ON);
1401  if (Response == RIE_Success)
1402  Response = RadioWaitOnState (FW_ON);
1403  break;
1404  default:
1405  if(Response == RIE_Success)
1406  Response = RadioSendCommandNoWait(CMD_PHY_OFF);
1407  if (Response == RIE_Success)
1408  Response = RadioWaitOnState (FW_OFF);
1409  break;
1410  }
1411  if (Response == RIE_Success)
1412  Response = RadioReadState(&FwState);
1413  }
1414  return Response;
1415 }
1416 /**
1417  @internal Hide from Doxegen
1418  @fn RIE_Responses RadioSyncComms (void)
1419  @brief Sync comms with the radio
1420  @param None
1421  @return RIE_Responses Error code
1422 **/
1423 static RIE_Responses RadioSyncComms (void)
1424 {
1425  RIE_Responses Response = RIE_Success;
1426  if (Response == RIE_Success)
1427  Response = RadioSendCommandWait(CMD_SYNC);
1428  if (Response == RIE_Success)
1429  Response = RadioWaitOnCmdLdr();
1430  return Response;
1431 }
1432 /**
1433  @fn RIE_Responses RadioWaitForPowerUp(void)
1434  @brief Wake Up the Part
1435 
1436  Assert SPI chip select which will wake up the radio if asleep
1437  Wait for MISO line to go high indicating SPI comms now possible
1438 
1439  @return RIE_Responses Error code
1440 **/
1441 static RIE_Responses RadioWaitForPowerUp(void)
1442 {
1443  RIE_Responses Response = RIE_Success;
1444  int i = 0x0;
1445  RADIO_CSN_ASSERT;
1446  while (!RADIO_MISO_IN && (i < 1000))
1447  i++;
1448  if (1000 == i)// Timed out waiting for MISO high?
1449  Response = RIE_RadioSPICommsFail;
1450  RADIO_CSN_DEASSERT;
1451  return Response;
1452 }
1453 
1454 /**
1455  \internal Hide from Doxegen
1456  \fn void Ext_Int8_Handler(void)
1457  \brief Radio Interrupt Handler
1458 **/
1459 extern void aducrf101_rx_packet_hook(void);
1460 void Ext_Int8_Handler (void)
1461 {
1462  RIE_Responses Response = RIE_Success;
1463  RIE_U8 ucInt0;
1464  RIE_U8 ucInt1;
1465 
1466  if (Response == RIE_Success)
1467  Response = RadioMMapRead(MCR_interrupt_source_0_Adr,0x1, &ucInt0);
1468  if (Response == RIE_Success)
1469  Response = RadioMMapRead(MCR_interrupt_source_1_Adr,0x1,&ucInt1);
1470  if (ucInt0 & interrupt_mask_0_interrupt_tx_eof)
1471  bPacketTx = RIE_TRUE;
1472  if (ucInt0 & interrupt_mask_0_interrupt_crc_correct) {
1473  bPacketRx = RIE_TRUE;
1474  aducrf101_rx_packet_hook();
1475  }
1476  // Clear all the interrupts that we have just handleed
1477  if (Response == RIE_Success)
1478  Response = RadioMMapWrite(MCR_interrupt_source_0_Adr,0x1, &ucInt0);
1479  if (Response == RIE_Success)
1480  Response = RadioMMapWrite(MCR_interrupt_source_1_Adr,0x1,&ucInt1);
1481  // Clear the interrupt
1482  pADI_INTERRUPT->EICLR = EICLR_IRQ8;
1483 }
1484 /**
1485  \internal Hide from Doxegen
1486  \fn void RadioSPIXferByte(RIE_U8 ucByte,RIE_U8 *pData)
1487  \brief Transfer a byte via SPI to the radio and optionally return
1488  received byte.
1489  Chip Select is manually controlled elsewhere.
1490  \param ucByte Command or data byte to be transferred.
1491  \param pData NULL, or storage for response
1492  \return RIE_Responses Error code
1493 **/
1494 static RIE_Responses RadioSPIXferByte(RIE_U8 ucByte,RIE_U8 *pData)
1495 {
1496  RIE_Responses Response = RIE_Success;
1497 
1498  SEND_SPI(ucByte); // Send byte
1499  WAIT_SPI_RX; // wait for data received status bit
1500  if(pData)
1501  *pData = READ_SPI;
1502  else
1503  (void)READ_SPI;
1504  return Response;
1505 }
1506 /**
1507  \internal Hide from Doxegen
1508  \fn RIE_Responses RadioSendCommandBytes(RIE_U8 *pCmdBytes,RIE_U8 NumBytes)
1509  \brief Send a complete command to the radio.
1510 
1511  It is neccessary to disable the radio interrupt when doing this
1512  as a command in progress must finish before a radio interrupt
1513  can be handled.
1514 
1515  \param pCmdBytes Pointer to a number of bytes to be transferred.
1516  \param NumBytes Number of bytes to transfer
1517 
1518  \return RIE_Responses Error code
1519 **/
1520 static RIE_Responses RadioSendCommandBytes(RIE_U8 *pCmdBytes,RIE_U8 NumBytes)
1521 {
1522  RIE_Responses Response = RIE_Success;
1523 
1524  NVIC_DisableIRQ(UHFTRX_IRQn);
1525  RADIO_CSN_ASSERT;
1526  while ((NumBytes--) && (Response == RIE_Success))
1527  Response = RadioSPIXferByte(*(pCmdBytes++),NULL); // Send Command
1528  RADIO_CSN_DEASSERT; // De-assert SPI chip select
1529  NVIC_EnableIRQ (UHFTRX_IRQn);
1530 
1531  return Response;
1532 }
1533 /**
1534  \internal Hide from Doxegen
1535  \fn RIE_Responses RadioSendCommandNoWait (Radio_CmdCodes CmdCode )
1536  \brief Send a single byte command to the radio.
1537  \param CmdCode Command code to be sent
1538  \return RIE_Responses Error code
1539 **/
1540 static RIE_Responses RadioSendCommandNoWait (Radio_CmdCodes CmdCode )
1541 {
1542  RIE_U8 Command = (RIE_U8)CmdCode;
1543  return RadioSendCommandBytes(&Command,0x1);
1544 }
1545 /**
1546  \internal Hide from Doxegen
1547  \fn RIE_Responses RadioSendCommandWait (Radio_CmdCodes CmdCode )
1548  \brief Send a single byte command to the radio.
1549  \param CmdCode Command code to be sent
1550  \return RIE_Responses Error code
1551 **/
1552 static RIE_Responses RadioSendCommandWait (Radio_CmdCodes CmdCode )
1553 {
1554  RIE_Responses Response = RIE_Success;
1555  RIE_U8 Command = (RIE_U8)CmdCode;
1556 
1557  if (Response == RIE_Success)
1558  Response = RadioWaitOnCmdLdr();
1559  if (Response == RIE_Success)
1560  Response = RadioSendCommandBytes(&Command,0x1);
1561  return Response;
1562 }
1563 /**
1564  \fn RIE_Responses RadioMMapRead(RIE_U32 ulAdr, RIE_U32 ulLen, RIE_U8 *pData)
1565  \brief Read bytes from specified memory map address
1566  \param ulAdr Address to read at.
1567  \param ulLen Length of data to read.
1568  \param pData Pointer to location to stored read data.
1569  \return RIE_Responses Error code
1570 **/
1571 static RIE_Responses RadioMMapRead(RIE_U32 ulAdr, RIE_U32 ulLen, RIE_U8 *pData)
1572 {
1573  RIE_Responses Response = RIE_Success;
1574 
1575  NVIC_DisableIRQ(UHFTRX_IRQn);
1576  RADIO_CSN_ASSERT;
1577 
1578  if(Response == RIE_Success) // Send first byte (SPI_MEMR_RD + Bytes)
1579  Response = RadioSPIXferByte(SPI_MEM_RD | ((ulAdr & 0x700) >> 8),NULL);
1580  if(Response == RIE_Success)// Send Second byte remainder of address
1581  Response = RadioSPIXferByte((RIE_U8)(ulAdr & 0xFF),NULL);
1582  if(Response == RIE_Success)
1583  Response = RadioSPIXferByte((RIE_U8)SPI_NOP,NULL);
1584  while(ulLen-- && (Response == RIE_Success))
1585  Response = RadioSPIXferByte(SPI_NOP,pData++);
1586  RADIO_CSN_DEASSERT;
1587  NVIC_EnableIRQ (UHFTRX_IRQn);
1588 
1589  return Response;
1590 }
1591 /**
1592  \fn RIE_Responses RadioMMapWrite(RIE_U32 ulAdr, RIE_U32 ulLen, RIE_U8 *pData)
1593  \brief Read bytes from specified memory map address
1594  \param ulAdr Address to read at.
1595  \param ulLen Length of data to read.
1596  \param pData Pointer to location of data to write.
1597  \return RIE_Responses Error code
1598 **/
1599 static RIE_Responses RadioMMapWrite(RIE_U32 ulAdr,RIE_U32 ulLen,RIE_U8 * pData)
1600 {
1601  RIE_Responses Response = RIE_Success;
1602 
1603  NVIC_DisableIRQ(UHFTRX_IRQn);
1604  RADIO_CSN_ASSERT;
1605  if(Response == RIE_Success) // Send first byte (SPI_MEMR_WR + Bytes)
1606  Response = RadioSPIXferByte(SPI_MEM_WR | ((ulAdr & 0x700) >> 8),NULL);
1607  if(Response == RIE_Success) // Send Second byte remainder of addrress
1608  Response = RadioSPIXferByte((RIE_U8)(ulAdr & 0xFF),NULL);
1609  while(ulLen-- && (Response == RIE_Success))
1610  Response = RadioSPIXferByte(*(pData++),NULL);
1611  RADIO_CSN_DEASSERT;
1612  NVIC_EnableIRQ (UHFTRX_IRQn);
1613 
1614  return Response;
1615 }
1616 
1617 /**
1618  \internal Hide from Doxegen
1619  \fn void SetRadioConfiguration(void)
1620  \brief Create a default radio configuration that all base configurations
1621  are derived from.
1622 
1623  \return RIE_Responses Error code
1624 **/
1625 static RIE_Responses SetRadioConfiguration(RIE_BaseConfigs BaseConfig)
1626 {
1627  RIE_Responses Response = RIE_Success;
1628 
1629  bRadioConfigurationChanged = RIE_TRUE;
1630  switch (BaseConfig)
1631  {
1632  case DR_1_0kbps_Dev10_0kHz:
1633  memcpy((void *)&RadioConfiguration,
1634  (void *)DR_1_0kbps_Dev10_0kHz_Configuration,
1635  sizeof(TyRadioConfiguration));
1636  DataRate = 1000;
1637  break;
1638  case DR_38_4kbps_Dev20kHz:
1639  memcpy((void *)&RadioConfiguration,
1640  (void *)DR_38_4kbps_Dev20kHz_Configuration,
1641  sizeof(TyRadioConfiguration));
1642  DataRate = 38400;
1643  break;
1644  case DR_300_0kbps_Dev75_0kHz:
1645  memcpy((void *)&RadioConfiguration,
1646  (void *)DR_300_0kbps_Dev75_0kHz_Configuration,
1647  sizeof(TyRadioConfiguration));
1648  DataRate = 300000;
1649  break;
1650  default:
1651  Response = RIE_UnsupportedRadioConfig;
1652  break;
1653  }
1654  return Response;
1655 }
1656 /**
1657  @internal Hide from Doxegen
1658  @fn RIE_Responses RadioConfigure (void)
1659  @brief Configure the Radio as per the current configuration
1660  @return RIE_Responses Error code
1661 **/
1662 RIE_Responses RadioConfigure (void)
1663 {
1664  RIE_Responses Response = RIE_Success;
1665  if(Response == RIE_Success)
1666  Response = RadioToOffMode();
1667  if(Response == RIE_Success) // Write the configuration to the radio memory
1668  Response = RadioMMapWrite(BBRAM_START,
1669  sizeof(TyRadioConfiguration),
1670  (RIE_U8 *)&RadioConfiguration);
1671  if(Response == RIE_Success) // Apply that configuration to the radio
1672  Response = RadioSendCommandWait(CMD_CONFIG_DEV);
1673  if(Response == RIE_Success)
1674  Response = RadioToOnMode();
1675  return Response;
1676 }
1677 
1678 
1679 /**
1680  @fn RIE_Responses RadioRadioGetRSSI (RIE_S8 *pRSSIdBm)
1681  @brief Return a Received Signal Strength Indicator value
1682  @param pRSSIdBm :{} detected RSSI in dBm.
1683  @pre RadioInit() must be called before this function is called.
1684  @code
1685  RIE_S8 RSSIdBm;
1686  if (RIE_Response == RIE_Success)
1687  RIE_Response = RadioRadioGetRSSI(&RSSIdBm);
1688  @endcode
1689  @return RIE_Responses Error code
1690 **/
1691 RIE_Responses RadioRadioGetRSSI (RIE_S8 *pRSSIdBm)
1692 {
1693  RIE_Responses Response = RIE_Success;
1694 
1695  if(Response == RIE_Success)
1696  Response = RadioCommitRadioConfig();
1697  if (Response == RIE_Success)
1698  Response = RadioToOnMode();
1699  if (Response == RIE_Success)
1700  Response = RadioSendCommandWait(CMD_GET_RSSI);
1701  if (Response == RIE_Success)
1702  Response = RadioSyncComms(); //
1703  if (pRSSIdBm)
1704  {
1705  if (Response == RIE_Success)
1706  Response = RadioMMapRead(MCR_rssi_readback_Adr,0x1, (RIE_U8 *)pRSSIdBm);
1707  *pRSSIdBm -= 107; // Convert to dBm
1708  }
1709  return Response;
1710 }
1711 
1712 /**
1713  @fn RIE_Responses RadioTxSetPower(RIE_PAPowerLevel Power)
1714  @brief Set the Transmit Power Level for Radio Transmission.
1715  @param Power :{PowerLevel0 ,PowerLevel1 ,PowerLevel2 ,PowerLevel3,
1716  PowerLevel4 ,PowerLevel5 ,PowerLevel6 ,PowerLevel7,
1717  PowerLevel8 ,PowerLevel9 ,PowerLevel10,PowerLevel11,
1718  PowerLevel12,PowerLevel13,PowerLevel14,PowerLevel15}
1719  @pre RadioInit() must be called before this function is called.
1720  @code
1721  Response = RadioTxSetPower(PowerLevel8);
1722  @endcode
1723  @note Max TX Power is used by default.
1724  @return RIE_Responses Error code
1725 */
1726 RIE_Responses RadioTxSetPower (RIE_PAPowerLevel Power)
1727 {
1728  RIE_Responses Response = RIE_Success;
1729  RIE_U8 ucNewRegVal = RadioConfiguration.radio_cfg_8_r;
1730  unsigned long pa_level_mcr,pa_ramp, codes_per_bit,min_codes_per_bit;
1731 
1732  if (RadioConfiguration.radio_cfg_8_r & radio_cfg_8_pa_single_diff_sel_differential)
1733  ucNewRegVal = radio_cfg_8_pa_single_diff_sel_differential;
1734  else
1735  ucNewRegVal = radio_cfg_8_pa_single_diff_sel_single_ended;
1736 
1737  if(Response == RIE_Success)
1738  {
1739  switch (Power)
1740  {
1741  case PowerLevel0 :
1742  case PowerLevel1 :
1743  case PowerLevel2 :
1744  case PowerLevel3 :
1745  case PowerLevel4 :
1746  case PowerLevel5 :
1747  case PowerLevel6 :
1748  case PowerLevel7 :
1749  case PowerLevel8 :
1750  case PowerLevel9 :
1751  case PowerLevel10:
1752  case PowerLevel11:
1753  case PowerLevel12:
1754  case PowerLevel13:
1755  case PowerLevel14:
1756  case PowerLevel15:
1757  ucNewRegVal |= ((RIE_U8)Power << radio_cfg_8_pa_power_offset);
1758  // Calculate the minimum allowable codes per bit
1759  pa_level_mcr = (((RIE_U8)Power)* 4) + 0x3;
1760  min_codes_per_bit = (pa_level_mcr * 2500)/(DataRate/100);
1761  pa_ramp = 0x1;
1762  codes_per_bit = 256;
1763  while (codes_per_bit > min_codes_per_bit)
1764  {
1765  pa_ramp++;
1766  codes_per_bit = 512 >> pa_ramp;
1767  if (pa_ramp >= 7)
1768  break; // This is the maximum
1769  }
1770  ucNewRegVal |= ((RIE_U8)pa_ramp << radio_cfg_8_pa_ramp_offset);
1771  break;
1772  default:
1773  Response = RIE_UnsupportedRadioConfig;
1774  break;
1775  }
1776  }
1777 
1778  if(Response == RIE_Success)
1779  {
1780  if (ucNewRegVal != RadioConfiguration.radio_cfg_8_r )
1781  {
1782  // Write directly to the MCR in this case and avoid a reconfigure
1783  if (Response == RIE_Success)
1784  Response = RadioMMapWrite(MCR_pa_level_mcr_Adr, 0x1, (RIE_U8 *)&ucNewRegVal);
1785  RadioConfiguration.radio_cfg_8_r = ucNewRegVal;
1786  }
1787  }
1788  return Response;
1789 }
1790 
RadioTxCarrier
RIE_Responses RadioTxCarrier(void)
Transmit a carrier tone using the current radio configuration.
Definition: radioeng.c:959
RadioRxPacketVariableLen
RIE_Responses RadioRxPacketVariableLen(void)
Enter receive mode and wait for a packet to be received.
Definition: radioeng.c:1050
RadioMMapRead
static RIE_Responses RadioMMapRead(RIE_U32 ulAdr, RIE_U32 ulLen, RIE_U8 *pData)
Read bytes from specified memory map address.
Definition: radioeng.c:1571
RadioTxPreamble
RIE_Responses RadioTxPreamble(void)
Transmit a pre-amble (alternating ones and zeros) using the current radio configuration.
Definition: radioeng.c:987
RIE_PATypes
RIE_PATypes
Definition: radioeng.h:90
RadioTxSetPA
RIE_Responses RadioTxSetPA(RIE_PATypes PAType, RIE_PAPowerLevel Power)
Set PA Type and the Transmit Power Level for Radio Transmission.
Definition: radioeng.c:879
RadioWaitForPowerUp
static RIE_Responses RadioWaitForPowerUp(void)
Wake Up the Part.
Definition: radioeng.c:1441
RIE_ModulationTypes
RIE_ModulationTypes
Definition: radioeng.h:79
NVIC_EnableIRQ
__STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn)
Enable External Interrupt.
Definition: core_cm0.h:535
RadioTxPacketComplete
RIE_BOOL RadioTxPacketComplete(void)
Checks if a packet has finished transmitting.
Definition: radioeng.c:858
NVIC_DisableIRQ
__STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn)
Disable External Interrupt.
Definition: core_cm0.h:547
RadioRxBERTestMode
RIE_Responses RadioRxBERTestMode(void)
Enter receiver Bit Error Rate (BER) test mode where the clock and data appear on GPIO pins...
Definition: radioeng.c:1185
RadioRxPacketFixedLen
RIE_Responses RadioRxPacketFixedLen(RIE_U8 Len)
Enter receive mode and wait for a packet to be received.
Definition: radioeng.c:1017
RadioRxPacketAvailable
RIE_BOOL RadioRxPacketAvailable(void)
Checks if a packet has been received.
Definition: radioeng.c:1092
aducrf101_rx_packet_hook
void aducrf101_rx_packet_hook(void)
Trigger function called by ADI radio engine upon packet RX.
Definition: radio.c:405
RadioTxSetPower
RIE_Responses RadioTxSetPower(RIE_PAPowerLevel Power)
Set the Transmit Power Level for Radio Transmission.
Definition: radioeng.c:1726
RadioTxPacketFixedLen
RIE_Responses RadioTxPacketFixedLen(RIE_U8 Len, RIE_U8 *pData)
Transmit a fixed length packet.
Definition: radioeng.c:772
NVIC_SetPriority
__STATIC_INLINE void NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
Set Interrupt Priority.
Definition: core_cm0.h:602
NVIC_ClearPendingIRQ
__STATIC_INLINE void NVIC_ClearPendingIRQ(IRQn_Type IRQn)
Clear Pending Interrupt.
Definition: core_cm0.h:587
RIE_BOOL
RIE_BOOL
Definition: radioeng.h:110
RadioTxPacketVariableLen
RIE_Responses RadioTxPacketVariableLen(RIE_U8 Len, RIE_U8 *pData)
Transmit a Variable length packet.
Definition: radioeng.c:813
NULL
#define NULL
The null pointer.
Definition: platform-common.h:186
RIE_BaseConfigs
RIE_BaseConfigs
Definition: radioeng.h:62
RadioPowerOff
RIE_Responses RadioPowerOff(void)
Shutdown the radio and place it in its lowest power sleep mode.
Definition: radioeng.c:521
RadioSetModulationType
RIE_Responses RadioSetModulationType(RIE_ModulationTypes ModulationType)
Set the Radio Transmitter Modulation Type.
Definition: radioeng.c:612
RadioSwitchConfig
RIE_Responses RadioSwitchConfig(RIE_BaseConfigs BaseConfig)
Change the Radio to using specified configuration.
Definition: radioeng.c:369
RadioWaitOnState
static RIE_Responses RadioWaitOnState(RadioState FinalState)
Wait for Final State to be reached.
Definition: radioeng.c:1280
RadioSetFrequency
RIE_Responses RadioSetFrequency(RIE_U32 Frequency)
Set frequency for radio communications.
Definition: radioeng.c:574
RadioPayldManchesterEncode
RIE_Responses RadioPayldManchesterEncode(RIE_BOOL bEnable)
Enable or Disable Manchester Encoding of payload data.
Definition: radioeng.c:670
RadioMMapWrite
static RIE_Responses RadioMMapWrite(RIE_U32 ulAdr, RIE_U32 ulLen, RIE_U8 *pData)
Read bytes from specified memory map address.
Definition: radioeng.c:1599
RadioGetAPIVersion
RIE_Responses RadioGetAPIVersion(RIE_U32 *pVersion)
Return the Radio Interface Engine API Version.
Definition: radioeng.c:347
RadioDeInit
RIE_Responses RadioDeInit(void)
Deinitialise the Radio, and power it down.
Definition: radioeng.c:472
RadioReadState
static RIE_Responses RadioReadState(RadioState *pState)
Read the current state.
Definition: radioeng.c:1256
RadioWaitOnCmdLdr
static RIE_Responses RadioWaitOnCmdLdr(void)
Wait for Final State to be reached.
Definition: radioeng.c:1297
RadioTerminateRadioOp
RIE_Responses RadioTerminateRadioOp(void)
Terminate a currently running radio RX or TX operation.
Definition: radioeng.c:551
RIE_Responses
RIE_Responses
Definition: radioeng.h:131
RadioPayldDataWhitening
RIE_Responses RadioPayldDataWhitening(RIE_BOOL bEnable)
Enable or Disable Data Whitening of payload data.
Definition: radioeng.c:729
RadioInit
RIE_Responses RadioInit(RIE_BaseConfigs BaseConfig)
Initialise the Radio, using specified configuration.
Definition: radioeng.c:396
RadioRxPacketRead
RIE_Responses RadioRxPacketRead(RIE_U8 BufferLen, RIE_U8 *pPktLen, RIE_U8 *pData, RIE_S8 *pRSSIdBm)
Read the packet that was received by the radio.
Definition: radioeng.c:1125
RadioRadioGetRSSI
RIE_Responses RadioRadioGetRSSI(RIE_S8 *pRSSIdBm)
Return a Received Signal Strength Indicator value.
Definition: radioeng.c:1691
Generated on Thu Jul 6 2017 20:52:44 for Contiki 3.x by   doxygen 1.8.6