////////////////////////////////////////////////////////////////////////////////
  /*RECEPTEUR LoRa
  par : Robin Cavalieri
        IMA5SC
  PFE 2018 */
  ////////////////////////////////////////////////////////////////////////////////
  //Headers
  #include "mbed.h"
  #include "main.h"
  #include "sx1276-hal.h"
  #include "debug.h"
  ////////////////////////////////////////////////////////////////////////////////

  #define DEBUG_MESSAGE   0

  ////////////////////////////////////////////////////////////////////////////////
  
  ////////////////////////////////////////////////////////////////////////////////
  //Modulation LoRa active
  #define USE_MODEM_LORA  1
  #define USE_MODEM_FSK   !USE_MODEM_LORA
  //Paramètres
  #define RF_FREQUENCY 868000000 //Hz : Fréquence de travail pour UE
  #define TX_OUTPUT_POWER 14     //dBm : puissance de sortie du signal
  #define LORA_BANDWIDTH 1         // 0:125 kHz de BP
  #define LORA_SPREADING_FACTOR 10 // [SF7..SF12] Portée du débit. grande portée inutile
  #define LORA_CODINGRATE 1
  #define LORA_PREAMBLE_LENGTH 8   // Same for Tx and Rx
  #define LORA_SYMBOL_TIMEOUT 5    // Symbols
  #define LORA_FIX_LENGTH_PAYLOAD_ON false

  #define LORA_FHSS_ENABLED false //true initial

  #define LORA_NB_SYMB_HOP 4
  #define LORA_IQ_INVERSION_ON false
  #define LORA_CRC_ENABLED true
  #define RX_TIMEOUT_VALUE 0      // in ms
  #define BUFFER_SIZE 32        // Define the payload size here
  #define TRAME_SIZE 13
  ////////////////////////////////////////////////////////////////////////////////
  
  ////////////////////////////////////////////////////////////////////////////////
  //Variables globales
  typedef enum
  {
      LOWPOWER = 0,
      IDLE,
      RX,
      RX_TIMEOUT,
      RX_ERROR,
      CAD,
      CAD_DONE
  }AppStates_t;
  
  volatile AppStates_t State = LOWPOWER;
  static RadioEvents_t RadioEvents;
  SX1276MB1xAS Radio( NULL );
  uint16_t BufferSize = BUFFER_SIZE;
  uint8_t Buffer[BUFFER_SIZE];
  int16_t RssiValue = 0.0;
  int8_t SnrValue = 0.0;
  uint8_t receptMsg[13];
  ////////////////////////////////////////////////////////////////////////////////
  
  ////////////////////////////////////////////////////////////////////////////////

  //Fonctions utiles
  void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr )
  {
      Radio.SetChannel( HoppingFrequencies[0] );
      Radio.Sleep( );
      BufferSize = size;
      memcpy( Buffer, payload, BufferSize );
      RssiValue = rssi;
      SnrValue = snr;
      State = RX;
      debug_if( DEBUG_MESSAGE, "> OnRxDone\n\r" );
  }
  
  void OnRxTimeout( void )
  {
      Radio.SetChannel( HoppingFrequencies[0] );
      Radio.Sleep( );
      Buffer[BufferSize] = 0;
      State = RX_TIMEOUT;
      debug_if( DEBUG_MESSAGE, "> OnRxTimeout\n\r" );
  }
  
  void OnRxError( void )
  {
      Radio.SetChannel( HoppingFrequencies[0] );
      Radio.Sleep( );
      State = RX_ERROR;
      debug_if( DEBUG_MESSAGE, "> OnRxError\n\r" );
  }
  
  void OnFhssChangeChannel( uint8_t channelIndex )
  {
      Radio.SetChannel( HoppingFrequencies[channelIndex] );
      debug_if( DEBUG_MESSAGE, "F%d-", channelIndex );
  }
  ////////////////////////////////////////////////////////////////////////////////
  
  ////////////////////////////////////////////////////////////////////////////////

  void TrameComp()
  {
      //Création d'une trame de comparaison pour vérifier si l'id de l'emetteur est bonne
      /*
      [1...] : ID de l'emetteur
      [...] : ID du recepteur cible
      [...] : Température communiquée ici 20 pour l'exemple
      */
      //Converti en ASCII
      receptMsg[0] =  0x46; //emetteur F
      receptMsg[1] =  0x33; //emetteur 3
      receptMsg[2] =  0x30; //emetteur 0
      receptMsg[3] =  0x33; //emetteur 3
      receptMsg[4] =  0x52; //emetteur R
      receptMsg[5] =  0x45; //emetteur E
      //
      receptMsg[6] =  0x46; //recepteur F
      receptMsg[7] =  0x30; //recepteur 0
      receptMsg[8] =  0x39; //recepteur 9
      receptMsg[9] =  0x31; //recepteur 1
      receptMsg[10] = 0x43; //recepteur C
      //
      receptMsg[11] = 0x32; //temperature non vérifiee
      receptMsg[12] = 0x31; //temperature non verifiee
  }
  ////////////////////////////////////////////////////////////////////////////////
  
  ////////////////////////////////////////////////////////////////////////////////

  //Main réception
  int main( void )
  {
      debug("\nRecepteur SX1276 \n\n\r");
  
      // Initialize Radio driver
      RadioEvents.RxDone = OnRxDone;
      RadioEvents.RxError = OnRxError;
      RadioEvents.RxTimeout = OnRxTimeout;
      RadioEvents.FhssChangeChannel = OnFhssChangeChannel;
      Radio.Init(&RadioEvents);
  
      //Véification de la communication avec la board
      while(Radio.Read(REG_VERSION) == 0x00)
      {
          debug("Aucune radio detectee\n\r", NULL);
          wait(1);
      }
  
      //Checking du matériel connecté
      debug_if( ( DEBUG_MESSAGE & ( Radio.DetectBoardType( ) == SX1276MB1LAS ) ), "\n\r Materiel detecte : SX1276MB1LAS \n\r" );
      debug_if( ( DEBUG_MESSAGE & ( Radio.DetectBoardType( ) == SX1276MB1MAS ) ), "\n\r Materiel detecte : SX1276MB1MAS \n\r" );
  
      //Paramétrage du canal
      Radio.SetChannel( HoppingFrequencies[0] );
  
      #if USE_MODEM_LORA == 1
  
          debug_if( LORA_FHSS_ENABLED, "\n\n\r             > LORA FHSS Mode < \n\n\r" );
          debug_if( !LORA_FHSS_ENABLED, "\n\n\r             > LORA Mode < \n\n\r" );
  
          Radio.SetRxConfig( MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
                               LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
                               LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON, 0,
                               LORA_CRC_ENABLED, LORA_FHSS_ENABLED, LORA_NB_SYMB_HOP,
                               LORA_IQ_INVERSION_ON, true );
  
      #else
          #error "Aucun modem defini"
      #endif

          TrameComp();
          debug("Reception en cours...\r\n");
          debug("Etat initial du Buffer : %s\r\n",(char*)Buffer);

  
          while(1)
          {

              Radio.Rx(RX_TIMEOUT_VALUE); //Reception mode en continu car TIME_OUT_VALUE = 0

              if( BufferSize > 0 )
              {

                  if(strncmp((const char*)Buffer, (const char*)receptMsg, TRAME_SIZE-2 ) == 0) //-2 pour ne vérifier que l'entete

                  {

                      //Buffer de données

                      debug("%s\n",(char*)Buffer);

                      //Puissance de reception du signal
                      debug("%d\n",RssiValue);

                      //il faut enregistrer la trame

                      //PROGRAMME PYTHON recorder.py POUR ENREGISTRER LES DONNEES sortant du port série

                      //il faut vider le buffer
                      memset (Buffer, NULL, BUFFER_SIZE);

                  }

                  wait_ms(300);

              }
          }
  }
  ////////////////////////////////////////////////////////////////////////////////