Il y a incompatibilité entre la bibliothèque « Servo.h » et « IRremote.h » et autres ?

LamiRene · April 5, 2026, 7:08pm

Bonjour,

J'ai des véhicules robots autonomes et télécommandables, avec des capteurs différents, sur les uns j'ai un HC-SR04P sur servomoteur sur d'autre j'ai trois ou plus de HC-SR04P fixe, etc.

Le problème est que mon code source qui fonctionne parfaitement sur les véhicules robots sans servomoteurs ne fonctionne plus correctement dès que j'utilise un ou des servomoteurs. Le capteur IR capte la télécommande, mais les codes reçus ne correspondent plus à la table des valeurs reconnues.

Vous auriez une ou des pistes de solution en français, les pages du forum ne me sont pas traduisible automatiquement par le navigateur Web Brave que j'utilise par sécurité informatique et pour faire respecter la vie privée des utilisateurs ?

Cordialement,

LamiRene · April 5, 2026, 9:36pm

J’ai tenté une adaptation du code de la page du forum :

https://forum.arduino.cc/t/conflitto-interrupt-libreria-servo-irremote-risolto-in-parte/

Qui devient pour moi :

/*
 * Sony_IR_Shield_MioBot
 */

// Include servo library
#include <Servo.h>
 
// Declare left and right servos
Servo servoLeft;
Servo servoRight;

// I/O pin constants 
const int ServoLeftPin =11;
const int IrDetPin = 21;
const int BeeperPin = 12;

// Non-alpha remote button constants
const word Enter = 16720605;
const word ChUp = 16712445;
const word ChDn = 16761405;
const word VolUp = 16748655;
const word VolDn = 16754775;
const word Power = 16753245;

 
int irPulse;    // Stores pulses from IR detector
int remoteCode; // Stores code from remote
int mode = 1;   // Stores mode

void setup()   // Setup runs once then loop takes over
{
  tone(BeeperPin, 3000, 1000);// Play tone for 1 second
  delay(1000);                // Delay to finish tone
 
}

void loop()                    // Auto-repeats after setup
{
  int remoteCode = GetIrCode();// Get code from remote
  
  // Note, detaching servos is nice because they stay still regardless of
  // whether or not they are calibrated.  This prevents them from turning 
  // gradually if they are out of calibration.
  if(remoteCode == -1)                       // If nothing, detach servos
  {
    if((servoLeft.attached()==true) && (servoRight.attached()==true))
    {
      servoLeft.detach();
      servoRight.detach();
    }
  }
  else                                       // Otherwise, remote code received,
  {                                          // so attach/re-attach them.
    if((servoLeft.attached()==false) && (servoRight.attached()==false))
    {
      servoLeft.attach(ServoLeftPin);
    }
  }  
  // Padding to ignore end of remote code before attempting to detect objects.
  // This sketch only collects first 7 of 12 remote bits.  So delay for the 
  // rest of the remote message is required before attempting object detection.
  // Otherwise, the remote's signaling would interfere with the IR object detection.
  delay(10); 
  
 // Decide what to do with the remote code.  Implement number pad control
  // and equivalent channel/volume control.
  switch(remoteCode)                         
  {
    case 1:                                  // 1 -> pivot left
       maneuver(0, 200, 20);               // Execute maneuver for at least 20 ms
      break;                                // If this case, then done, skip other cases.
      
    case 2:                                 // 2 button
    case ChUp:                              // or Channel up button
        maneuver(200, 200, 20);
      break;
      
    case 3:                                // 3 button
        maneuver(200, 0, 20);              // Pivot right for at least 20 ms
      break;
      
    case 4:                                // 4 button pressed
    case VolDn:                            // Or volume down button pressed
      maneuver(-200, 200, 20);             // Rotate left in place for at least 20 ms
      break;
      
    case 5:                                // 5 button pressed
      maneuver(0, 0, 20);                  // Stay still for at least 20 ms
      break;
      
    case 6:                                // 6 button pressed
    case VolUp:                            // or volume up button pressed
      maneuver(200, -200, 20);             // Rotate right in place at least 20 ms
      break;
      
    case 7:                                // 7 button pressed
      maneuver(0, -200, 20);               // Pivot backward-left for at least 20 ms
      break;
      
    case 8:                                // 8 button pressed
    case ChDn:                             // or channel down button pressed
      maneuver(-200, -200, 20);            // Back up for at least 20 ms
      break;
      
    case 9:                                // 9 button pressed
      maneuver(-200, -0, 20);              // Pivot backward-right for at least 20 ms
      break;
      
    // Whoa, somebody pressed power, to select a new mode.
    // Back to outer switch...case.  Take no action if timeout (-1) or any non mapped remote
    // code is received.
    default:                               
      servoLeft.detach();                
      servoRight.detach();
      break;
  }   
}                                          // Loop function auto-repeats at this point

/*
 * Check for and decode SONY TV remote messages coming from the IR TV detector in a TV set.
 * Returns: Code for button pressed on remote, or -1 if timeout (no code received).
 * Source: http://www.parallax.com/tabid/768/ProductID/149/Default.aspx
 * Modified for Arduino.
 */ 
int GetIrCode(){
  unsigned long irPulse = -1;                // Local variables    
  int irCode = 0;
  do{
    // Use pulseIn with 15 ms timeout if mode is roaming or following, or 50 ms timeout for control by TV remote.
    if((mode==3)||(mode==2)) irPulse = pulseIn(IrDetPin, LOW, 15000); else irPulse = pulseIn(IrDetPin, LOW, 50000); 
    // If timeout, return -1.
    if(irPulse==0) return -1;
  }while((irPulse <= 2000) || (irPulse >= 2800));
  // While condition filters for valid pulses and filters fluorescent ballast interference 
  
  // Capture first 7 of 12 bits from the remote.
  for(int i = 0; i <= 11; i++)
  {
    irPulse = pulseIn(IrDetPin, LOW, 2000);
    if((irPulse > 1000) && (irPulse < 1400)) bitSet(irCode, i);
  }

  // Convert alphanumeric codes to their corresponding button values.  
  if(irCode <= 9) irCode++;
  if(irCode == 10) irCode = 0;

  return irCode;
}

/*
 * Control BOE Shield-Bot servo direction, speed, set and forget version.
 * Parameters: speedLeft - left servo speed
 *             speedRight - right servo speed
 *             Backward  Linear  Stop  Linear   Forward
 *             -200      -100......0......100       200
 */ 
void maneuver(int speedLeft, int speedRight)
{
  // Call maneuver with just 1 ms blocking; servos will keep going indefinitely.
  maneuver(speedLeft, speedRight, 1);              
}

/*
 * Control BOE Shield-Bot servo direction, speed and maneuver duration.   
 * Parameters: speedLeft - left servo speed
 *             speedRight - right servo speed
 *             Backward  Linear  Stop  Linear   Forward
 *             -200      -100......0......100       200
 *             msTime - time to block code execution before another maneuver
 * Source:     http://learn.parallax.com/ManeuverFunction
 */ 
void maneuver(int speedLeft, int speedRight, int msTime)
{
  servoLeft.writeMicroseconds(1500 + speedLeft);   // Set Left servo speed
  servoRight.writeMicroseconds(1500 - speedRight); // Set right servo speed
  if(msTime==-1)                                   // if msTime = -1
  {                                  
    servoLeft.detach();                            // Stop servo signals
    servoRight.detach();   
  }
  delay(msTime);                                   // Delay for msTime
}

Mais aucun signe de vie du robot.

Avec ce type de télécommande et de capteur :

Cordialement,

jpbbricole · April 6, 2026, 5:38am

Bonjour LamiRene

Pour contourner le problème, il y aurait la bibliothèque ServoTimer2.h

Cordialement
jpbbricole

LamiRene · April 6, 2026, 1:15pm

Bonjour jpbbricole, merci pour votre aide !

J’ai placé l’archive décompressée « ServoTimer2 » dans le dossier suivant, mais elle n’apparait jamais dans le gestionnaire de bibliothèque de l’Arduino-IDE 2.3.8 que j’ai d’installé dans le dossier « /home/rene/sda6/Logiciel/Arduino/arduino-ide » :

/home/rene/Arduino/libraries

Ou ou au format zippé dans :

/home/rene/.arduino15/staging/libraries

Dans les préférence de l’Arduino-IDE il est configuré pour :

/home/rene/Arduino/

Vous auriez une piste de solution ?

Cordialement,

L’ami René

jpbbricole · April 6, 2026, 1:50pm

Bonjour LamiRene
Tel quel, il n'est pas nécessaire que la bibliothèque apparaisse dans l'index de l'IDE, il suffit de l'utiliser dans le sketch.
Remplaces:
#include <Servo.h>
par
#Include <ServoTimer2.h>

A+
jpbbricole

fdufnews · April 6, 2026, 3:55pm

Les explications ne sont pas très claires.
Pour installer un zip de bibliothèque 2 possiblités

tu décompresses la librairie et tu la copies dans la librairie de ton répertoire projet à priori /home/rene/Arduino/libraries
et si tu as peur de faire une erreur, le plus simple, tu ouvres le menu Croquis/Importer une bibliothèque/Ajouter la bibliothèque .ZIP ...

LamiRene · April 6, 2026, 7:40pm

Bonjour fdufnews, merci pour votre aide !

Les deux solutions fonctionnent pour rendre fonctionnelle la ligne :

#Include <ServoTimer2.h>

Mais aucune de ces méthodes ne rend visible la bibliothèque dans le gestionnaire des bibliothèques.

Cordialement,

L’ami René

fdufnews · April 6, 2026, 9:21pm

Le gestionnaire de bibliothèque ne liste que les librairies enregistrées par Arduino pas celle que l'on peut pêcher à gauche à droite et que l'on installe à la main.
Par contre, si l'installation s'est bien passées, tu devrais la voir dans le menu Croquis/Importer une bibliothèque dans la partie Librairies tierce-partie

LamiRene · April 6, 2026, 11:47pm

Bonsoir fdufnews,

Merci pour ces informations supplémentaires !

C’est l’information qui me permet de confirmer l’installation d’une nouvelle bibliothèque, c'est ce qui me manquait. Super !

Cordialement,

L’ami René

LamiRene · April 7, 2026, 10:34pm

Voici le code source que j’utilise pour le capteur IR et le ServoTimer2, mais le capteur reçoit des codes (chiffres) qu'il ne retrouve pas dans sa liste des touches possibles :

...
#include "ServoTimer2.h"
...
const byte CAPTEUR_IR_0_OUT = 21;
...
#define Capteur_IR_0 IrReceiver
ServoTimer2 Servomoteur_1;
...
if (Capteur_IR_0.decode ())
{
// Récupérer la valeur de la touche de la télécommande.
TelecommandeBoutonValeur = Capteur_IR_0.decodedIRData.command;
Capteur_IR_0.resume ();
switch (TelecommandeBoutonValeur)
...
}
while (Capteur_IR_0.decode ())
{
delay (BoutonTempsRebon);// Pour absorber les microcoupures des rebonds).
// Récupérer la valeur de la touche de la télécommande.
TelecommandeBoutonValeur = Capteur_IR_0.decode();
Capteur_IR_0.resume ();
}
...
void setup ()
{
...
// Configurer le port Arduino en entrée pour le capteur infrarouge sur un port d'interruption.
Capteur_IR_0.begin (CAPTEUR_IR_0_OUT);
...
// Initialisation du servomoteur du sonar 1.
Servomoteur_1.attach (SERVOMOTEUR_1_IN);
...
// L'angle du servomoteur du sonar initialisé a 90°.
Servomoteur_1.write (Servomoteur_1_AngleCentre);
delay (UneSeconde / 3);
...
}

Sinon, j'ai le code source suivant qui ne passe pas la compilation :

...
#include "ServoTimer2.h"
...
const byte CAPTEUR_IR_0_OUT = 21;
...
IRrecv Capteur_IR_0 (CAPTEUR_IR_0_OUT);
decode_results Capteur_IR_0_Results;
ServoTimer2 Servomoteur_1;
...
if (Capteur_IR_0.decode (&Capteur_IR_0_Results))
{
// Récupérer la valeur de la touche de la télécommande.
TelecommandeBoutonValeur = Capteur_IR_0_Results.value;
Capteur_IR_0.resume ();
switch (TelecommandeBoutonValeur)
{
case TelecommandeBoutonPower:
...
}
while (Capteur_IR_0.decode (&Capteur_IR_0_Results))
{
// Pour absorber les microcoupures des rebonds).
delay (TelecommandeTempsRebon);
// Récupérer la valeur de la touche de la télécommande.
TelecommandeBoutonValeur = Capteur_IR_0_Results.value;
Capteur_IR_0.resume ();
}
...
void setup ()
{
...
// Configurer le port Arduino en entrée pour le capteur infrarouge sur un port d'interruption.
pinMode (CAPTEUR_IR_0_OUT, ENTREE);
// Initialisation et début de la réception du capteur infrarouge.
Capteur_IR_0.enableIRIn ();
...
// Initialisation du servomoteur du sonar 1.
Servomoteur_1.attach (SERVOMOTEUR_1_IN);
// L'angle du servomoteur du sonar initialisé a 90°.
Servomoteur_1.write (Servomoteur_1_AngleCentre);
delay (UneSeconde / 3);
...
}

Que fais-je d'incorrect ?

Cordialement,

L'ami René

terwal · April 8, 2026, 7:20am

Tu n'a pas utilisé les balises qui doit encapsuler tout code sur le forum, comme indiqué dans le sujet épinglé sur les bonnes pratiques
Une fois ca fait, on pourra lire ton code sans avoir un mal de tête et surement t'aider.

LamiRene · April 8, 2026, 10:55am

Bonjour terwal,

OK, il y a du nouveau dans « sur les bonnes pratiques » depuis que je suis membre, alors toutes mes excuses pour mes manques, et je vais reprendre ici l’équivalant de la première partie de mon précédent message sans tronquer le code, mais pour moi c’est cela qui va alourdir le sujet.

Voici le code source que j’utilise pour le capteur IR et le ServoTimer2, mais le capteur reçoit des codes (chiffres) qu'il ne retrouve pas dans sa liste des touches possibles (ne regarder que le code des sections qui concerne le problème c'est à dire, en recherchant les textes IRremote, ServoTimer2, Capteur_IR_0 et Servomoteur_1) :

//*****************************************************************************
// Programme Arduino : MegaRobot077_PNP
//*****************************************************************************
// Nom du programme pour l'afficher sur le terminal série et/ou de l'écran LCD.
const char NOM_DU_PROGRAMME [17] = "MegaRobot077_PNP";
/*
Écrit par : René Ross

Date : 2026-04-07

Ce code source est sous licence publique générale GNU (GNU General Public
Licence "GPL"), désignation « open source », ou « code source ouvert ».
Référence : http://www.fsffrance.org/index.fr.html
Ce programme est un logiciel libre; vous pouvez le redistribuer et / ou le 
modifier selon les termes de la licence GNU V2. Ce programme est distribué 
dans l'espoir qu'il sera utile, mais SANS AUCUNE GARANTIE, sans même la 
garantie implicite de COMMERCIALISATION ou D'ADAPTATION À UN USAGE 
PARTICULIER. Voir la GNU General Public License, Version 2 pour plus de 
détails. 

Ce code source se veut didactique, c'est pourquoi les commentaires y prennent 
une très grande place. Mais cela ne doit pas vous effrayez, au contraire, cela
devrait vous rassurez en facilitant la compréhension du code source.
*/
//*****************************************************************************
// Que fait ce programme ?
//*****************************************************************************
/*
Ce programme contrôle un véhicule robot a deux roues motrices et une série de 
capteurs pour se déplacer intelligemment en évitant les obstacles. Il utilise 
un module à ultrason, un moteur servoCommand, des moteurs des moteurs à 
courant continu et des capteurs infrarouges pour détecter son environnement. 
Une télécommande et un capteur infrarouge permettent de le contrôler à 
distance et de modifier plusieurs de ses paramètres. Il est aussi activé par 
un bouton directement sur la planche d'expérimentation. Sur l'écran LCD et ou 
dans le moniteur série, il affiche des informations de base sur un écran LCD 
intégré sur le véhicule.
*/
//*****************************************************************************

//*****************************************************************************
// Matériel requis ?
//*****************************************************************************
/*
Testé avec : l'éditeur compilateur Arduino 2.3.8

8 x Batterie AA 1.5 volt jetable ou rechargeable :
https://www.aliexpress.com/w/wholesale-6-x-Batterie-AA-1.5-vols.html

1 x Boîtier à 6 piles AA 1.5V (9V) avec interrupteur et fils :
https://fr.aliexpress.com/item/1005006356512618.html

Ou

1 x Boîtier à 8 piles AA 1.5V (12V) avec interrupteur et fils :
https://fr.aliexpress.com/item/1005006356512618.html

1 x Bouton interrupteur à locket "Self lock" 6 broches à 2.5mm d'écartement  :
https://www.aliexpress.com/item/1005006101795331.html
https://www.aliexpress.com/item/4000697078907.html
https://www.aliexpress.com/w/wholesale-bouton-interrupteur-6-broche.html

1 x Bouton pression Normalement Ouvert "NO"
https://www.aliexpress.com/item/1005009037419937.html
https://www.aliexpress.com/w/wholesale-bouton-pression-4-broche.html

1 x Buzzers Mini Piézo-Électriques Passif.
https://fr.aliexpress.com/item/1005002930525751.html

1 x Câble USB Type A à Male type B Male :
https://www.aliexpress.com/item/1005001792948103.html
https://www.aliexpress.com/w/wholesale-Cable-USB-Type-A-%C3%A0-Male-type-B-Male.html

1 x Capteur infra-rouge VS1838B (TSOP1838) :
https://www.aliexpress.com/item/1005005249874271.html

1 x Capteur Sonar Ultrason (émetteur/récepteur) HR-SC04 :
https://fr.aliexpress.com/item/1005005314866486.html
https://www.aliexpress.com/w/wholesale-HC%2525252dSR04.html

1 x Carte Arduino Mega 2560 R3 :
http://arduino.cc/en/Main/ArduinoBoardMega2560
https://fr.aliexpress.com/item/32864836449.html
https://ca.robotshop.com/fr/products/microcontroleur-adeept-atmega2560

1 x Condansateur Électrolytiques en Aluminium 16V 7400uF pour fournir les moteurs :
https://fr.aliexpress.com/item/1005005673464788.html
https://fr.aliexpress.com/item/1005005682537727.html
https://www.aliexpress.com/w/wholesale-condensateur-16v-4700%CE%BCf.html

1 x Connecteur d'alimentation 5.5x2.1mm cc femelle Type A pour la batterie :
https://fr.aliexpress.com/item/1005005583190148.html
https://fr.aliexpress.com/item/1005003324016159.html
https://fr.aliexpress.com/item/1005005909680276.html

1 x Contrôleur moteur L298N (H-Bridge) pour 2 moteurs CC ou 1 moteur Pas-A-Pas () : 
https://fr.aliexpress.com/item/1005004510885871.html
https://fr.aliexpress.com/item/32392774289.html

1 x Écran LCD LCD2004 :
https://www.aliexpress.com/w/wholesale-LCD2004-vec-pin-soud%C3%A9.html

2 x Moteur 6V 77RPM JGA25-370 avec réducteur, Support de montage, roue :
https://www.aliexpress.com/item/1005006213252744.html
https://www.aliexpress.com/item/1005007792948140.html
https://www.aliexpress.com/w/wholesale-Moteur-6V-77RPM-JGA25-370-roue.html

2 x Planche d'expérimentation « BreadBoard » à 400 trous.
https://www.aliexpress.com/item/1005010426826947.html

2 x Potentiomètre 10K trois pattes multitours :
https://www.aliexpress.com/item/1005009916232428.html

2 x Radiateur pour régulateur de tension L7805CV 5v et carte Arduino :
https://www.aliexpress.com/item/1005006884532566.html
https://www.aliexpress.com/item/1005007022170517.html

1 x Servomoteur SG90 180° :
https://www.aliexpress.com/item/1005006283358420.html
https://www.aliexpress.com/item/1005006572297006.html
https://www.aliexpress.com/w/wholesale-Servomoteur-9g.html

1 x Servomoteur MG996R 180° :
https://www.aliexpress.com/item/1005006347992707.html
https://www.aliexpress.com/item/1005008199970178.html
https://www.aliexpress.com/w/wholesale-Servomoteur-MG996R-180%C2%B0.html

1 x Télécommande Mini MP3 universelle à 21 touches :
https://www.aliexpress.com/item/33057121369.html
https://www.aliexpress.com/item/1005004042081071.html
https://www.aliexpress.com/w/wholesale-T%C3%A9l%C3%A9commande-mini-MP3.html

Autres liens en rapport avec le sujet :

1 x Câbles Dupon M-M, F-F et M-F :
https://fr.aliexpress.com/item/1005003021442186.html
https://fr.aliexpress.com/item/1005005231300375.html
https://fr.aliexpress.com/item/1005005924705004.html

1 x Câble d'extension, fil électrique 2 broches, 20 AWG corde 
2468, 2x0.5mm, utilisation pour 9V à 24V :
https://fr.aliexpress.com/item/1005006075807377.html
https://fr.aliexpress.com/item/1005005565459721.html
https://fr.aliexpress.com/item/1005005626890017.html

1 x Câble d'extension, fil électrique pour « BreadBoard » Philmore UL1007 mono brin :
(De toutes les couleurs disponibles pour planche d'expérimentation « BreadBoard ».)
https://www.aliexpress.com/item/1005008597540397.html
https://www.aliexpress.com/item/1005007656269037.html
https://www.aliexpress.com/w/wholesale-UL1007.html

1 x Condensateur électrolytique 6.3V1500UF à 450V150UF :
https://fr.aliexpress.com/item/1005003189675117.html
https://fr.aliexpress.com/item/1005006152274501.html

1 x Kit de connecteurs Dupont PCB, 1550 pièces, 2.54mm, broches mâles et femelles :
https://www.aliexpress.com/item/1005010504383683.html

1 x Pince coupe fil en acier au carbone, coupe-câble électronique bricolage :
https://www.aliexpress.com/item/1005010285471501.html

1 x Pince à dénuder de précision et réglable, FS-D5Y :
https://fr.aliexpress.com/item/1005005876356584.html

1 x Pince à sertir série mersible SN-48BS 0.25-1.5mm 2/23-16AWG pour onglet 2.8 4.8 6.3 SM2.5 DuPont2.54 :
https://fr.aliexpress.com/item/1005005046405703.html
https://fr.aliexpress.com/item/1005005614121560.html

1 x Résistances à couche de carbone, 100 pièces/lot, 1/4W, de 1R à 10M Ohm :
https://fr.aliexpress.com/item/1005006207035114.html
https://fr.aliexpress.com/item/1005005681112858.html
https://fr.aliexpress.com/item/1005006203325326.html
*/
//*****************************************************************************

//*****************************************************************************
// Circuit à réaliser.
//*****************************************************************************
/*
Dans cette section, toutes les connexions des composantes du montage sont 
listées, qu'ils soient utilisés ou non, et cela pour éviter tout oublie et 
rendre le copier / coller par bloc complet pour une pièce, plus facile d'un 
montage à l'autre. Le plus souvent possible le libellé de la pièce précédé du 
nom court de la pièce est utilisé, par exemple « ARDUINO_A3 », pour la broche 
analogique A3 d'une carte contrôleur Arduino Uno R3.

Plaque d'expérimentation « BreanBoard » :

Pour identifier les trous d'une plaque d'expérimentation « BreanBoard », c'est 
comme dans le jeu de bataille navale "Battle Ship". Les lignes sont identifiées 
pas des numéros. Pour un BreanBoard MB-104, les lignes vont de 1 à 63 et les 
colonnes sont identifiées par les lettres "a" a "j" plus deux colonnes avec les 
signes « + » et « - » à gauche (G) et à droite (D). Donc (i10) indique le trou 
à l'intersection de la colonne « i » avec la ligne numéro « 10 ». Pour une 
broche des colonnes négatives ou GND, c'est par exemple (-51G) pour la colonne 
du négatif à gauche et sur la ligne 51 et c'est (+51D)  pour la colonne du 
positif à droit et sur la ligne 51. Dans des situation simple ou évidnte on 
utilise aussi pour une broche des colonnes négatives ou GND, par exemple (-5V) 
et c'est (+5V) dans le cas ou c'est du courant 5 Volts qui allimante ces 
colonnes. Les parenthèses « ( » et « ) », c'est pour bien spécifier une 
position de trou de la planche d'expérimentation.
*/
/*
Le circuit : (Voir la page Web :...)

Câblage de l'Arduino Mega sur la planche d'expérimentation MB-104 :

ARDUINO_USB             = Par câble USB a un ordinateur
ARDUINO_IOREF           = ARDUINO_A1
ARDUINO_PWR12V          = En phase de test Adaptateur 9V, autonome piles 9V ou pack 6 piles AA.
ARDUINO_RESET           = ARDUINO_A0 (Kamikaze par télécommande)
ARDUINO_3_3V            = 
ARDUINO_5V_1            = (+21D)
ARDUINO_GND1            = (-21D)
ARDUINO_GND2            = (-21D)
ARDUINO_VIN             = (i2)

ARDUINO_A0              = ARDUINO_RECET (Kamikaze par télécommande)
ARDUINO_A1              = ARDUINO_AREF
ARDUINO_A2              = (e6) -- LCD_1_RS
ARDUINO_A3              = (e8) -- LCD_1_E
ARDUINO_A4              = (e13) -- LCD_1_D4
ARDUINO_A5              = (e14) -- LCD_1_D5
ARDUINO_A6              = (e15) -- LCD_1_D6
ARDUINO_A7              = (e16) -- LCD_1_D7

ARDUINO_A8              = SONAR_1_TRIG
ARDUINO_A9              = SONAR_1_ECHO
ARDUINO_A10             = CAPTEUR_IR_1_OUT
ARDUINO_A11             = CAPTEUR_IR_2_OUT
ARDUINO_A12             = CAPTEUR_IR_3_OUT
ARDUINO_A13             = CAPTEUR_IR_4_OUT
ARDUINO_A14             = CAPTEUR_IR_5_OUT
ARDUINO_A15             = 

ARDUINO_AREF            = 
ARDUINO_GND3            = BUZZER_1_GND
ARDUINO_13_PWM_DEL      = DEL_1_VIN
ARDUINO_12_PWM          = BUZZER_1_VIN
ARDUINO_11_PWM          = 
ARDUINO_10_PWM          = CONTROLE_MOTEUR_1_IN4
ARDUINO_9_PWM           = CONTROLE_MOTEUR_1_IN3
ARDUINO_8_PWM           = CONTROLE_MOTEUR_1_ENB

ARDUINO_7_PWM           = CONTROLE_MOTEUR_1_IN2
ARDUINO_6_PWM           = CONTROLE_MOTEUR_1_IN1
ARDUINO_5_PWM           = CONTROLE_MOTEUR_1_ENA
ARDUINO_4_PWM           = CAPTEUR_IR_0_OUT
ARDUINO_3_PWM_INT1      = (i26) -- BOUTON_1_OUT
ARDUINO_2_PWM_INT0      = SERVOMOTEUR_1_IN
ARDUINO_1_PWM_TX0       = 
ARDUINO_0_PWM_RX0       = 

ARDUINO_14_PWM_TX3      = 
ARDUINO_15_PWM_RX3      = 
ARDUINO_16_PWM_TX2      = 
ARDUINO_17_PWM_RX2      = 
ARDUINO_18_PWM_TX1_INT5 = 
ARDUINO_19_PWM_RX1_INT4 = 
ARDUINO_20_PWM_SDA_INT3 = 
ARDUINO_21_PWM_SCL_INT2 = 

ARDUINO_5V_2            = 
ARDUINO_5V_3            = 
ARDUINO_22              = 
ARDUINO_23              = 
ARDUINO_24              = 
ARDUINO_25              = 
ARDUINO_26              = 
ARDUINO_27              = 
ARDUINO_28              = 
ARDUINO_29              = 
ARDUINO_30              = 
ARDUINO_31              = 
ARDUINO_32              = 
ARDUINO_33              = 
ARDUINO_34              = 
ARDUINO_35              = 
ARDUINO_36              = 
ARDUINO_37              = 
ARDUINO_38              = 
ARDUINO_39              = 
ARDUINO_40              = 
ARDUINO_41              = 
ARDUINO_42              = 
ARDUINO_43              = 
ARDUINO_44_PWM          = 
ARDUINO_45_PWM          = 
ARDUINO_46_PWM          = 
ARDUINO_47              = 
ARDUINO_48              = 
ARDUINO_49              = 
ARDUINO_40              = 
ARDUINO_41              = 
ARDUINO_42              = 
ARDUINO_43              = 
ARDUINO_44              = 
ARDUINO_45              = 
ARDUINO_46              = 
ARDUINO_47              = 
ARDUINO_48              = 
ARDUINO_49              = 
ARDUINO_50_MISO         = 
ARDUINO_51_MOSI         = 
ARDUINO_52_SCK          = 
ARDUINO_53_SS           = 
ARDUINO_GND4            = 
ARDUINO_GND5            = 

Câblage pour le bouton 4 pattes sur la planche d'expérimentation :

BOUTON_1_OUT_1     = (d7)
BOUTON_1_OUT_2     = (d9)
BOUTON_1_OUT_3     = (g9); (i9) -- 
BOUTON_1_OUT_4     = (g7); (j7) -- (+7D)
Résistance 100 Ohm = (j9) -- (-9D)

Câblage pour le Buzzer sur la planche d'expérimentation et l'Arduino :

BUZZER_1_VIN = ARDUINO_12_MISO
BUZZER_1_GND = ARDUINO_GND3

Câblage pour le capteur infra-rouge utiliser avec la télécommande, sur la
planche d'expérimentation  :

CAPTEUR_IR_0_OUT     = (h13), (f13) -- ARDUINO_3_INT2_PWM
CAPTEUR_IR_0_GND     = (h14), (j14) -- (-13D)
CAPTEUR_IR_0_VIN     = (h15); Résistance 100 Ohm

Câblage pour le capteur de distance infra-rouge 1 :

CAPTEUR_IR_1_OUT = ARDUINO_A11
CAPTEUR_IR_1_VIN = (+5V)
CAPTEUR_IR_1_GND = (-5V)

Câblage pour le capteur de distance infra-rouge 2 :

CAPTEUR_IR_2_OUT = ARDUINO_A12
CAPTEUR_IR_2_VIN = (+5V)
CAPTEUR_IR_2_GND = (-5V)

Câblage pour le capteur de distance infra-rouge 3 :

CAPTEUR_IR_3_OUT = ARDUINO_A13
CAPTEUR_IR_3_VIN = (+5V)
CAPTEUR_IR_3_GND = (-5V)

Câblage pour le capteur de distance infra-rouge 4 :

CAPTEUR_IR_4_OUT = ARDUINO_A14
CAPTEUR_IR_4_VIN = (+5V)
CAPTEUR_IR_4_GND = (-5V)

Câblage pour le capteur de distance infra-rouge 4 :

CAPTEUR_IR_5_VIN = (+5V)
CAPTEUR_IR_5_GND = (-5V)
CAPTEUR_IR_5_OUT = ARDUINO_A15

// Pour éviter une trop grande baisse de tension du aux moteurs :
Condensateur 2200uF 16V = (+49D) (-51D)

Câblage pour les deux moteur DC 6V 77RPM sur la planche d'expérimentation :

CONTROLE_MOTEUR_1_VIN  = 6V~12V
CONTROLE_MOTEUR_1_GND  = 6V~12V; (j23)
CONTROLE_MOTEUR_1_5V   = (j22)
CONTROLE_MOTEUR_1_ENA  = ARDUINO_44
CONTROLE_MOTEUR_1_IN1  = ARDUINO_42
CONTROLE_MOTEUR_1_IN2  = ARDUINO_40
CONTROLE_MOTEUR_1_ENB  = ARDUINO_45
CONTROLE_MOTEUR_1_IN3  = ARDUINO_43
CONTROLE_MOTEUR_1_IN4  = ARDUINO_41
CONTROLE_MOTEUR_1_OUT1 = Moteur1_GND
CONTROLE_MOTEUR_1_OUT2 = Moteur1_VIN
CONTROLE_MOTEUR_1_OUT3 = Moteur2_GND
CONTROLE_MOTEUR_1_OUT4 = Moteur2_VIN

Câblage directe de la carte a écran LCD LCD1602-6Boutons sur la carte Arduino :
Diagramme : http://www.zartronic.fr/doc/E2/E2N1P193/LCD_Keypad_Shield_SCH.pdf

LCD_1_VSS broche 1  = (c21); (a21) -- (-21G)
LCD_1_VDD broche 2  = (c22); (a22) -- (+22G)
LCD_1_VO  broche 3  = (c23); (d23) -- (d20); POTENTIOMETRE_10K_1_OUT
LCD_1_RS  broche 4  = (c24); (d24) -- ARDUINO_22
LCD_1_RW  broche 5  = (c25); (a25) -- (-25G)
LCD_1_E   broche 6  = (c26); (d26) -- ARDUINO_23
LCD_1_D0  broche 7  = (c27)
LCD_1_D1  broche 8  = (c28)
LCD_1_D2  broche 9  = (c29)
LCD_1_D3  broche 10 = (c30)
LCD_1_D4  broche 11 = (c31); (d31) -- ARDUINO_24
LCD_1_D5  broche 12 = (c32); (d32) -- ARDUINO_25
LCD_1_D6  broche 13 = (c33); (d33) -- ARDUINO_26
LCD_1_D7  broche 14 = (c34); (e34) -- ARDUINO_27
LCD_1_A   broche 15 = (c35); (d35) -- (d37); POTENTIOMETRE_10K_2_OUT
LCD_1_K   broche 16 = (c36); (a36) -- (-36G)

Câblage pour le potentiometre 10KOhm pour la valeur de la luminosité des 
caractre sur l'écran LCD sur une planche d'expérimentation :

POTENTIOMETRE_10K_1_VIN = (c19); (a19) -- (+19G)
POTENTIOMETRE_10K_1_OUT = (c20); (d20) -- (d23); LCD_1_VO
POTENTIOMETRE_10K_1_GND = (c21); (a21) -- (-21G)

Câblage pour le potentiometre 10KOhm pour la valeur de la luminosité du 
rétroéclairage sur l'écran LCD sur une planche d'expérimentation :

POTENTIOMETRE_10K_2_VIN = (c38); (a38) -- (+38G)
POTENTIOMETRE_10K_2_OUT = (c37); (d37) -- (d35); LCD_1_A
POTENTIOMETRE_10K_2_GND = (c36); (a36) -- (-36G)

Câblage pour le servo moteur 1 de la planche d'expérimentation :

SERVOMOTEUR_1_GND = (i23); CONTROLE_MOTEUR_1_GND
SERVOMOTEUR_1_VIN = (i22); CONTROLE_MOTEUR_1_5V
SERVOMOTEUR_1_IN  = ARDUINO_2_INT1

Câblage pour le module a ultrason, sur la section 2 de la planche 
d'expérimentation et l'Arduino :

SONAR_1_VCC  = (+17D)
SONAR_1_TRIG = ARDUINO_7_PWM
SONAR_1_ECHO = ARDUINO_8_PWM
SONAR_1_GND  = (-17D)
*/
//*****************************************************************************

//*****************************************************************************
// Inclusion des librairies utilisées.
//*****************************************************************************
#include "IRremote.hpp"
/*
Il s'agit de la bibliothèque irRemote pour télécommande avec l'Arduino.

Pour télécharger depuis github :

http://github.com/shirriff/Arduino-IRremote

Cliquez sur le lien "Télécharger" en haut à droite, cliquez sur « Télécharger
au format Zip", pour obtenir un fichier zip. Décompressez-le et renommez le
répertoire « Shirriff-Arduino-irRemote-NNN » pour « irRemote ». Pour
l'installer, déplacer le répertoire de irRemote téléchargée dans votre dossier
des bibliothèque Arduino « ~/Arduino/libraries/IRremote ». Pour avoir accès à la
nouvelle bibliothèque, vous devez redémarrer l'éditeur Arduino. Pour plus de
détails sur la bibliothèque voir le wiki sur github ou le poste :

http://arcfn.com/2009/08/multi-protocol-infrared-remote-library.html blog

Copyright 2009-2012 Ken Shirriff

Merci à cette personne pour sa contribution !
*/

#include "LiquidCrystal.h"
/*
« Cette librairie permet à une carte Arduino de contrôler un afficheur LCD
alphanumérique standard à cristaux liquides basé sur le circuit intégré Hitachi
HD44780 (ou compatible), ce qui est le cas de la plupart des afficheurs
alphanumériques LCD disponibles. La librairie fonctionne aussi bien en mode 4
bits qu'en mode 8 bits (càd utilisant 4 ou 8 broches numériques en plus des
broches de contrôle RS, Enable et RW (optionnel)). Ainsi, en mode 4 bits,
6 broches numériques de la carte Arduino suffisent pour contrôler un afficheur
LCD alphanumérique.

Référence : http://arduino.cc/fr/Main/LibrairieLCD
*/

#include "NotesDeMusique.h"
/*
Fichier contenant les définitions de notes de musique.
*/

#include "ServoTimer2.h"
/*
Cette librairie permet à une carte Arduino de contrôler les servomoteurs de 
modélisme. Les servomoteurs intègrent un mécanisme et un axe qui peut-être 
contrôlé précisément. Les servomoteurs standards permettent de positionner 
l'axe à différents angles, habituellement entre 0 et 180 degrès (ces 
servomoteurs permettent de maintenir l'axe à une position précise). Les 
servomoteurs à rotation continue permettent des rotations de l'axe à 
différentes vitesses.

A partir d'Arduino 0017, la librairie Servo supporte jusqu'à 12 servomoteurs 
sur la plupart des cartes Arduino (la Duemilanove par exemple) et 48 sur 
l'Arduino Mega. Sur les cartes autres que la Mega, l'utilisation de la 
librairie Servo désactive l'instruction analogWrite() sur les broches 9 et 
10, qu'il y ait ou non un servomoteur sur ces broches. Sur la Mega, jusqu'à 12 
servomoteurs peuvent être utilisés sans interférer avec la fonction PWM (càd 
avec l'instruction analogWrite); utiliser de 12 à 23 servomoteurs désactivera 
les impulsions PWM sur les broches 11 et 12. (Note : PWM pour Pulse Width 
Modulation ou Modulation de Largeur d'Impulsion).

Avec Arduino 0016 et précédent, la librairie Servo utilise la fonction 
fournie par le matériel (càd l'ATmega de la carte), et fonctionne uniquement 
sur les broches 9 et 10 (et ne fonctionne pas sur l'Arduino Mega). Dans ce 
cas, si seulement un servomoteur est utilisé, l'autre broche ne peut pas être 
utilisée pour générer une sortie PWM normale avec l'instruction analogWrite().
Par exemple, avec Arduino 0016 et précédent, vous ne pouvez avoir un 
servomoteur sur la broche 9 et une sortie PWM sur la broche 10. 

Source : http://arduino.cc/fr/Main/LibrairieServo
*/

#include "TelecommandeValeurBoutons.h"
/*
Fichier contenant la valeur envoyée pour chaque boutons de la télécommande.
*/
//*****************************************************************************

//*****************************************************************************
// Déclaration des constantes de base pour franciser le code source.
//*****************************************************************************
/*
Par convention, pour nommer une constante, nous utiliserons des noms écrits
tout en majuscule, en capitale, ce qui facilitera leur repérage et rendra le
code plus facilement compréhensible. Le mot devant notre nom de constante
indique à l'Arduino l'espace mémoire à réserver pour stocker cette donnée.
Après le nom de notre constante, on lui attribue sa valeur.
*/
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « ENTREE » est l'équivalent du paramètre « INPUT ». Ce paramètre est
pour prépare l'Arduino a recevoir une tension électrique pour ce connecteur, sur
ce port de communication, sur ce "pin".
*/
const byte ENTREE = INPUT;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « ENTREE_ET_RESISTENCE_INTERNE » est l'équivalent du paramètre
« INPUT_PULLUP ». Ce paramètre est pour prépare l'Arduino en activant sa
résistance interne et a recevoir une tension électrique pour ce connecteur,
sur ce port de communication, sur ce "pin".
*/
const byte ENTREE_ET_RESISTENCE_INTERNE = INPUT_PULLUP;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « SORTIE » est l'équivalent du paramètre « OUTPUT ». Ce paramètre
est pour prépare l'Arduino a émettre une tension électrique pour ce connecteur,
sur ce port de communication, sur ce "pin".
*/
const byte SORTIE = OUTPUT;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « HAUT » est l'équivalent du paramètre « HIGH ». Ce paramètre fait
que l'Arduino maintiendra un voltage haut sur ce connecteur, soit 3.3 Volts,
soit 5 Volts, selon sa propre tension d'alimentation. En électronique, cela
correspondra aux valeurs logiques « 1 », « Oui », ou « Vrai », etc.
*/
const byte HAUT = HIGH;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « BAS » est l'équivalent du paramètre « LOW ». Ce paramètre fait
que l'Arduino maintiendra un voltage bas sur ce connecteur, soit 0 Volt. En
électronique, cela correspondra aux valeurs logiques « 0 », « Non », ou
« Faut », etc.
*/
const byte BAS = LOW;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « NON » est l'équivalent du paramètre « false », cela
correspondra aux valeurs logiques « 0 », « Non », ou « Faut », etc.
*/
const byte NON = false;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « OUI » est l'équivalent du paramètre « true », cela
correspondra aux valeurs logiques « 1 », « Oui », ou « Vrai », etc.
*/
const byte OUI = true;
//*****************************************************************************

//*****************************************************************************
// Déclaration des constantes des connecteurs Arduino.
//*****************************************************************************
// Broche d'Arduino la valeur du courant (max 5.0 Vols) fournit par l'Arduino.
const byte ARDUINO_IOREF                = A1;

// En prévision d'un ARDUINO_RESET par télécommande.
const byte ARDUINO_RESET                = A0;

// Pour gérer l'action d'humains le bouton de la planche d'expérimentation.
const byte BOUTON_1_OUT                 = 3;

// Câblage pour le Buzzer sur la planche d'expérimentation et l'Arduino :
const byte BUZZER_1_VIN                 = 12;

// Broche d'Arduino pour recevoir le signale du capteur infrarouge de télécom.
const byte CAPTEUR_IR_0_OUT             = 21;

// Broche des capteurs de distance infra-rouge 1 a 5 :
const byte CAPTEUR_IR_1_OUT             = A10;// Avant gauche.
const byte CAPTEUR_IR_2_OUT             = A11;// Arriere gauche.
const byte CAPTEUR_IR_3_OUT             = A12;// Arriere droite.
const byte CAPTEUR_IR_4_OUT             = A13;// Avant droite.
const byte CAPTEUR_IR_5_OUT             = A14;// Avant droite.

// Broche d'Arduino pour le controleur moteur 1 (double Pont en H).
const byte CONTROLE_MOTEUR_1_ENA        = 5;
const byte CONTROLE_MOTEUR_1_IN1        = 6;
const byte CONTROLE_MOTEUR_1_IN2        = 7;
const byte CONTROLE_MOTEUR_1_ENB        = 8;
const byte CONTROLE_MOTEUR_1_IN3        = 9;
const byte CONTROLE_MOTEUR_1_IN4        = 10;

// Câblage pour la DEL verte sur la planche d'expérimentation et l'Arduino
const byte DEL_1_VIN                    = 13;

// Constantes des broches sur l'Arduino pour une carte LCD1602.
const byte LCD_1_RS                     = A2;// Écran LCD.
const byte LCD_1_E                      = A3;// Écran LCD.
const byte LCD_1_D4                     = A4;// Écran LCD.
const byte LCD_1_D5                     = A5;// Écran LCD.
const byte LCD_1_D6                     = A6;// Écran LCD.
const byte LCD_1_D7                     = A7;// Écran LCD.

// Attribution des ports Arduino controlent les servomoteurs 1 et 2.
const byte SERVOMOTEUR_1_IN             = 11;// DigitalPWM

// Broche d'Arduino pour le capteur a ultrason 2, le sonar.
const byte SONAR_1_TRIG                 = A8;
const byte SONAR_1_ECHO                 = A9;
const byte SONAR_1_Reset                = 2;
//*****************************************************************************

//*****************************************************************************
// Déclaration des autres constantes de travail.
//*****************************************************************************
// Constantes des parametres de l'objet ECRAN_LCD.
// Nombre de lignes et de colonnes.
const byte LCD_1_NOMBRE_DE_COLONNES     = 16;
const byte LCD_1_NOMBRE_DE_LIGNES       = 2;

// 1.0 est le maximum, il ne faut pas dépasser 255 pour les moteur, etc.
const float MOTEURS_VITESSE_ECART_TYPE  = 0.90;
const word MOTEUR_1_VITESSE_MINIMUM     = 160;// C'est le plus bas possible.
const word MOTEUR_1_VITESSE_MAXIMUM     = 255;// 255 est le plus haut possible.
const word MOTEUR_2_VITESSE_MINIMUM     = int (MOTEUR_1_VITESSE_MINIMUM * 
                                               MOTEURS_VITESSE_ECART_TYPE);
const word MOTEUR_2_VITESSE_MAXIMUM     = int (MOTEUR_1_VITESSE_MAXIMUM * 
                                               MOTEURS_VITESSE_ECART_TYPE);
/*
// 1.0 est le maximum, il ne faut pas dépasser 255 pour les moteur, etc.
const float MOTEURS_VITESSE_ECART_TYPE  = 0.9;
const word MOTEUR_2_VITESSE_MINIMUM     = 130;// C'est le plus bas possible.
const word MOTEUR_2_VITESSE_MAXIMUM     = 255;// 255 est le plus haut possible.
const word MOTEUR_1_VITESSE_MINIMUM     = int (MOTEUR_2_VITESSE_MINIMUM * 
                                               MOTEURS_VITESSE_ECART_TYPE);
const word MOTEUR_1_VITESSE_MAXIMUM     = int (MOTEUR_2_VITESSE_MAXIMUM * 
                                               MOTEURS_VITESSE_ECART_TYPE);
*/
//*****************************************************************************

//*****************************************************************************
// Déclaration des variables globales.
//*****************************************************************************
/*
Par convention, pour nommer une variable, nous utiliserons des noms écrits
avec un majuscule pour la première lettre de chaque mot composant le nom de la
variable, ce qui facilitera leur repérage et rendra le code plus facilement
compréhensible. Le mot devant notre nom de variable indique à l'Arduino l'espace
mémoire à réserver pour stocker cette donnée. Après le nom de notre variable, on
lui attribue sa valeur.
*/

// Afficher les données dans l'écran LDC.
boolean AfficherEcranLCD                = OUI;

// Afficher les données dans le moniteur série d'Arduino (débogage).
boolean AfficherMoniteurSerie           = NON;

/*
Ici, nous définissons la variable qui controlera la grande boucle principale,
qui s'active avec le bouton « Power » de la télécommande. Par défaut, le robot
ne fait rien a l'exeption d'initialiser ses périphériques.
*/
boolean Boucler                         = NON;

// Délai pour réduire la vitesse de réaction entre les lectues des boutons
// d'une télécommande Infra Rouge (IR).
int BoutonTempsRebon                    = 9;

// Nombre de colonne autorisé pour l'affichage Série.
int NbColloneRapport = 80;

// Valeur de la mesure convertie en centimètre
int CapteurIR_1_DistanceEnCM            = 0;
int CapteurIR_2_DistanceEnCM            = 0;
int CapteurIR_3_DistanceEnCM            = 0;
int CapteurIR_4_DistanceEnCM            = 0;
int CapteurIR_5_DistanceEnCM            = 0;
int CapteurIR_1_Valeur                  = 0;
int CapteurIR_2_Valeur                  = 0;
int CapteurIR_3_Valeur                  = 0;
int CapteurIR_4_Valeur                  = 0;
int CapteurIR_5_Valeur                  = 0;
// Nombre de mesure à réaliser pour le moyennage.
int CapteursIR_NombreDeMesure           = 3;
// Valeur maximale pour la distance en centimètre.
int CapteursIR_DistanceMaximum          = 31;// En centimtre.
int CapteursIR_DistanceMinimum          = 10;// En centimtre.

// Recoit la valeur indicant la condition de déplacement en cours.
byte CodeSituation                      = 0;

// Contiend la vitesse moteur a applique et donc aussi la vitesse courante.
int Moteur_1_PointMort                  = MOTEUR_1_VITESSE_MINIMUM;
int Moteur_2_PointMort                  = MOTEUR_2_VITESSE_MINIMUM;
int Moteur_1_Vitesse                    = 0;
int Moteur_2_Vitesse                    = 0;
// Délai de fonctionnement des moteurs des roues pour pivoter le robot de 1 pas.
int MoteursDelaiUnPas                   = 10;

// Déclaration des variables pour le servo moteur.
// Variable recevant la valeur de l'angle du servo moteur.
int Servomoteur_1_Angle                 = 0;
int Servomoteur_1_AngleMinimum          = 0;// Selon les datasheet.
int Servomoteur_1_AngleMaximum          = 180;// Selon les datasheet.
int Servomoteur_1_AngleCentre           = int ((Servomoteur_1_AngleMaximum - 
                                                Servomoteur_1_AngleMinimum) / 2);
// Les valeurs des changements d'un angle a un autre, le Pas.
int Servomoteur_1_AnglePas              = 5;
// La valeur pour le temps requis pour les changements 1° d'angle.
int Servomoteur_1_Delai_1_Degre         = 10;
// La valeur pour le temps requis pour les changements 1° d'angle.
int Servomoteur_1_Delai_1_Pas           = Servomoteur_1_AnglePas * 
                                          Servomoteur_1_Delai_1_Degre;
// Largeur impulsion pour position 0° ServoCommand .
int Servomoteur_1_FrequenceMinimum      = 500;
// largeur impulsion pour position 180° ServoCommand TowerPro MG996R.
int Servomoteur_1_FrequenceMaximum      = 2000;

int Sonar_1_DelaiEntreMesures           = Servomoteur_1_AnglePas * 15;
// Dernière valeur fournit par le sonar.
int Sonar_1_DistanceActuele             = 0;
int Sonar_1_DistanceMaximumTrouve       = 0;
int Sonar_1_DistanceMaximumTrouveAngle  = 0;
// Distance limite pour la fiabilité des mesure du sonar.
int Sonar_1_DistanceValideMaximum       = 300;
// Variables pour établir la durée de la commande ping. Le résultat donnera la 
// distance en pouces et/ou en centimètres :
int Sonar_1_DureeEchoSonar              = 0;
int Sonar_1_LargeureChampDeBalayage     = Servomoteur_1_AngleMaximum - 
                                          Servomoteur_1_AngleMinimum;
// Pour contrer l'imprécission des echos sonars, plusieur lectures pour une moyene.
int Sonar_NombreDeLecture               = 3;

// Variable des distances conditionnant les mouvements du robot
int Distance1                           = 15;
int Distance2                           = Distance1 * 2;
int Distance3                           = Distance2 * 2;
// En extérieur, soit Sonar_1_DistanceValideMaximum
// Ou maximum pour un int soit 32767.
int Distance4                           = Sonar_1_DistanceValideMaximum;

// Pour la fonction « delay », qui compte le temps en milliseconde.
const int UneSeconde                    = 1000;

// Valeurs pour la gestion du temps dans les boucles de controle en milliseconde.
unsigned long TempsActuele              = 0;
// Condition de controle de l'affichage LCD par seconde pour éviter le 
// syntillement de l'afficheur. Tout est en milliseconde.
unsigned long TempsAfficher_Delai       = 40;// 40 = 25 rafraichissement par seconde.
unsigned long TempsAfficher_Precedent   = 0;
//*****************************************************************************

//*****************************************************************************
// Création en mémoire des objet pour les interfaces des périphériques.
//*****************************************************************************
// Pour le capteur infrarouge crée un objet sur la broche voulue.
IRrecv Capteur_IR_0 (CAPTEUR_IR_0_OUT);
decode_results Capteur_IR_0_Results;

// Créer et initialisation LCD en mode 4 bits.
LiquidCrystal LCD_1 (LCD_1_RS, LCD_1_E, LCD_1_D4, LCD_1_D5, LCD_1_D6, LCD_1_D7);

// Pour le contrôle des servomoteurs 1 et 2 du capteur a ultrason 1.
ServoTimer2 Servomoteur_1;
//*****************************************************************************

//*****************************************************************************
// FONCTION mapFloat
//*****************************************************************************
float mapFloat (float x, float in_min, float in_max, float out_min, float out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
//*****************************************************************************

//*****************************************************************************
// FONCTION UneNoteDeMusique
//*****************************************************************************
void UneNoteDeMusique (int BUZZER_1_VIN, float noteFrequency, long noteDuration)
{
  // Convertir la fréquence en microsecondes.
  float microsecondsPerWave = 1000000 / noteFrequency;
  // Calculez combien de cycles HAUT / BAS il ya par milliseconde.
  float millisecondsPerCycle = 1000 / (microsecondsPerWave * 2);
  // Multipliez noteDuration en nombre de cycles * par milliseconde.
  float loopTime = noteDuration * millisecondsPerCycle;
  // Jouez la note pour la boucle calculé.
  for (int i = 0; i < loopTime ; i = i + 1)
  {
    digitalWrite (BUZZER_1_VIN, HAUT);
    delayMicroseconds (microsecondsPerWave);
    digitalWrite (BUZZER_1_VIN, BAS);
    delayMicroseconds (microsecondsPerWave);
  }
}
//*****************************************************************************

//*****************************************************************************
// FONCTION Bip_1
//*****************************************************************************
void Bip_1 ()
{
  UneNoteDeMusique (BUZZER_1_VIN, Note_B7, 100);// Note de musique B
}
//*****************************************************************************

//*****************************************************************************
// FONCTION BiBip_1
//*****************************************************************************
void BiBip_1 ()
{
  UneNoteDeMusique (BUZZER_1_VIN, Note_B7, 100);// Note de musique B
  UneNoteDeMusique (BUZZER_1_VIN, Note_A7, 100);// Note de musique A
}
//*****************************************************************************

//*****************************************************************************
// FONCTION BiBiBi_1
//*****************************************************************************
void BiBiBi_1 ()
{
  UneNoteDeMusique (BUZZER_1_VIN, Note_B7, 100);// Note de musique B
  delay (100);
  UneNoteDeMusique (BUZZER_1_VIN, Note_B7, 100);// Note de musique B
  delay (100);
  UneNoteDeMusique (BUZZER_1_VIN, Note_B7, 100);// Note de musique B
}
//*****************************************************************************

//*****************************************************************************
// FONCTION R2D2_1
//*****************************************************************************
void R2D2_1 ()
{
  UneNoteDeMusique (BUZZER_1_VIN, Note_A7, 100);// Note de musique A
  UneNoteDeMusique (BUZZER_1_VIN, Note_E7, 100);// Note de musique E
  UneNoteDeMusique (BUZZER_1_VIN, Note_C7, 100);// Note de musique C
  UneNoteDeMusique (BUZZER_1_VIN, Note_D7, 100);// Note de musique D
  UneNoteDeMusique (BUZZER_1_VIN, Note_B7, 100);// Note de musique B
  UneNoteDeMusique (BUZZER_1_VIN, Note_F7, 100);// Note de musique F
}
//*****************************************************************************

//*****************************************************************************
// FONCTION AjusterVitesseDesMoteurs
//*****************************************************************************
void AjusterVitesseDesMoteurs ()
{
  // Modifier la vitesse des moteurs CC selon la distance devant le véhicule.
  Moteur_1_Vitesse = map (Sonar_1_DistanceActuele, 0, Sonar_1_DistanceValideMaximum, 
                          Moteur_1_PointMort, MOTEUR_1_VITESSE_MAXIMUM);

  Moteur_2_Vitesse = map (Sonar_1_DistanceActuele, 0, Sonar_1_DistanceValideMaximum, 
                          Moteur_2_PointMort, MOTEUR_2_VITESSE_MAXIMUM);

  // Délai de fonctionnement des moteurs des roues pour pivoter le robot de 1°.
  MoteursDelaiUnPas = int ((Moteur_1_Vitesse + Moteur_1_Vitesse) / 
                           (80 / Servomoteur_1_AnglePas));
}
//*****************************************************************************

//*****************************************************************************
// FONCTION DeplacementArret
//*****************************************************************************
void DeplacementArreter ()
{
  Moteur_1_Vitesse = 0;
  Moteur_2_Vitesse = 0;

  // Pour le moteur 1.
  digitalWrite (CONTROLE_MOTEUR_1_IN1, BAS);
  digitalWrite (CONTROLE_MOTEUR_1_IN2, BAS);
  analogWrite  (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
  // Pour le moteur 2.
  digitalWrite (CONTROLE_MOTEUR_1_IN3, BAS);
  digitalWrite (CONTROLE_MOTEUR_1_IN4, BAS);
  analogWrite  (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************

//*****************************************************************************
// FONCTION DeplacementAvancer
//*****************************************************************************
void DeplacementAvancer ()
{
  // Pour le moteur 1.
  digitalWrite (CONTROLE_MOTEUR_1_IN1, HAUT);
  digitalWrite (CONTROLE_MOTEUR_1_IN2, BAS);
  analogWrite  (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
  // Pour le moteur 2.
  digitalWrite (CONTROLE_MOTEUR_1_IN3, HAUT);
  digitalWrite (CONTROLE_MOTEUR_1_IN4, BAS);
  analogWrite  (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************

//*****************************************************************************
// FONCTION DeplacementAvancerDroite
//*****************************************************************************
void DeplacementAvancerDroite ()
{
  // Pour le moteur 1.
  digitalWrite (CONTROLE_MOTEUR_1_IN1, HAUT);
  digitalWrite (CONTROLE_MOTEUR_1_IN2, BAS);
  analogWrite  (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
  // Pour le moteur 2.
  digitalWrite (CONTROLE_MOTEUR_1_IN3, BAS);
  digitalWrite (CONTROLE_MOTEUR_1_IN4, BAS);
  analogWrite  (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************

//*****************************************************************************
// FONCTION DeplacementAvancerGauche
//*****************************************************************************
void DeplacementAvancerGauche ()
{
  // Pour le moteur 1.
  digitalWrite (CONTROLE_MOTEUR_1_IN1, BAS);
  digitalWrite (CONTROLE_MOTEUR_1_IN2, BAS);
  analogWrite  (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
  // Pour le moteur 2.
  digitalWrite (CONTROLE_MOTEUR_1_IN3, HAUT);
  digitalWrite (CONTROLE_MOTEUR_1_IN4, BAS);
  analogWrite  (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************

//*****************************************************************************
// FONCTION DeplacementPivoterDroite
//*****************************************************************************
void DeplacementPivoterDroite ()
{
  // Pour le moteur 1.
  digitalWrite (CONTROLE_MOTEUR_1_IN1, HAUT);
  digitalWrite (CONTROLE_MOTEUR_1_IN2, BAS);
  analogWrite  (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
  // Pour le moteur 2.
  digitalWrite (CONTROLE_MOTEUR_1_IN3, BAS);
  digitalWrite (CONTROLE_MOTEUR_1_IN4, HAUT);
  analogWrite  (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************

//*****************************************************************************
// FONCTION DeplacementPivoterGauche
//*****************************************************************************
void DeplacementPivoterGauche ()
{
  // Pour le moteur 1.
  digitalWrite (CONTROLE_MOTEUR_1_IN1, BAS);
  digitalWrite (CONTROLE_MOTEUR_1_IN2, HAUT);
  analogWrite  (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
  // Pour le moteur 2.
  digitalWrite (CONTROLE_MOTEUR_1_IN3, HAUT);
  digitalWrite (CONTROLE_MOTEUR_1_IN4, BAS);
  analogWrite  (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************

//*****************************************************************************
// FONCTION DeplacementReculer
//*****************************************************************************
void DeplacementReculer ()
{
  // Pour le moteur 1.
  digitalWrite (CONTROLE_MOTEUR_1_IN1, BAS);
  digitalWrite (CONTROLE_MOTEUR_1_IN2, HAUT);
  analogWrite  (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
  // Pour le moteur 2.
  digitalWrite (CONTROLE_MOTEUR_1_IN3, BAS);
  digitalWrite (CONTROLE_MOTEUR_1_IN4, HAUT);
  analogWrite  (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************

//*****************************************************************************
// FONCTION DeplacementReculerDroite
//*****************************************************************************
void DeplacementReculerDroite ()
{
  // Pour le moteur 1.
  digitalWrite (CONTROLE_MOTEUR_1_IN1, BAS);
  digitalWrite (CONTROLE_MOTEUR_1_IN2, HAUT);
  analogWrite  (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
  // Pour le moteur 2.
  digitalWrite (CONTROLE_MOTEUR_1_IN3, BAS);
  digitalWrite (CONTROLE_MOTEUR_1_IN4, BAS);
  analogWrite  (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************

//*****************************************************************************
// FONCTION DeplacementReculerGauche
//*****************************************************************************
void DeplacementReculerGauche ()
{
  // Pour le moteur 1.
  digitalWrite (CONTROLE_MOTEUR_1_IN1, BAS);
  digitalWrite (CONTROLE_MOTEUR_1_IN2, BAS);
  analogWrite  (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
  // Pour le moteur 2.
  digitalWrite (CONTROLE_MOTEUR_1_IN3, BAS);
  digitalWrite (CONTROLE_MOTEUR_1_IN4, HAUT);
  analogWrite  (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************

//*****************************************************************************
// FONCTION GererAfficherMoniteurSerie
//*****************************************************************************
void GererAfficherMoniteurSerie ()
{
  // Écriture dans le moniteur série de l'IDE d'Arduino des valeurs lues.
  Serial.print ("***********************************************************");
  Serial.println ();

  Serial.print ("* Sonar_1_DelaiEntreMesures          : ");
  Serial.print (Sonar_1_DelaiEntreMesures);
  Serial.println ();
  Serial.print ("* MoteursDelaiUnPas                  : ");
  Serial.print (MoteursDelaiUnPas);
  Serial.println ();
  Serial.print ("* Servomoteur_1_Angle                : ");
  Serial.print (Servomoteur_1_Angle);
  Serial.println ();
  Serial.print ("* Moteur_1_Vitesse                   : ");
  Serial.print (Moteur_1_Vitesse);
  Serial.println ();
  Serial.print ("* Moteur_2_Vitesse                   : ");
  Serial.print (Moteur_2_Vitesse);
  Serial.println ();
/*
  Serial.print ("* Sonar_1_DistanceActuele            : ");
  Serial.print (Sonar_1_DistanceActuele);
  Serial.println ();
  Serial.print ("* Sonar_1_DistanceMaximumTrouve      : ");
  Serial.print (Sonar_1_DistanceMaximumTrouve);
  Serial.println ();
  Serial.print ("* Sonar_1_DistanceMaximumTrouveAngle : ");
  Serial.print (Sonar_1_DistanceMaximumTrouveAngle);
  Serial.println ();
  Serial.print ("* CapteurIR_1_DistanceEnCM           : ");
  Serial.print (CapteurIR_1_DistanceEnCM);
  Serial.println ();
  Serial.print ("* CapteurIR_2_DistanceEnCM           : ");
  Serial.print (CapteurIR_2_DistanceEnCM);
  Serial.println ();
  Serial.print ("* CapteurIR_3_DistanceEnCM           : ");
  Serial.print (CapteurIR_3_DistanceEnCM);
  Serial.println ();
  Serial.print ("* CapteurIR_4_DistanceEnCM           : ");
  Serial.print (CapteurIR_4_DistanceEnCM);
  Serial.println ();
  Serial.print ("* CapteurIR_5_DistanceEnCM           : ");
  Serial.print (CapteurIR_5_DistanceEnCM);
  Serial.println ();
  Serial.print ("* CodeSituation                      : ");
  Serial.print (CodeSituation);
  Serial.println ();
*/
}
//*****************************************************************************

//*****************************************************************************
// FONCTION GererAfficherEcranLCD
//*****************************************************************************
void GererAfficherEcranLCD ()
{
  // Écriture dans l'écran LCD des valeurs lues.
  // NoColonne 0000000000111111
  // NoColonne 0123456789012345
  // Ligne 0 = 255 400 180 9999
  // Ligne 1 = 255 400 5.0 9 99
  LCD_1.clear ();
  LCD_1.setCursor (0, 0);
  LCD_1.print (Moteur_1_Vitesse);
  LCD_1.setCursor (4, 0);
  LCD_1.print (Sonar_1_DistanceActuele);
  LCD_1.setCursor (8, 0);
  LCD_1.print (Sonar_1_DistanceMaximumTrouveAngle);
  LCD_1.setCursor (12, 0);
  LCD_1.print (map (CapteurIR_1_DistanceEnCM, 0, CapteursIR_DistanceMaximum, 0, 9));
  LCD_1.setCursor (13, 0);
  LCD_1.print (map (CapteurIR_3_DistanceEnCM, 0, CapteursIR_DistanceMaximum, 0, 9));
  LCD_1.setCursor (14, 0);
  LCD_1.print (map (CapteurIR_4_DistanceEnCM, 0, CapteursIR_DistanceMaximum, 0, 9));
  LCD_1.setCursor (15, 0);
  LCD_1.print (map (CapteurIR_5_DistanceEnCM, 0, CapteursIR_DistanceMaximum, 0, 9));
  LCD_1.setCursor (0, 1);
  LCD_1.print (Moteur_2_Vitesse);
  LCD_1.setCursor (4, 1);
  LCD_1.print (Sonar_1_DistanceMaximumTrouve);
  LCD_1.setCursor (11, 1);
  LCD_1.print (" ");
  LCD_1.setCursor (12, 1);
  LCD_1.print (map (CapteurIR_2_DistanceEnCM, 0, CapteursIR_DistanceMaximum, 0, 9));
  LCD_1.setCursor (14, 1);
  LCD_1.print (CodeSituation);
}
//*****************************************************************************

//*****************************************************************************
// FONCTION GererAffichages
//*****************************************************************************
void GererAffichages ()
{
  if (AfficherMoniteurSerie)
  {
    GererAfficherMoniteurSerie ();
  }
  if (AfficherEcranLCD)
  {
    GererAfficherEcranLCD ();
  }
}
//*****************************************************************************

//*****************************************************************************
// FONCTION GererBoutonMarcheArret
//*****************************************************************************
void GererBoutonMarcheArret ()
/*
Gestion de l'utilisation d'un bouton sur la planche d'expérimentation.
*/
{
  int EtatBouton = digitalRead (BOUTON_1_OUT);
  if (EtatBouton == HAUT)
  {
    if (Boucler == OUI)
    {
      CodeSituation = 73;
      DeplacementArreter ();
      GererAffichages ();
      R2D2_1 ();
      Boucler = NON;
      digitalWrite (DEL_1_VIN, Boucler);
      // L'angle du servomoteur du sonar initialisé a 90°.
      Servomoteur_1.write (Servomoteur_1_AngleCentre);
      delay (UneSeconde);
      // Configurer le port Arduino pour un RESET par télécommande.
      pinMode (ARDUINO_RESET, SORTIE);
      // Activer la broche ARDUINO_RESET.
      digitalWrite (ARDUINO_RESET, BAS);
      delay (UneSeconde);
    }
    else
    {
      CodeSituation = 74;
      Bip_1 ();
      Boucler = OUI;
      digitalWrite (DEL_1_VIN, Boucler);
    }
    while (EtatBouton == HAUT)
    {
      delay (BoutonTempsRebon);// Pour absorber les micro-coupures des rebonds.
      EtatBouton = digitalRead (BOUTON_1_OUT);
    }
  }
}
//*****************************************************************************

//*****************************************************************************
// FONCTION GererBoutonTeleCommande
//*****************************************************************************
void GererBoutonTeleCommande ()
/*
Gérer l'utilisation d'une télécommande type MP3 avec capteur infrarouge.

Ici tous les boutons de la télécommande sont listés et la majorité ont un
effet sur le déroulement de de la boucle principale ou sur les paramètres de
fonctionnement du moteur ou les deux  la fois et la touche « Mode » est
l'actionneur de la broche RESET de la carte Arduino, donc du redémarrage du
Système complet.

En synthèse les boutons font :

Power     : Active/désactive la boucle principale du programme, arrêt moteur.
Mode      : Bouton kamikaze qui utilise la broche RESET de la carte Arduino.
Son       :
PlayPause : Fait une pause des moteurs, comme un arrêt sur image.
Debut     :
Fin       :
EQ        : Inversé l'état de cette variable, basculer On/Off Off/On.
Moins     : Diminuer Moteur_1_PointMort et Moteur_2_PointMort de 10.
Plus      : Ogmenter Moteur_1_PointMort et Moteur_2_PointMort de 10.
0         :
Recycle   :
U_SD      :
1         : Déplacement, Avancer en tournant à Gauche, une roue tourne.
2         : Déplacement, Avancer en ligne droite, les deux roues tournent.
3         : Déplacement, Avancer en tournant à Droit, une roue tourne.
4         : Déplacement, Pivoter en tournant à Gauche, les deux roues tournent.
5         : Déplacement, Arrêt sur place les deux roues s'arrêtent.
6         : Déplacement, Pivoter en tournant à Droit, les deux roues tournent.
7         : Déplacement, Reculer en tournant à Gauche, une roue tourne.
8         : Déplacement, Reculer en ligne droite, une roue tourne.
9         : Déplacement, Reculer en tournant à Droit, une roue tourne.
default   : Une télécommande génère beaucoup d'autres codes qui sont inutiles ici.
*/
{
  if (Capteur_IR_0.decode (&Capteur_IR_0_Results))
  {
    // Récupérer la valeur de la touche de la télécommande.
    TelecommandeBoutonValeur = Capteur_IR_0_Results.value;
    Capteur_IR_0.resume ();
    switch (TelecommandeBoutonValeur)
    {
      case TelecommandeBoutonPower:
        Serial.print ("* TelecommandeBoutonPower = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        if (Boucler == OUI)
        {
          CodeSituation = 75;
          Boucler = NON;
          digitalWrite (DEL_1_VIN, Boucler);
          DeplacementArreter ();
        }
        else
        {
          CodeSituation = 76;
          Boucler = OUI;
          digitalWrite (DEL_1_VIN, Boucler);
        }
        break;
      case TelecommandeBoutonMode:
        CodeSituation = 77;
        Serial.print ("* TelecommandeBoutonMode = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        DeplacementArreter ();
        GererAffichages ();
        R2D2_1 ();
        // L'angle du servomoteur du sonar initialisé a 90°.
        Servomoteur_1.write (Servomoteur_1_AngleCentre);
        delay (UneSeconde);
        // Configurer le port Arduino pour un RESET par télécommande.
        pinMode (ARDUINO_RESET, SORTIE);
        // Activer la broche ARDUINO_RESET.
        digitalWrite (ARDUINO_RESET, BAS);
        delay (UneSeconde);
        break;
      case TelecommandeBoutonSon:
        CodeSituation = 78;
        Serial.print ("* TelecommandeBoutonSon = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        break;
      case TelecommandeBoutonPlayPause:
        Serial.print ("* TelecommandeBoutonPlayPause = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        if (Boucler == OUI)
        {
          CodeSituation = 79;
          DeplacementArreter ();
          Boucler = NON;
          digitalWrite (DEL_1_VIN, Boucler);
          Serial.print ("* En attente d'une action d'humaine");
          Serial.println ();
        }
        else
        {
          CodeSituation = 80;
          Boucler = OUI;
          digitalWrite (DEL_1_VIN, Boucler);
          Serial.print ("* Poursuite du programme");
          Serial.println ();
        }
        break;
      case TelecommandeBoutonDebut:
        CodeSituation = 81;
        Serial.print ("* TelecommandeBoutonDebut = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        break;
      case TelecommandeBoutonFin:
        CodeSituation = 82;
        Serial.print ("* TelecommandeBoutonFin = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        break;
      case TelecommandeBoutonEQ:
        CodeSituation = 83;
        Serial.print ("* TelecommandeBoutonEQ = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        // Inversé l'état de cette variable, basculer On/Off Off/On.
        AfficherMoniteurSerie = AfficherMoniteurSerie - 1;
        Bip_1 ();
        break;
      case TelecommandeBoutonMoins:
        CodeSituation = 84;
        Serial.print ("* TelecommandeBoutonMoins = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Moteur_1_PointMort = Moteur_1_PointMort - 10;
        Moteur_2_PointMort = Moteur_2_PointMort - 10;
        Bip_1 ();
        break;
      case TelecommandeBoutonPlus:
        CodeSituation = 85;
        Serial.print ("* TelecommandeBoutonPlus = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Moteur_1_PointMort = Moteur_1_PointMort + 10;
        Moteur_2_PointMort = Moteur_2_PointMort + 10;
        Bip_1 ();
        break;
      case TelecommandeBouton0:
        CodeSituation = 86;
        Serial.print ("* TelecommandeBouton0 = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        break;
      case TelecommandeBoutonRecycle:
        CodeSituation = 87;
        Serial.print ("* TelecommandeBoutonRecycle = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        break;
      case TelecommandeBoutonU_SD:
        CodeSituation = 88;
        Serial.print ("* TelecommandeBoutonU_SD = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        break;
      case TelecommandeBouton1:
        CodeSituation = 89;
        Serial.print ("* TelecommandeBouton1 = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        Moteur_1_Vitesse = Moteur_1_PointMort;
        Moteur_2_Vitesse = Moteur_2_PointMort;
        DeplacementAvancerGauche ();
        Boucler = NON;
        digitalWrite (DEL_1_VIN, Boucler);
        break;
      case TelecommandeBouton2:
        CodeSituation = 90;
        Serial.print ("* TelecommandeBouton2 = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        Moteur_1_Vitesse = Moteur_1_PointMort;
        Moteur_2_Vitesse = Moteur_2_PointMort;
        DeplacementAvancer ();
        Boucler = NON;
        digitalWrite (DEL_1_VIN, Boucler);
        break;
      case TelecommandeBouton3:
        CodeSituation = 91;
        Serial.print ("* TelecommandeBouton3 = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        Moteur_1_Vitesse = Moteur_1_PointMort;
        Moteur_2_Vitesse = Moteur_2_PointMort;
        DeplacementAvancerDroite ();
        Boucler = NON;
        digitalWrite (DEL_1_VIN, Boucler);
        break;
      case TelecommandeBouton4:
        CodeSituation = 92;
        Serial.print ("* TelecommandeBouton4 = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        Moteur_1_Vitesse = Moteur_1_PointMort;
        Moteur_2_Vitesse = Moteur_2_PointMort;
        DeplacementPivoterGauche ();
        Boucler = NON;
        digitalWrite (DEL_1_VIN, Boucler);
        break;
      case TelecommandeBouton5:
        CodeSituation = 93;
        Serial.print ("* TelecommandeBouton5 = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        DeplacementArreter ();
        Boucler = NON;
        digitalWrite (DEL_1_VIN, Boucler);
        break;
      case TelecommandeBouton6:
        CodeSituation = 94;
        Serial.print ("* TelecommandeBouton6 = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        Moteur_1_Vitesse = Moteur_1_PointMort;
        Moteur_2_Vitesse = Moteur_2_PointMort;
        DeplacementPivoterDroite ();
        Boucler = NON;
        digitalWrite (DEL_1_VIN, Boucler);
        break;
      case TelecommandeBouton7:
        CodeSituation = 95;
        Serial.print ("* TelecommandeBouton7 = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        Moteur_1_Vitesse = Moteur_1_PointMort;
        Moteur_2_Vitesse = Moteur_2_PointMort;
        DeplacementReculerGauche ();
        Boucler = NON;
        digitalWrite (DEL_1_VIN, Boucler);
        break;
      case TelecommandeBouton8:
        CodeSituation = 96;
        Serial.print ("* TelecommandeBouton8 = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        Moteur_1_Vitesse = Moteur_1_PointMort;
        Moteur_2_Vitesse = Moteur_2_PointMort;
        DeplacementReculer ();
        Boucler = NON;
        digitalWrite (DEL_1_VIN, Boucler);
        break;
      case TelecommandeBouton9:
        CodeSituation = 97;
        Serial.print ("* TelecommandeBouton9 = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Bip_1 ();
        Moteur_1_Vitesse = Moteur_1_PointMort;
        Moteur_2_Vitesse = Moteur_2_PointMort;
        DeplacementReculerDroite ();
        Boucler = NON;
        digitalWrite (DEL_1_VIN, Boucler);
        break;
      default:
        CodeSituation = 98;
        Serial.print ("* Code de telecommande infrarouge inconnu = ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        BiBip_1 ();
        ;
    }
  }
  while (Capteur_IR_0.decode (&Capteur_IR_0_Results))
  {
    // Pour absorber les micro-coupures des rebonds).
    delay (TelecommandeTempsRebon);
    // Récupérer la valeur de la touche de la télécommande.
    TelecommandeBoutonValeur = Capteur_IR_0_Results.value;
    Capteur_IR_0.resume ();
  }
}
//*****************************************************************************

//*****************************************************************************
// FONCTION GererBoutons
//*****************************************************************************
void GererBoutons ()
{
  GererBoutonMarcheArret (); // Un bouton sur planche d'expérimentation.
  GererBoutonTeleCommande ();// 21 boutons d'une télécommande type MP3.
}
//*****************************************************************************

//*****************************************************************************
// FONCTION GererTempsAffichagesBoutons
//*****************************************************************************
void GererTempsAffichagesBoutons ()
{
  // Condition de controle de l'affichage LCD par seconde pour éviter le 
  // syntillement de l'afficheur.
  TempsActuele = millis ();
  if (TempsActuele > (TempsAfficher_Precedent + TempsAfficher_Delai))
  {
    TempsAfficher_Precedent = TempsActuele;
    GererAffichages ();
    GererBoutons ();
  }
}
//*****************************************************************************

//*****************************************************************************
// FONCTION ConvertionMicrosecondsEnCentimetres
//*****************************************************************************
int ConvertionMicrosecondsEnCentimetres (int microseconds)
{
/*
La vitesse du son est de 340 metres par seconde ou 29 microsecondes par 
centimètre. Le ping voyage aller et retour, de sorte à trouver la distance de
l'objet, nous prenons la moitié de la distance parcourue. Voir:
http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
*/
  return int (microseconds / 29 / 2);// Donc division par 58.
}
//*****************************************************************************

//*****************************************************************************
// FONCTION CapteurUltrasonUneLecture
//*****************************************************************************
void CapteurUltrasonUneLecture ()
{
  /* Le capteur est déclenché par une impulsion haute d'au moins
  10 microsecondes. Donne une courte impulsion basse à l'avance pour assurer
  une impulsion HAUT propre:
  */
  // Lecture echo sonar 1
  delayMicroseconds (2);
  digitalWrite (SONAR_1_TRIG, HAUT);
  delayMicroseconds (10);
  digitalWrite (SONAR_1_TRIG, BAS);
  Sonar_1_DureeEchoSonar = pulseIn (SONAR_1_ECHO, HAUT);
  // convertir le temps en une distance
  Sonar_1_DistanceActuele = ConvertionMicrosecondsEnCentimetres 
                           (Sonar_1_DureeEchoSonar);
  // Limiter la distance mesurée a la valeur de Sonar_1_DistanceValideMaximum.
  if (Sonar_1_DistanceActuele > Sonar_1_DistanceValideMaximum)
  {
    Sonar_1_DistanceActuele = Sonar_1_DistanceValideMaximum;
  }
  else if (Sonar_1_DistanceActuele < 0)
  {
    Sonar_1_DistanceActuele = 0;
  }
  digitalWrite (SONAR_1_Reset, HAUT);
  delay (10);
  digitalWrite (SONAR_1_Reset, BAS);
}
//*****************************************************************************

//*****************************************************************************
// FONCTION CapteurUltrasonLecture
//*****************************************************************************
void CapteurUltrasonLectures ()
{
  // Pour contrer l'imprécission des echos sonars, deux lecture et la moyene.
  byte i = 0;
  float EchosSonar1 [Sonar_NombreDeLecture];

  // Les lectures pour le sonar 1
  i = 0;
  CapteurUltrasonUneLecture ();
  EchosSonar1 [i] = Sonar_1_DistanceActuele;
  while ((EchosSonar1 [i] ==! EchosSonar1 [i + 1]) and (i < Sonar_NombreDeLecture))
  {
    CapteurUltrasonUneLecture ();
    EchosSonar1 [i + 1] = Sonar_1_DistanceActuele;
    if (EchosSonar1 [i] == EchosSonar1 [i + 1])
    {
      i = i + 1;
    }
    else
    {
      EchosSonar1 [i] = EchosSonar1 [i + 1];
    }
  }
}
//*****************************************************************************

//*****************************************************************************
// FONCTION CapAuPlusGrandDegagement
//*****************************************************************************
void CapAuPlusGrandDegagement ()
{
  CodeSituation = 47;
  Servomoteur_1.write (Servomoteur_1_Angle);
  delay (abs (Servomoteur_1_Angle - Servomoteur_1_AngleCentre) * 
              Servomoteur_1_Delai_1_Degre);

  Moteur_1_Vitesse = Moteur_1_PointMort;
  Moteur_2_Vitesse = Moteur_2_PointMort;

  while ((abs (Servomoteur_1_Angle - Servomoteur_1_AngleCentre) >=
               Servomoteur_1_AnglePas))
  {
    if (Servomoteur_1_Angle > Servomoteur_1_AngleCentre)
    {
      DeplacementPivoterDroite ();
      Servomoteur_1_Angle = Servomoteur_1_Angle - Servomoteur_1_AnglePas;
    }
    else
    {
      DeplacementPivoterGauche ();
      Servomoteur_1_Angle = Servomoteur_1_Angle + Servomoteur_1_AnglePas;
    }
    Servomoteur_1.write (Servomoteur_1_Angle);
    delay (MoteursDelaiUnPas);
    GererTempsAffichagesBoutons ();
  }
  DeplacementArreter ();
}
//*****************************************************************************

//*****************************************************************************
// FONCTION TrouverPlusGrandDegagement
//*****************************************************************************
void TrouverPlusGrandDegagement ()
{
  CodeSituation = 57;
  Sonar_1_DistanceMaximumTrouve = 0;
  Sonar_1_DistanceMaximumTrouveAngle = 0;
  // Un baleillage de tout le champs de rotation du servo moteur du sonar.
  Servomoteur_1_Angle = Servomoteur_1_AngleMinimum;
  Servomoteur_1.write (Servomoteur_1_Angle);
  delay ((Servomoteur_1_AngleCentre - Servomoteur_1_Angle) * 
         Servomoteur_1_Delai_1_Degre);

  while (Servomoteur_1_Angle < Servomoteur_1_AngleMaximum)
  {
    Servomoteur_1.write (Servomoteur_1_Angle);
    delay (Servomoteur_1_Delai_1_Pas);
    CapteurUltrasonLectures ();
    
    if (Sonar_1_DistanceActuele > Sonar_1_DistanceMaximumTrouve)
    {
      Sonar_1_DistanceMaximumTrouve = Sonar_1_DistanceActuele;
      Sonar_1_DistanceMaximumTrouveAngle = Servomoteur_1_Angle;
    }
    Servomoteur_1_Angle = Servomoteur_1_Angle + Servomoteur_1_AnglePas;
    GererTempsAffichagesBoutons ();
  }
  Servomoteur_1_Angle = Sonar_1_DistanceMaximumTrouveAngle;
  CapAuPlusGrandDegagement ();
}
//*****************************************************************************

//*****************************************************************************
// FONCTION CapteurIR_Mesurer
//*****************************************************************************
void CapteurIR_Mesurer (byte NumeroDeBrocheDuCapteurIR, int NombreDeMesure, 
                        int *MesureMoyenne, int *MesureDistanceEnCM)
{
  // Variable pour acquisition résultat brut de 0 à 1023.
  int MesureBrute     = 0;
  // Variable pour MesureCumul des mesures.
  int MesureCumul     = 0;
  // Variable pour MesureCumul des mesures.
  *MesureMoyenne      = 0;
  *MesureDistanceEnCM = 0;
  // Tableau de valeurs en millivolts pour la distance de 5 en 5cm de 10 à 80 cm 
  // pour le capteur de distance à l'infrarouge. 1ère valeur a l'index 0.
  const int TableauDeConvertion [] = 
  {// Début du tableau
      0,//  0 cm - index  0
     32,//  1 cm - index  1
     33,//  2 cm - index  2
     34,//  3 cm - index  3
     35,//  4 cm - index  4
     38,//  5 cm - index  5
     41,//  6 cm - index  6
     52,//  7 cm - index  7
     90,//  8 cm - index  8
    138,//  9 cm - index  9 
    181,// 10 cm - index 10
    215,// 11 cm - index 11
    240,// 12 cm - index 12
    273,// 13 cm - index 13
    283,// 14 cm - index 14
    304,// 15 cm - index 15
    313,// 16 cm - index 16
    330,// 17 cm - index 17
    341,// 18 cm - index 18
    352,// 19 cm - index 19
    366,// 20 cm - index 20
    375,// 21 cm - index 21
    380,// 22 cm - index 22
    385,// 23 cm - index 23
    390,// 24 cm - index 24
    395,// 25 cm - index 25
    400,// 26 cm - index 26
    405,// 27 cm - index 27
    410,// 28 cm - index 28
    415,// 29 cm - index 29
    425,// 30 cm - index 30
    1023,// +30cm - index 31
  }; // Fin du tableau
  byte TableauDeConvertionNbItem = 31;

  // Calcul d'une moyenne de plusieurs mesures.
  for (int i = 0; i < NombreDeMesure; i = i + 1) // répète la mesure
  {
    MesureBrute = analogRead (NumeroDeBrocheDuCapteurIR);
    MesureCumul = MesureCumul + MesureBrute;
  }
  
  // Calcul MesureMoyenne
  *MesureMoyenne = int (MesureCumul / NombreDeMesure);
  
  // Détermination de la distance à partir du tableau de reference
  // teste les valeurs de calibrage.
  for (int j = 0; j < TableauDeConvertionNbItem; j = j + 1)
  {
    // Si la mesure est comprise entre 2 valeurs :
    if ((*MesureMoyenne >= TableauDeConvertion [j]) and 
        (*MesureMoyenne < TableauDeConvertion [j + 1]))
    {
      // Calcule de la distance en cm à partir de l'index courant.
      *MesureDistanceEnCM = j;
    }
  }
}
//*****************************************************************************

//*****************************************************************************
// FONCTION CapteursInfrarouges
//*****************************************************************************
void CapteursInfrarouges ()
{
  CapteurIR_Mesurer (CAPTEUR_IR_1_OUT, CapteursIR_NombreDeMesure, 
                     &CapteurIR_1_Valeur, &CapteurIR_1_DistanceEnCM);
  CapteurIR_Mesurer (CAPTEUR_IR_2_OUT, CapteursIR_NombreDeMesure, 
                     &CapteurIR_2_Valeur, &CapteurIR_2_DistanceEnCM);
  CapteurIR_Mesurer (CAPTEUR_IR_3_OUT, CapteursIR_NombreDeMesure, 
                     &CapteurIR_3_Valeur, &CapteurIR_3_DistanceEnCM);
  CapteurIR_Mesurer (CAPTEUR_IR_4_OUT, CapteursIR_NombreDeMesure, 
                     &CapteurIR_4_Valeur, &CapteurIR_4_DistanceEnCM);
  CapteurIR_Mesurer (CAPTEUR_IR_5_OUT, CapteursIR_NombreDeMesure, 
                     &CapteurIR_5_Valeur, &CapteurIR_5_DistanceEnCM);
}
//*****************************************************************************

//*****************************************************************************
// FONCTION GererDeplacements
//*****************************************************************************
void GererDeplacements ()
{
  CapteurUltrasonLectures ();
  CapteursInfrarouges ();
  AjusterVitesseDesMoteurs ();

  if (CapteurIR_1_DistanceEnCM < CapteursIR_DistanceMinimum)
  {
    CodeSituation = 1;
    DeplacementPivoterDroite ();
  }

  else if (CapteurIR_2_DistanceEnCM < CapteursIR_DistanceMinimum)
  {
    CodeSituation = 2;
    DeplacementReculer ();
    delay (250);
    DeplacementArreter ();
    delay (250);
    TrouverPlusGrandDegagement ();
  }

  else if (CapteurIR_3_DistanceEnCM < CapteursIR_DistanceMinimum)
  {
    CodeSituation = 3;
    DeplacementPivoterGauche ();
  }

  else if (CapteurIR_4_DistanceEnCM < CapteursIR_DistanceMinimum)
  {
    CodeSituation = 4;
    DeplacementAvancerGauche ();
  }

  else if (CapteurIR_5_DistanceEnCM < CapteursIR_DistanceMinimum)
  {
    CodeSituation = 5;
    DeplacementAvancerDroite ();
  }

  else if (Sonar_1_DistanceActuele <= Distance1)
  {
    CodeSituation = 6;
    DeplacementReculer ();
    delay (150);
    DeplacementArreter ();
    delay (150);
    TrouverPlusGrandDegagement ();
  }

  else if ((Sonar_1_DistanceActuele > Distance1) and 
           (Sonar_1_DistanceActuele <= Distance2))
  {
    CodeSituation = 7;
    DeplacementAvancer ();
  }

  else if ((Sonar_1_DistanceActuele > Distance2) and 
           (Sonar_1_DistanceActuele <= Distance3))
  {
    CodeSituation = 8;
    DeplacementAvancer ();
  }
  
  else if ((Sonar_1_DistanceActuele > Distance3) and 
           (Sonar_1_DistanceActuele <= Distance4))
  {
    CodeSituation = 9;
    DeplacementAvancer ();
  }
  
  else if (Sonar_1_DistanceActuele > Distance4)
  {
    CodeSituation = 10;
    DeplacementArreter ();
  }
  
  else
  {
    CodeSituation = 99;
    DeplacementArreter ();
  }
}
//*****************************************************************************

//*****************************************************************************
// FONCTION SETUP = Code d'initialisation.
//*****************************************************************************
/*
La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du
programme. Pour éviter de mettre des composantes sous tension avec la dernière
version du programme chargé dans l'Arduino, Nous utilisant une boucle « while »,
tant qu'une première action n'est pas accompli par l'utilisateur, on ne fait
rien (Télécommande, bouton, etc.).

L'activation du rappel au + interne des connecteurs en entrée si nécessaire.
L'instruction « digitalWrite (pin, HIGH); » écrit la valeur HIGH, qui vaux 1 
sur le connecteur en entrée, ce qui active la résistance de "rappel au +" 
(pullup) au plus de ce connecteur. L'utilisation de cette résistance interne 
est une protection minimale pour l'intégrité physique pour la puce principale.
*/
void setup ()
{
  // Ici les instructions à exécuter au démarrage.

  // Définition des constantes et variable.
  int LongueurNomProgramme = NOM_DU_PROGRAMME [17];
  int NbEspacement = (NbColloneRapport - LongueurNomProgramme) / 2;

  // IMPORTANT : régler le terminal côté PC avec la même valeur de
  // transmission.
  Serial.begin (9600);

  // Boucle qui attend que le terminal "Serial" soi actif avant de poursuivre !
  while (!Serial);
  // Impression de l'entête du rapport sur le terminale Série qui à comme 
  // titre le nom du programme et le tout centré sur 80 colonnes.
  Serial.println ();
  Serial.println ();
  Serial.println ();
  for (int i = 0; i < NbColloneRapport; i++)
    Serial.print ("*");
  Serial.println ();
  Serial.print ("*");
  if (((NbEspacement * 2) + LongueurNomProgramme) < NbColloneRapport)
    Serial.print (" ");
  for (int i = 1; i < NbEspacement; i++)
    Serial.print (" ");
  Serial.print (NOM_DU_PROGRAMME);
  for (int i = 1; i < NbEspacement; i++)
    Serial.print (" ");
  Serial.print ("*");
  Serial.println ();
  for (int i = 0; i < NbColloneRapport; i++)
    Serial.print ("*");
  Serial.println ();

  //----------------------------------------------------------------------------
    // Le minimum de connecteurs en entrées et sorties d'activé par sécurité
  // en cas de changement des port de connexion.
  
  // Pour affichage dans l'écran LCD.
  LCD_1.begin (LCD_1_NOMBRE_DE_COLONNES, LCD_1_NOMBRE_DE_LIGNES);
  LCD_1.clear ();
  LCD_1.noCursor ();
  LCD_1.setCursor (0,0);
  LCD_1.print (NOM_DU_PROGRAMME);
  LCD_1.setCursor (0,1);
  LCD_1.print ("*   Boutons    *");

  Serial.print ("* Broches de l'ecran LCD sur le BreanBoard activer        *");
  Serial.println ();

  // Pour le bouton Marche/Arrêt sur la planche d'expérimentation.
  // Configurer le port Arduino en entrée pour le bouton.
  pinMode (BOUTON_1_OUT, ENTREE);
  // Activer la résistance au plus PULLUP.
  digitalWrite (BOUTON_1_OUT, HAUT);
  Serial.print ("* Broche du bouton sur le BreanBoard activer              *");
  Serial.println ();

  // Configurer le port Arduino en entrée pour le capteur infrarouge sur un port d'interruption.
  pinMode (CAPTEUR_IR_0_OUT, ENTREE);
  // Initialisation et début de la réception du capteur infrarouge.
  Capteur_IR_0.enableIRIn ();
  
  Serial.print ("* Broche du capteur infrarouge de telecommande activer    *");
  Serial.println ();

  // Fixer le BUZZER_1_VIN en sortie.
  pinMode (BUZZER_1_VIN, SORTIE);
  Bip_1 ();
  Serial.print ("* Broche du Buzzer de l'Arduinobot activer                *");
  Serial.println ();

  // Active la DEL de l'Arduino.
  pinMode (DEL_1_VIN, SORTIE);
  digitalWrite (DEL_1_VIN, Boucler);
  Serial.print ("* DEL de la carte Arduino                                 *");
  Serial.println ();
  Serial.print ("***********************************************************");
  Serial.println ();
  Serial.print ("* Attante : Telecommande (Power) ou Bouton MarcheArret... *");
  Serial.println ();
  Serial.print ("***********************************************************");
  Serial.println ();

  // Boucle pour éviter qu'un ancien programme chargé ne s'exécute avec un
  // nouveau montage installé, en attente du chargement du nouveau programme.
  // Jusqu'ici, c'est le minimum qui est activé, le reste des connexions
  // seront activé après la boucle d'attente.
  while (Boucler == NON)
  {
    GererBoutons ();
  }

  digitalWrite (DEL_1_VIN, Boucler);

  // Activer la broche pour la lecture de la 
  pinMode (ARDUINO_IOREF, ENTREE);

  // Activer les capteurs de distance infra-rouge 1 a 4 :
  pinMode (CAPTEUR_IR_1_OUT, ENTREE);
  pinMode (CAPTEUR_IR_2_OUT, ENTREE);
  pinMode (CAPTEUR_IR_3_OUT, ENTREE);
  pinMode (CAPTEUR_IR_4_OUT, ENTREE);
  pinMode (CAPTEUR_IR_5_OUT, ENTREE);
  Serial.print ("* Broches des capteurs de proximite activer               *");
  Serial.println ();
  LCD_1.setCursor (0,1);
  LCD_1.print ("CAPTEUR_IR_4_O");

  // Pour les moteurs de déplacement du véhicule sur les port de l'Arduino.
  // Ajustement initial de la vitesse moteur 1 et 2, a l'arret.
  // Moteur a l'arret, au cas ou.
  pinMode      (CONTROLE_MOTEUR_1_IN1, SORTIE);
  digitalWrite (CONTROLE_MOTEUR_1_IN1, BAS);
  pinMode      (CONTROLE_MOTEUR_1_IN2, SORTIE);
  digitalWrite (CONTROLE_MOTEUR_1_IN2, BAS);
  pinMode      (CONTROLE_MOTEUR_1_IN3, SORTIE);
  digitalWrite (CONTROLE_MOTEUR_1_IN3, BAS);
  pinMode      (CONTROLE_MOTEUR_1_IN4, SORTIE);
  digitalWrite (CONTROLE_MOTEUR_1_IN4, BAS);
  pinMode      (CONTROLE_MOTEUR_1_ENA, SORTIE);
  digitalWrite (CONTROLE_MOTEUR_1_ENA, BAS);
  pinMode      (CONTROLE_MOTEUR_1_ENB, SORTIE);
  digitalWrite (CONTROLE_MOTEUR_1_ENB, BAS);
  
  Serial.print ("* Broches du controleur des moteurs activer               *");
  Serial.println ();
  LCD_1.setCursor (0,1);
  LCD_1.print ("CONTROLE_MOTEUR_");

  // Initialisation des servomoteur du sonar 1.
  Servomoteur_1.attach (SERVOMOTEUR_1_IN);
  // L'angle du servomoteur du sonar initialisé a 90°.
  Servomoteur_1.write (Servomoteur_1_AngleCentre);
  delay (UneSeconde / 3);

  Serial.print ("* Broches des Servomoteurs pour le sonar activer          *");
  Serial.println ();
  LCD_1.setCursor (0,1);
  LCD_1.print ("SERVOMOTEUR_1_IN");

  // L'angle du servomoteur du sonar initialisé a 90°.
  Servomoteur_1.write (Servomoteur_1_AngleCentre);
  delay (UneSeconde / 3);

  Serial.print ("* Centrage des Servomoteurs pour le sonar fait            *");
  Serial.println ();
  LCD_1.setCursor (0,1);
  LCD_1.print ("ServomoteurCentr");

  // Pour le sonar, activation des port de l'Arduino.
  pinMode      (SONAR_1_TRIG, SORTIE);
  pinMode      (SONAR_1_ECHO, ENTREE);
  pinMode      (SONAR_1_Reset, SORTIE);
  digitalWrite (SONAR_1_TRIG, BAS);
  digitalWrite (SONAR_1_Reset, BAS);
  
  Serial.print ("* Broches du sonar activer                                *");
  Serial.println ();
  LCD_1.setCursor (0,1);
  LCD_1.print ("SONAR_1_ECHO    ");

  // Message de la fin du processus d'initialisation du systme.
  Serial.print ("***********************************************************");
  Serial.println ();
  Serial.print ("*    Fin de la procedure d'initialisation du systeme...   *");
  Serial.println ();
  Serial.print ("***********************************************************");
  Serial.println ();
  Serial.print ("***********************************************************");
  Serial.println ();
  Serial.print ("*                  Variable du programme                  *");
  Serial.println ();
  Serial.print ("***********************************************************");
  Serial.println ();
  Serial.print ("* Servomoteur_1_Angle           = ");
  Serial.print (Servomoteur_1_Angle);
  Serial.println ();
  Serial.print ("* Sonar_1_DelaiEntreMesures     = ");
  Serial.print (Sonar_1_DelaiEntreMesures);
  Serial.println ();
  Serial.print ("* Servomoteur_1_AnglePas        = ");
  Serial.print (Servomoteur_1_AnglePas);
  Serial.println ();
  Serial.print ("* Sonar_1_DistanceValideMaximum = ");
  Serial.print (Sonar_1_DistanceValideMaximum);
  Serial.println ();
  Serial.print ("* Distance1                     = ");
  Serial.print (Distance1);
  Serial.println ();
  Serial.print ("* Distance2                     = ");
  Serial.print (Distance2);
  Serial.println ();
  Serial.print ("* Distance3                     = ");
  Serial.print (Distance3);
  Serial.println ();
  Serial.print ("* Distance4                     = ");
  Serial.print (Distance4);
  Serial.println ();
  Serial.print ("***********************************************************");
  Serial.println ();
  Serial.print ("* CodeSituation           = ");
  Serial.print (CodeSituation);
  Serial.println ();
  Serial.print ("***********************************************************");
  Serial.println ();

  // Pour affichage dans l'écran LCD.
  LCD_1.clear ();
  LCD_1.setCursor (0,0);
  LCD_1.print (">>>>>> OK <<<<<<");
  LCD_1.setCursor (0,1);
  LCD_1.print (">>>>>> GO <<<< ");
  LCD_1.setCursor (15,1);
  LCD_1.print (CodeSituation);

  TempsAfficher_Precedent = millis ();

  AjusterVitesseDesMoteurs ();
  TrouverPlusGrandDegagement ();
}
//*****************************************************************************

//*****************************************************************************
// FONCTION LOOP = Boucle sans fin = coeur du programme.
//*****************************************************************************
// La fonction loop() s'exécute sans fin en boucle aussi longtemps que
// l'Arduino est sous tension.

void loop()
{
  // Ici les instructions à exécuter par le programme principal.

  AjusterVitesseDesMoteurs ();

  GererTempsAffichagesBoutons ();
    
  if (Boucler == OUI)
  {
    GererDeplacements ();
  }
}
//*****************************************************************************

Et voici ma table de référence pour la valeur de chaque bouton de la mini télécommande (TelecommandeValeurBoutons.h) :

//Définition de la valeur retourné par les boutons de la télécommande type MP3.
// Écrit par : René Ross
// Date : 2013-09-09
const unsigned long TelecommandeBoutonPower     = 16753245;
const unsigned long TelecommandeBoutonMode      = 16736925;
const unsigned long TelecommandeBoutonSon       = 16769565;
const unsigned long TelecommandeBoutonPlayPause = 16720605;
const unsigned long TelecommandeBoutonDebut     = 16712445;
const unsigned long TelecommandeBoutonFin       = 16761405;
const unsigned long TelecommandeBoutonEQ        = 16769055;
const unsigned long TelecommandeBoutonMoins     = 16754775;
const unsigned long TelecommandeBoutonPlus      = 16748655;
const unsigned long TelecommandeBouton0         = 16738455;
const unsigned long TelecommandeBoutonRecycle   = 16750695;
const unsigned long TelecommandeBoutonU_SD      = 16756815;
const unsigned long TelecommandeBouton1         = 16724175;
const unsigned long TelecommandeBouton2         = 16718055;
const unsigned long TelecommandeBouton3         = 16743045;
const unsigned long TelecommandeBouton4         = 16716015;
const unsigned long TelecommandeBouton5         = 16726215;
const unsigned long TelecommandeBouton6         = 16734885;
const unsigned long TelecommandeBouton7         = 16728765;
const unsigned long TelecommandeBouton8         = 16730805;
const unsigned long TelecommandeBouton9         = 16732845;
// Pour contenir la valeur du dernier bouton pressé.
unsigned long TelecommandeBoutonValeur = 0;
// Délai pour réduire la vitesse de réaction entre les lectures des boutons.
unsigned long TelecommandeTempsRebon   = 50;

Pour les notes de musique c’est (NotesDeMusique.h) :

// Référence : Cette liste a été adaptée à partir de la table situé ici :
// http://www.phy.mtu.edu/~suits/notefreqs.html
// Écrit par : René Ross
// Date : 2013-09-09
const float Note_C7  = 2093;   //C7
const float Note_D7  = 2349.32;//D7
const float Note_E7  = 2637.02;//E7
const float Note_F7  = 2793.83;//F7
const float Note_A7  = 3520;   //A7
const float Note_B7  = 3951.07;//B7

Est-ce vraiment plus clair pour vous ?

Cordialement,

L’ami René

terwal · April 8, 2026, 12:18pm

Pas tout a fait, tu es sur d'avoir utiliser les balises ? Car a la différence de ton post #2, il n'y a pas la coloration syntaxique. Sinon tu vois quand même une différence avec la présentation de ton message #10 ?


d'ailleurs il intéressant que tu édite ton message 10, pour ne pas laisser du code si peu lisible, quand pense tu ?

Topic		Replies	Views
Question pour un champion des IR Receiver VS1838B ? Français	23	758	August 12, 2024
Projet pour un étudiant en électromécanique Français	36	300	December 30, 2025
Can't figure out how to control servo with IR remote General Guidance	60	219	December 31, 2025
Commande de servos comme moteurs d'aiguillage Français	18	312	September 12, 2025
Compilation error: IRremote.h: No such file or directory Français	18	151	April 6, 2026

Il y a incompatibilité entre la bibliothèque « Servo.h » et « IRremote.h » et autres ?

Related topics