///////////////////////////////////////////////////////////////////////////////////////////
  //                   DECLARATIONS DES BIBLIOTHEQUES & VARIABLES                          //
  ///////////////////////////////////////////////////////////////////////////////////////////
  #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)
  
  // Déclaration des variables 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 "Fréquence ↓"
  boolean bouton_6 = false; // Provisoirement "Fréquence ↑"
  
  // 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.
  
  // 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)
  
  // 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
  
  /////////////////////////////////////////////////////////////////////////
  ////////////////////////////   SETUP    /////////////////////////////////
  /////////////////////////////////////////////////////////////////////////
  void setup() 
  {
    lcd.begin(16, 2); // Initialisation de l'afficheur (16 caractères, 2 lignes)
    // lcd.begin (20, 4) // Autre exemple d'initialisation avec un afficheur de 20 caractères et 4 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
  
    // Chargement des paramètres initiaux
    freq40 = 7100000; // Fréquence initiale sur 40 m (modifiable)
    freq10 = 28480000; // Fréquence initiale sur 10 m (modifiable)
    freq = freq40; // Fréquence à la mise sous tension (modifiable en freq10)
    bande = 0; // Bande des 40 m la mise sous tension (modifiable en bande = 1)
    index_BLU = 0; // BLI à l'allumage (modifiable en index_BLU = 1)
    pos_freq = 5; // Affichage de la fréquence sur le digit 6 (si bande des 40 m, sinon digit 5)
    etat_RIT = 0; // RIT inactif (modifiable)
    Rit = 0; // Décalage nul (modifiable)
    index_pef = 0; // Index du tableau des pas en fréquence (0, 1, 2 ou 3)
    pef = pas_en_freq [index_pef]; // index_pef = 0 correspond à 10 Hz (modifiable)
  }  
  /////////////////////            FIN DE SETUP      ////////////////
  
  ////////////////////////         PROGRAMME PRINCIPAL     /////////////
  void loop()
  {   
    lcd.clear(); // Effacement de l'afficheur
    lcd.setCursor (0,0); // Positionnement du curseur position 0, ligne 0 
    lcd.print (mode_BLU[index_BLU]); // Affichage de BLI ou BLS
    RXTX ();  // Appel de la fonction RXTX () définie en fin de programme (à ne pas confondre avec la variable RxTx)
    PAS_FREQUENCE (); // Appel de la fonction PAS_FREQUENCE () définie en fin de programme
    FREQ_et_RIT(); // Appel de la fonction FREQ_et_RIT () définie en fin de programme
    CLAVIER (); // Appel de la fonction CLAVIER() définie en fin de programme
    delay(50); // Délai de 150 ms nécessaire pour une bonne perception de l'affichage (provisoire)
  
    // Sélection BLI ou BLS
    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_BLU = index_BLU + 1; // Si la condition est vraie, l'index_BLU est augmenté de 1
      if(index_BLU > 1)// Si l'index_BLU est supérieur à 1...
      {
        index_BLU = 0; // ...il est remis à 0
      }
      avant[1] = bouton_1; // La variable de l'état précédent prend la valeur du bouton (maintenant enfoncé)
    }
    else  // programmation du port digital 10 
    {  
      if(index_BLU == 0) // BLI
      {
        digitalWrite (10,LOW);  // Le port digital D10 est mis à l'état bas (BLI)
      }
      if (index_BLU == 1) // BLS
      {
        digitalWrite (10,HIGH);  // Sinon, le port digital D10 est mis à l'état haut (BLS)pour commuter un relais faible consommation ou un transistor
      }
    }
  
    if (bouton_1 == false) // Si le bouton est relâché...
    {
      avant[1] = false;  // ... son état devient relâché
    }
  
  
    // 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 (40 m)
      }
      etat_RIT = 0; 
      Rit = 0; // Le changement de bande annule le mode RIT
      avant[2] = bouton_2;
  
      if (bande == 1)  // 10 m
      {
        index_BLU = 1; // Le changement de bande réinitialise la valeur par défaut : BLS sur 10 m
        freq = freq10 ; // Fréquences sur la bande des 10m
        pos_freq = 4;
        digitalWrite (0,HIGH);
      }
      if (bande == 0)  // 40 m
      {
        index_BLU = 0; // Le changement de bande réinitialise la valeur par défaut : BLI sur 40 m
        freq = freq40;// Fréquences sur la bande des 40m
        pos_freq = 5;
        digitalWrite (0,LOW);
      }
    }
    if (bouton_2 == false)
    {
      avant[2] = false;
    }
  
    ///////////////////  Fin de Fréquence ↓ et Fréquence ↑ et RIT//////////////////////////
  
  }  
  ///  FIN DE void()
  
  ///////////////////////////////////////////////////////////////////
  ////////////// DEFINITION DES FONCTIONS  //////////////////////////
  ///////////////////////////////////////////////////////////////////
  // RXTX
  void RXTX()
  {
    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 numérique A1
    if (RxTx==HIGH)// Le transceiver est en mode émission
    {    
      lcd.print(float(freq)/1000); // Affiche la fréquence d'émission
      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 appelée ici
    }
    else // Le transceiver est en mode réception
    {
      RIT (); // Appel de la fonction RIT
      if ((Rit != 0) && (etat_RIT == 1)) // Si le décalage n'est pas nul et que le RIT est activé...
      {
        lcd.print(float(freq + Rit)/1000); // ...affichage de la fréquence de réception en kHz avec RIT (2 chiffres après la virgule par défaut)
      }
      else
      {
        lcd.setCursor (pos_freq,0);  
        lcd.print(float(freq)/1000); // Sinon, affichage de 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 appelée ici
    }
  }
  
  /////////////////////////////////////////////////////////////////////////////
  // Gestion 2 des boutons Fréquence ↓ et Fréquence ↑ et RIT (PROVISOIRE)
  void FREQ_et_RIT ()
  { 
    if (etat_RIT == 0) // Teste si le RIT est hors service
  
    {
      if(bouton_6 == true) //Teste si la bouton 6 (↑) est enfoncé
      {
        if (bande == 1) // 10 m
        {
          freq = freq10; // La fréquence courante d'émission prend la valeur par défaut sur 10 m
          freq = freq + pef; // La fréquence est augmentée du pas défini par l'utilisateur
          freq10 = freq; // La fréquence par défaut sur 10 m prend la valeur de la fréquence courante 
        }
        else
        {
          freq = freq40; // idem pour 40 m
          freq = freq + pef; // idem pour 40 m
          freq40 = freq; // idem pour 40 m
        }
      }
      if(bouton_5 == true) //Teste si la bouton 5 (↓) est enfoncé
      {
        if (bande == 1)
        {
          freq = freq10;
          freq = freq - pef; // La fréquence est diminuée du pas défini par l'utilisateur
          freq10 = freq;
        }
        else
        {
          freq = freq40;
          freq = freq - pef; // La fréquence est diminuée du pas défini par l'utilisateur
          freq40 = freq;
        }
      }
    }
    else  // Le RIT est activé
    {
      lcd.setCursor (12, 0); // Positionnement du curseur juste après la fréquence
  
      if (bouton_6 == true) 
      {
        Rit = Rit + 10; // Le décalage du RIT est augmenté de 10 Hz (modifiable)
      }
      if (bouton_5 == true) 
      {
        Rit = Rit - 10; // Le décalage du RIT diminué de 10 Hz (modifiable)
      }
      if (Rit==0)
      {
        lcd.print ("="); // Si le décalage est nul, mais le RIT actif, le signe = s'affiche
      }
      if (Rit > 0) 
      {
        lcd.print ("+"); // Si le décalage est >0, le signe + s'affiche
        // On pourrait utiliser avantageusement le signe ↑ qui existe sur certains afficheurs
      }
      if (Rit < 0)  
      {
        lcd.print ("-"); // Si le décalage est <0, le signe - s'affiche
        // On pourrait utiliser avantageusement le signe ↓ qui existe sur certains afficheurs
      }
    }
  }
  ////////////////////////////////////////////////////////////////////
  //Détermination du pas en fréquence (10, 100, 1000 ou 10000 Hz)
  void PAS_FREQUENCE ()
  {
    if ((bouton_4 == true) && (avant[4] == false)) // Teste si le bouton "Pas en fréquence" est enfoncé
    {   
      avant[4] = bouton_4;
      index_pef = index_pef + 1; // Incrémentation de l'index du pas en fréquence à chaque appui sur le bouton
      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) // Pour les deux positions à droite du point de la fréquence... 
      {
        lcd.setCursor (11 - index_pef, 0); // ...positionnement du curseur sur le chiffre des 100 Hz ou 10 Hz
      }
      else
      {
        lcd.setCursor (11 - index_pef-1, 0); // Sinon positionnement du curseur sur le chiffre des 10 kHz ou kHz
      }
      lcd.print (char (255)); // Noircit le chiffre sélectionné pour indiquer le pas en fréquence sélectionné
      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 Hz, 100 Hz, 1 kHz ou 10 kHz
    }   
    if (bouton_4 == false)
    {
      avant[4] = false;
    }
  }
  ////////////////////////////////////////// 
  // Gestion du RIT
  void RIT ()
  { 
    if ((bouton_3 == true) && (avant[3] == false)) // Teste si le bouton du RIT est enfoncé
    {   
      avant[3] = bouton_3; 
      etat_RIT = etat_RIT + 1;  // Le RIT est activé
  
      if(etat_RIT > 1)
      {
        etat_RIT = 0;  
  
      }
    } 
    if (bouton_3 == false) 
    {
      avant[3] = false;
    }
  }
  ///////////////////////////////////////////
  // 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;  // Sinon il est considéré comme relâché
    }
  
    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ée
      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)  // Si la valeur de la tension convertie est comprise entre 6 et 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
  void ROSMETRE ()  // même fonctionnement que le S-mètre, avec des seuils et affichages différents
  {
    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");
    }
  }