GenericPingPong.cpp

00001 /*
00002  * This file contains a copy of the master content sx1276PingPong
00003  * with adaption for the SX1276Generic environment
00004  * (c) 2017 Helmut Tschemernjak
00005  * 30826 Garbsen (Hannover) Germany
00006  */
00007  
00008 #include "mbed.h"
00009 #include "PinMap.h"
00010 #include "GenericPingPong.h"
00011 #include "sx1276-mbed-hal.h"
00012 #include "main.h"
00013 
00014 #ifdef FEATURE_LORA
00015 
00016 /* Set this flag to '1' to display debug messages on the console */
00017 #define DEBUG_MESSAGE   1
00018 
00019 /* Set this flag to '1' to use the LoRa modulation or to '0' to use FSK modulation */
00020 #define USE_MODEM_LORA  1
00021 #define USE_MODEM_FSK   !USE_MODEM_LORA
00022 #define RF_FREQUENCY            RF_FREQUENCY_868_1  // Hz
00023 #define TX_OUTPUT_POWER         14                  // 14 dBm
00024 
00025 #if USE_MODEM_LORA == 1
00026 
00027 #define LORA_BANDWIDTH          125000  // LoRa default, details in SX1276::BandwidthMap
00028 #define LORA_SPREADING_FACTOR   LORA_SF11
00029 #define LORA_CODINGRATE         LORA_ERROR_CODING_RATE_4_5
00030 
00031 #define LORA_PREAMBLE_LENGTH    6       // Same for Tx and Rx
00032 #define LORA_SYMBOL_TIMEOUT     10       // Symbols
00033 #define LORA_FIX_LENGTH_PAYLOAD_ON  false
00034 #define LORA_FHSS_ENABLED       false  
00035 #define LORA_NB_SYMB_HOP        4     
00036 #define LORA_IQ_INVERSION_ON    false
00037 #define LORA_CRC_ENABLED        true
00038     
00039 #elif USE_MODEM_FSK == 1
00040 
00041 #define FSK_FDEV                25000     // Hz
00042 #define FSK_DATARATE            19200     // bps
00043 #define FSK_BANDWIDTH           50000     // Hz
00044 #define FSK_AFC_BANDWIDTH       83333     // Hz
00045 #define FSK_PREAMBLE_LENGTH     6         // Same for Tx and Rx
00046 #define FSK_FIX_LENGTH_PAYLOAD_ON   true
00047 #define FSK_CRC_ENABLED         true
00048     
00049 #else
00050     #error "Please define a modem in the compiler options."
00051 #endif 
00052 
00053 
00054 #define RX_TIMEOUT_VALUE    3500    // in ms
00055 
00056 //#define BUFFER_SIZE       32        // Define the payload size here
00057 #define BUFFER_SIZE         2        // Define the payload size here
00058 
00059 /*
00060  *  Global variables declarations
00061  */
00062 typedef enum {
00063     SLEEP = 0,
00064     RX_INIT,
00065     RX_INIT_WAIT,
00066     RX_ENUM,
00067     RX_ENUM_WAIT,
00068     TX_PING, 
00069     RX_TIMEOUT,
00070     RX_ERROR,
00071     TX_INIT,
00072     TX_INIT_WAIT,
00073     TX_ENUM,
00074     TX_ENUM_WAIT,
00075     CAD,
00076     CAD_DONE
00077 } AppStates_t;
00078 
00079 volatile AppStates_t State = TX_INIT;
00080 
00081 /*!
00082  * Radio events function pointer
00083  */
00084 static RadioEvents_t RadioEvents;
00085 
00086 /*
00087  *  Global variables declarations
00088  */
00089 SX1276Generic *Radio;
00090 
00091 
00092 const uint8_t PingMsg[] = { 0xFF, 0xFF, 0xFF, 0xFF};// "PING";
00093 const uint8_t PongMsg[] = { 0xFF, 0xFF, 0xFF, 0xFF};// "PONG";
00094 uint16_t BufferSize = BUFFER_SIZE;
00095 uint8_t *Buffer;
00096 
00097 DigitalOut *led3;
00098 
00099 
00100 int SX1276PingPong() 
00101 {
00102 #if( defined ( TARGET_KL25Z ) || defined ( TARGET_LPC11U6X ) )
00103     DigitalOut *led = new DigitalOut(LED2);
00104 #elif defined(TARGET_NUCLEO_L073RZ) || defined(TARGET_DISCO_L072CZ_LRWAN1)
00105     DigitalOut *led = new DigitalOut(LED4);   // RX red
00106     led3 = new DigitalOut(LED3);  // TX blue
00107 #else
00108     DigitalOut *led = new DigitalOut(LED1);
00109     led3 = led;
00110 #endif
00111     
00112     Buffer = new  uint8_t[BUFFER_SIZE];
00113     *led3 = 1;
00114 
00115 #ifdef B_L072Z_LRWAN1_LORA
00116     Radio = new SX1276Generic(NULL, MURATA_SX1276,
00117             LORA_SPI_MOSI, LORA_SPI_MISO, LORA_SPI_SCLK, LORA_CS, LORA_RESET,
00118             LORA_DIO0, LORA_DIO1, LORA_DIO2, LORA_DIO3, LORA_DIO4, LORA_DIO5,
00119             LORA_ANT_RX, LORA_ANT_TX, LORA_ANT_BOOST, LORA_TCXO);
00120 #else // RFM95
00121     Radio = new SX1276Generic(NULL, RFM95_SX1276,
00122             LORA_SPI_MOSI, LORA_SPI_MISO, LORA_SPI_SCLK, LORA_CS, LORA_RESET,
00123             LORA_DIO0, LORA_DIO1, LORA_DIO2, LORA_DIO3, LORA_DIO4, LORA_DIO5);
00124 
00125 #endif
00126     
00127     uint8_t i;
00128     
00129     dprintf("SX1276 Ping Pong Demo Application" );
00130     dprintf("Freqency: %.1f", (double)RF_FREQUENCY/1000000.0);
00131     dprintf("TXPower: %d dBm",  TX_OUTPUT_POWER);
00132 #if USE_MODEM_LORA == 1
00133     dprintf("Bandwidth: %d Hz", LORA_BANDWIDTH);
00134     dprintf("Spreading factor: SF%d", LORA_SPREADING_FACTOR);
00135 #elif USE_MODEM_FSK == 1
00136     dprintf("Bandwidth: %d kHz",  FSK_BANDWIDTH);
00137     dprintf("Baudrate: %d", FSK_DATARATE);
00138 #endif
00139     // Initialize Radio driver
00140     RadioEvents.TxDone = OnTxDone;
00141     RadioEvents.RxDone = OnRxDone;
00142     RadioEvents.RxError = OnRxError;
00143     RadioEvents.TxTimeout = OnTxTimeout;
00144     RadioEvents.RxTimeout = OnRxTimeout;    
00145     if (Radio->Init( &RadioEvents ) == false) {
00146         while(1) {
00147             dprintf("Radio could not be detected!");
00148             wait( 1 );
00149         }
00150     }
00151 
00152     
00153     switch(Radio->DetectBoardType()) {
00154         case SX1276MB1LAS:
00155             if (DEBUG_MESSAGE)
00156                 dprintf(" > Board Type: SX1276MB1LAS <");
00157             break;
00158         case SX1276MB1MAS:
00159             if (DEBUG_MESSAGE)
00160                 dprintf(" > Board Type: SX1276MB1LAS <");
00161         case MURATA_SX1276:
00162             if (DEBUG_MESSAGE)
00163                 dprintf(" > Board Type: MURATA_SX1276_STM32L0 <");
00164             break;
00165         case RFM95_SX1276:
00166             if (DEBUG_MESSAGE)
00167                 dprintf(" > HopeRF RFM95xx <");
00168             break;
00169         default:
00170             dprintf(" > Board Type: unknown <");
00171     }
00172 
00173     Radio->SetChannel(RF_FREQUENCY ); 
00174 
00175 #if USE_MODEM_LORA == 1
00176     
00177     if (LORA_FHSS_ENABLED)
00178         dprintf("             > LORA FHSS Mode <");
00179     if (!LORA_FHSS_ENABLED)
00180         dprintf("             > LORA Mode <");
00181 
00182     Radio->SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
00183                          LORA_SPREADING_FACTOR, LORA_CODINGRATE,
00184                          LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
00185                          LORA_CRC_ENABLED, LORA_FHSS_ENABLED, LORA_NB_SYMB_HOP, 
00186                          LORA_IQ_INVERSION_ON, 2000 );
00187     
00188     Radio->SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
00189                          LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
00190                          LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON, 0,
00191                          LORA_CRC_ENABLED, LORA_FHSS_ENABLED, LORA_NB_SYMB_HOP, 
00192                          LORA_IQ_INVERSION_ON, true );
00193                          
00194 #elif USE_MODEM_FSK == 1
00195 
00196     dprintf("              > FSK Mode <");
00197     Radio->SetTxConfig( MODEM_FSK, TX_OUTPUT_POWER, FSK_FDEV, 0,
00198                          FSK_DATARATE, 0,
00199                          FSK_PREAMBLE_LENGTH, FSK_FIX_LENGTH_PAYLOAD_ON,
00200                          FSK_CRC_ENABLED, 0, 0, 0, 2000 );
00201     
00202     Radio->SetRxConfig( MODEM_FSK, FSK_BANDWIDTH, FSK_DATARATE,
00203                          0, FSK_AFC_BANDWIDTH, FSK_PREAMBLE_LENGTH,
00204                          0, FSK_FIX_LENGTH_PAYLOAD_ON, 0, FSK_CRC_ENABLED,
00205                          0, 0, false, true );
00206                          
00207 #else
00208 
00209 #error "Please define a modem in the compiler options."
00210 
00211 #endif
00212      
00213         
00214     if (DEBUG_MESSAGE)
00215         dprintf("Starting INIT_LOOP");
00216 
00217 
00218 
00219     while( 1 ) {
00220 #ifdef TARGET_STM32L4
00221         WatchDogUpdate();
00222 #endif
00223 
00224         switch( State ) {
00225             case SLEEP:
00226 
00227                 dprintf("Sleep()");
00228                 wait_ms(10000);
00229                 State = RX_INIT;
00230                 break;
00231             case RX_INIT:
00232                 dprintf("RX_INIT()");
00233                 Radio->Rx( 8000 );
00234                 while(State == RX_INIT) {} 
00235                 break;
00236             case RX_ENUM:
00237                 dprintf("RX_ENUM()!!!!!!!!!!!!!!!!!!!!!!!!");
00238                 Radio->Rx( 23000 );
00239                 while(State == RX_ENUM) {} 
00240                 break;
00241             case RX_TIMEOUT:
00242                 dprintf("RX_TIMEOUT()");
00243                 State = SLEEP;
00244                 break;
00245             
00246             case TX_PING:
00247                 dprintf("RX_Ping()!!!!!!!!!!!!!!!!!!!!!!!!");
00248                 State = SLEEP;
00249                 break;
00250             case TX_INIT:
00251             int txcount = 0;
00252                 for(txcount=0;txcount<1000;txcount++) {
00253                 dprintf("TX_INIT()");
00254                 // Send the next PING frame
00255                 //memcpy(Buffer, PingMsg, 2);
00256                 
00257                 wait_ms( 1000 );
00258                   dprintf("dump(0x%x, %d bytes)", PingMsg, 2);
00259                 Radio->Send( (void*) PingMsg, BufferSize );
00260                 dprintf("TX_INIT_SENT()");
00261                 State = TX_INIT_WAIT;
00262                 while(State == TX_INIT_WAIT) {};
00263                 
00264                 }
00265                 State=TX_ENUM;
00266                 break;
00267             case TX_INIT_WAIT:
00268                 wait_ms(100);
00269                 break;
00270             case TX_ENUM:
00271                 dprintf("TX_ENUM()!!!!!!!!!!!!!!!!!!!!!!!!!!");
00272                 wait_ms(500);
00273                 // Send the next PING frame
00274                 memcpy(Buffer, PingMsg, sizeof(PingMsg));
00275                 for( i = 4; i < BufferSize; i++ ) {
00276                     Buffer[i] = i - 4;
00277                 }
00278                 wait_ms( 10 );
00279                 Radio->Send( Buffer, BufferSize );
00280                 dprintf("TX_ENUM_SENT()");
00281                 State = TX_INIT_WAIT;
00282                 while(State == TX_INIT_WAIT) {}
00283                 break;
00284             default:
00285                 State = SLEEP;
00286                 break;
00287         }
00288     }
00289 }
00290 
00291 void OnTxDone(void *radio, void *a, void *b)
00292 {
00293     Radio->Sleep( );
00294     if(State == TX_INIT_WAIT) State = TX_INIT;
00295     dprintf("> OnTxDone");
00296 }
00297 
00298 void OnRxDone(void *radio, void *a, void *b, uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr)
00299 {
00300   dprintf("dump(0x%x, %d bytes)", payload, 2);
00301     dprintf("> OnRxDone");
00302     Radio->Sleep( );
00303     BufferSize = size;
00304     //memcpy( Buffer, payload, BufferSize );
00305     dprintf("> OnRxDone: RssiValue=%d dBm, SnrValue=%d, size=%d", rssi, snr, size);
00306     if(size != 2) {
00307     State=SLEEP;
00308     dprintf("> Payload error");
00309     return;}
00310     decodePayload(payload, size);
00311 }
00312 
00313 void decodePayload(const void *data, int len)
00314 {
00315     dprintf("dump(0x%x, %d bytes)", data, len);
00316 
00317     unsigned char *u;
00318 
00319     u = (unsigned char *)data;
00320     if(*u == 1) State = RX_ENUM;
00321     if(*u == 2) State == TX_PING;
00322     else {
00323     dprintf("> Invalid RX Command");
00324     State = SLEEP;
00325     }
00326 }
00327 
00328 void OnTxTimeout(void *radio, void *a, void *b)
00329 {
00330     Radio->Sleep( );
00331     State = SLEEP;
00332     dprintf("> OnTxTimeout");
00333 }
00334 
00335 void OnRxTimeout(void *radio, void *a, void *b)
00336 {
00337     dprintf("> OnRxTimeout");
00338     Radio->Sleep( );
00339     Buffer[BufferSize-1] = 0;
00340     dprintf("> OnRxTimeout");
00341     State = SLEEP;
00342 }
00343 
00344 void OnRxError(void *radio, void *a, void *b)
00345 {
00346     dprintf("> OnRxError");
00347     Radio->Sleep( );
00348     dprintf("> OnRxError");
00349 }
00350 
00351 #endif