sx1276-mbed-hal.cpp

00001 /*
00002  / _____)             _              | |
00003 ( (____  _____ ____ _| |_ _____  ____| |__
00004  \____ \| ___ |    (_   _) ___ |/ ___)  _ \
00005  _____) ) ____| | | || |_| ____( (___| | | |
00006 (______/|_____)_|_|_| \__)_____)\____)_| |_|
00007     (C) 2014 Semtech
00008 
00009 Description: -
00010 
00011 License: Revised BSD License, see LICENSE.TXT file include in the project
00012 
00013 Maintainers: Miguel Luis, Gregory Cristian and Nicolas Huguenin
00014 */
00015 
00016 /*
00017  * additional development to make it more generic across multiple OS versions
00018  * (c) 2017 Helmut Tschemernjak
00019  * 30826 Garbsen (Hannover) Germany
00020  */
00021 
00022 #ifdef ARDUINO
00023  #include "arduino-mbed.h"
00024 #endif
00025 
00026 #include "sx1276-mbed-hal.h"
00027 
00028 
00029 
00030 SX1276Generic::SX1276Generic( RadioEvents_t *events, BoardType_t board,
00031                             PinName mosi, PinName miso, PinName sclk, PinName nss, PinName reset,
00032                             PinName dio0, PinName dio1, PinName dio2, PinName dio3, PinName dio4, PinName dio5,
00033                             PinName antSwitch, PinName antSwitchTX, PinName antSwitchTXBoost, PinName tcxo)
00034                             : SX1276 ( events)
00035 {
00036     Sleep_ms( 10 );
00037     this->RadioEvents = events;
00038     boardConnected = board;
00039     
00040     _antSwitch = NULL;
00041     _antSwitchTX = NULL;
00042     _antSwitchTXBoost = NULL;
00043     
00044     _tcxo = NULL;
00045     if (tcxo != NC)
00046         _tcxo = new DigitalOut(tcxo);
00047     
00048     switch(boardConnected) {
00049         case SX1276MB1MAS:
00050         case SX1276MB1LAS:
00051             _antSwitch = new DigitalOut(antSwitch);
00052             break;
00053         case RFM95_SX1276:
00054             break;
00055         case MURATA_SX1276:
00056             _antSwitch = new DigitalOut(antSwitch);
00057             _antSwitchTX = new DigitalOut(antSwitchTX);
00058             _antSwitchTXBoost = new DigitalOut(antSwitchTXBoost);
00059             break;
00060         default:
00061             break;
00062     }
00063     _spi = new XSPI(mosi, miso, sclk );
00064     _nss = new DigitalOut(nss);
00065     
00066     _reset = new DigitalInOut(reset);
00067     
00068     _dio0 = NULL;
00069     _dio1 = NULL;
00070     _dio2 = NULL;
00071     _dio3 = NULL;
00072     _dio4 = NULL;
00073     _dio5 = NULL;
00074     if (dio0 != NC)
00075         _dio0 = new InterruptIn(dio0);
00076     if (dio1 != NC)
00077         _dio1 = new InterruptIn(dio1);
00078     if (dio2 != NC)
00079         _dio2 = new InterruptIn(dio2);
00080     if (dio3 != NC)
00081         _dio3 = new InterruptIn(dio3);
00082     if (dio4 != NC)
00083         _dio4 = new InterruptIn(dio4);
00084     if (dio5 != NC)
00085         _dio5 = new DigitalIn(dio5);
00086    
00087     Reset( );
00088 
00089     IoInit( );
00090 
00091     RxChainCalibration( );
00092  
00093     SetOpMode( RF_OPMODE_SLEEP );
00094 
00095     IoIrqInit( dioIrq );
00096 
00097     RadioRegistersInit( );
00098 
00099     SetModem( MODEM_FSK );
00100 }
00101 
00102 SX1276Generic::~SX1276Generic()
00103 {
00104     if (_antSwitch )
00105         delete _antSwitch ;
00106     if (_antSwitchTX)
00107         delete _antSwitchTX;
00108     if (_antSwitchTXBoost)
00109         delete _antSwitchTXBoost;
00110     
00111     if (_tcxo ) {
00112         *_tcxo  = 0;
00113         delete (_tcxo );
00114     }
00115     delete _reset ;
00116     delete _spi ;
00117     delete _nss;
00118     
00119     if (_dio0 )
00120         delete _dio0 ;
00121     if (_dio1)
00122         delete _dio1;
00123     if (_dio2)
00124         delete _dio2;
00125     if (_dio3)
00126         delete _dio3;
00127     if (_dio4)
00128         delete _dio4;
00129     if (_dio5)
00130         delete _dio5;
00131 }
00132 
00133 
00134 //-------------------------------------------------------------------------
00135 //                      Board relative functions
00136 //-------------------------------------------------------------------------
00137 uint8_t SX1276Generic::DetectBoardType( void )
00138 {
00139     return boardConnected;
00140 }
00141 
00142 void SX1276Generic::IoInit( void )
00143 {
00144     if (_tcxo )
00145         *_tcxo  = 1;
00146     AntSwInit( );
00147     SpiInit( );
00148 }
00149 
00150 
00151 void SX1276Generic::SpiInit( void )
00152 {
00153     *_nss = 1;
00154     _spi ->format( 8,0 );
00155     uint32_t frequencyToSet = 8000000;
00156 #ifdef TARGET_KL25Z //busclock frequency is halved -> double the spi frequency to compensate
00157     _spi ->frequency( frequencyToSet * 2 );
00158 #else
00159     _spi ->frequency( frequencyToSet );
00160 #endif
00161     wait_ms(100);
00162 }
00163 
00164 void SX1276Generic::IoIrqInit( DioIrqHandler *irqHandlers )
00165 {
00166     if (_dio0 )
00167         _dio0 ->rise(callback(this, static_cast< Trigger > ( irqHandlers[0] )));
00168     if (_dio1)
00169         _dio1->rise(callback(this, static_cast< Trigger > ( irqHandlers[1] )));
00170     if (_dio2)
00171         _dio2->rise(callback(this, static_cast< Trigger > ( irqHandlers[2] )));
00172     if (_dio3)
00173         _dio3->rise(callback(this, static_cast< Trigger > ( irqHandlers[3] )));
00174     if (_dio4)
00175         _dio4->rise(callback(this, static_cast< Trigger > ( irqHandlers[4] )));
00176 }
00177 
00178 void SX1276Generic::IoDeInit( void )
00179 {
00180     //nothing
00181 }
00182 
00183 void SX1276Generic::SetRfTxPower( int8_t power )
00184 {
00185     uint8_t paConfig = 0;
00186     uint8_t paDac = 0;
00187     
00188     paConfig = Read( REG_PACONFIG );
00189     paDac = Read( REG_PADAC );
00190     
00191     paConfig = ( paConfig & RF_PACONFIG_PASELECT_MASK ) | GetPaSelect( this->settings.Channel );
00192     paConfig = ( paConfig & RF_PACONFIG_MAX_POWER_MASK ) | 0x70;
00193     
00194     if( ( paConfig & RF_PACONFIG_PASELECT_PABOOST ) == RF_PACONFIG_PASELECT_PABOOST )
00195     {
00196         if( power > 17 )
00197         {
00198             paDac = ( paDac & RF_PADAC_20DBM_MASK ) | RF_PADAC_20DBM_ON;
00199         }
00200         else
00201         {
00202             paDac = ( paDac & RF_PADAC_20DBM_MASK ) | RF_PADAC_20DBM_OFF;
00203         }
00204         if( ( paDac & RF_PADAC_20DBM_ON ) == RF_PADAC_20DBM_ON )
00205         {
00206             if( power < 5 )
00207             {
00208                 power = 5;
00209             }
00210             if( power > 20 )
00211             {
00212                 power = 20;
00213             }
00214             paConfig = ( paConfig & RF_PACONFIG_OUTPUTPOWER_MASK ) | ( uint8_t )( ( uint16_t )( power - 5 ) & 0x0F );
00215         }
00216         else
00217         {
00218             if( power < 2 )
00219             {
00220                 power = 2;
00221             }
00222             if( power > 17 )
00223             {
00224                 power = 17;
00225             }
00226             paConfig = ( paConfig & RF_PACONFIG_OUTPUTPOWER_MASK ) | ( uint8_t )( ( uint16_t )( power - 2 ) & 0x0F );
00227         }
00228     }
00229     else
00230     {
00231         if( power < -1 )
00232         {
00233             power = -1;
00234         }
00235         if( power > 14 )
00236         {
00237             power = 14;
00238         }
00239         paConfig = ( paConfig & RF_PACONFIG_OUTPUTPOWER_MASK ) | ( uint8_t )( ( uint16_t )( power + 1 ) & 0x0F );
00240     }
00241     Write( REG_PACONFIG, paConfig );
00242     Write( REG_PADAC, paDac );
00243 }
00244 
00245 
00246 uint8_t SX1276Generic::GetPaSelect( uint32_t channel )
00247 {
00248     if( channel > RF_MID_BAND_THRESH )
00249     {
00250         if (boardConnected == SX1276MB1LAS || boardConnected == RFM95_SX1276 || boardConnected == MURATA_SX1276)
00251         {
00252             return RF_PACONFIG_PASELECT_PABOOST;
00253         }
00254         else
00255         {
00256             return RF_PACONFIG_PASELECT_RFO;
00257         }
00258     }
00259     else
00260     {
00261         return RF_PACONFIG_PASELECT_RFO;
00262     }
00263 }
00264 
00265 void SX1276Generic::SetAntSwLowPower( bool status )
00266 {
00267     if( isRadioActive != status )
00268     {
00269         isRadioActive = status;
00270     
00271         if( status == false )
00272         {
00273             AntSwInit( );
00274         }
00275         else
00276         {
00277             AntSwDeInit( );
00278         }
00279     }
00280 }
00281 
00282 void SX1276Generic::AntSwInit( void )
00283 {
00284     if (_antSwitch )
00285         *_antSwitch  = 0;
00286     if (boardConnected == MURATA_SX1276) {
00287         *_antSwitchTX = 0;
00288         *_antSwitchTXBoost = 0;
00289     }
00290 }
00291 
00292 void SX1276Generic::AntSwDeInit( void )
00293 {
00294     if (_antSwitch )
00295         *_antSwitch  = 0;
00296     if (boardConnected == MURATA_SX1276) {
00297         *_antSwitchTX = 0;
00298         *_antSwitchTXBoost = 0;
00299     }
00300 }
00301 
00302 
00303 void SX1276Generic::SetAntSw( uint8_t opMode )
00304 {
00305     switch( opMode )
00306     {
00307         case RFLR_OPMODE_TRANSMITTER:
00308             if (boardConnected == MURATA_SX1276) {
00309                 *_antSwitch  = 0;// Murata-RX
00310                 if (Read( REG_PACONFIG) & RF_PACONFIG_PASELECT_PABOOST)
00311                     *_antSwitchTXBoost = 1;
00312                 else
00313                     *_antSwitchTX = 1;  // alternate: antSwitchTXBoost = 1
00314             } else {
00315                 if (_antSwitch )
00316                     *_antSwitch  = 1;
00317             }
00318             break;
00319         case RFLR_OPMODE_RECEIVER:
00320         case RFLR_OPMODE_RECEIVER_SINGLE:
00321         case RFLR_OPMODE_CAD:
00322             if (boardConnected == MURATA_SX1276) {
00323                 *_antSwitch  = 1;  // Murata-RX
00324                 *_antSwitchTX = 0;
00325                 *_antSwitchTXBoost = 0;
00326             } else {
00327                 if (_antSwitch )
00328                     _antSwitch  = 0;
00329             }
00330             break;
00331         case RFLR_OPMODE_SLEEP:
00332         case RFLR_OPMODE_STANDBY:
00333         default:
00334             if (boardConnected == MURATA_SX1276) {
00335                 *_antSwitch  = 0;  //Murata-RX
00336                 *_antSwitchTX = 0;
00337                 *_antSwitchTXBoost = 0;
00338             } else {
00339                 if (_antSwitch )
00340                     *_antSwitch  = 0;
00341             }
00342             break;
00343     }
00344 }
00345 
00346 void SX1276Generic::SetTimeout(TimeoutTimer_t timer, timeoutFuncPtr func, int timeout_ms)
00347 {
00348     switch(timer) {
00349         case RXTimeoutTimer:
00350             if (func)
00351                 rxTimeoutTimer.attach_us(callback(this, func), timeout_ms);
00352             else
00353                 rxTimeoutTimer.detach();
00354             break;
00355         case TXTimeoutTimer:
00356             if (func)
00357                 txTimeoutTimer .attach_us(callback(this, func), timeout_ms);
00358             else
00359                 txTimeoutTimer .detach();
00360             break;
00361         case RXTimeoutSyncWordTimer:
00362             if (func)
00363                 rxTimeoutSyncWord.attach_us(callback(this, func), timeout_ms);
00364             else
00365                 rxTimeoutSyncWord.detach();
00366             break;
00367     }
00368 }
00369 
00370 void
00371 SX1276Generic::Sleep_ms(int ms)
00372 {
00373     wait_ms(ms);
00374 }
00375 
00376 bool SX1276Generic::CheckRfFrequency( uint32_t frequency )
00377 {
00378     if (frequency > 1200000)
00379         return false;
00380     // Implement check. Currently all frequencies are supported
00381     return true;
00382 }
00383 
00384 void SX1276Generic::Reset( void )
00385 {
00386     _reset ->output();
00387     *_reset  = 0;
00388     wait_ms( 1 );
00389     *_reset  = 1;
00390     _reset ->input();    // I don't know my input again, maybe to save power (Helmut T)
00391     wait_ms( 6 );
00392 }
00393 
00394 void SX1276Generic::Write( uint8_t addr, uint8_t data )
00395 {
00396     Write( addr, &data, 1 );
00397 }
00398 
00399 uint8_t SX1276Generic::Read( uint8_t addr )
00400 {
00401     uint8_t data;
00402     Read( addr, &data, 1 );
00403     return data;
00404 }
00405 
00406 void SX1276Generic::Write( uint8_t addr, void *buffer, uint8_t size )
00407 {
00408     uint8_t i;
00409     uint8_t *p = (uint8_t *)buffer;
00410 
00411     *_nss = 0; // what about SPI hold/release timing on fast MCUs? Helmut
00412     _spi ->write( addr | 0x80 );
00413     for( i = 0; i < size; i++ )
00414     {
00415         _spi ->write(*p++);
00416     }
00417     *_nss = 1;
00418 }
00419 
00420 void SX1276Generic::Read( uint8_t addr, void *buffer, uint8_t size )
00421 {
00422     uint8_t i;
00423     uint8_t *p = (uint8_t *)buffer;
00424     
00425     *_nss = 0; // what about SPI hold/release timing on fast MCUs? Helmut
00426     _spi ->write( addr & 0x7F );
00427     for( i = 0; i < size; i++ )
00428     {
00429         *p++ = _spi ->write( 0 );
00430     }
00431     *_nss = 1;
00432 }
00433 
00434 void SX1276Generic::WriteFifo( void *buffer, uint8_t size )
00435 {
00436     Write( 0, buffer, size );
00437 }
00438 
00439 void SX1276Generic::ReadFifo( void *buffer, uint8_t size )
00440 {
00441     Read( 0, buffer, size );
00442 }