Blame view

emetteur/SX1276Lib/radio/radio.h 13.4 KB
64abd45d   rcavalie   arrangements fich...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
  /*
   / _____)             _              | |
  ( (____  _____ ____ _| |_ _____  ____| |__
   \____ \| ___ |    (_   _) ___ |/ ___)  _ \
   _____) ) ____| | | || |_| ____( (___| | | |
  (______/|_____)_|_|_| \__)_____)\____)_| |_|
      (C) 2014 Semtech
  
  Description: Interface for the radios, contains the main functions that a radio needs, and 5 callback functions
  
  License: Revised BSD License, see LICENSE.TXT file include in the project
  
  Maintainers: Miguel Luis, Gregory Cristian and Nicolas Huguenin
  */
  #ifndef __RADIO_H__
  #define __RADIO_H__
  
  #include "mbed.h"
  
  #include "./enums/enums.h"
  
  /*!
   * @brief Radio driver callback functions
   */
  typedef struct
  {
      /*!
       * @brief  Tx Done callback prototype.
       */
      void    ( *TxDone )( void );
      /*!
       * @brief  Tx Timeout callback prototype.
       */
      void    ( *TxTimeout )( void );
      /*!
       * @brief Rx Done callback prototype.
       *
       * @param [IN] payload Received buffer pointer
       * @param [IN] size    Received buffer size
       * @param [IN] rssi    RSSI value computed while receiving the frame [dBm]
       * @param [IN] snr     Raw SNR value given by the radio hardware
       *                     FSK : N/A ( set to 0 )
       *                     LoRa: SNR value in dB
       */
      void    ( *RxDone )( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr );
      /*!
       * @brief  Rx Timeout callback prototype.
       */
      void    ( *RxTimeout )( void );
      /*!
       * @brief Rx Error callback prototype.
       */
      void    ( *RxError )( void );
      /*!
       * \brief  FHSS Change Channel callback prototype.
       *
       * \param [IN] currentChannel   Index number of the current channel
       */
      void ( *FhssChangeChannel )( uint8_t currentChannel );
      /*!
       * @brief CAD Done callback prototype.
       *
       * @param [IN] channelDetected    Channel Activity detected during the CAD
       */
      void ( *CadDone ) ( bool channelActivityDetected );
  }RadioEvents_t;
  
  /*!
   *    Interface for the radios, contains the main functions that a radio needs, and 5 callback functions
   */
  class Radio
  {
  protected:
      RadioEvents_t* RadioEvents;
  
  public:
      //-------------------------------------------------------------------------
      //                        Constructor
      //-------------------------------------------------------------------------
      /*!
       * @brief Constructor of the radio object, the parameters are the callback functions described in the header.
       *
       * @param [IN] events Structure containing the driver callback functions
       */
      Radio( RadioEvents_t *events );
      virtual ~Radio( ) {};
  
      //-------------------------------------------------------------------------
      //                        Pure virtual functions
      //-------------------------------------------------------------------------
      /*!
       * @brief Initializes the radio
       *
       * @param [IN] events Structure containing the driver callback functions
       */
      virtual void Init( RadioEvents_t *events ) = 0;
      /*!
       * @brief Return current radio status
       *
       * @param status Radio status.[RF_IDLE, RF_RX_RUNNING, RF_TX_RUNNING]
       */
      virtual RadioState GetStatus( void ) = 0; 
      /*!
       * @brief Configures the radio with the given modem
       *
       * @param [IN] modem Modem to be used [0: FSK, 1: LoRa] 
       */
      virtual void SetModem( RadioModems_t modem ) = 0;
      /*!
       * @brief Sets the channel frequency
       *
       * @param [IN] freq         Channel RF frequency
       */
      virtual void SetChannel( uint32_t freq ) = 0;
      /*!
       * @brief Sets the channels configuration
       *
       * @param [IN] modem      Radio modem to be used [0: FSK, 1: LoRa]
       * @param [IN] freq       Channel RF frequency
       * @param [IN] rssiThresh RSSI threshold
       *
       * @retval isFree         [true: Channel is free, false: Channel is not free]
       */
      virtual bool IsChannelFree( RadioModems_t modem, uint32_t freq, int16_t rssiThresh ) = 0;
      /*!
       * @brief Generates a 32 bits random value based on the RSSI readings
       *
       * \remark This function sets the radio in LoRa modem mode and disables
       *         all interrupts.
       *         After calling this function either Radio.SetRxConfig or
       *         Radio.SetTxConfig functions must be called.
       *
       * @retval randomValue    32 bits random value
       */
      virtual uint32_t Random( void )= 0;
      /*!
       * @brief Sets the reception parameters
       *
       * @param [IN] modem        Radio modem to be used [0: FSK, 1: LoRa]
       * @param [IN] bandwidth    Sets the bandwidth
       *                          FSK : >= 2600 and <= 250000 Hz
       *                          LoRa: [0: 125 kHz, 1: 250 kHz,
       *                                 2: 500 kHz, 3: Reserved]
       * @param [IN] datarate     Sets the Datarate
       *                          FSK : 600..300000 bits/s
       *                          LoRa: [6: 64, 7: 128, 8: 256, 9: 512,
       *                                10: 1024, 11: 2048, 12: 4096  chips]
       * @param [IN] coderate     Sets the coding rate ( LoRa only )
       *                          FSK : N/A ( set to 0 )
       *                          LoRa: [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
       * @param [IN] bandwidthAfc Sets the AFC Bandwidth ( FSK only )
       *                          FSK : >= 2600 and <= 250000 Hz
       *                          LoRa: N/A ( set to 0 )
       * @param [IN] preambleLen  Sets the Preamble length ( LoRa only )
       *                          FSK : N/A ( set to 0 )
       *                          LoRa: Length in symbols ( the hardware adds 4 more symbols )
       * @param [IN] symbTimeout  Sets the RxSingle timeout value
       *                          FSK : timeout number of bytes
       *                          LoRa: timeout in symbols
       * @param [IN] fixLen       Fixed length packets [0: variable, 1: fixed]
       * @param [IN] payloadLen   Sets payload length when fixed lenght is used
       * @param [IN] crcOn        Enables/Disables the CRC [0: OFF, 1: ON]
       * @param [IN] freqHopOn    Enables disables the intra-packet frequency hopping  [0: OFF, 1: ON] (LoRa only)
       * @param [IN] hopPeriod    Number of symbols bewteen each hop (LoRa only)
       * @param [IN] iqInverted   Inverts IQ signals ( LoRa only )
       *                          FSK : N/A ( set to 0 )
       *                          LoRa: [0: not inverted, 1: inverted]
       * @param [IN] rxContinuous Sets the reception in continuous mode
       *                          [false: single mode, true: continuous mode]
       */
      virtual void SetRxConfig ( RadioModems_t modem, uint32_t bandwidth,
                                 uint32_t datarate, uint8_t coderate,
                                 uint32_t bandwidthAfc, uint16_t preambleLen,
                                 uint16_t symbTimeout, bool fixLen,
                                 uint8_t payloadLen,
                                 bool crcOn, bool freqHopOn, uint8_t hopPeriod,
                                 bool iqInverted, bool rxContinuous ) = 0;
      /*!
       * @brief Sets the transmission parameters
       *
       * @param [IN] modem        Radio modem to be used [0: FSK, 1: LoRa]
       * @param [IN] power        Sets the output power [dBm]
       * @param [IN] fdev         Sets the frequency deviation ( FSK only )
       *                          FSK : [Hz]
       *                          LoRa: 0
       * @param [IN] bandwidth    Sets the bandwidth ( LoRa only )
       *                          FSK : 0
       *                          LoRa: [0: 125 kHz, 1: 250 kHz,
       *                                 2: 500 kHz, 3: Reserved]
       * @param [IN] datarate     Sets the Datarate
       *                          FSK : 600..300000 bits/s
       *                          LoRa: [6: 64, 7: 128, 8: 256, 9: 512,
       *                                10: 1024, 11: 2048, 12: 4096  chips]
       * @param [IN] coderate     Sets the coding rate ( LoRa only )
       *                          FSK : N/A ( set to 0 )
       *                          LoRa: [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
       * @param [IN] preambleLen  Sets the preamble length
       * @param [IN] fixLen       Fixed length packets [0: variable, 1: fixed]
       * @param [IN] crcOn        Enables disables the CRC [0: OFF, 1: ON]
       * @param [IN] freqHopOn    Enables disables the intra-packet frequency hopping  [0: OFF, 1: ON] (LoRa only)
       * @param [IN] hopPeriod    Number of symbols bewteen each hop (LoRa only)
       * @param [IN] iqInverted   Inverts IQ signals ( LoRa only )
       *                          FSK : N/A ( set to 0 )
       *                          LoRa: [0: not inverted, 1: inverted]
       * @param [IN] timeout      Transmission timeout [us]
       */
      virtual void SetTxConfig( RadioModems_t modem, int8_t power, uint32_t fdev,
                                uint32_t bandwidth, uint32_t datarate,
                                uint8_t coderate, uint16_t preambleLen,
                                bool fixLen, bool crcOn, bool freqHopOn,
                                uint8_t hopPeriod, bool iqInverted, uint32_t timeout ) = 0;
      /*!
       * @brief Checks if the given RF frequency is supported by the hardware
       *
       * @param [IN] frequency RF frequency to be checked
       * @retval isSupported [true: supported, false: unsupported]
       */
      virtual bool CheckRfFrequency( uint32_t frequency ) = 0;
      /*!
       * @brief Computes the packet time on air for the given payload
       *
       * \Remark Can only be called once SetRxConfig or SetTxConfig have been called
       *
       * @param [IN] modem      Radio modem to be used [0: FSK, 1: LoRa]
       * @param [IN] pktLen     Packet payload length
       *
       * @retval airTime        Computed airTime for the given packet payload length
       */
      virtual uint32_t TimeOnAir ( RadioModems_t modem, uint8_t pktLen ) = 0;
      /*!
       * @brief Sends the buffer of size. Prepares the packet to be sent and sets
       *        the radio in transmission
       *
       * @param [IN]: buffer     Buffer pointer
       * @param [IN]: size       Buffer size
       */
      virtual void Send( uint8_t *buffer, uint8_t size ) = 0;
      /*!
       * @brief Sets the radio in sleep mode
       */
      virtual void Sleep( void ) = 0;
      /*!
       * @brief Sets the radio in standby mode
       */
      virtual void Standby( void ) = 0;
      /*!
       * @brief Sets the radio in CAD mode
       */
      virtual void StartCad( void ) = 0;
      /*!
       * @brief Sets the radio in reception mode for the given time
       * @param [IN] timeout Reception timeout [us]
       *                     [0: continuous, others timeout]
       */
      virtual void Rx( uint32_t timeout ) = 0;
      /*!
       * @brief Sets the radio in transmission mode for the given time
       * @param [IN] timeout Transmission timeout [us]
       *                     [0: continuous, others timeout]
       */
      virtual void Tx( uint32_t timeout ) = 0;
      /*!
       * @brief Sets the radio in continuous wave transmission mode
       *
       * @param [IN]: freq       Channel RF frequency
       * @param [IN]: power      Sets the output power [dBm]
       * @param [IN]: time       Transmission mode timeout [s]
       */
      virtual void SetTxContinuousWave( uint32_t freq, int8_t power, uint16_t time ) = 0;
      /*!
       * @brief Reads the current RSSI value
       *
       * @retval rssiValue Current RSSI value in [dBm]
       */
      virtual int16_t GetRssi ( RadioModems_t modem ) = 0;
      /*!
       * @brief Writes the radio register at the specified address
       *
       * @param [IN]: addr Register address
       * @param [IN]: data New register value
       */
      virtual void Write ( uint8_t addr, uint8_t data ) = 0;
      /*!
       * @brief Reads the radio register at the specified address
       *
       * @param [IN]: addr Register address
       * @retval data Register value
       */
      virtual uint8_t Read ( uint8_t addr ) = 0;
      /*!
       * @brief Writes multiple radio registers starting at address
       *
       * @param [IN] addr   First Radio register address
       * @param [IN] buffer Buffer containing the new register's values
       * @param [IN] size   Number of registers to be written
       */
      virtual void Write( uint8_t addr, uint8_t *buffer, uint8_t size ) = 0;
      /*!
       * @brief Reads multiple radio registers starting at address
       *
       * @param [IN] addr First Radio register address
       * @param [OUT] buffer Buffer where to copy the registers data
       * @param [IN] size Number of registers to be read
       */
      virtual void Read ( uint8_t addr, uint8_t *buffer, uint8_t size ) = 0;
      /*!
       * @brief Writes the buffer contents to the Radio FIFO
       *
       * @param [IN] buffer Buffer containing data to be put on the FIFO.
       * @param [IN] size Number of bytes to be written to the FIFO
       */
      virtual void WriteFifo( uint8_t *buffer, uint8_t size ) = 0;
      /*!
       * @brief Reads the contents of the Radio FIFO
       *
       * @param [OUT] buffer Buffer where to copy the FIFO read data.
       * @param [IN] size Number of bytes to be read from the FIFO
       */
      virtual void ReadFifo( uint8_t *buffer, uint8_t size ) = 0;
      /*!
       * @brief Sets the maximum payload length.
       *
       * @param [IN] modem      Radio modem to be used [0: FSK, 1: LoRa]
       * @param [IN] max        Maximum payload length in bytes
       */
      virtual void SetMaxPayloadLength( RadioModems_t modem, uint8_t max ) = 0;
      /*!
       * @brief Sets the network to public or private. Updates the sync byte.
       *
       * @remark Applies to LoRa modem only
       *
       * @param [IN] enable if true, it enables a public network
       */
      virtual void SetPublicNetwork( bool enable ) = 0;
  };
  
  #endif // __RADIO_H__