////////////////////////////////////////////////////////////////////////////////

  /*EMETTEUR LoRa

  par : Robin Cavalieri

        IMA5SC

  PFE 2018 */

  ////////////////////////////////////////////////////////////////////////////////

  //Headers

  #include "mbed.h"

  #include "main.h"

  #include "sx1276-hal.h"

  #include "debug.h"

  ////////////////////////////////////////////////////////////////////////////////

  #define DEBUG_MESSAGE   1

  ////////////////////////////////////////////////////////////////////////////////

  //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 20     //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 3500      // in ms

  #define BUFFER_SIZE 32        // Define the payload size here

  #define TRAME_SIZE 18

  ////////////////////////////////////////////////////////////////////////////////

  

  ////////////////////////////////////////////////////////////////////////////////

  //Variables globales

  typedef enum

  {

      LOWPOWER = 0,

      IDLE,

      TX,

      TX_TIMEOUT,

      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 cpt_trames = 0;

  uint8_t testMsg[TRAME_SIZE];

  ////////////////////////////////////////////////////////////////////////////////

  

  ////////////////////////////////////////////////////////////////////////////////

  //Fonctions utiles

  

  //Debug pour savoir si le message a été transmis

  void OnTxDone( void )

  {

      Radio.SetChannel( HoppingFrequencies[0] );

      Radio.Sleep( );

      State = TX;

      debug_if( DEBUG_MESSAGE, "\nEnvoye \n\r" );

  }

  

  //Time out de transmission. Échec de l'envoi

  void OnTxTimeout( void )

  {

      Radio.SetChannel(HoppingFrequencies[0]);

      Radio.Sleep( );

      State = TX_TIMEOUT;

      debug_if( DEBUG_MESSAGE, "Echec de l'envoi \n\r");

  }

  

  //Modification du canal d'emission

  void OnFhssChangeChannel( uint8_t channelIndex )

  {

      Radio.SetChannel(HoppingFrequencies[channelIndex]);

      debug_if(DEBUG_MESSAGE, "F%d-", channelIndex);

  }

  

  //fonction permettant de convertir int en uint8_t (ASCII)

  uint8_t RandAscii(int nb)

  {

    int return_var;

  

    if (nb == 0) {

      return_var = 0x30;

    }

    else if (nb == 1) {

      return_var = 0x31;

    }

    else if (nb == 2) {

      return_var = 0x32;

    }

    else if (nb == 3) {

      return_var = 0x33;

    }

    else if (nb == 4) {

      return_var = 0x34;

    }

    else if (nb == 5) {

      return_var = 0x35;

    }

    else if (nb == 6) {

      return_var = 0x36;

    }

    else if (nb == 7) {

      return_var = 0x37;

    }

    else if (nb == 8) {

      return_var = 0x38;

    }

    else if (nb == 9) {

      return_var = 0x39;

    }

    return return_var;

  }

  ////////////////////////////////////////////////////////////////////////////////

  

  ////////////////////////////////////////////////////////////////////////////////

  void TrameCreation()

  {

      //Création d'une trame

      /*

      [1...6] : ID de l'emetteur

      [7...11] : ID du recepteur cible

      [12...13] : Température communiquée ici 20 pour l'exemple

      */

      //Génération aléatoire des températures

      int dizaines_i = rand()%10;

      int unites_i = rand()%10;

      uint8_t dizaines_c = RandAscii(dizaines_i);

      uint8_t unites_c = RandAscii(unites_i);

  

      if(cpt_trames == 101)

      {

        cpt_trames = 0;

      }

  

      cpt_trames = cpt_trames + 1;

  

      debug("compteur trames : %d\n", cpt_trames);

      uint8_t centaines_cpt = RandAscii((cpt_trames/100) % 10);

      uint8_t dizaines_cpt = RandAscii((cpt_trames/10)  % 10);

      uint8_t unites_cpt = RandAscii(cpt_trames % 10);

      //Converti en ASCII

      testMsg[0] =  0x7C; //emetteur |

      testMsg[1] =  0x46; //emetteur F

      testMsg[2] =  0x33; //emetteur 3

      testMsg[3] =  0x30; //emetteur 0

      testMsg[4] =  0x33; //emetteur 3

      testMsg[5] =  0x52; //emetteur R

      testMsg[6] =  0x45; //emetteur E

      //

      testMsg[7] =  0x46; //recepteur F

      testMsg[8] =  0x30; //recepteur 0

      testMsg[9] =  0x39; //recepteur 9

      testMsg[10] =  0x31; //recepteur 1

      testMsg[11] = 0x43; //recepteur C

      //

      testMsg[12] = dizaines_c; //temperature 2 dizaines

      testMsg[13] = unites_c; //temperature 0 unités

      testMsg[14] = 0x7C; //emetteur |

      //

      testMsg[15] = centaines_cpt;

      testMsg[16] = dizaines_cpt;

      testMsg[17] = unites_cpt;

  }

  ////////////////////////////////////////////////////////////////////////////////

  

  ////////////////////////////////////////////////////////////////////////////////

  //Main emission

  int main( void )

  {

      uint8_t i;

      debug("\nEmetteur SX1276 \n\n\r");

  

      // Initialize Radio driver

      RadioEvents.TxDone = OnTxDone;

      RadioEvents.TxTimeout = OnTxTimeout;

      RadioEvents.FhssChangeChannel = OnFhssChangeChannel;

      Radio.Init(&RadioEvents);

      //Véification de la connexion avec la carte

      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" );

          //Configuration du modem transmission

          Radio.SetTxConfig( MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,

                               LORA_SPREADING_FACTOR, LORA_CODINGRATE,

                               LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,

                               LORA_CRC_ENABLED, LORA_FHSS_ENABLED, LORA_NB_SYMB_HOP,

                               LORA_IQ_INVERSION_ON, 4000 );

      #else

          #error "Aucun modem defini"

      #endif

      debug_if( DEBUG_MESSAGE, "Procedure d'emission lancee\r\n" );

      //Boucle d'émission infinie

      while(1)

      {

         //On génère la trame

         TrameCreation();

         debug("\nTentative d'envoi... \r\n");

         strcpy((char*)Buffer, (char*)testMsg);

         for(i=TRAME_SIZE; i<BufferSize; i++)

         {

              Buffer[i] = i - TRAME_SIZE;

         }

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

         Radio.Send(Buffer, BufferSize);

         debug("Message envoye \r\n");

         //Trafic normal

         //wait_ms(5000);

         //Attaque de ping

         wait_ms(1000);

      }

  }

  ////////////////////////////////////////////////////////////////////////////////