Fork of SX1276Lib for the NiceRF SX1276 module.

Fork of SX1276Lib by Semtech

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers sx1276-hal.cpp Source File

sx1276-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 #include "sx1276-hal.h"
00016 
00017 const RadioRegisters_t  SX1276MB1xAS::RadioRegsInit[] = RADIO_INIT_REGISTERS_VALUE;
00018 
00019 SX1276MB1xAS::SX1276MB1xAS( RadioEvents_t *events,
00020                             PinName mosi, PinName miso, PinName sclk, PinName nss, PinName reset,
00021                             PinName dio0, PinName dio1, PinName dio2, PinName dio3, PinName dio4, PinName dio5,
00022                             PinName antSwitch )
00023                             : SX1276 ( events, mosi, miso, sclk, nss, reset, dio0, dio1, dio2, dio3, dio4, dio5 ),
00024                             antSwitch( antSwitch ),
00025                         #if( defined ( TARGET_NUCLEO_L152RE ) )
00026                             fake( D8 )
00027                         #else
00028                             fake( A3 )
00029                         #endif
00030 {
00031     this->RadioEvents = events;
00032 
00033     Reset( );
00034 
00035     RxChainCalibration( );
00036 
00037     IoInit( );
00038 
00039     SetOpMode( RF_OPMODE_SLEEP );
00040 
00041     IoIrqInit( dioIrq );
00042 
00043     RadioRegistersInit( );
00044 
00045     SetModem( MODEM_FSK );
00046 
00047     this->settings.State = RF_IDLE ;
00048 }
00049 
00050 SX1276MB1xAS::SX1276MB1xAS( RadioEvents_t *events )
00051                         #if defined ( TARGET_NUCLEO_L152RE )
00052                         :   SX1276 ( events, D11, D12, D13, D10, A0, D2, D3, D4, D5, A3, D9 ), // For NUCLEO L152RE dio4 is on port A3
00053                             antSwitch( A4 ),
00054                             fake( D8 )
00055                         #elif defined( TARGET_LPC11U6X )
00056                         :   SX1276 ( events, D11, D12, D13, D10, A0, D2, D3, D4, D5, D8, D9 ),
00057                             antSwitch( P0_23 ), 
00058                             fake( A3 )
00059                         #else
00060                         :   SX1276 ( events, D11, D12, D13, D10, A0, D2, D3, D4, D5, D8, D9 ),
00061                             antSwitch( A4 ), 
00062                             fake( A3 )
00063                         #endif
00064 {
00065     this->RadioEvents = events;
00066 
00067     Reset( );
00068 
00069     boardConnected = UNKNOWN;
00070 
00071     DetectBoardType( );
00072 
00073     RxChainCalibration( );
00074 
00075     IoInit( );
00076 
00077     SetOpMode( RF_OPMODE_SLEEP );
00078     IoIrqInit( dioIrq );
00079 
00080     RadioRegistersInit( );
00081 
00082     SetModem( MODEM_FSK );
00083 
00084     this->settings.State = RF_IDLE ;
00085 }
00086 
00087 //-------------------------------------------------------------------------
00088 //                      Board relative functions
00089 //-------------------------------------------------------------------------
00090 uint8_t SX1276MB1xAS::DetectBoardType( void )
00091 {
00092     if( boardConnected == UNKNOWN )
00093     {
00094         antSwitch .input( );
00095         wait_ms( 1 );
00096         if( antSwitch  == 1 )
00097         {
00098             boardConnected = SX1276MB1LAS;
00099         }
00100         else
00101         {
00102             boardConnected = SX1276MB1MAS;
00103         }
00104         antSwitch .output( );
00105         wait_ms( 1 );
00106     }
00107     return ( boardConnected );
00108 }
00109 
00110 void SX1276MB1xAS::IoInit( void )
00111 {
00112     AntSwInit( );
00113     SpiInit( );
00114 }
00115 
00116 void SX1276MB1xAS::RadioRegistersInit( )
00117 {
00118     uint8_t i = 0;
00119     for( i = 0; i < sizeof( RadioRegsInit ) / sizeof( RadioRegisters_t  ); i++ )
00120     {
00121         SetModem( RadioRegsInit[i].Modem );
00122         Write( RadioRegsInit[i].Addr, RadioRegsInit[i].Value );
00123     }    
00124 }
00125 
00126 void SX1276MB1xAS::SpiInit( void )
00127 {
00128     nss = 1;    
00129     spi .format( 8,0 );   
00130     uint32_t frequencyToSet = 8000000;
00131     #if( defined ( TARGET_NUCLEO_L152RE ) ||  defined ( TARGET_LPC11U6X ) )
00132         spi .frequency( frequencyToSet );
00133     #elif( defined ( TARGET_KL25Z ) ) //busclock frequency is halved -> double the spi frequency to compensate
00134         spi .frequency( frequencyToSet * 2 );
00135     #else
00136         #warning "Check the board's SPI frequency"
00137     #endif
00138     wait(0.1); 
00139 }
00140 
00141 void SX1276MB1xAS::IoIrqInit( DioIrqHandler *irqHandlers )
00142 {
00143 #if( defined ( TARGET_NUCLEO_L152RE ) || defined ( TARGET_LPC11U6X ) )
00144     dio0 .mode( PullDown );
00145     dio1.mode( PullDown );
00146     dio2.mode( PullDown );
00147     dio3.mode( PullDown );
00148     dio4.mode( PullDown );
00149 #endif
00150     dio0 .rise( this, static_cast< TriggerMB1xAS > ( irqHandlers[0] ) );
00151     dio1.rise( this, static_cast< TriggerMB1xAS > ( irqHandlers[1] ) );
00152     dio2.rise( this, static_cast< TriggerMB1xAS > ( irqHandlers[2] ) );
00153     dio3.rise( this, static_cast< TriggerMB1xAS > ( irqHandlers[3] ) );
00154     dio4.rise( this, static_cast< TriggerMB1xAS > ( irqHandlers[4] ) );
00155 }
00156 
00157 void SX1276MB1xAS::IoDeInit( void )
00158 {
00159     //nothing
00160 }
00161 
00162 uint8_t SX1276MB1xAS::GetPaSelect( uint32_t channel )
00163 {
00164     if( channel > RF_MID_BAND_THRESH )
00165     {
00166         if( boardConnected == SX1276MB1LAS )
00167         {
00168             return RF_PACONFIG_PASELECT_PABOOST;
00169         }
00170         else
00171         {
00172             return RF_PACONFIG_PASELECT_RFO;
00173         }
00174     }
00175     else
00176     {
00177         return RF_PACONFIG_PASELECT_RFO;
00178     }
00179 }
00180 
00181 void SX1276MB1xAS::SetAntSwLowPower( bool status )
00182 {
00183     if( isRadioActive != status )
00184     {
00185         isRadioActive = status;
00186     
00187         if( status == false )
00188         {
00189             AntSwInit( );
00190         }
00191         else
00192         {
00193             AntSwDeInit( );
00194         }
00195     }
00196 }
00197 
00198 void SX1276MB1xAS::AntSwInit( void )
00199 {
00200     antSwitch  = 0;
00201 }
00202 
00203 void SX1276MB1xAS::AntSwDeInit( void )
00204 {
00205     antSwitch  = 0;
00206 }
00207 
00208 void SX1276MB1xAS::SetAntSw( uint8_t rxTx )
00209 {
00210 
00211     this->rxTx = rxTx ;
00212 
00213     // 1: Tx, 0: Rx
00214     if( rxTx != 0 )
00215     {
00216         antSwitch  = 1;
00217     }
00218     else
00219     {
00220         antSwitch  = 0;
00221     }
00222 }
00223 
00224 bool SX1276MB1xAS::CheckRfFrequency( uint32_t frequency )
00225 {
00226     //TODO: Implement check, currently all frequencies are supported
00227     return true;
00228 }
00229 
00230 
00231 void SX1276MB1xAS::Reset( void )
00232 {
00233     reset .output();
00234     reset  = 0;
00235     wait_ms( 1 );
00236     reset .input();
00237     wait_ms( 6 );
00238 }
00239     
00240 void SX1276MB1xAS::Write( uint8_t addr, uint8_t data )
00241 {
00242     Write( addr, &data, 1 );
00243 }
00244 
00245 uint8_t SX1276MB1xAS::Read( uint8_t addr )
00246 {
00247     uint8_t data;
00248     Read( addr, &data, 1 );
00249     return data;
00250 }
00251 
00252 void SX1276MB1xAS::Write( uint8_t addr, uint8_t *buffer, uint8_t size )
00253 {
00254     uint8_t i;
00255 
00256     nss = 0;
00257     spi .write( addr | 0x80 );
00258     for( i = 0; i < size; i++ )
00259     {
00260         spi .write( buffer[i] );
00261     }
00262     nss = 1;
00263 }
00264 
00265 void SX1276MB1xAS::Read( uint8_t addr, uint8_t *buffer, uint8_t size )
00266 {
00267     uint8_t i;
00268 
00269     nss = 0;
00270     spi .write( addr & 0x7F );
00271     for( i = 0; i < size; i++ )
00272     {
00273         buffer[i] = spi .write( 0 );
00274     }
00275     nss = 1;
00276 }
00277 
00278 void SX1276MB1xAS::WriteFifo( uint8_t *buffer, uint8_t size )
00279 {
00280     Write( 0, buffer, size );
00281 }
00282 
00283 void SX1276MB1xAS::ReadFifo( uint8_t *buffer, uint8_t size )
00284 {
00285     Read( 0, buffer, size );
00286 }