Mistake on this page?
Report an issue in GitHub or email us
SX1272_LoRaRadio.h
1 /**
2  / _____) _ | |
3 ( (____ _____ ____ _| |_ _____ ____| |__
4  \____ \| ___ | (_ _) ___ |/ ___) _ \
5  _____) ) ____| | | || |_| ____( (___| | | |
6 (______/|_____)_|_|_| \__)_____)\____)_| |_|
7  (C)2013 Semtech
8  ___ _____ _ ___ _ _____ ___ ___ ___ ___
9 / __|_ _/_\ / __| |/ / __/ _ \| _ \/ __| __|
10 \__ \ | |/ _ \ (__| ' <| _| (_) | / (__| _|
11 |___/ |_/_/ \_\___|_|\_\_| \___/|_|_\\___|___|
12 embedded.connectivity.solutions===============
13 
14 Description: Radio driver for Semtech SX1272 radio. Implements LoRaRadio class.
15 
16 License: Revised BSD License, see LICENSE.TXT file include in the project
17 
18 Maintainer: Miguel Luis ( Semtech ), Gregory Cristian ( Semtech ) and Daniel Jaeckle ( STACKFORCE )
19 
20 
21 Copyright (c) 2017, Arm Limited and affiliates.
22 
23 SPDX-License-Identifier: BSD-3-Clause
24 */
25 
26 #ifndef SX1272_LORARADIO_H_
27 #define SX1272_LORARADIO_H_
28 
29 #if DEVICE_SPI
30 
31 #include "PinNames.h"
32 #include "InterruptIn.h"
33 #include "DigitalOut.h"
34 #include "DigitalInOut.h"
35 #include "SPI.h"
36 #include "platform/PlatformMutex.h"
37 #ifdef MBED_CONF_RTOS_PRESENT
38 #include "rtos/Thread.h"
39 #endif
40 
41 #include "lorawan/LoRaRadio.h"
42 
43 #ifdef MBED_CONF_SX1272_LORA_DRIVER_BUFFER_SIZE
44 #define MAX_DATA_BUFFER_SIZE_SX172 MBED_CONF_SX1272_LORA_DRIVER_BUFFER_SIZE
45 #else
46 #define MAX_DATA_BUFFER_SIZE_SX172 255
47 #endif
48 
49 #if DEVICE_LPTICKER
50 #include "LowPowerTimeout.h"
51 #define ALIAS_LORAWAN_TIMER mbed::LowPowerTimeout
52 #else
53 #include "Timeout.h"
54 #define ALIAS_LORAWAN_TIMER mbed::Timeout
55 #endif
56 
57 /**
58  * Radio driver implementation for Semtech SX1272 plus variants.
59  * Supports only SPI at the moment. Implements pure virtual LoRaRadio class.
60  */
61 class SX1272_LoRaRadio: public LoRaRadio {
62 public:
63  /**
64  * Use this constructor if pin definitions are provided manually.
65  * The pins that are marked NC are optional. It is assumed that these
66  * pins are not connected until/unless configured otherwise.
67  */
68  SX1272_LoRaRadio(PinName mosi = MBED_CONF_SX1272_LORA_DRIVER_SPI_MOSI,
69  PinName miso = MBED_CONF_SX1272_LORA_DRIVER_SPI_MISO,
70  PinName sclk = MBED_CONF_SX1272_LORA_DRIVER_SPI_SCLK,
71  PinName nss = MBED_CONF_SX1272_LORA_DRIVER_SPI_CS,
72  PinName reset = MBED_CONF_SX1272_LORA_DRIVER_RESET,
73  PinName dio0 = MBED_CONF_SX1272_LORA_DRIVER_DIO0,
74  PinName dio1 = MBED_CONF_SX1272_LORA_DRIVER_DIO1,
75  PinName dio2 = MBED_CONF_SX1272_LORA_DRIVER_DIO2,
76  PinName dio3 = MBED_CONF_SX1272_LORA_DRIVER_DIO3,
77  PinName dio4 = MBED_CONF_SX1272_LORA_DRIVER_DIO4,
78  PinName dio5 = MBED_CONF_SX1272_LORA_DRIVER_DIO5,
79  PinName rf_switch_ctl1 = MBED_CONF_SX1272_LORA_DRIVER_RF_SWITCH_CTL1,
80  PinName rf_switch_ctl2 = MBED_CONF_SX1272_LORA_DRIVER_RF_SWITCH_CTL2,
81  PinName txctl = MBED_CONF_SX1272_LORA_DRIVER_TXCTL,
82  PinName rxctl = MBED_CONF_SX1272_LORA_DRIVER_RXCTL,
83  PinName ant_switch = MBED_CONF_SX1272_LORA_DRIVER_ANT_SWITCH,
84  PinName pwr_amp_ctl = MBED_CONF_SX1272_LORA_DRIVER_PWR_AMP_CTL,
85  PinName tcxo = MBED_CONF_SX1272_LORA_DRIVER_TCXO
86  );
87 
88  /**
89  * Destructor
90  */
91  virtual ~SX1272_LoRaRadio();
92 
93  /**
94  * Registers radio events with the Mbed LoRaWAN stack and
95  * undergoes initialization steps if any
96  *
97  * @param events Structure containing the driver callback functions
98  */
99  virtual void init_radio(radio_events_t *events);
100 
101  /**
102  * Resets the radio module
103  */
104  virtual void radio_reset();
105 
106  /**
107  * Put the RF module in sleep mode
108  */
109  virtual void sleep(void);
110 
111  /**
112  * Sets the radio in standby mode
113  */
114  virtual void standby(void);
115 
116  /**
117  * Sets the reception parameters
118  *
119  * @param modem Radio modem to be used [0: FSK, 1: LoRa]
120  * @param bandwidth Sets the bandwidth
121  * FSK : >= 2600 and <= 250000 Hz
122  * LoRa: [0: 125 kHz, 1: 250 kHz,
123  * 2: 500 kHz, 3: Reserved]
124  * @param datarate Sets the Datarate
125  * FSK : 600..300000 bits/s
126  * LoRa: [6: 64, 7: 128, 8: 256, 9: 512,
127  * 10: 1024, 11: 2048, 12: 4096 chips]
128  * @param coderate Sets the coding rate ( LoRa only )
129  * FSK : N/A ( set to 0 )
130  * LoRa: [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
131  * @param bandwidth_afc Sets the AFC Bandwidth ( FSK only )
132  * FSK : >= 2600 and <= 250000 Hz
133  * LoRa: N/A ( set to 0 )
134  * @param preamble_len Sets the Preamble length ( LoRa only )
135  * FSK : N/A ( set to 0 )
136  * LoRa: Length in symbols ( the hardware adds 4 more symbols )
137  * @param symb_timeout Sets the RxSingle timeout value
138  * FSK : timeout number of bytes
139  * LoRa: timeout in symbols
140  * @param fixLen Fixed length packets [0: variable, 1: fixed]
141  * @param payload_len Sets payload length when fixed lenght is used
142  * @param crc_on Enables/Disables the CRC [0: OFF, 1: ON]
143  * @param freq_hop_on Enables disables the intra-packet frequency hopping [0: OFF, 1: ON] (LoRa only)
144  * @param hop_period Number of symbols bewteen each hop (LoRa only)
145  * @param iq_inverted Inverts IQ signals ( LoRa only )
146  * FSK : N/A ( set to 0 )
147  * LoRa: [0: not inverted, 1: inverted]
148  * @param rx_continuous Sets the reception in continuous mode
149  * [false: single mode, true: continuous mode]
150  */
151  virtual void set_rx_config(radio_modems_t modem, uint32_t bandwidth,
152  uint32_t datarate, uint8_t coderate,
153  uint32_t bandwidth_afc, uint16_t preamble_len,
154  uint16_t symb_timeout, bool fix_len,
155  uint8_t payload_len,
156  bool crc_on, bool freq_hop_on, uint8_t hop_period,
157  bool iq_inverted, bool rx_continuous);
158 
159  /**
160  * Sets the transmission parameters
161  *
162  * @param modem Radio modem to be used [0: FSK, 1: LoRa]
163  * @param power Sets the output power [dBm]
164  * @param fdev Sets the frequency deviation ( FSK only )
165  * FSK : [Hz]
166  * LoRa: 0
167  * @param bandwidth Sets the bandwidth ( LoRa only )
168  * FSK : 0
169  * LoRa: [0: 125 kHz, 1: 250 kHz,
170  * 2: 500 kHz, 3: Reserved]
171  * @param datarate Sets the Datarate
172  * FSK : 600..300000 bits/s
173  * LoRa: [6: 64, 7: 128, 8: 256, 9: 512,
174  * 10: 1024, 11: 2048, 12: 4096 chips]
175  * @param coderate Sets the coding rate ( LoRa only )
176  * FSK : N/A ( set to 0 )
177  * LoRa: [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
178  * @param preamble_len Sets the preamble length
179  * @param fix_len Fixed length packets [0: variable, 1: fixed]
180  * @param crc_on Enables disables the CRC [0: OFF, 1: ON]
181  * @param freq_hop_on Enables disables the intra-packet frequency hopping [0: OFF, 1: ON] (LoRa only)
182  * @param hop_period Number of symbols bewteen each hop (LoRa only)
183  * @param iq_inverted Inverts IQ signals ( LoRa only )
184  * FSK : N/A ( set to 0 )
185  * LoRa: [0: not inverted, 1: inverted]
186  * @param timeout Transmission timeout [ms]
187  */
188  virtual void set_tx_config(radio_modems_t modem, int8_t power, uint32_t fdev,
189  uint32_t bandwidth, uint32_t datarate,
190  uint8_t coderate, uint16_t preamble_len,
191  bool fix_len, bool crc_on, bool freq_hop_on,
192  uint8_t hop_period, bool iq_inverted, uint32_t timeout);
193 
194  /**
195  * Sends the buffer of size
196  *
197  * Prepares the packet to be sent and sets the radio in transmission
198  *
199  * @param buffer Buffer pointer
200  * @param size Buffer size
201  */
202  virtual void send(uint8_t *buffer, uint8_t size);
203 
204  /**
205  * For backwards compatibility
206  */
207  virtual void receive(uint32_t timeout)
208  {
209  (void) timeout;
210  receive();
211  }
212 
213  /**
214  * Sets the radio to receive
215  *
216  * All necessary configuration options for receptions are set in
217  * 'set_rx_config(parameters)' API.
218  */
219  virtual void receive(void);
220 
221  /**
222  * Sets the carrier frequency
223  *
224  * @param freq Channel RF frequency
225  */
226  virtual void set_channel(uint32_t freq);
227 
228  /**
229  * Generates a 32 bits random value based on the RSSI readings
230  *
231  * Remark this function sets the radio in LoRa modem mode and disables
232  * all interrupts.
233  * After calling this function either Radio.SetRxConfig or
234  * Radio.SetTxConfig functions must be called.
235  *
236  * @return 32 bits random value
237  */
238  virtual uint32_t random(void);
239 
240  /**
241  * Get radio status
242  *
243  * @param status Radio status [RF_IDLE, RF_RX_RUNNING, RF_TX_RUNNING]
244  * @return Return current radio status
245  */
246  virtual uint8_t get_status(void);
247 
248  /**
249  * Sets the maximum payload length
250  *
251  * @param modem Radio modem to be used [0: FSK, 1: LoRa]
252  * @param max Maximum payload length in bytes
253  */
254  virtual void set_max_payload_length(radio_modems_t modem, uint8_t max);
255 
256  /**
257  * Sets the network to public or private
258  *
259  * Updates the sync byte. Applies to LoRa modem only
260  *
261  * @param enable if true, it enables a public network
262  */
263  virtual void set_public_network(bool enable);
264 
265  /**
266  * Computes the packet time on air for the given payload
267  *
268  * Remark can only be called once SetRxConfig or SetTxConfig have been called
269  *
270  * @param modem Radio modem to be used [0: FSK, 1: LoRa]
271  * @param pkt_len Packet payload length
272  * @return Computed airTime for the given packet payload length
273  */
274  virtual uint32_t time_on_air(radio_modems_t modem, uint8_t pkt_len);
275 
276  /**
277  * Perform carrier sensing
278  *
279  * Checks for a certain time if the RSSI is above a given threshold.
280  * This threshold determines if there is already a transmission going on
281  * in the channel or not.
282  *
283  * @param modem Type of the radio modem
284  * @param freq Carrier frequency
285  * @param rssi_threshold Threshold value of RSSI
286  * @param max_carrier_sense_time time to sense the channel
287  *
288  * @return true if there is no active transmission
289  * in the channel, false otherwise
290  */
291  virtual bool perform_carrier_sense(radio_modems_t modem,
292  uint32_t freq,
293  int16_t rssi_threshold,
294  uint32_t max_carrier_sense_time);
295 
296  /**
297  * Sets the radio in CAD mode
298  *
299  */
300  virtual void start_cad(void);
301 
302  /**
303  * Check if the given RF is in range
304  *
305  * @param frequency frequency needed to be checked
306  */
307  virtual bool check_rf_frequency(uint32_t frequency);
308 
309  /** Sets the radio in continuous wave transmission mode
310  *
311  * @param freq Channel RF frequency
312  * @param power Sets the output power [dBm]
313  * @param time Transmission mode timeout [s]
314  */
315  virtual void set_tx_continuous_wave(uint32_t freq, int8_t power, uint16_t time);
316 
317  /**
318  * Acquire exclusive access
319  */
320  virtual void lock(void);
321 
322  /**
323  * Release exclusive access
324  */
325  virtual void unlock(void);
326 
327 private:
328 
329  // SPI and chip select control
330  mbed::SPI _spi;
331  mbed::DigitalOut _chip_select;
332 
333  // module rest control
334  mbed::DigitalInOut _reset_ctl;
335 
336  // Interrupt controls
337  mbed::InterruptIn _dio0_ctl;
338  mbed::InterruptIn _dio1_ctl;
339  mbed::InterruptIn _dio2_ctl;
340  mbed::InterruptIn _dio3_ctl;
341  mbed::InterruptIn _dio4_ctl;
342  mbed::InterruptIn _dio5_ctl;
343 
344  // Radio specific controls
345  mbed::DigitalOut _rf_switch_ctl1;
346  mbed::DigitalOut _rf_switch_ctl2;
347  mbed::DigitalOut _txctl;
348  mbed::DigitalOut _rxctl;
349  mbed::DigitalInOut _ant_switch;
350  mbed::DigitalOut _pwr_amp_ctl;
351  mbed::DigitalOut _tcxo;
352 
353  // Contains all RF control pin names
354  // This storage is needed even after assigning the
355  // pins to corresponding object, as the driver needs to know
356  // which control pins are connected and which are not. This
357  // variation is inherent to driver because of target configuration.
358  rf_ctrls _rf_ctrls;
359 
360  // We need these PinNames as not all modules have those connected
361  PinName _dio4_pin;
362  PinName _dio5_pin;
363 
364  // Structure containing all user and network specified settings
365  // for radio module
366  radio_settings_t _rf_settings;
367 
368  // Structure containing function pointers to the stack callbacks
369  radio_events_t *_radio_events;
370 
371  // Data buffer used for both TX and RX
372  // Size of this buffer is configurable via Mbed config system
373  // Default is 256 bytes
374  uint8_t _data_buffer[MAX_DATA_BUFFER_SIZE_SX172];
375 
376  // TX timer in ms. This timer is used as a fail safe for TX.
377  // If the chip fails to transmit, its a fatal error, reflecting
378  // some catastrophic bus failure etc. We wish to have the control
379  // back from the driver in such a case.
380  ALIAS_LORAWAN_TIMER tx_timeout_timer;
381 
382 #ifdef MBED_CONF_RTOS_PRESENT
383  // Thread to handle interrupts
384  rtos::Thread irq_thread;
385 #endif
386 
387  // Access protection
388  PlatformMutex mutex;
389 
390  uint8_t radio_variant;
391 
392  /**
393  * Flag used to set the RF switch control pins in low power mode when the radio is not active.
394  */
395  bool radio_is_active;
396 
397  // helper functions
398  void setup_registers();
399  void default_antenna_switch_ctrls();
400  void set_antenna_switch(uint8_t operation_mode);
401  void setup_spi();
402  void gpio_init();
403  void gpio_deinit();
404  void setup_interrupts();
405  void set_modem(uint8_t modem);
406  void set_operation_mode(uint8_t mode);
407  void set_low_power_mode(bool status);
408  void set_sx1272_variant_type();
409  uint8_t get_pa_conf_reg();
410  void set_rf_tx_power(int8_t power);
411  int16_t get_rssi(radio_modems_t modem);
412  uint8_t get_fsk_bw_reg_val(uint32_t bandwidth);
413  void write_to_register(uint8_t addr, uint8_t data);
414  void write_to_register(uint8_t addr, uint8_t *data, uint8_t size);
415  uint8_t read_register(uint8_t addr);
416  void read_register(uint8_t addr, uint8_t *buffer, uint8_t size);
417  void write_fifo(uint8_t *buffer, uint8_t size);
418  void read_fifo(uint8_t *buffer, uint8_t size);
419  void transmit(uint32_t timeout);
420  void rf_irq_task(void);
421 
422  // ISRs
423  void dio0_irq_isr();
424  void dio1_irq_isr();
425  void dio2_irq_isr();
426  void dio3_irq_isr();
427  void dio4_irq_isr();
428  void dio5_irq_isr();
429  void timeout_irq_isr();
430 
431  // Handlers called by thread in response to signal
432  void handle_dio0_irq();
433  void handle_dio1_irq();
434  void handle_dio2_irq();
435  void handle_dio3_irq();
436  void handle_dio4_irq();
437  void handle_dio5_irq();
438  void handle_timeout_irq();
439 };
440 
441 #endif // DEVICE_SPI
442 
443 #endif /* SX1272_LORARADIO_H_ */
The Thread class allow defining, creating, and controlling thread functions in the system...
Definition: Thread.h:92
virtual uint32_t time_on_air(radio_modems_t modem, uint8_t pkt_len)
Computes the packet time on air for the given payload.
virtual void receive(void)
Sets the radio to receive.
virtual void standby(void)
Sets the radio in standby mode.
enum modem_type radio_modems_t
Type of modem.
virtual void set_channel(uint32_t freq)
Sets the carrier frequency.
Structure to hold RF controls for LoRa Radio.
Definition: LoRaRadio.h:35
virtual void set_tx_config(radio_modems_t modem, int8_t power, uint32_t fdev, uint32_t bandwidth, uint32_t datarate, uint8_t coderate, uint16_t preamble_len, bool fix_len, bool crc_on, bool freq_hop_on, uint8_t hop_period, bool iq_inverted, uint32_t timeout)
Sets the transmission parameters.
virtual void start_cad(void)
Sets the radio in CAD mode.
virtual ~SX1272_LoRaRadio()
Destructor.
virtual void radio_reset()
Resets the radio module.
A digital input/output, used for setting or reading a bi-directional pin.
Definition: DigitalInOut.h:35
The PlatformMutex class is used to synchronize the execution of threads.
Definition: PlatformMutex.h:47
virtual void set_tx_continuous_wave(uint32_t freq, int8_t power, uint16_t time)
Sets the radio in continuous wave transmission mode.
Reporting functions for upper layers.
Definition: LoRaRadio.h:389
virtual void unlock(void)
Release exclusive access.
virtual void set_max_payload_length(radio_modems_t modem, uint8_t max)
Sets the maximum payload length.
virtual void set_rx_config(radio_modems_t modem, uint32_t bandwidth, uint32_t datarate, uint8_t coderate, uint32_t bandwidth_afc, uint16_t preamble_len, uint16_t symb_timeout, bool fix_len, uint8_t payload_len, bool crc_on, bool freq_hop_on, uint8_t hop_period, bool iq_inverted, bool rx_continuous)
Sets the reception parameters.
virtual void init_radio(radio_events_t *events)
Registers radio events with the Mbed LoRaWAN stack and undergoes initialization steps if any...
virtual void lock(void)
Acquire exclusive access.
virtual void send(uint8_t *buffer, uint8_t size)
Sends the buffer of size.
A digital interrupt input, used to call a function on a rising or falling edge.
Definition: InterruptIn.h:65
virtual void receive(uint32_t timeout)
For backwards compatibility.
virtual bool check_rf_frequency(uint32_t frequency)
Check if the given RF is in range.
A digital output, used for setting the state of a pin.
Definition: DigitalOut.h:49
SX1272_LoRaRadio(PinName mosi=MBED_CONF_SX1272_LORA_DRIVER_SPI_MOSI, PinName miso=MBED_CONF_SX1272_LORA_DRIVER_SPI_MISO, PinName sclk=MBED_CONF_SX1272_LORA_DRIVER_SPI_SCLK, PinName nss=MBED_CONF_SX1272_LORA_DRIVER_SPI_CS, PinName reset=MBED_CONF_SX1272_LORA_DRIVER_RESET, PinName dio0=MBED_CONF_SX1272_LORA_DRIVER_DIO0, PinName dio1=MBED_CONF_SX1272_LORA_DRIVER_DIO1, PinName dio2=MBED_CONF_SX1272_LORA_DRIVER_DIO2, PinName dio3=MBED_CONF_SX1272_LORA_DRIVER_DIO3, PinName dio4=MBED_CONF_SX1272_LORA_DRIVER_DIO4, PinName dio5=MBED_CONF_SX1272_LORA_DRIVER_DIO5, PinName rf_switch_ctl1=MBED_CONF_SX1272_LORA_DRIVER_RF_SWITCH_CTL1, PinName rf_switch_ctl2=MBED_CONF_SX1272_LORA_DRIVER_RF_SWITCH_CTL2, PinName txctl=MBED_CONF_SX1272_LORA_DRIVER_TXCTL, PinName rxctl=MBED_CONF_SX1272_LORA_DRIVER_RXCTL, PinName ant_switch=MBED_CONF_SX1272_LORA_DRIVER_ANT_SWITCH, PinName pwr_amp_ctl=MBED_CONF_SX1272_LORA_DRIVER_PWR_AMP_CTL, PinName tcxo=MBED_CONF_SX1272_LORA_DRIVER_TCXO)
Use this constructor if pin definitions are provided manually.
A SPI Master, used for communicating with SPI slave devices.
Definition: SPI.h:98
Global radio settings.
Definition: LoRaRadio.h:347
virtual uint32_t random(void)
Generates a 32 bits random value based on the RSSI readings.
Radio driver implementation for Semtech SX1272 plus variants.
virtual uint8_t get_status(void)
Get radio status.
Interface for the radios, containing the main functions that a radio needs, and five callback functio...
Definition: LoRaRadio.h:440
virtual bool perform_carrier_sense(radio_modems_t modem, uint32_t freq, int16_t rssi_threshold, uint32_t max_carrier_sense_time)
Perform carrier sensing.
virtual void set_public_network(bool enable)
Sets the network to public or private.
virtual void sleep(void)
Put the RF module in sleep mode.
Important Information for this Arm website

This site uses cookies to store information on your computer. By continuing to use our site, you consent to our cookies. If you are not happy with the use of these cookies, please review our Cookie Policy to learn how they can be disabled. By disabling cookies, some features of the site will not work.