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