///////////////////////////////////////////////////////////////////////////////////////////
  //           DECLARATIONS DES VARIABLES - BIBLIOTHEQUES - INITIALISATION                 //
  ///////////////////////////////////////////////////////////////////////////////////////////
  #include <LiquidCrystal.h> // Déclaration de la librairie de gestion de l’afficheur
  LiquidCrystal lcd(8, 9, 4, 5, 6, 7); // Mode de connexion de l'afficheur (objet appelé lcd)
  #include <Wire.h> // Déclaration de la librairie permettant la gestion du bus I2C
  
  // Déclaration variables et entrées/sorties du clavier analogique
  #define ClavierAnalog 1 // Définition de la constante ClavierAnalog égale à 1
  int tensionClav = 0; // tensionClav est la variable qui sera lue sur l'entrée analogique 1
  boolean avant [8] = {false}; // Tableau contenant les états précédents des boutons poussoirs (false = bouton relâché)
  
  // Déclaration des variables des boutons poussoirs : bouton relâché = false, bouton enfoncé = true
  boolean bouton_0 = false; // Non câblé sur la maquette
  boolean bouton_1 = false; // BLI, BLS
  boolean bouton_2 = false; // 40 m ou 10 m
  boolean bouton_3 = false; // RIT
  boolean bouton_4 = false; // Pas en fréquence
  boolean bouton_5 = false; // Provisoirement inutilisé
  boolean bouton_6 = false; // Provisoirement inutilisé
  
  // Déclaration des variables pour sélectionner fréquence, pas en fréquence, fréquence émission, fréquence réception, FI, OL
  int pas_en_freq [] = {10, 100, 1000, 10000}; // Tableau contenant les 4 pas en fréquence possibles : 10, 100, 1000 ou 10000 Hz
  int pef; // Variable pas en fréquence (pef)
  byte index_pef; // Déclaration de l'index "pas en fréquence" 
  unsigned long freq40; // Fréquence courante bande 40 m
  unsigned long freq10; // Fréquence courante bande 10 m
  unsigned long freq; // Variable fréquence émission servant aux calculs 
  unsigned long freqFI; // Fréquence FI. Non utilisée dans la partie 1.
  unsigned long freqOL; // Non utilisée dans la partie 1.
  
  byte Freq40[4]; // Tableau indexé de 0 à 3 contenant 4 octets de poids forts et faibles de la fréquence sur 40 m 
  unsigned long Freq40PF ; // Poids forts sur 32 bits
  unsigned long Freq40Pf ; // Poids faibles sur 32 bits
  
  byte Freq10[5]; // idem sur 10 m
  unsigned long Freq10PF ;
  unsigned long Freq10Pf ;
  
  // Déclaration des variables pour sélectionner le mode BLI/BLS
  char* mode_BLU[] = {"BLI", "BLS"}; // Tableau contenant 2 chaînes de caractères BLI et BLS
  byte index_BLU; // Variable de l'index_BLU (0 = BLI, 1 = BLS)
  byte index_BLU40 = 0; // index_BLU sur 40 m, initialisé à 0 (BLI)
  byte index_BLU10 = 1; // index_BLU sur 10 m, initialisé à 1 (BLS)
  
  // Déclaration des variables pour sélectionner la bande 40 m ou 10 m
  byte bande; // Variable bande (0 pour le 40 m, 1 pour le 10 m)
  byte pos_freq; // La fréquence sur 10 m s'affichera sur le 6ème digit (pos_freq = 5), le 5ème pour le 10 m. Valeur calculée 
  
  // Déclaration des variables du S-mètre et du ROS-mètre
  #define Smetre 0 // Définition de la constante Smetre (= 0)
  #define Rosmetre 0 // Définition de la constante Rosmetre (= 0)
  int tensionA0 = 0; // Initialisation à 0 de la variable tensionA0
  
  // Déclaration de la variable émission/réception
  byte RxTx = 0; // En réception RxTx = 0, en émission RxTx = 1
  
  // Déclaration des variables du RIT
  byte etat_RIT; // RIT actif : etat_RIT = 1, sinon 0
  int Rit; //Décalage en fréquence positif ou négatif
  
  // Déclaration supplémentaire pour la gestion des mémoires en EEPROM
  byte memoire [12]; // tableau contenant les octets à sauvegarder (12 = 11 positions utilisées + 1)
  
  // Déclaration de la variable image de la tension d'alimentation pour déclenchement automatique de la sauvegarde 
  int tension_sonde_alim;
  
  // Déclaration AD9851
  #define DDS_CLOCK 179996860  // Constante à ajuster pour calibrer le DDS (initialement 180000000)
  byte LOAD = 12; // Port digital 12 affecté à LOAD
  byte CLOCK = 13; // Port digital 13 affecté à CLOCK
  byte DATA = 11; // Port digital 11 affecté à DATA
  
  // Déclaration des ports et des variables de l'encodeur optique
  #define encodeur_A 2 // Voie A de l'encodeur sur le port digital D2
  #define encodeur_B 3 // Voie B de l'encodeur sur le port digital D3
  boolean etat_A; // Etat de A
  boolean etat_B; // Etat de B
  
  /////////////////////////////////////////////////////////////////////////
  ////////////////////////////   SETUP    /////////////////////////////////
  /////////////////////////////////////////////////////////////////////////
  void setup() 
  {
    Wire.begin(); // Initialisation de la bibliothèque Wire.h pour gestion I2C
    lcd.begin(16, 2); // Initialisation de l'afficheur (16 caractères, 2 lignes)
    pinMode (10, OUTPUT); // Port digital D10 configuré en sortie pour commande BLI/BLS
    pinMode (0, OUTPUT); // Port digital D0 configuré en sortie pour commande 40 m/10 m
    pinMode (1, INPUT); // Port digital D1 configuré en entrée pour RX ou TX
  
    // Initialisation du DDS, de l'encodeur et des interruptions
    pinMode (DATA, OUTPUT); // Port digital D11 configuré en sortie (ves DDS-D7)
    pinMode (CLOCK, OUTPUT); // Port digital D13 configuré en sortie (DDS-WCLK)
    pinMode (LOAD, OUTPUT); // Port digital D12 configuré en sortie (DDS-FQUP)
    pinMode(encodeur_A, INPUT); // Port digital D2 configuré en entrée (encodeur optique voie A)
    pinMode(encodeur_B, INPUT); // Port digital D3 configuré en entrée (encodeur optique voie B)
    attachInterrupt(0, Traitement_A, CHANGE); // Interruption provoquée par le changement d'état du port digital D2
    attachInterrupt(1, Traitement_B, CHANGE); // Interruption provoquée par le changement d'état du port digital D3
  
    ///////////////////////// RECUPERATION DES PARAMETRES ////////////////////////////////////////////////////
  
    //////////////////////    PLAN MEMOIRE DE L'EEPROM     ////////////////////////////////////////////////////
  
    /* byte memoire [] = {index_pef, bande, index_BLU40, index_BLU10,         // index 0, 3 : pas en fréquence, bande, mode sur 40 m, mode sur 10 m 
                          Freq40[3], Freq40[2], Freq40[1], Freq40[0],         // index 4 à 7 : fréquence courante 40m
                          Freq10[3], Freq10[2], Freq10[1], Freq10[0] };       // index 8 à 11 : fréquence courante 10m
    */
  
    for(byte i = 0; i < 12; i=i+1) 
    {
      memoire[i] = eeprom_read (0x50, i); // Lecture octet par octet des positions mémoire à l'adresse 0x50 de l'EEPROM
    }
    index_pef = memoire [0]; // Index du pas en fréquence : 0, 1, 2 ou 3 
    pef = pas_en_freq [(index_pef)]; // pef est calculé
    bande = memoire[1];
    index_BLU40 = memoire[2];
    index_BLU10 = memoire[3];
    Freq40[3] = memoire[4];
    Freq40[2] = memoire[5];
    Freq40[1] = memoire[6];
    Freq40[0] = memoire[7];
    Freq10[3] = memoire[8];
    Freq10[2] = memoire[9];
    Freq10[1] = memoire[10];
    Freq10[0] = memoire[11];
  
    Freq40PF = ((Freq40[3]<<8)&0xFF00)+(Freq40[2]&0x00FF);
    Freq40Pf = ((Freq40[1]<<8)&0xFF00)+(Freq40[0]&0x00FF);
    Freq10PF = ((Freq10[3]<<8)&0xFF00)+(Freq10[2]&0x00FF);
    Freq10Pf = ((Freq10[1]<<8)&0xFF00)+(Freq10[0]&0x00FF);
  
    lcd.clear(); // Effacement de l'afficheur
    lcd.setCursor (0,0); // Positionnement du curseur position 0, ligne 0 pour afficher BLU ou BLI
    lcd.print ("   Chargement");
    lcd.setCursor (0,1);
    lcd.print ("    en cours");
    delay (2000); 
  
    ///////////////////////////// FIN DE LA RECUPERATION DES PARAMETRES        /////////////////////////////////////////////////////////////////
    // Calcul des paramètres initiaux
    // A la première utilisation, les fréquences initiales freq40 et freq10 doivent être chargées.
    // Pour cela, ôter les // des deux lignes suivantes.
    //freq40 = 7100000;
    //freq10 = 28480000;
  
    // Les deux lignes suivantes doivent être masquées par // à la première initialisation
    freq40 = (((Freq40PF<<16)&0xFFFF0000)+(Freq40Pf&0x0000FFFF));
    freq10 = (((Freq10PF<<16)&0xFFFF0000)+(Freq10Pf&0x0000FFFF));
  
    if (bande == 0)
    {
      freq = freq40;
      pos_freq = 5;
    }
    else
    {
      freq = freq10; 
      pos_freq = 4;
    } 
  }  
  /////////////////////            FIN DE SETUP      ////////////////
  
  ///////////////              PROGRAMME PRINCIPAL void()   ////////////
  void loop()
  {   
    lcd.clear(); // Effacement de l'afficheur
    lcd.setCursor (0,0);
    RXTX ();  
    PAS_FREQUENCE (); 
    CLAVIER (); 
    delay(10); // A ajuster pour optimiser le rafraichissement de l'affichage
  
    ///// Mise hors tension et sauvegarde des données  ////////////////////////////////////////////////////
    // Mode manuel, via le bouton 0 (provisoire)
    // La ligne ci-dessous devra être masquée par // en fonctionnement automatique
    if (bouton_0 == true) // Provisoirement, c'est l'appui sur la bouton 0 qui déclenche la sauvegarde des paramètres
  
      // En automatique, une fois l'interface intégrée au transceiver, la sauvegarde sera déclenchée par le port analogique 2 
      // Il faudra donc démasquer les 2 lignes suivantes :
      // tension_sonde_alim = analogRead (2);
      // if (tension_sonde_alim < 716)// 716 est la valeur convertie de 0 à 1023 de la tension de 3,5 V correspondant à 11 V 
    {
      lcd.clear ();
      lcd.setCursor (0,0); // Positionnement du curseur position 0, ligne 0 pour afficher BLU ou BLI
      lcd.print ("   Sauvegarde ");
      lcd.setCursor (0,1);
      lcd.print ("    en cours");
      sauve_param ();
      lcd.setCursor (0,0); // Positionnement du curseur position 0, ligne 0 pour afficher BLU ou BLI
      lcd.print (" Sauvegarde ok !");
      lcd.setCursor (0,1);
      lcd.print ("  Au revoir...");
      delay (3000);  // Temporisation laissant le temps au transceiver de s'éteindre
    }
    //////////////  Fin de Mise hors tension et sauvegarde des données  //////////
  
    /////////// Commutation 40m /10m ///////////////////////////////////////////
    if ((bouton_2 == true) && (avant[2] == false))
    {
      bande = bande + 1;
      if(bande > 1)// La variable bande ne peut prendre (pour le moment) que 2 valeurs (0 ou 1) 
      {
        bande = 0; // Remise à 0
      }
      etat_RIT = 0; 
      Rit = 0; // Le changement de bande annule le mode RIT
  
      avant[2] = bouton_2;
    }
    if (bande == 0)  // 40 m
    {
      MODE_BLU40();
      freq = freq40;// Fréquences sur la bande des 40m
      pos_freq = 5;
      digitalWrite (0,LOW);
    }
    if (bande == 1)  // 10 m
    {
      MODE_BLU10();
      freq = freq10 ; // Fréquences sur la bande des 10m
      pos_freq = 4;
      digitalWrite (0,HIGH);
    }
    if (bouton_2 == false)
    {
      avant[2] = false;
    }
    /////////////////// Fin de commutation 40 m / 10 m //////////////////////////
  
    envoyerFrequence(freq); // Appel de la fonction envoyerFrequence (DDS)
  
  }  ///  FIN DE void()
  
  ///////////////////////////////////////////////////////////////////////////////////////////
  //                          SOUS-PROGRAMMES ET FONCTIONS                                 //
  ///////////////////////////////////////////////////////////////////////////////////////////
  void MODE_BLU40 ()
  {
    if ((bouton_1 == true) && (avant[1] == false)) // Test de l'appui sur le bouton et prise en compte de son état précédent
    {
      index_BLU40 = index_BLU40 + 1; // Si la condition est vraie, l'index_BLU est augmenté de 1
      if(index_BLU40 > 1)// Si l'index_BLU est supérieur à 1...
      {
        index_BLU40 = 0; // ...il est remis à 0
      }
      avant[1] = bouton_1; // La variable de l'état précédent prend la valeur du bouton (maintenant enfoncé)
    }
  
    if(index_BLU40 == 0) // BLI
    {
      digitalWrite (10,LOW);  // Le port digital D10 est mis à l'état bas (BLI)
      index_BLU = 0;
    }
    if (index_BLU40 == 1) // BLS
    {
      digitalWrite (10,HIGH);  // Sinon, le port digital D10 est mis à l'état haut (BLS)pour commuter relais faible consommation ou un transistor
      index_BLU = 1;
    }
  
    if (bouton_1 == false) // Si le bouton est relâché...
    {
      avant[1] = false;  // ... son état devient relâché
    }
  } 
  /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  void MODE_BLU10 ()
  {
    if ((bouton_1 == true) && (avant[1] == false)) // Test de l'appui sur le bouton et prise en compte de son état précédent
    {
      index_BLU10 = index_BLU10 + 1; // Si la condition est vraie, l'index_BLU est augmenté de 1
      if(index_BLU10 > 1)// Si l'index_BLU est supérieur à 1...
      {
        index_BLU10 = 0; // ...il est remis à 0
      }
      avant[1] = bouton_1; // La variable de l'état précédent prend la valeur du bouton (maintenant enfoncé)
    }
  
    if(index_BLU10 == 0) // BLI
    {
      digitalWrite (10,LOW);  // Le port digital D10 est mis à l'état bas (BLI)
      index_BLU = 0;
    }
    if (index_BLU10 == 1) // BLS
    {
      digitalWrite (10,HIGH);  // Sinon, le port digital D10 est mis à l'état haut (BLS)pour commuter relais faible consommation ou un transistor
      index_BLU = 1;
    }
  
    if (bouton_1 == false) // Si le bouton est relâché...
    {
      avant[1] = false;  // ... son état devient relâché
    }
  } 
  //////////////////////////////////////////////////////////////////
  // RXTX
  void RXTX()
  {
    lcd.print (mode_BLU[index_BLU]);
    lcd.setCursor (pos_freq,0); // Positionnement du curseur sur le 5ème ou 6ème digit
    RxTx = digitalRead (1); // Lecture de l'état émission ou réception sur le port digital A1
    if (RxTx==HIGH)// Le transceiver est en mode émission
    {    
      lcd.print(float(freq)/1000); // Affiche la fréquence d'émission
      AFF_RIT (); // Affichage du RIT (si activé)
      lcd.setCursor(0,1); // Positionnement du curseur position 0, ligne 1 pour afficher le ROS-mètre
      ROSMETRE (); // Ne pas confondre Rosmetre en tant que variable et ROSMETRE en tant que fonction
    }
    else
    {
      RIT (); // Appel de la fonction RIT
      AFF_RIT (); // Affichage du RIT (si activé)
      if ((Rit != 0) && (etat_RIT == 1))
      {
        lcd.setCursor (pos_freq,0);
        lcd.print(float(freq + Rit)/1000); // Affiche la fréquence de réception en kHz avec 2 chiffres après la virgule
      }
      else
      {
        lcd.setCursor (pos_freq,0);
        lcd.print(float(freq)/1000); // Affiche la fréquence de réception sans RIT en kHz avec 2 chiffres après la virgule
      }
      lcd.setCursor(0,1); // Positionnement du curseur position 0, ligne 1 pour afficher le S-mètre
      SMETRE (); // Ne pas confondre Smetre en tant que variable et SMETRE en tant que fonction
    }
  }
  ////////////////////////////////////////////////////////////////////////////
  // // Traitement de l'interruption générée par le changement d'état de A
  void Traitement_A()
  {
    // Transition montante?
    if ((digitalRead(encodeur_A) == HIGH)&(!etat_B))
    {   
      etat_A = true;
      ///////////////////////////////////////////////////////////////////////////
      // Instructions à exécuter :
      if (etat_RIT == 0) // Teste si le RIT est hors service
      {
        if (bande == 1)
        {
          freq = freq10;
          freq = freq + pef; // La fréquence est augmentée du pas défini par l'utilisateur
          freq10 = freq;
        }
        else
        {
          freq = freq40;
          freq = freq + pef; // La fréquence est augmentée du pas défini par l'utilisateur
          freq40 = freq;
        }
      }
      else  // Le RIT est activé
      {
        if (RxTx==LOW) // Le réglage du décalage du RIT n'est possible qu'en mode réception
        {
          Rit = Rit + 10; // La fréquence est augmentée de 10 Hz (modifiable)
        }
      }
    }
    // Fin des instructions à exécuter.
    ///////////////////////////////////////////////////////////////////////////
    // Transition descendante?
    if (digitalRead(encodeur_A) == LOW)
    {
      etat_A = false;  
    }
  }
  // Traitement de l'interruption générée par le changement d'état de B
  void Traitement_B()
  {
    // Transition montante?
    if ((digitalRead(encodeur_B) == HIGH)&(!etat_A))
    {   
      etat_B = true;
      /////////////////////////////////////////////////////////////////////////////
      // Instructions à exécuter :
      if (etat_RIT == 0) // Teste si le RIT est hors service
      {
        if (bande == 1)
        {
          freq = freq10;
          freq = freq - pef; // La fréquence est augmentée du pas défini par l'utilisateur
          freq10 = freq;
        }
        else
        {
          freq = freq40;
          freq = freq - pef; // La fréquence est augmentée du pas défini par l'utilisateur
          freq40 = freq;
        }
      }
      else  // Le RIT est activé
      {
        if (RxTx==LOW) // Le réglage du décalage du RIT n'est possible qu'en mode réception
        {
          Rit = Rit - 10; // La fréquence est diminuée de 10 Hz (modifiable)
        }
      }
    }
    // Fin des instructions à exécuter.
    ///////////////////////////////////////////////////////////////////////////
    // Transition descendante?
    if (digitalRead(encodeur_B) == LOW)
    {
      etat_B = false;
    }
  }
  ////////////////////////////////////////////////////////////////////
  //Détermination du pas en fréquence (10, 100, 1000 ou 10000 Hz)
  void PAS_FREQUENCE ()
  {
    if ((bouton_4 == true) && (avant[4] == false))
    {   
      avant[4] = bouton_4;
      index_pef = index_pef + 1;
      if(index_pef > 3) // le compteur_pef peut prendre les valeurs 0, 1, 2 ou 3
      {
        index_pef = 0;
      }
      if (index_pef == 0 || index_pef == 1)
      {
        lcd.setCursor (11 - index_pef, 0); // Positionne le curseur sur le chiffre 100 Hz ou 10 Hz
      }
      else
      {
        lcd.setCursor (11 - index_pef-1, 0); // Positionne le curseur sur le chiffre des 10 kHz ou kHz
      }
      lcd.print (char (255)); 
      delay (200);// Noircit pendant 2/10ème de seconde le chiffre sélectionné pour indiquer le pas en fréquence
      pef = pas_en_freq [index_pef]; // Le pas en fréquence devient 10, 100, 1000 ou 10000 Hz
    }   
    if ((bouton_4 == false) && (avant[4] == true))
    {
      avant[4] = false;
    }
  }
  ////////////////////////////////////////// 
  // Gestion du RIT
  void RIT ()
  { 
    if ((bouton_3 == true) && (avant[3] == false))
    {   
      avant[3] = bouton_3; 
      etat_RIT = etat_RIT + 1;
  
      if(etat_RIT > 1)
      {
        etat_RIT = 0;
      }
    } 
    if ((bouton_3 == false) && (avant[3] == true))
    {
      avant[3] = false;
    }
  }
  // Affichage RIT
  void AFF_RIT ()
  {
    if (etat_RIT == 1)
    {
      lcd.setCursor (12, 0);
      if (Rit==0)
      {
        lcd.print ("=");
      }
      if (Rit > 0)
      {
        lcd.print ("+");
      }
      if (Rit < 0)  
      {
        lcd.print ("-");
      }
    }
  }
  ///////////////////////////////////////////
  // Gestion du clavier analogique
  void CLAVIER()
  {
    tensionClav = analogRead(ClavierAnalog); // La variable tensionClav prend la valeur lue sur l'entrée A0 (car ClavierAnalog = 0)
  
    if (tensionClav > 117 && tensionClav < 137) // Si la valeur convertie de la tension lue est entre 117 et 137...
    {
      bouton_6 = true; // ...le bouton est considéré comme enfoncé
    }
    else
    {
      bouton_6 = false;
    }
  
    if (tensionClav > 246 && tensionClav < 266) // idem pour tous les autres valeurs
    {
      bouton_5 = true;
    }
    else
    {
      bouton_5 = false;
    }
  
    if (tensionClav > 374 && tensionClav < 394)
    {
      bouton_4 = true;
    }
    else
    {
      bouton_4 = false;
    }
  
    if (tensionClav > 502 && tensionClav < 522)
    {
      bouton_3 = true;
    }
    else
    {
      bouton_3 = false;
    }
  
    if (tensionClav > 630 && tensionClav < 650)
    {
      bouton_2 = true;
    }
    else
    {
      bouton_2 = false;
    }
  
    if (tensionClav > 758 && tensionClav < 778)
    {
      bouton_1 = true;
    }
    else
    {
      bouton_1 = false;
    }
    if (tensionClav > 890 && tensionClav < 900)
    {
      bouton_0 = true;
    }
    else
    {
      bouton_0 = false;
    }
  }
  ///////////////////////////////////////////
  // Gestion du S-mètre
  void SMETRE ()
  {
    tensionA0 = map(analogRead(Smetre), 0, 1023, 0, 500); // Port A0, plage 0 à 1023 ramenée de 0 à 500 (voir explication dans l'article)
    if (tensionA0 < 7) // Si la valeur de la tension convertie est < 7...
    {
      lcd.print("<");  // ...le caractère < est affiché
      lcd.setCursor(10,1); // Le curseur est positionné après la fin de la barre graphique
      lcd.print("<S1"); // Le niveau en clair est affiché. Ici <S1
    }
    if (tensionA0 > 6 && tensionA0 < 47)
    {
      lcd.print(char (255)); // ...le caractère ■ est affiché
      lcd.setCursor(11,1);
      lcd.print("S1");
    }
    if (tensionA0 > 46 && tensionA0 < 76) // idem pour tous les autres valeurs 
    {
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.setCursor(11,1);
      lcd.print("S2");
    }
    if (tensionA0 > 75 && tensionA0 < 110)
    {
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.setCursor(11,1);
      lcd.print("S3");
    }
    if (tensionA0 > 109 && tensionA0 < 146)
    {
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.setCursor(11,1);
      lcd.print("S4");
    }
    if (tensionA0 > 145 && tensionA0 < 181)
    {
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.setCursor(11,1);
      lcd.print("S5");
    }
    if (tensionA0 > 180 && tensionA0 < 216)
    {
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.setCursor(11,1);
      lcd.print("S6");
    }
    if (tensionA0 > 215 && tensionA0 < 249)
    {
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.setCursor(11,1);
      lcd.print("S7");
    }
    if (tensionA0 > 248 && tensionA0 < 290)
    {
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.setCursor(11,1);
      lcd.print("S8");
    }
    if (tensionA0 > 289 && tensionA0 < 350)
    {
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.setCursor(11,1);
      lcd.print("S9");
    }
    if (tensionA0 > 349 && tensionA0 < 400)
    {
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(">");
      lcd.setCursor(11,1);
      lcd.print("S9+10");
    }
    if (tensionA0 > 399)
    {
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(">>");
      lcd.setCursor(11,1);
      lcd.print("S9+20");
    }
  }
  ///////////////////////////////////////////
  // Gestion du ROS-mètre // même fonctionnement que le S-mètre, avec des seuils et affichages différents
  void ROSMETRE ()
  {
    tensionA0 = map(analogRead(Rosmetre), 0, 1023, 0, 500); // Port analogique A0, plage 0 à 1023 ramenée à 500
    if (tensionA0 < 7)
    {
      lcd.setCursor(8,1);
      lcd.print("ROS=1");
    }
    if (tensionA0 > 6 && tensionA0 < 47)
    {
      lcd.print(char (255));
      lcd.setCursor(8,1);
      lcd.print("ROS=1.1");
    }
    if (tensionA0 > 46 && tensionA0 < 76)
    {
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.setCursor(8,1);
      lcd.print("ROS=1.3");
    }
    if (tensionA0 > 75 && tensionA0 < 110)
    {
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.setCursor(8,1);
      lcd.print("ROS=1.7");
    }
    if (tensionA0 > 109 && tensionA0 < 146)
    {
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.setCursor(8,1);
      lcd.print("ROS=2");
    }
    if (tensionA0 > 145 && tensionA0 < 181)
    {
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.setCursor(8,1);
      lcd.print("ROS=2.5");
    }
    if (tensionA0 > 180 && tensionA0 < 216)
    {
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.setCursor(8,1);
      lcd.print("ROS=3");
    }
    if (tensionA0 > 215)
    {
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.print(char (255));
      lcd.setCursor(7,1);
      lcd.print(">3 DANGER");
    }
  }
  //////////////////////////////////////////////////////////////////////////////
  //                                 Gestion DDS                              //           
  // Original code from Peter Marks                                           //
  // http://blog.marxy.org/2008/05/controlling-ad9851-dds-with-arduino.html   //
  // Modified par George Smart, M1GEO - 12 Feb 2012                           //
  //////////////////////////////////////////////////////////////////////////////
  void envoyerFrequence(unsigned long freq)
  {
    unsigned long tuning_word = (freq * pow(2, 32)) / DDS_CLOCK;
    digitalWrite (LOAD, LOW); 
  
    for(int i = 0; i < 32; i++)
    {
      if ((tuning_word & 1) == 1)
        outOne();
      else
        outZero();
      tuning_word = tuning_word >> 1;
    }
    byte_out(0x09);
  
    digitalWrite (LOAD, HIGH); 
  }
  void byte_out(unsigned char byte)
  {
    int i;
  
    for (i = 0; i < 8; i++)
    {
      if ((byte & 1) == 1)
        outOne();
      else
        outZero();
      byte = byte >> 1;
    }
    delay (10); // initialement à 200. Ajuster cette valeur pour augmenter ou diminuer la vitesse de synthèse en fréquence
  }
  
  void outOne()
  {
    digitalWrite(CLOCK, LOW);
    digitalWrite(DATA, HIGH);
    digitalWrite(CLOCK, HIGH);
    digitalWrite(DATA, LOW);
  }
  
  void outZero()
  {
    digitalWrite(CLOCK, LOW);
    digitalWrite(DATA, LOW);
    digitalWrite(CLOCK, HIGH);
  }
  /////////////////////////////////////////////////////
  //             GESTION EEPROM                      //
  /////////////////////////////////////////////////////
  // Sauvegarde des paramètres ////////////////////////
  void sauve_param ()
  {
    // Conversion nombre entier non signé long (unsigned long) vers 4 octets
  
    Freq40[3] = (freq40>>24)&(0xFF);
    Freq40[2] = (freq40>>16)&(0xFF);
    Freq40[1] = (freq40>>8)&(0xFF);
    Freq40[0] = (freq40)&(0xFF);
  
    Freq10[3] = (freq10>>24)&(0xFF);
    Freq10[2] = (freq10>>16)&(0xFF);
    Freq10[1] = (freq10>>8)&(0xFF);
    Freq10[0] = (freq10)&(0xFF);
  
  
    byte memoire [] = {
      index_pef, bande, index_BLU40, index_BLU10,               // index 0, 3 : pas en fréquence, bande, mode sur 40 m, mode sur 10 m 
      Freq40[3], Freq40[2], Freq40[1], Freq40[0],               // index 4 à 7 : fréquence courante 40m
      Freq10[3], Freq10[2], Freq10[1], Freq10[0]   };             // index 8 à 11 : fréquence courante 10m
  
  
    for(byte i = 0; i < 12; i=i+1)// Ecriture en mémoire 
    {
      eeprom_write (0x50, i, memoire [i]);
      delay (100);
    }
  }
  
  void eeprom_write( byte device_address, byte mem_address, byte data)
  {
    Wire.beginTransmission(device_address);
    Wire.write(mem_address);
    Wire.write(data);
    Wire.endTransmission();
  }
  //////////////////////////////////////////////////////
  byte eeprom_read(int device_address, int mem_address)
  {
    Wire.beginTransmission(device_address);
    Wire.write(mem_address);
    Wire.endTransmission();
  
    Wire.requestFrom(device_address, 1);
    if(Wire.available())
      return Wire.read();
    else
      return 0xFF;
  }