1 /*!
2 * \file sx126x.c
3 *
4 * \brief SX126x driver implementation
5 *
6 * \copyright Revised BSD License, see section \ref LICENSE.
7 *
8 * \code
9 * ______ _
10 * / _____) _ | |
11 * ( (____ _____ ____ _| |_ _____ ____| |__
12 * \____ \| ___ | (_ _) ___ |/ ___) _ \
13 * _____) ) ____| | | || |_| ____( (___| | | |
14 * (______/|_____)_|_|_| \__)_____)\____)_| |_|
15 * (C)2013-2017 Semtech
16 *
17 * \endcode
18 *
19 * \author Miguel Luis ( Semtech )
20 *
21 * \author Gregory Cristian ( Semtech )
22 */
23 #include <string.h>
24 #include "radio.h"
25 #include "sx126x.h"
26 #include "sx126x-board.h"
27 #include "ulog/ulog.h"
28 /*!
29 * \brief Radio registers definition
30 */
31 typedef struct
32 {
33 uint16_t Addr; //!< The address of the register
34 uint8_t Value; //!< The value of the register
35 }RadioRegisters_t;
36
37 /*!
38 * \brief Stores the current packet type set in the radio
39 */
40 static RadioPacketTypes_t PacketType;
41
42 /*!
43 * \brief Stores the current packet header type set in the radio
44 */
45 static volatile RadioLoRaPacketLengthsMode_t LoRaHeaderType;
46
47 /*!
48 * \brief Stores the last frequency error measured on LoRa received packet
49 */
50 volatile uint32_t FrequencyError = 0;
51
52 /*!
53 * \brief Hold the status of the Image calibration
54 */
55 static bool ImageCalibrated = false;
56
57 /*
58 * SX126x DIO IRQ callback functions prototype
59 */
60
61 /*!
62 * \brief DIO 0 IRQ callback
63 */
64 void SX126xOnDioIrq( void );
65
66 /*!
67 * \brief DIO 0 IRQ callback
68 */
69 void SX126xSetPollingMode( void );
70
71 /*!
72 * \brief DIO 0 IRQ callback
73 */
74 void SX126xSetInterruptMode( void );
75
76 /*
77 * \brief Process the IRQ if handled by the driver
78 */
79 void SX126xProcessIrqs( void );
80
SX126xInit(DioIrqHandler dioIrq)81 void SX126xInit( DioIrqHandler dioIrq )
82 {
83 SX126xIoInit( );
84 SX126xReset( );
85
86 SX126xIoIrqInit( dioIrq );
87
88 SX126xWakeup( );
89 SX126xSetStandby( STDBY_RC );
90
91 // Initialize TCXO control
92 SX126xIoTcxoInit( );
93
94 // Initialize RF switch control
95 SX126xIoRfSwitchInit( );
96
97 SX126xSetOperatingMode( MODE_STDBY_RC );
98 }
99
SX126xCheckDeviceReady(void)100 void SX126xCheckDeviceReady( void )
101 {
102 if( ( SX126xGetOperatingMode( ) == MODE_SLEEP ) || ( SX126xGetOperatingMode( ) == MODE_RX_DC ) )
103 {
104 SX126xWakeup( );
105 // Switch is turned off when device is in sleep mode and turned on is all other modes
106 SX126xAntSwOn( );
107 }
108 SX126xWaitOnBusy( );
109 }
110
SX126xSetPayload(uint8_t * payload,uint8_t size)111 void SX126xSetPayload( uint8_t *payload, uint8_t size )
112 {
113 SX126xWriteBuffer( 0x00, payload, size );
114 }
115
SX126xGetPayload(uint8_t * buffer,uint8_t * size,uint8_t maxSize)116 uint8_t SX126xGetPayload( uint8_t *buffer, uint8_t *size, uint8_t maxSize )
117 {
118 uint8_t offset = 0;
119
120 SX126xGetRxBufferStatus( size, &offset );
121 if( *size > maxSize )
122 {
123 return 1;
124 }
125 SX126xReadBuffer( offset, buffer, *size );
126 return 0;
127 }
128
SX126xSendPayload(uint8_t * payload,uint8_t size,uint32_t timeout)129 void SX126xSendPayload( uint8_t *payload, uint8_t size, uint32_t timeout )
130 {
131 SX126xSetPayload( payload, size );
132 SX126xSetTx( timeout );
133 }
134
SX126xSetSyncWord(uint8_t * syncWord)135 uint8_t SX126xSetSyncWord( uint8_t *syncWord )
136 {
137 SX126xWriteRegisters( REG_LR_SYNCWORDBASEADDRESS, syncWord, 8 );
138 return 0;
139 }
140
SX126xSetCrcSeed(uint16_t seed)141 void SX126xSetCrcSeed( uint16_t seed )
142 {
143 uint8_t buf[2];
144
145 buf[0] = ( uint8_t )( ( seed >> 8 ) & 0xFF );
146 buf[1] = ( uint8_t )( seed & 0xFF );
147
148 switch( SX126xGetPacketType( ) )
149 {
150 case PACKET_TYPE_GFSK:
151 SX126xWriteRegisters( REG_LR_CRCSEEDBASEADDR, buf, 2 );
152 break;
153
154 default:
155 break;
156 }
157 }
158
SX126xSetCrcPolynomial(uint16_t polynomial)159 void SX126xSetCrcPolynomial( uint16_t polynomial )
160 {
161 uint8_t buf[2];
162
163 buf[0] = ( uint8_t )( ( polynomial >> 8 ) & 0xFF );
164 buf[1] = ( uint8_t )( polynomial & 0xFF );
165
166 switch( SX126xGetPacketType( ) )
167 {
168 case PACKET_TYPE_GFSK:
169 SX126xWriteRegisters( REG_LR_CRCPOLYBASEADDR, buf, 2 );
170 break;
171
172 default:
173 break;
174 }
175 }
176
SX126xSetWhiteningSeed(uint16_t seed)177 void SX126xSetWhiteningSeed( uint16_t seed )
178 {
179 uint8_t regValue = 0;
180
181 switch( SX126xGetPacketType( ) )
182 {
183 case PACKET_TYPE_GFSK:
184 regValue = SX126xReadRegister( REG_LR_WHITSEEDBASEADDR_MSB ) & 0xFE;
185 regValue = ( ( seed >> 8 ) & 0x01 ) | regValue;
186 SX126xWriteRegister( REG_LR_WHITSEEDBASEADDR_MSB, regValue ); // only 1 bit.
187 SX126xWriteRegister( REG_LR_WHITSEEDBASEADDR_LSB, ( uint8_t )seed );
188 break;
189
190 default:
191 break;
192 }
193 }
194
SX126xGetRandom(void)195 uint32_t SX126xGetRandom( void )
196 {
197 uint32_t number = 0;
198 uint8_t regAnaLna = 0;
199 uint8_t regAnaMixer = 0;
200
201 regAnaLna = SX126xReadRegister( REG_ANA_LNA );
202 SX126xWriteRegister( REG_ANA_LNA, regAnaLna & ~( 1 << 0 ) );
203
204 regAnaMixer = SX126xReadRegister( REG_ANA_MIXER );
205 SX126xWriteRegister( REG_ANA_MIXER, regAnaMixer & ~( 1 << 7 ) );
206
207 // Set radio in continuous reception
208 SX126xSetRx( 0xFFFFFF ); // Rx Continuous
209
210 SX126xReadRegisters( RANDOM_NUMBER_GENERATORBASEADDR, ( uint8_t* )&number, 4 );
211
212 SX126xSetStandby( STDBY_RC );
213
214 SX126xWriteRegister( REG_ANA_LNA, regAnaLna );
215 SX126xWriteRegister( REG_ANA_MIXER, regAnaMixer );
216
217 return number;
218 }
219
SX126xSetSleep(SleepParams_t sleepConfig)220 void SX126xSetSleep( SleepParams_t sleepConfig )
221 {
222 SX126xAntSwOff( );
223
224 uint8_t value = ( ( ( uint8_t )sleepConfig.Fields.WarmStart << 2 ) |
225 ( ( uint8_t )sleepConfig.Fields.Reset << 1 ) |
226 ( ( uint8_t )sleepConfig.Fields.WakeUpRTC ) );
227 SX126xWriteCommand( RADIO_SET_SLEEP, &value, 1 );
228 SX126xSetOperatingMode( MODE_SLEEP );
229 }
230
SX126xSetStandby(RadioStandbyModes_t standbyConfig)231 void SX126xSetStandby( RadioStandbyModes_t standbyConfig )
232 {
233 SX126xWriteCommand( RADIO_SET_STANDBY, ( uint8_t* )&standbyConfig, 1 );
234 if( standbyConfig == STDBY_RC )
235 {
236 SX126xSetOperatingMode( MODE_STDBY_RC );
237 }
238 else
239 {
240 SX126xSetOperatingMode( MODE_STDBY_XOSC );
241 }
242 }
243
SX126xSetFs(void)244 void SX126xSetFs( void )
245 {
246 SX126xWriteCommand( RADIO_SET_FS, 0, 0 );
247 SX126xSetOperatingMode( MODE_FS );
248 }
249
SX126xSetTx(uint32_t timeout)250 void SX126xSetTx( uint32_t timeout )
251 {
252 uint8_t buf[3];
253
254 SX126xSetOperatingMode( MODE_TX );
255
256 buf[0] = ( uint8_t )( ( timeout >> 16 ) & 0xFF );
257 buf[1] = ( uint8_t )( ( timeout >> 8 ) & 0xFF );
258 buf[2] = ( uint8_t )( timeout & 0xFF );
259 SX126xWriteCommand( RADIO_SET_TX, buf, 3 );
260 }
261
SX126xSetRx(uint32_t timeout)262 void SX126xSetRx( uint32_t timeout )
263 {
264 uint8_t buf[3];
265
266 SX126xSetOperatingMode( MODE_RX );
267
268 buf[0] = ( uint8_t )( ( timeout >> 16 ) & 0xFF );
269 buf[1] = ( uint8_t )( ( timeout >> 8 ) & 0xFF );
270 buf[2] = ( uint8_t )( timeout & 0xFF );
271 SX126xWriteCommand( RADIO_SET_RX, buf, 3 );
272 }
273
SX126xSetRxBoosted(uint32_t timeout)274 void SX126xSetRxBoosted( uint32_t timeout )
275 {
276 uint8_t buf[3];
277
278 SX126xSetOperatingMode( MODE_RX );
279
280 SX126xWriteRegister( REG_RX_GAIN, 0x96 ); // max LNA gain, increase current by ~2mA for around ~3dB in sensivity
281
282 buf[0] = ( uint8_t )( ( timeout >> 16 ) & 0xFF );
283 buf[1] = ( uint8_t )( ( timeout >> 8 ) & 0xFF );
284 buf[2] = ( uint8_t )( timeout & 0xFF );
285 SX126xWriteCommand( RADIO_SET_RX, buf, 3 );
286 }
287
SX126xSetRxDutyCycle(uint32_t rxTime,uint32_t sleepTime)288 void SX126xSetRxDutyCycle( uint32_t rxTime, uint32_t sleepTime )
289 {
290 uint8_t buf[6];
291
292 buf[0] = ( uint8_t )( ( rxTime >> 16 ) & 0xFF );
293 buf[1] = ( uint8_t )( ( rxTime >> 8 ) & 0xFF );
294 buf[2] = ( uint8_t )( rxTime & 0xFF );
295 buf[3] = ( uint8_t )( ( sleepTime >> 16 ) & 0xFF );
296 buf[4] = ( uint8_t )( ( sleepTime >> 8 ) & 0xFF );
297 buf[5] = ( uint8_t )( sleepTime & 0xFF );
298 SX126xWriteCommand( RADIO_SET_RXDUTYCYCLE, buf, 6 );
299 SX126xSetOperatingMode( MODE_RX_DC );
300 }
301
SX126xSetCad(void)302 void SX126xSetCad( void )
303 {
304 SX126xWriteCommand( RADIO_SET_CAD, 0, 0 );
305 SX126xSetOperatingMode( MODE_CAD );
306 }
307
SX126xSetTxContinuousWave(void)308 void SX126xSetTxContinuousWave( void )
309 {
310 SX126xWriteCommand( RADIO_SET_TXCONTINUOUSWAVE, 0, 0 );
311 SX126xSetOperatingMode( MODE_TX );
312 }
313
SX126xSetTxInfinitePreamble(void)314 void SX126xSetTxInfinitePreamble( void )
315 {
316 SX126xWriteCommand( RADIO_SET_TXCONTINUOUSPREAMBLE, 0, 0 );
317 SX126xSetOperatingMode( MODE_TX );
318 }
319
SX126xSetStopRxTimerOnPreambleDetect(bool enable)320 void SX126xSetStopRxTimerOnPreambleDetect( bool enable )
321 {
322 SX126xWriteCommand( RADIO_SET_STOPRXTIMERONPREAMBLE, ( uint8_t* )&enable, 1 );
323 }
324
SX126xSetLoRaSymbNumTimeout(uint8_t symbNum)325 void SX126xSetLoRaSymbNumTimeout( uint8_t symbNum )
326 {
327 SX126xWriteCommand( RADIO_SET_LORASYMBTIMEOUT, &symbNum, 1 );
328
329 if( symbNum >= 64 )
330 {
331 uint8_t mant = symbNum >> 1;
332 uint8_t exp = 0;
333 uint8_t reg = 0;
334
335 while( mant > 31 )
336 {
337 mant >>= 2;
338 exp++;
339 }
340
341 reg = exp + ( mant << 3 );
342 SX126xWriteRegister( REG_LR_SYNCH_TIMEOUT, reg );
343 }
344 }
345
SX126xSetRegulatorMode(RadioRegulatorMode_t mode)346 void SX126xSetRegulatorMode( RadioRegulatorMode_t mode )
347 {
348 SX126xWriteCommand( RADIO_SET_REGULATORMODE, ( uint8_t* )&mode, 1 );
349 }
350
SX126xCalibrate(CalibrationParams_t calibParam)351 void SX126xCalibrate( CalibrationParams_t calibParam )
352 {
353 uint8_t value = ( ( ( uint8_t )calibParam.Fields.ImgEnable << 6 ) |
354 ( ( uint8_t )calibParam.Fields.ADCBulkPEnable << 5 ) |
355 ( ( uint8_t )calibParam.Fields.ADCBulkNEnable << 4 ) |
356 ( ( uint8_t )calibParam.Fields.ADCPulseEnable << 3 ) |
357 ( ( uint8_t )calibParam.Fields.PLLEnable << 2 ) |
358 ( ( uint8_t )calibParam.Fields.RC13MEnable << 1 ) |
359 ( ( uint8_t )calibParam.Fields.RC64KEnable ) );
360
361 SX126xWriteCommand( RADIO_CALIBRATE, &value, 1 );
362 }
363
SX126xCalibrateImage(uint32_t freq)364 void SX126xCalibrateImage( uint32_t freq )
365 {
366 uint8_t calFreq[2];
367
368 if( freq > 900000000 )
369 {
370 calFreq[0] = 0xE1;
371 calFreq[1] = 0xE9;
372 }
373 else if( freq > 850000000 )
374 {
375 calFreq[0] = 0xD7;
376 calFreq[1] = 0xDB;
377 }
378 else if( freq > 770000000 )
379 {
380 calFreq[0] = 0xC1;
381 calFreq[1] = 0xC5;
382 }
383 else if( freq > 460000000 )
384 {
385 calFreq[0] = 0x75;
386 calFreq[1] = 0x81;
387 }
388 else if( freq > 425000000 )
389 {
390 calFreq[0] = 0x6B;
391 calFreq[1] = 0x6F;
392 }
393 SX126xWriteCommand( RADIO_CALIBRATEIMAGE, calFreq, 2 );
394 }
395
SX126xSetPaConfig(uint8_t paDutyCycle,uint8_t hpMax,uint8_t deviceSel,uint8_t paLut)396 void SX126xSetPaConfig( uint8_t paDutyCycle, uint8_t hpMax, uint8_t deviceSel, uint8_t paLut )
397 {
398 uint8_t buf[4];
399
400 buf[0] = paDutyCycle;
401 buf[1] = hpMax;
402 buf[2] = deviceSel;
403 buf[3] = paLut;
404 SX126xWriteCommand( RADIO_SET_PACONFIG, buf, 4 );
405 }
406
SX126xSetRxTxFallbackMode(uint8_t fallbackMode)407 void SX126xSetRxTxFallbackMode( uint8_t fallbackMode )
408 {
409 SX126xWriteCommand( RADIO_SET_TXFALLBACKMODE, &fallbackMode, 1 );
410 }
411
SX126xSetDioIrqParams(uint16_t irqMask,uint16_t dio1Mask,uint16_t dio2Mask,uint16_t dio3Mask)412 void SX126xSetDioIrqParams( uint16_t irqMask, uint16_t dio1Mask, uint16_t dio2Mask, uint16_t dio3Mask )
413 {
414 uint8_t buf[8];
415
416 buf[0] = ( uint8_t )( ( irqMask >> 8 ) & 0x00FF );
417 buf[1] = ( uint8_t )( irqMask & 0x00FF );
418 buf[2] = ( uint8_t )( ( dio1Mask >> 8 ) & 0x00FF );
419 buf[3] = ( uint8_t )( dio1Mask & 0x00FF );
420 buf[4] = ( uint8_t )( ( dio2Mask >> 8 ) & 0x00FF );
421 buf[5] = ( uint8_t )( dio2Mask & 0x00FF );
422 buf[6] = ( uint8_t )( ( dio3Mask >> 8 ) & 0x00FF );
423 buf[7] = ( uint8_t )( dio3Mask & 0x00FF );
424 SX126xWriteCommand( RADIO_CFG_DIOIRQ, buf, 8 );
425 }
426
SX126xGetIrqStatus(void)427 uint16_t SX126xGetIrqStatus( void )
428 {
429 uint8_t irqStatus[5] = {0}; //irqNo, irqMask, dio0Mask, dio1Mask, dio2Mask
430 uint8_t status = SX126xReadCommand( RADIO_GET_IRQSTATUS, irqStatus, sizeof(irqStatus) );
431 /*
432 LOG("cmdStatus:%d, irqNo:0x%02x, irqMask:0x%02x, dio0Mask:0x%02x, dio1Mask:0x%02x, dio2Mask:0x%02x", status, irqStatus[0]
433 , irqStatus[1], irqStatus[2]
434 , irqStatus[3], irqStatus[4]);
435 */
436 return irqStatus[0];
437 }
438
SX126xSetDio2AsRfSwitchCtrl(uint8_t enable)439 void SX126xSetDio2AsRfSwitchCtrl( uint8_t enable )
440 {
441 SX126xWriteCommand( RADIO_SET_RFSWITCHMODE, &enable, 1 );
442 }
443
SX126xSetDio3AsTcxoCtrl(RadioTcxoCtrlVoltage_t tcxoVoltage,uint32_t timeout)444 void SX126xSetDio3AsTcxoCtrl( RadioTcxoCtrlVoltage_t tcxoVoltage, uint32_t timeout )
445 {
446 uint8_t buf[4];
447
448 buf[0] = tcxoVoltage & 0x07;
449 buf[1] = ( uint8_t )( ( timeout >> 16 ) & 0xFF );
450 buf[2] = ( uint8_t )( ( timeout >> 8 ) & 0xFF );
451 buf[3] = ( uint8_t )( timeout & 0xFF );
452
453 SX126xWriteCommand( RADIO_SET_TCXOMODE, buf, 4 );
454 }
455
SX126xSetRfFrequency(uint32_t frequency)456 void SX126xSetRfFrequency( uint32_t frequency )
457 {
458 uint8_t buf[4];
459 uint32_t freq = 0;
460
461 if( ImageCalibrated == false )
462 {
463 SX126xCalibrateImage( frequency );
464 ImageCalibrated = true;
465 }
466
467 freq = ( uint32_t )( ( double )frequency / ( double )FREQ_STEP );
468 buf[0] = ( uint8_t )( ( freq >> 24 ) & 0xFF );
469 buf[1] = ( uint8_t )( ( freq >> 16 ) & 0xFF );
470 buf[2] = ( uint8_t )( ( freq >> 8 ) & 0xFF );
471 buf[3] = ( uint8_t )( freq & 0xFF );
472 SX126xWriteCommand( RADIO_SET_RFFREQUENCY, buf, 4 );
473 }
474
SX126xSetPacketType(RadioPacketTypes_t packetType)475 void SX126xSetPacketType( RadioPacketTypes_t packetType )
476 {
477 // Save packet type internally to avoid questioning the radio
478 PacketType = packetType;
479 SX126xWriteCommand( RADIO_SET_PACKETTYPE, ( uint8_t* )&packetType, 1 );
480 }
481
SX126xGetPacketType(void)482 RadioPacketTypes_t SX126xGetPacketType( void )
483 {
484 return PacketType;
485 }
486
SX126xSetTxParams(int8_t power,RadioRampTimes_t rampTime)487 void SX126xSetTxParams( int8_t power, RadioRampTimes_t rampTime )
488 {
489 uint8_t buf[2];
490
491 if( SX126xGetDeviceId( ) == SX1261 )
492 {
493 if( power == 15 )
494 {
495 SX126xSetPaConfig( 0x06, 0x00, 0x01, 0x01 );
496 }
497 else
498 {
499 SX126xSetPaConfig( 0x04, 0x00, 0x01, 0x01 );
500 }
501 if( power >= 14 )
502 {
503 power = 14;
504 }
505 else if( power < -17 )
506 {
507 power = -17;
508 }
509 }
510 else // sx1262
511 {
512 // WORKAROUND - Better Resistance of the SX1262 Tx to Antenna Mismatch, see DS_SX1261-2_V1.2 datasheet chapter 15.2
513 // RegTxClampConfig = @address 0x08D8
514 SX126xWriteRegister( 0x08D8, SX126xReadRegister( 0x08D8 ) | ( 0x0F << 1 ) );
515 // WORKAROUND END
516
517 SX126xSetPaConfig( 0x04, 0x07, 0x00, 0x01 );
518 if( power > 22 )
519 {
520 power = 22;
521 }
522 else if( power < -9 )
523 {
524 power = -9;
525 }
526 }
527 buf[0] = power;
528 buf[1] = ( uint8_t )rampTime;
529 SX126xWriteCommand( RADIO_SET_TXPARAMS, buf, 2 );
530 }
531
SX126xSetModulationParams(ModulationParams_t * modulationParams)532 void SX126xSetModulationParams( ModulationParams_t *modulationParams )
533 {
534 uint8_t n;
535 uint32_t tempVal = 0;
536 uint8_t buf[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
537
538 // Check if required configuration corresponds to the stored packet type
539 // If not, silently update radio packet type
540 if( PacketType != modulationParams->PacketType )
541 {
542 SX126xSetPacketType( modulationParams->PacketType );
543 }
544
545 switch( modulationParams->PacketType )
546 {
547 case PACKET_TYPE_GFSK:
548 n = 8;
549 tempVal = ( uint32_t )( 32 * ( ( double )XTAL_FREQ / ( double )modulationParams->Params.Gfsk.BitRate ) );
550 buf[0] = ( tempVal >> 16 ) & 0xFF;
551 buf[1] = ( tempVal >> 8 ) & 0xFF;
552 buf[2] = tempVal & 0xFF;
553 buf[3] = modulationParams->Params.Gfsk.ModulationShaping;
554 buf[4] = modulationParams->Params.Gfsk.Bandwidth;
555 tempVal = ( uint32_t )( ( double )modulationParams->Params.Gfsk.Fdev / ( double )FREQ_STEP );
556 buf[5] = ( tempVal >> 16 ) & 0xFF;
557 buf[6] = ( tempVal >> 8 ) & 0xFF;
558 buf[7] = ( tempVal& 0xFF );
559 SX126xWriteCommand( RADIO_SET_MODULATIONPARAMS, buf, n );
560 break;
561 case PACKET_TYPE_LORA:
562 n = 4;
563 buf[0] = modulationParams->Params.LoRa.SpreadingFactor;
564 buf[1] = modulationParams->Params.LoRa.Bandwidth;
565 buf[2] = modulationParams->Params.LoRa.CodingRate;
566 buf[3] = modulationParams->Params.LoRa.LowDatarateOptimize;
567
568 SX126xWriteCommand( RADIO_SET_MODULATIONPARAMS, buf, n );
569
570 break;
571 default:
572 case PACKET_TYPE_NONE:
573 return;
574 }
575 }
576
SX126xSetPacketParams(PacketParams_t * packetParams)577 void SX126xSetPacketParams( PacketParams_t *packetParams )
578 {
579 uint8_t n;
580 uint8_t crcVal = 0;
581 uint8_t buf[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
582
583 // Check if required configuration corresponds to the stored packet type
584 // If not, silently update radio packet type
585 if( PacketType != packetParams->PacketType )
586 {
587 SX126xSetPacketType( packetParams->PacketType );
588 }
589
590 switch( packetParams->PacketType )
591 {
592 case PACKET_TYPE_GFSK:
593 if( packetParams->Params.Gfsk.CrcLength == RADIO_CRC_2_BYTES_IBM )
594 {
595 SX126xSetCrcSeed( CRC_IBM_SEED );
596 SX126xSetCrcPolynomial( CRC_POLYNOMIAL_IBM );
597 crcVal = RADIO_CRC_2_BYTES;
598 }
599 else if( packetParams->Params.Gfsk.CrcLength == RADIO_CRC_2_BYTES_CCIT )
600 {
601 SX126xSetCrcSeed( CRC_CCITT_SEED );
602 SX126xSetCrcPolynomial( CRC_POLYNOMIAL_CCITT );
603 crcVal = RADIO_CRC_2_BYTES_INV;
604 }
605 else
606 {
607 crcVal = packetParams->Params.Gfsk.CrcLength;
608 }
609 n = 9;
610 buf[0] = ( packetParams->Params.Gfsk.PreambleLength >> 8 ) & 0xFF;
611 buf[1] = packetParams->Params.Gfsk.PreambleLength;
612 buf[2] = packetParams->Params.Gfsk.PreambleMinDetect;
613 buf[3] = ( packetParams->Params.Gfsk.SyncWordLength /*<< 3*/ ); // convert from byte to bit
614 buf[4] = packetParams->Params.Gfsk.AddrComp;
615 buf[5] = packetParams->Params.Gfsk.HeaderType;
616 buf[6] = packetParams->Params.Gfsk.PayloadLength;
617 buf[7] = crcVal;
618 buf[8] = packetParams->Params.Gfsk.DcFree;
619 break;
620 case PACKET_TYPE_LORA:
621 n = 6;
622 buf[0] = ( packetParams->Params.LoRa.PreambleLength >> 8 ) & 0xFF;
623 buf[1] = packetParams->Params.LoRa.PreambleLength;
624 buf[2] = LoRaHeaderType = packetParams->Params.LoRa.HeaderType;
625 buf[3] = packetParams->Params.LoRa.PayloadLength;
626 buf[4] = packetParams->Params.LoRa.CrcMode;
627 buf[5] = packetParams->Params.LoRa.InvertIQ;
628 break;
629 default:
630 case PACKET_TYPE_NONE:
631 return;
632 }
633 SX126xWriteCommand( RADIO_SET_PACKETPARAMS, buf, n );
634 }
635
SX126xSetCadParams(RadioLoRaCadSymbols_t cadSymbolNum,uint8_t cadDetPeak,uint8_t cadDetMin,RadioCadExitModes_t cadExitMode,uint32_t cadTimeout)636 void SX126xSetCadParams( RadioLoRaCadSymbols_t cadSymbolNum, uint8_t cadDetPeak, uint8_t cadDetMin, RadioCadExitModes_t cadExitMode, uint32_t cadTimeout )
637 {
638 uint8_t buf[7];
639
640 buf[0] = ( uint8_t )cadSymbolNum;
641 buf[1] = cadDetPeak;
642 buf[2] = cadDetMin;
643 buf[3] = ( uint8_t )cadExitMode;
644 buf[4] = ( uint8_t )( ( cadTimeout >> 16 ) & 0xFF );
645 buf[5] = ( uint8_t )( ( cadTimeout >> 8 ) & 0xFF );
646 buf[6] = ( uint8_t )( cadTimeout & 0xFF );
647 SX126xWriteCommand( RADIO_SET_CADPARAMS, buf, 7 );
648 SX126xSetOperatingMode( MODE_CAD );
649 }
650
SX126xSetBufferBaseAddress(uint8_t txBaseAddress,uint8_t rxBaseAddress)651 void SX126xSetBufferBaseAddress( uint8_t txBaseAddress, uint8_t rxBaseAddress )
652 {
653 uint8_t buf[2];
654
655 buf[0] = txBaseAddress;
656 buf[1] = rxBaseAddress;
657 SX126xWriteCommand( RADIO_SET_BUFFERBASEADDRESS, buf, 2 );
658 }
659
SX126xGetStatus(void)660 RadioStatus_t SX126xGetStatus( void )
661 {
662 uint8_t stat = 0;
663 RadioStatus_t status = { .Value = 0 };
664 stat = SX126xReadCommand( RADIO_GET_STATUS, NULL, 0 );
665 status.Fields.CmdStatus = ( stat & ( 0x07 << 1 ) ) >> 1;
666 status.Fields.ChipMode = ( stat & ( 0x07 << 4 ) ) >> 4;
667 LOG("stat:%d, chip mode:%d command status:%d", stat, status.Fields.ChipMode, status.Fields.CmdStatus);
668 return status;
669 }
670
SX126xGetRssiInst(void)671 int8_t SX126xGetRssiInst( void )
672 {
673 uint8_t buf[1];
674 int8_t rssi = 0;
675
676 SX126xReadCommand( RADIO_GET_RSSIINST, buf, 1 );
677 rssi = -buf[0] >> 1;
678 return rssi;
679 }
680
SX126xGetRxBufferStatus(uint8_t * payloadLength,uint8_t * rxStartBufferPointer)681 void SX126xGetRxBufferStatus( uint8_t *payloadLength, uint8_t *rxStartBufferPointer )
682 {
683 uint8_t status[2];
684
685 uint8_t cmdStatus = SX126xReadCommand( RADIO_GET_RXBUFFERSTATUS, status, 2 );
686 //LOG("[%s]cmdStatus:%d, PayloadLengthRx:%d, RxStartBufferPointer:%d", __func__, cmdStatus, status[0], status[1]);
687 // In case of LORA fixed header, the payloadLength is obtained by reading
688 // the register REG_LR_PAYLOADLENGTH
689 if( ( SX126xGetPacketType( ) == PACKET_TYPE_LORA ) && ( LoRaHeaderType == LORA_PACKET_FIXED_LENGTH ) )
690 {
691 *payloadLength = SX126xReadRegister( REG_LR_PAYLOADLENGTH );
692 }
693 else
694 {
695 *payloadLength = status[0];
696 }
697 *rxStartBufferPointer = status[1];
698 }
699
SX126xGetPacketStatus(PacketStatus_t * pktStatus)700 void SX126xGetPacketStatus( PacketStatus_t *pktStatus )
701 {
702 uint8_t status[3];
703
704 SX126xReadCommand( RADIO_GET_PACKETSTATUS, status, 3 );
705
706 pktStatus->packetType = SX126xGetPacketType( );
707 switch( pktStatus->packetType )
708 {
709 case PACKET_TYPE_GFSK:
710 pktStatus->Params.Gfsk.RxStatus = status[0];
711 pktStatus->Params.Gfsk.RssiSync = -status[1] >> 1;
712 pktStatus->Params.Gfsk.RssiAvg = -status[2] >> 1;
713 pktStatus->Params.Gfsk.FreqError = 0;
714 break;
715
716 case PACKET_TYPE_LORA:
717 pktStatus->Params.LoRa.RssiPkt = -status[0] >> 1;
718 // Returns SNR value [dB] rounded to the nearest integer value
719 pktStatus->Params.LoRa.SnrPkt = ( ( ( int8_t )status[1] ) + 2 ) >> 2;
720 pktStatus->Params.LoRa.SignalRssiPkt = -status[2] >> 1;
721 pktStatus->Params.LoRa.FreqError = FrequencyError;
722 break;
723
724 default:
725 case PACKET_TYPE_NONE:
726 // In that specific case, we set everything in the pktStatus to zeros
727 // and reset the packet type accordingly
728 memset( pktStatus, 0, sizeof( PacketStatus_t ) );
729 pktStatus->packetType = PACKET_TYPE_NONE;
730 break;
731 }
732 }
733
SX126xGetDeviceErrors(void)734 RadioError_t SX126xGetDeviceErrors( void )
735 {
736 uint8_t err[] = { 0, 0 };
737 RadioError_t error = { .Value = 0 };
738
739 SX126xReadCommand( RADIO_GET_ERROR, ( uint8_t* )err, 2 );
740 error.Fields.PaRamp = ( err[0] & ( 1 << 0 ) ) >> 0;
741 error.Fields.PllLock = ( err[1] & ( 1 << 6 ) ) >> 6;
742 error.Fields.XoscStart = ( err[1] & ( 1 << 5 ) ) >> 5;
743 error.Fields.ImgCalib = ( err[1] & ( 1 << 4 ) ) >> 4;
744 error.Fields.AdcCalib = ( err[1] & ( 1 << 3 ) ) >> 3;
745 error.Fields.PllCalib = ( err[1] & ( 1 << 2 ) ) >> 2;
746 error.Fields.Rc13mCalib = ( err[1] & ( 1 << 1 ) ) >> 1;
747 error.Fields.Rc64kCalib = ( err[1] & ( 1 << 0 ) ) >> 0;
748 return error;
749 }
750
SX126xClearDeviceErrors(void)751 void SX126xClearDeviceErrors( void )
752 {
753 uint8_t buf[2] = { 0x00, 0x00 };
754 SX126xWriteCommand( RADIO_CLR_ERROR, buf, 2 );
755 }
756
SX126xClearIrqStatus(uint16_t irq)757 void SX126xClearIrqStatus( uint16_t irq )
758 {
759 uint8_t buf[2];
760
761 buf[0] = ( uint8_t )( ( ( uint16_t )irq >> 8 ) & 0x00FF );
762 buf[1] = ( uint8_t )( ( uint16_t )irq & 0x00FF );
763 SX126xWriteCommand( RADIO_CLR_IRQSTATUS, buf, 2 );
764 }
765