Keil Studio Cloud
Mistake on this page?
Report an issue in GitHub or email us
STM32WL_LoRaRadio.h
1 /**
2  / _____) _ | |
3 ( (____ _____ ____ _| |_ _____ ____| |__
4  \____ \| ___ | (_ _) ___ |/ ___) _ \
5  _____) ) ____| | | || |_| ____( (___| | | |
6 (______/|_____)_|_|_| \__)_____)\____)_| |_|
7  (C)2015 Semtech
8  ___ _____ _ ___ _ _____ ___ ___ ___ ___
9 / __|_ _/_\ / __| |/ / __/ _ \| _ \/ __| __|
10 \__ \ | |/ _ \ (__| ' <| _| (_) | / (__| _|
11 |___/ |_/_/ \_\___|_|\_\_| \___/|_|_\\___|___|
12 embedded.connectivity.solutions===============
13 
14 Description: LoRaWAN stack layer that controls both MAC and PHY underneath
15 
16 License: Revised BSD License, see LICENSE.TXT file include in the project
17 
18 Maintainer: Miguel Luis, Gregory Cristian & Gilbert Menth
19 
20 Copyright (c) 2019, Arm Limited and affiliates.
21 
22 SPDX-License-Identifier: BSD-3-Clause
23 */
24 /**
25  ******************************************************************************
26  *
27  * Portions COPYRIGHT 2020 STMicroelectronics
28  *
29  * @file STM32WL_loRaRadio.h
30  * @author MCD Application Team
31  * @brief header of radio driver
32  ******************************************************************************
33  */
34 
35 #ifndef MBED_LORA_RADIO_DRV_STM32WL_LORARADIO_H_
36 #define MBED_LORA_RADIO_DRV_STM32WL_LORARADIO_H_
37 
38 #include "platform/mbed_critical.h"
39 #include "drivers/DigitalOut.h"
40 #include "platform/PlatformMutex.h"
41 #include "lorawan/LoRaRadio.h"
42 
43 #include "STM32WL_radio_driver.h"
44 
45 // Data buffer used for both TX and RX
46 // Size of this buffer is configurable via Mbed config system
47 // Default is 255 bytes
48 #ifdef MBED_CONF_STM32WL_LORA_DRIVER_BUFFER_SIZE
49 #define MAX_DATA_BUFFER_SIZE_STM32WL MBED_CONF_STM32WL_LORA_DRIVER_BUFFER_SIZE
50 #else
51 #define MAX_DATA_BUFFER_SIZE_STM32WL 255
52 #endif
53 
54 
55 
56 class STM32WL_LoRaRadio : public LoRaRadio {
57 
58 public:
59  STM32WL_LoRaRadio(PinName rf_switch_ctrl1 = MBED_CONF_STM32WL_LORA_DRIVER_RF_SWITCH_CTL1,
60  PinName rf_switch_ctrl2 = MBED_CONF_STM32WL_LORA_DRIVER_RF_SWITCH_CTL2,
61  PinName rf_switch_ctrl3 = MBED_CONF_STM32WL_LORA_DRIVER_RF_SWITCH_CTL3);
62 
63  virtual ~STM32WL_LoRaRadio();
64 
65  /**
66  * Registers radio events with the Mbed LoRaWAN stack and
67  * undergoes initialization steps if any
68  *
69  * @param events Structure containing the driver callback functions
70  */
71  virtual void init_radio(radio_events_t *events);
72 
73  /**
74  * Resets the radio module
75  */
76  virtual void radio_reset();
77 
78  /**
79  * Put the RF module in sleep mode
80  */
81  virtual void sleep(void);
82 
83  /**
84  * Sets the radio in standby mode
85  */
86  virtual void standby(void);
87 
88  /**
89  * Sets the reception parameters
90  *
91  * @param modem Radio modem to be used [0: FSK, 1: LoRa]
92  * @param bandwidth Sets the bandwidth
93  * FSK : >= 2600 and <= 250000 Hz
94  * LoRa: [0: 125 kHz, 1: 250 kHz,
95  * 2: 500 kHz, 3: Reserved]
96  * @param datarate Sets the Datarate
97  * FSK : 600..300000 bits/s
98  * LoRa: [6: 64, 7: 128, 8: 256, 9: 512,
99  * 10: 1024, 11: 2048, 12: 4096 chips]
100  * @param coderate Sets the coding rate ( LoRa only )
101  * FSK : N/A ( set to 0 )
102  * LoRa: [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
103  * @param bandwidth_afc Sets the AFC Bandwidth ( FSK only )
104  * FSK : >= 2600 and <= 250000 Hz
105  * LoRa: N/A ( set to 0 )
106  * @param preamble_len Sets the Preamble length ( LoRa only )
107  * FSK : N/A ( set to 0 )
108  * LoRa: Length in symbols ( the hardware adds 4 more symbols )
109  * @param symb_timeout Sets the RxSingle timeout value
110  * FSK : timeout number of bytes
111  * LoRa: timeout in symbols
112  * @param fixLen Fixed length packets [0: variable, 1: fixed]
113  * @param payload_len Sets payload length when fixed lenght is used
114  * @param crc_on Enables/Disables the CRC [0: OFF, 1: ON]
115  * @param freq_hop_on Enables disables the intra-packet frequency hopping [0: OFF, 1: ON] (LoRa only)
116  * @param hop_period Number of symbols bewteen each hop (LoRa only)
117  * @param iq_inverted Inverts IQ signals ( LoRa only )
118  * FSK : N/A ( set to 0 )
119  * LoRa: [0: not inverted, 1: inverted]
120  * @param rx_continuous Sets the reception in continuous mode
121  * [false: single mode, true: continuous mode]
122  */
123  virtual void set_rx_config(radio_modems_t modem, uint32_t bandwidth,
124  uint32_t datarate, uint8_t coderate,
125  uint32_t bandwidth_afc, uint16_t preamble_len,
126  uint16_t symb_timeout, bool fix_len,
127  uint8_t payload_len,
128  bool crc_on, bool freq_hop_on, uint8_t hop_period,
129  bool iq_inverted, bool rx_continuous);
130 
131  /**
132  * Sets the transmission parameters
133  *
134  * @param modem Radio modem to be used [0: FSK, 1: LoRa]
135  * @param power Sets the output power [dBm]
136  * @param fdev Sets the frequency deviation ( FSK only )
137  * FSK : [Hz]
138  * LoRa: 0
139  * @param bandwidth Sets the bandwidth ( LoRa only )
140  * FSK : 0
141  * LoRa: [0: 125 kHz, 1: 250 kHz,
142  * 2: 500 kHz, 3: Reserved]
143  * @param datarate Sets the Datarate
144  * FSK : 600..300000 bits/s
145  * LoRa: [6: 64, 7: 128, 8: 256, 9: 512,
146  * 10: 1024, 11: 2048, 12: 4096 chips]
147  * @param coderate Sets the coding rate ( LoRa only )
148  * FSK : N/A ( set to 0 )
149  * LoRa: [1: 4/5, 2: 4/6, 3: 4/7, 4: 4/8]
150  * @param preamble_len Sets the preamble length
151  * @param fix_len Fixed length packets [0: variable, 1: fixed]
152  * @param crc_on Enables disables the CRC [0: OFF, 1: ON]
153  * @param freq_hop_on Enables disables the intra-packet frequency hopping [0: OFF, 1: ON] (LoRa only)
154  * @param hop_period Number of symbols bewteen each hop (LoRa only)
155  * @param iq_inverted Inverts IQ signals ( LoRa only )
156  * FSK : N/A ( set to 0 )
157  * LoRa: [0: not inverted, 1: inverted]
158  * @param timeout Transmission timeout [ms]
159  */
160  virtual void set_tx_config(radio_modems_t modem, int8_t power, uint32_t fdev,
161  uint32_t bandwidth, uint32_t datarate,
162  uint8_t coderate, uint16_t preamble_len,
163  bool fix_len, bool crc_on, bool freq_hop_on,
164  uint8_t hop_period, bool iq_inverted, uint32_t timeout);
165 
166  /**
167  * Sends the buffer of size
168  *
169  * Prepares the packet to be sent and sets the radio in transmission
170  *
171  * @param buffer Buffer pointer
172  * @param size Buffer size
173  */
174  virtual void send(uint8_t *buffer, uint8_t size);
175 
176  /**
177  * For backwards compatibility
178  */
179  virtual void receive(uint32_t timeout)
180  {
181  (void) timeout;
182  receive();
183  }
184 
185  /**
186  * Sets the radio to receive
187  *
188  * All necessary configuration options for reception are set in
189  * 'set_rx_config(parameters)' API.
190  */
191  virtual void receive(void);
192 
193  /**
194  * Sets the carrier frequency
195  *
196  * @param freq Channel RF frequency
197  */
198  virtual void set_channel(uint32_t freq);
199 
200  /**
201  * Generates a 32 bits random value based on the RSSI readings
202  *
203  * Remark this function sets the radio in LoRa modem mode and disables
204  * all interrupts.
205  * After calling this function either Radio.SetRxConfig or
206  * Radio.SetTxConfig functions must be called.
207  *
208  * @return 32 bits random value
209  */
210  virtual uint32_t random(void);
211 
212  /**
213  * Get radio status
214  *
215  * @param status Radio status [RF_IDLE, RF_RX_RUNNING, RF_TX_RUNNING]
216  * @return Return current radio status
217  */
218  virtual uint8_t get_status(void);
219 
220  /**
221  * Sets the maximum payload length
222  *
223  * @param modem Radio modem to be used [0: FSK, 1: LoRa]
224  * @param max Maximum payload length in bytes
225  */
226  virtual void set_max_payload_length(radio_modems_t modem, uint8_t max);
227 
228  /**
229  * Sets the network to public or private
230  *
231  * Updates the sync byte. Applies to LoRa modem only
232  *
233  * @param enable if true, it enables a public network
234  */
235  virtual void set_public_network(bool enable);
236 
237  /**
238  * Computes the packet time on air for the given payload
239  *
240  * Remark can only be called once SetRxConfig or SetTxConfig have been called
241  *
242  * @param modem Radio modem to be used [0: FSK, 1: LoRa]
243  * @param pkt_len Packet payload length
244  * @return Computed airTime for the given packet payload length
245  */
246  virtual uint32_t time_on_air(radio_modems_t modem, uint8_t pkt_len);
247 
248  /**
249  * Perform carrier sensing
250  *
251  * Checks for a certain time if the RSSI is above a given threshold.
252  * This threshold determines if there is already a transmission going on
253  * in the channel or not.
254  *
255  * @param modem Type of the radio modem
256  * @param freq Carrier frequency
257  * @param rssi_threshold Threshold value of RSSI
258  * @param max_carrier_sense_time time to sense the channel
259  *
260  * @return true if there is no active transmission
261  * in the channel, false otherwise
262  */
263  virtual bool perform_carrier_sense(radio_modems_t modem,
264  uint32_t freq,
265  int16_t rssi_threshold,
266  uint32_t max_carrier_sense_time);
267 
268  /**
269  * Sets the radio in CAD mode
270  *
271  */
272  virtual void start_cad(void);
273 
274  /**
275  * Check if the given RF is in range
276  *
277  * @param frequency frequency needed to be checked
278  */
279  virtual bool check_rf_frequency(uint32_t frequency);
280 
281  /** Sets the radio in continuous wave transmission mode
282  *
283  * @param freq Channel RF frequency
284  * @param power Sets the output power [dBm]
285  * @param time Transmission mode timeout [s]
286  */
287  virtual void set_tx_continuous_wave(uint32_t freq, int8_t power, uint16_t time);
288 
289  /**
290  * Acquire exclusive access
291  */
292  virtual void lock(void);
293 
294  /**
295  * Release exclusive access
296  */
297  virtual void unlock(void);
298 
299  static void HAL_SUBGHZ_TxCpltCallback(void);
300  static void HAL_SUBGHZ_RxCpltCallback(void);
301  static void HAL_SUBGHZ_CRCErrorCallback(void);
302  static void HAL_SUBGHZ_CADStatusCallback(void);
303  static void HAL_SUBGHZ_RxTxTimeoutCallback(void);
304 
305 
306  static void clear_irq_status(uint16_t irq);
307  static uint16_t get_irq_status(void);
308  static void read_opmode_command(uint8_t cmd, uint8_t *buffer, uint16_t size);
309  static void write_opmode_command(uint8_t cmd, uint8_t *buffer, uint16_t size);
310  static void read_fifo(uint8_t *buffer, uint8_t size, uint8_t offset);
311  static void get_rx_buffer_status(uint8_t *payload_len, uint8_t *rx_buffer_ptr);
312  static void get_packet_status(packet_status_t *pkt_status);
313  static uint8_t get_modem();
314  static uint8_t read_register(uint16_t addr);
315 
316 private:
317 
318  // Radio specific controls (TX/RX duplexer switch control)
319  mbed::DigitalOut _rf_switch_ctrl1;
320  mbed::DigitalOut _rf_switch_ctrl2;
321  mbed::DigitalOut _rf_switch_ctrl3;
322 
323  // Access protection
324  PlatformMutex mutex;
325 
326  // helper functions
327  void wakeup();
328 
329  void SUBGRF_SetTcxoMode(radio_TCXO_ctrl_voltage_t voltage, uint32_t timeout);
330  void set_device_ready(void);
331  int8_t get_rssi();
332  uint8_t get_fsk_bw_reg_val(uint32_t bandwidth);
333  void write_to_register(uint16_t addr, uint8_t data);
334  void write_to_register(uint16_t addr, uint8_t *data, uint8_t size);
335 
336  void read_register(uint16_t addr, uint8_t *buffer, uint8_t size);
337  void write_fifo(uint8_t *buffer, uint8_t size);
338 
339  void rf_irq_task(void);
340  void set_modem(uint8_t modem);
341 
342 
343  uint8_t get_frequency_support(void);
344 
345 
346 
347  void set_modulation_params(modulation_params_t *modulationParams);
348  void set_packet_params(packet_params_t *packet_params);
349  void set_cad_params(lora_cad_symbols_t nb_symbols, uint8_t det_peak,
350  uint8_t det_min, cad_exit_modes_t exit_mode,
351  uint32_t timeout);
352  void set_buffer_base_addr(uint8_t tx_base_addr, uint8_t rx_base_addr);
353 
354  radio_error_t get_device_errors(void);
355  void clear_device_errors(void);
356 
357  void set_crc_seed(uint16_t seed);
358  void set_crc_polynomial(uint16_t polynomial);
359  void set_whitening_seed(uint16_t seed);
360  void set_pa_config(uint8_t pa_DC, uint8_t hp_max, uint8_t device_type,
361  uint8_t pa_LUT);
362  void set_tx_power(int8_t power);
363  void calibrate_image(uint32_t freq);
364  void configure_dio_irq(uint16_t irq_mask, uint16_t dio1_mask,
365  uint16_t dio2_mask, uint16_t dio3_mask);
366  void cold_start_wakeup();
367 
368  void SUBGRF_SetSwitch(uint8_t paSelect, RFState_t rxtx);
369  uint8_t SUBGRF_SetRfTxPower(int8_t power);
370  void SUBGRF_SetTxParams(uint8_t paSelect, int8_t power, radio_ramp_time_t rampTime);
371  void Radio_SMPS_Set(uint8_t level);
372  void set_antenna_switch(RBI_Switch_TypeDef state);
373  uint32_t RadioGetWakeupTime(void);
374 
375 
376  uint8_t _standby_mode;
377 
378  uint8_t _reception_mode;
379  uint32_t _tx_timeout;
380  uint32_t _rx_timeout;
381  uint8_t _rx_timeout_in_symbols;
382  int8_t _tx_power;
383  uint8_t _antSwitchPaSelect;
384  bool _image_calibrated;
385  bool _force_image_calibration;
386  bool _network_mode_public;
387 
388  // Structure containing all user and network specified settings
389  // for radio module
390  modulation_params_t _mod_params;
391  packet_params_t _packet_params;
392 
393  RFState_t rfstate;
394 
395 };
396 
397 
398 
399 #endif /* MBED_LORA_RADIO_DRV_STM32WL_LORARADIO_H_ */
STM32WL_LoRaRadio::get_status
virtual uint8_t get_status(void)
Get radio status.
STM32WL_LoRaRadio::perform_carrier_sense
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.
packet_params
The type describing the packet parameters for every packet types.
Definition: sx126x_ds.h:581
STM32WL_LoRaRadio::receive
virtual void receive(uint32_t timeout)
For backwards compatibility.
Definition: STM32WL_LoRaRadio.h:179
STM32WL_LoRaRadio::start_cad
virtual void start_cad(void)
Sets the radio in CAD mode.
STM32WL_radio_driver.h
STM32WL driver implementation.
STM32WL_LoRaRadio::receive
virtual void receive(void)
Sets the radio to receive.
STM32WL_LoRaRadio::send
virtual void send(uint8_t *buffer, uint8_t size)
Sends the buffer of size.
radio_error_t
Represents the possible radio system error states.
Definition: sx126x_ds.h:191
STM32WL_LoRaRadio::init_radio
virtual void init_radio(radio_events_t *events)
Registers radio events with the Mbed LoRaWAN stack and undergoes initialization steps if any...
radio_modems_t
enum modem_type radio_modems_t
Type of modem.
STM32WL_LoRaRadio::set_max_payload_length
virtual void set_max_payload_length(radio_modems_t modem, uint8_t max)
Sets the maximum payload length.
STM32WL_LoRaRadio::lock
virtual void lock(void)
Acquire exclusive access.
packet_status_t
Represents the packet status for every packet type.
Definition: sx126x_ds.h:613
PlatformMutex
The PlatformMutex class is used to synchronize the execution of threads.
Definition: PlatformMutex.h:47
STM32WL_LoRaRadio::radio_reset
virtual void radio_reset()
Resets the radio module.
STM32WL_LoRaRadio
Definition: STM32WL_LoRaRadio.h:56
radio_events
Reporting functions for upper layers.
Definition: LoRaRadio.h:389
STM32WL_LoRaRadio::set_channel
virtual void set_channel(uint32_t freq)
Sets the carrier frequency.
STM32WL_LoRaRadio::standby
virtual void standby(void)
Sets the radio in standby mode.
STM32WL_LoRaRadio::set_rx_config
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.
STM32WL_LoRaRadio::unlock
virtual void unlock(void)
Release exclusive access.
RFState_t
RFState_t
Radio driver internal state machine states definition.
Definition: STM32WL_radio_driver.h:693
STM32WL_LoRaRadio::set_public_network
virtual void set_public_network(bool enable)
Sets the network to public or private.
STM32WL_LoRaRadio::set_tx_config
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.
mbed::DigitalOut
A digital output, used for setting the state of a pin.
Definition: DigitalOut.h:49
STM32WL_LoRaRadio::check_rf_frequency
virtual bool check_rf_frequency(uint32_t frequency)
Check if the given RF is in range.
STM32WL_LoRaRadio::sleep
virtual void sleep(void)
Put the RF module in sleep mode.
STM32WL_LoRaRadio::time_on_air
virtual uint32_t time_on_air(radio_modems_t modem, uint8_t pkt_len)
Computes the packet time on air for the given payload.
LoRaRadio
Interface for the radios, containing the main functions that a radio needs, and five callback functio...
Definition: LoRaRadio.h:440
STM32WL_LoRaRadio::random
virtual uint32_t random(void)
Generates a 32 bits random value based on the RSSI readings.
modulation_params_t
The type describing the modulation parameters for every packet types.
Definition: sx126x_ds.h:557
STM32WL_LoRaRadio::set_tx_continuous_wave
virtual void set_tx_continuous_wave(uint32_t freq, int8_t power, uint16_t time)
Sets the radio in continuous wave transmission 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.