Guillou Glenn / Mbed 2 deprecated prog_recevoir_v3

Dependencies:   SX1272Lib mbed-src mbed

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers main.cpp Source File

main.cpp

00001 #include "mbed.h"
00002 #include "main.h"
00003 #include "sx1272-hal.h"
00004 #include "debug.h"
00005 //POUR TROUVER MES PODIFICATIONS, RECHERCHE LE MOT "jo" AVEC CTRL+F
00006 /* Set this flag to '1' to display debug messages on the console */
00007 #define DEBUG_MESSAGE   1
00008 
00009 /* Set this flag to '1' to use the LoRa modulation or to '0' to use FSK modulation */
00010 #define USE_MODEM_LORA  1
00011 #define USE_MODEM_FSK   !USE_MODEM_LORA
00012 
00013 #define RF_FREQUENCY                                    868000000 // Hz
00014 #define TX_OUTPUT_POWER                                 14        // 14 dBm
00015 
00016 #if USE_MODEM_LORA == 1
00017 
00018     #define LORA_BANDWIDTH                              2         // [0: 125 kHz,
00019                                                                   //  1: 250 kHz,
00020                                                                   //  2: 500 kHz,
00021                                                                   //  3: Reserved]
00022     #define LORA_SPREADING_FACTOR                       7         // [SF7..SF12]
00023     #define LORA_CODINGRATE                             1         // [1: 4/5,
00024                                                                   //  2: 4/6,
00025                                                                   //  3: 4/7,
00026                                                                   //  4: 4/8]
00027     #define LORA_PREAMBLE_LENGTH                        8         // Same for Tx and Rx
00028     #define LORA_SYMBOL_TIMEOUT                         5         // Symbols
00029     #define LORA_FIX_LENGTH_PAYLOAD_ON                  false
00030     #define LORA_FHSS_ENABLED                           false  
00031     #define LORA_NB_SYMB_HOP                            4     
00032     #define LORA_IQ_INVERSION_ON                        false
00033     #define LORA_CRC_ENABLED                            true
00034     
00035 #elif USE_MODEM_FSK == 1
00036 
00037     #define FSK_FDEV                                    25000     // Hz
00038     #define FSK_DATARATE                                19200     // bps
00039     #define FSK_BANDWIDTH                               50000     // Hz
00040     #define FSK_AFC_BANDWIDTH                           83333     // Hz
00041     #define FSK_PREAMBLE_LENGTH                         5         // Same for Tx and Rx
00042     #define FSK_FIX_LENGTH_PAYLOAD_ON                   false
00043     #define FSK_CRC_ENABLED                             true
00044     
00045 #else
00046     #error "Please define a modem in the compiler options."
00047 #endif
00048 
00049 #define RX_TIMEOUT_VALUE                                3500000   // in us
00050 #define BUFFER_SIZE                                     32        // Define the payload size here
00051 
00052 #if( defined ( TARGET_KL25Z ) || defined ( TARGET_LPC11U6X ) )
00053 DigitalOut led(LED2);
00054 #else
00055 DigitalOut led(LED1);
00056 #endif
00057 
00058 //Jonathan
00059 
00060 
00061 //
00062 /*
00063  *  Global variables declarations
00064  */
00065 typedef enum
00066 {
00067     LOWPOWER = 0,
00068     IDLE,
00069     
00070     RX,
00071     RX_TIMEOUT,
00072     RX_ERROR,
00073     
00074     TX,
00075     TX_TIMEOUT,
00076     
00077     CAD,
00078     CAD_DONE
00079 }AppStates_t;
00080 
00081 volatile AppStates_t State = LOWPOWER;
00082 
00083 /*!
00084  * Radio events function pointer
00085  */
00086 static RadioEvents_t RadioEvents;
00087 
00088 /*
00089  *  Global variables declarations
00090  */
00091 SX1272MB2xAS Radio( NULL );
00092 
00093 const uint8_t PingMsg[] = "PING";
00094 const uint8_t PongMsg[] = "PONG";
00095 
00096 /*const uint8_t PingMsg[] = 42;
00097 const uint8_t PongMsg[] = "Message reçu !";*/
00098 
00099 uint16_t BufferSize = BUFFER_SIZE;
00100 uint8_t Buffer[BUFFER_SIZE];
00101 
00102 int16_t RssiValue = 0.0;
00103 int8_t SnrValue = 0.0;
00104 
00105 
00106 
00107 
00108 int main() 
00109 {
00110     uint8_t i;
00111     bool isMaster = true;
00112     
00113     bool channel;
00114     
00115     channel = Radio.IsChannelFree(MODEM_LORA,9000000,RssiValue);
00116     debug("le channel est %d\n",channel);
00117     
00118     debug( "\n\n\r     SX1272 Ping Pong Demo Application \n\n\r" );
00119 
00120     // Initialize Radio driver
00121     RadioEvents.TxDone = OnTxDone;
00122     RadioEvents.RxDone = OnRxDone;
00123     RadioEvents.RxError = OnRxError;
00124     RadioEvents.TxTimeout = OnTxTimeout;
00125     RadioEvents.RxTimeout = OnRxTimeout;
00126     Radio.Init( &RadioEvents );
00127     
00128     
00129    
00130      
00131     //
00132     
00133     // verify the connection with the board
00134     while( Radio.Read( REG_VERSION ) == 0x00  )
00135     {
00136         debug( "Radio could not be detected!\n\r", NULL );
00137         wait( 1 );
00138     }
00139             
00140     debug_if( ( DEBUG_MESSAGE & ( Radio.DetectBoardType( ) == SX1272MB2XAS ) ) , "\n\r > Board Type: SX1272MB2xAS < \n\r" );
00141   
00142     Radio.SetChannel( RF_FREQUENCY ); 
00143 
00144 #if USE_MODEM_LORA == 1
00145     
00146     debug_if( LORA_FHSS_ENABLED, "\n\n\r             > LORA FHSS Mode < \n\n\r");
00147     debug_if( !LORA_FHSS_ENABLED, "\n\n\r             > LORA Mode < \n\n\r");
00148 
00149     Radio.SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
00150                          LORA_SPREADING_FACTOR, LORA_CODINGRATE,
00151                          LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
00152                          LORA_CRC_ENABLED, LORA_FHSS_ENABLED, LORA_NB_SYMB_HOP, 
00153                          LORA_IQ_INVERSION_ON, 2000000 );
00154     
00155     Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
00156                          LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
00157                          LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON, 0,
00158                          LORA_CRC_ENABLED, LORA_FHSS_ENABLED, LORA_NB_SYMB_HOP, 
00159                          LORA_IQ_INVERSION_ON, true );
00160                          
00161 #elif USE_MODEM_FSK == 1
00162 
00163     debug("\n\n\r              > FSK Mode < \n\n\r");
00164     Radio.SetTxConfig( MODEM_FSK, TX_OUTPUT_POWER, FSK_FDEV, 0,
00165                          FSK_DATARATE, 0,
00166                          FSK_PREAMBLE_LENGTH, FSK_FIX_LENGTH_PAYLOAD_ON,
00167                          FSK_CRC_ENABLED, 0, 0, 0, 2000000 );
00168     
00169     Radio.SetRxConfig( MODEM_FSK, FSK_BANDWIDTH, FSK_DATARATE,
00170                          0, FSK_AFC_BANDWIDTH, FSK_PREAMBLE_LENGTH,
00171                          0, FSK_FIX_LENGTH_PAYLOAD_ON, 0, FSK_CRC_ENABLED,
00172                          0, 0, false, true );
00173                          
00174 #else
00175 
00176 #error "Please define a modem in the compiler options."
00177 
00178 #endif
00179      
00180     debug_if( DEBUG_MESSAGE, "Starting Ping-Pong loop\r\n" ); 
00181         
00182     led = 0;
00183         
00184     Radio.Rx( RX_TIMEOUT_VALUE );
00185     uint8_t val_res[4];
00186     uint8_t val_condu[4];
00187     uint8_t val_tempe[4];
00188     uint8_t val_humi[4];
00189     float somme;
00190     float somme_condu;
00191     float somme_tempe;
00192     float somme_humi;
00193     wait(1);
00194     //on remplit le buffer a 0
00195     for( i = 0; i < BufferSize; i++ )
00196                         {
00197                             Buffer[i] =0;
00198                         }
00199     
00200     while( 1 )
00201     {
00202         wait(2);
00203         switch( State )
00204         {
00205         case RX:
00206             if( isMaster == true )
00207             {
00208                 if( BufferSize > 0 )
00209                 {
00210                     if( Buffer[1] == 0 and Buffer[3]==0)
00211                     {
00212                         led = !led;
00213                         debug( "\r\n" );
00214                         Buffer[0]=1;
00215                         
00216                         wait_ms( 1000 ); 
00217                         Radio.Send( Buffer, BufferSize );
00218                     }
00219                     else if(Buffer[1]==1 and Buffer[3]==0)
00220                     { // A master already exists then become a slave
00221                         debug( "On recoit les valeurs de A\r\n" );
00222                         
00223                         led = !led;
00224                         //isMaster = false;
00225                         // Send the next PONG frame            
00226                         strcpy( ( char* )Buffer, ( char* )PongMsg );
00227                         //debug("buf 0 %d\n",Buffer[0]);
00228                         val_res[0]=Buffer[4];
00229                          val_res[1]=Buffer[5];
00230                          val_res[2]=Buffer[6];
00231                          val_res[3]=Buffer[7];
00232                          somme=*( (float*)(val_res ));
00233                          //debug("Val res 0 vaut dans RX : %d\n",val_res[0]);
00234                         //debug("somme vaut : %f\n",somme);
00235                          val_condu[0]=Buffer[8];
00236                          val_condu[1]=Buffer[9];
00237                          val_condu[2]=Buffer[10];
00238                          val_condu[3]=Buffer[11];
00239                          somme_condu=*( (float*)(val_condu ));
00240                          
00241                          val_tempe[0]=Buffer[12];
00242                          val_tempe[1]=Buffer[13];
00243                          val_tempe[2]=Buffer[14];
00244                          val_tempe[3]=Buffer[15];
00245                          somme_tempe=*( (float*)(val_tempe ));
00246                          
00247                          val_humi[0]=Buffer[16];
00248                          val_humi[1]=Buffer[17];
00249                          val_humi[2]=Buffer[18];
00250                          val_humi[3]=Buffer[19];
00251                          somme_humi=*( (float*)(val_humi ));
00252                         // We fill the buffer with numbers for the payload 
00253                         for( i = 20; i < BufferSize; i++ )
00254                         {
00255                             Buffer[i] = i - 20;
00256                         }
00257                         Buffer[0]=0;
00258                         Buffer[2]=1;
00259                          somme=somme/10000;
00260                         somme_tempe=somme_tempe/100;
00261                         somme_humi=somme_humi/1000;
00262                         debug("A %f R,%f C,%f T,%f H\n",somme,somme_condu,somme_tempe,somme_humi);
00263                         wait_ms( 1000 ); 
00264                         
00265                         Radio.Send( Buffer, BufferSize );
00266                         //wait(10);
00267                     }
00268                     else if(Buffer[3]==1 and Buffer[1]==0)
00269                     { // A master already exists then become a slave
00270                         debug( "On recoit les valeurs de A\r\n" );
00271                         
00272                         led = !led;
00273                         //isMaster = false;
00274                         // Send the next PONG frame            
00275                         strcpy( ( char* )Buffer, ( char* )PongMsg );
00276                         //debug("buf 0 %d\n",Buffer[0]);
00277                         val_res[0]=Buffer[4];
00278                          val_res[1]=Buffer[5];
00279                          val_res[2]=Buffer[6];
00280                          val_res[3]=Buffer[7];
00281                          somme=*( (float*)(val_res ));
00282                          //debug("Val res 0 vaut dans RX : %d\n",val_res[0]);
00283                         //debug("somme vaut : %f\n",somme);
00284                          val_condu[0]=Buffer[8];
00285                          val_condu[1]=Buffer[9];
00286                          val_condu[2]=Buffer[10];
00287                          val_condu[3]=Buffer[11];
00288                          somme_condu=*( (float*)(val_condu ));
00289                          
00290                          val_tempe[0]=Buffer[12];
00291                          val_tempe[1]=Buffer[13];
00292                          val_tempe[2]=Buffer[14];
00293                          val_tempe[3]=Buffer[15];
00294                          somme_tempe=*( (float*)(val_tempe ));
00295                          
00296                          val_humi[0]=Buffer[16];
00297                          val_humi[1]=Buffer[17];
00298                          val_humi[2]=Buffer[18];
00299                          val_humi[3]=Buffer[19];
00300                          somme_humi=*( (float*)(val_humi ));
00301                         // We fill the buffer with numbers for the payload 
00302                         for( i = 20; i < BufferSize; i++ )
00303                         {
00304                             Buffer[i] = i - 20;
00305                         }
00306                         Buffer[2]=0;
00307                         Buffer[0]=1;
00308                          somme=somme/10000;
00309                         somme_tempe=somme_tempe/100;
00310                         somme_humi=somme_humi/1000;
00311                         debug("B %f R,%f C,%f T,%f H\n",somme,somme_condu,somme_tempe,somme_humi);
00312                         wait_ms( 1000 ); 
00313                         
00314                         Radio.Send( Buffer, BufferSize );
00315                         //wait(10);
00316                     }
00317                     else if(Buffer[1]==1 and Buffer[3]==1)
00318                     { // A master already exists then become a slave
00319                         debug( "Les deux sont a 1\r\n" );
00320                         
00321                         led = !led;
00322                         //isMaster = false;
00323                         // Send the next PONG frame            
00324                         Buffer[1]=0;
00325                         Buffer[2]=0;
00326                         Buffer[0]=1;
00327                         Buffer[3]=0;
00328                         // We fill the buffer with numbers for the payload 
00329                         for( i = 20; i < BufferSize; i++ )
00330                         {
00331                             Buffer[i] = i - 20;
00332                         }
00333                        wait_ms( 1000 ); 
00334                         
00335                         Radio.Send( Buffer, BufferSize );
00336                         //wait(10);
00337                     }
00338                     else // valid reception but neither a PING or a PONG message
00339                     {    // Set device as master ans start again
00340                         isMaster = true;
00341                         Radio.Rx( RX_TIMEOUT_VALUE );
00342                     }    
00343                 }
00344             }
00345             else
00346             {
00347                 
00348             }
00349             State = LOWPOWER;
00350             break;
00351         case TX:    
00352             led = !led; 
00353             //uint8_t val_res;
00354             int i;
00355             if( isMaster == true )  
00356             {
00357                 debug( "Tx envoi\r\n" );
00358                 
00359             }
00360             else
00361             {
00362                 debug( "Pong...\r\n" );
00363                 
00364             }
00365             Radio.Rx( RX_TIMEOUT_VALUE );
00366             State = LOWPOWER;
00367             break;
00368         case RX_TIMEOUT:
00369             if( isMaster == true )
00370             {
00371                 // Send the next PING frame
00372                 //strcpy( ( char* )Buffer, ( char* )PingMsg );
00373                 if(Buffer[1]==1){
00374                         val_res[0]=Buffer[4];
00375                          val_res[1]=Buffer[5];
00376                          val_res[2]=Buffer[6];
00377                          val_res[3]=Buffer[7];
00378                          somme=*( (float*)(val_res ));
00379                          
00380                          val_condu[0]=Buffer[8];
00381                          val_condu[1]=Buffer[9];
00382                          val_condu[2]=Buffer[10];
00383                          val_condu[3]=Buffer[11];
00384                          somme_condu=*( (float*)(val_condu ));
00385                          
00386                          val_tempe[0]=Buffer[12];
00387                          val_tempe[1]=Buffer[13];
00388                          val_tempe[2]=Buffer[14];
00389                          val_tempe[3]=Buffer[15];
00390                          somme_tempe=*( (float*)(val_tempe ));
00391                          
00392                          val_humi[0]=Buffer[16];
00393                          val_humi[1]=Buffer[17];
00394                          val_humi[2]=Buffer[18];
00395                          val_humi[3]=Buffer[19];
00396                          somme_humi=*( (float*)(val_humi ));
00397                          debug("A %f R,%f C,%f T,%f H\n",somme,somme_condu,somme_tempe,somme_humi);
00398                          }
00399                 else{
00400                     Buffer[0]=1;
00401                 }
00402                 for( i = 20; i < BufferSize; i++ )
00403                 {
00404                     Buffer[i] = i - 20;
00405                 }
00406                 wait_ms( 1000 ); 
00407                 Radio.Send( Buffer, BufferSize );
00408             }
00409             else
00410             {
00411                 Radio.Rx( RX_TIMEOUT_VALUE );  
00412             }             
00413             State = LOWPOWER;
00414             break;
00415         case RX_ERROR:
00416             // We have received a Packet with a CRC error, send reply as if packet was correct
00417             if( isMaster == true )
00418             {
00419                 // Send the next PING frame
00420                // strcpy( ( char* )Buffer, ( char* )PingMsg );
00421                 for( i = 0; i < BufferSize; i++ )
00422                 {
00423                     Buffer[i] = 0;
00424                 }
00425                 wait_ms( 1000 );  
00426                 Radio.Send( Buffer, BufferSize );
00427             }
00428             else
00429             {
00430                 // Send the next PONG frame
00431                 strcpy( ( char* )Buffer, ( char* )PongMsg );
00432                 for( i = 4; i < BufferSize; i++ )
00433                 {
00434                     Buffer[i] = i - 4;
00435                 }
00436                 wait_ms( 1000 );  
00437                 Radio.Send( Buffer, BufferSize );
00438             }
00439             State = LOWPOWER;
00440             break;
00441         case TX_TIMEOUT:
00442             Radio.Rx( RX_TIMEOUT_VALUE );
00443             State = LOWPOWER;
00444             break;
00445         case LOWPOWER:
00446             break;
00447         default:
00448             State = LOWPOWER;
00449             break;
00450         }  
00451         //wait(2);  
00452     }
00453 }
00454 
00455 void OnTxDone( void )
00456 {
00457     Radio.Sleep( );
00458     State = TX;
00459     debug_if( DEBUG_MESSAGE, "> OnTxDone\n\r" );
00460 }
00461 
00462 void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr)
00463 {
00464     Radio.Sleep( );
00465     BufferSize = size;
00466     memcpy( Buffer, payload, BufferSize );
00467     RssiValue = rssi;
00468     SnrValue = snr;
00469     State = RX;
00470     debug_if( DEBUG_MESSAGE, "> OnRxDone\n\r" );
00471 }
00472 
00473 void OnTxTimeout( void )
00474 {
00475     Radio.Sleep( );
00476     State = TX_TIMEOUT;
00477     debug_if( DEBUG_MESSAGE, "> OnTxTimeout\n\r" );
00478 }
00479 
00480 void OnRxTimeout( void )
00481 {
00482     Radio.Sleep( );
00483     Buffer[ BufferSize ] = 0;
00484     State = RX_TIMEOUT;
00485     debug_if( DEBUG_MESSAGE, "> OnRxTimeout\n\r" );
00486 }
00487 
00488 void OnRxError( void )
00489 {
00490     Radio.Sleep( );
00491     State = RX_ERROR;
00492     debug_if( DEBUG_MESSAGE, "> OnRxError\n\r" );
00493 }
00494