Code source autonome

Code source - Robot - Arduinobot - MegaRobotShieldUNO_L9110_N20_ServoGS90_4xIR

Voir vidéo : https://youtu.be/TdhUt5vo09w

Bonjour,

Ce tutoriel explique comment monter un circuit qui utilise entre autres :

L'éditeur compilateur Arduino 1.6.10.

1 x Arduino Mega 2560 R3 :

1 x Bouton-poussoir 2 pattes, rouge, "Push Button Switches" BPS-09, 250V/0.3A :

1 x Buzzer actif 5V noir de 3.5V à 5.5V Current 25mA; Fréquence de 500Hz à 2300Hz SKU-381747

1 x Capteur infra-rouge VS1838B (TSOP1838) :

1 x 4 Capteurs infra-rouges d'évitement d'obstacle, carte contrôleur et 16 câbles :

1 x Capteur ultrason (émetteur/récepteur) HR-SC04.

1 x Carte d'extension Protoshield avec le Conseil du Pain Mini pour Arduino SKU-120447

1 x Connecteur à Prise Baril 2.1mm, 30V/0.3A, femelle 3 brins fileté 1.4 cm avec écrou :

1 x Connecteur pour batterie 9 Volts avec cordons 6F22

1 x Contrôleur moteur L9110 pour 2 moteurs CC :

1 x Écran LCD LCD1602, 16 x 2, taille des caractères: 2.95x4.75, 5V :

16 x Entretoise Hexagonale en cuivre M3x10mm mâle-femelle fileté avec écroux et boulon 50 pièces 1 x 1 x Interrupteur "Switch" 6 pattes On/Off/On :

2 x Moteur DC à deux axes avec ratio de 1:48, 3V~6V, 100rpm avec ses roues jaunes

2 x Moteur DC et réducteur 6V 110rpm, GM15-N20VA-08220-150-10D, avec roues et fixation

2 x Condansateur 220 nF (224) pour les moteurs.

1 x Pile 9V 6LR61 :

1 x Radiateurs thermique en aluminium bleu (1.5 cm x 1.5 cm x 0.8 cm)

1 x Régulateur de voltage L7805CV, 5 Volts, In de 8 à 20 Volts, TO-220 :

1 x Roulette à Bille Tamiya (paire) RB-Tam-11 :

1 x Servomoteur Tower Pro SG-90 (Mini) de 4.8V à6.0V SKU-337848 :

1 x Télécommande type Mini MP3 :

1 x Transformateur 110V à 9V, 1A, câble 100cm pour Arduino :

Ce programme contrôle un véhicule robot à deux roues motrices et une série de capteurs pour se déplacer intelligemment en évitant les obstacles. Il utilise un capteur à ultrason, un servomoteur, deux moteurs à courant continu et des capteurs interrupteur infrarouges pour détecter son environnement. Une télécommande et un capteur infrarouge de type VS1838B qui permettent de le contrôler à distance et de modifier plusieurs de ses paramètres. Il est aussi activé par un bouton directement sur le bottier du robot. Sur un écran LCD et ou dans le moniteur série, il affiche des informations de base en temps réel. Une touche de la télécommande permet d'activer l'affichage sur le moniteur série (voir la "FONCTION GererBoutonTeleCommande", plus bas dans le présent code source). Pour ce qui est de la plage d'utilisation des moteurs qui est en fonction de la pile utilisée (6V,9V ou 12V), les paramètres des vitesses moteurs (Min., Max. et point mort de roulement différent de chaque moteur) permet un usage progressif de la puissance des moteurs et selon les données des capteurs.

En soi, le code source est très explicite et donne tous les détails requis pour son utilisation et le montage du circuit à réaliser.

Faites un copier-coller de ce code source dans l'éditeur Arduino et prenez le temps de le lire avant de l'exécuter, vous serez à même d'en apprécier toute la richesse et cela vous évitera bien des écueils.

Notez que le code source est plus lisible une fois copié dans l'éditeur Arduino. Ici la largeur d'une ligne de code n'est que de 40 à 50 caractères et le code source est mis en page pour une présentation sur 80 colonnes. Aussi, la coloration et la tabulation du code sont plus conforment et intéressantes dans l'éditeur Arduino. De ces faits, ici plusieurs lignes sont très difficiles a interpréter.

Attention, il y a trois fichiers qui compose ce programme à placer dans un même dossier :


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

Date : 2016-09-14

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 à deux roues motrices et une série de
capteurs pour se déplacer intelligemment en évitant les obstacles. Il utilise
un capteur à ultrason, un servomoteur, deux moteurs à courant continu et des
capteurs interrupteur infrarouges pour détecter son environnement. Une
télécommande et un capteur infrarouge de type VS1838B qui permettent de le
contrôler à distance et de modifier plusieurs de ses paramètres. Il est aussi
activé par un bouton directement sur le bottier du robot. Sur un écran LCD et
ou dans le moniteur série, il affiche des informations de base en temps réel.
Une touche de la télécommande permet d'activer l'affichage sur le moniteur
série (voir la "FONCTION GererBoutonTeleCommande", plus bas dans le présent
code source). Pour ce qui est de la plage d'utilisation des moteurs qui est en
fonction de la pile utilisée (6V, 9V ou 12V), les paramètres des vitesses
moteurs (Min., Max. et point mort de roulement différent de chaque moteur)
permet un usage progressif de la puissance des moteurs et selon les données
des capteurs.
*/

//*****************************************************************************

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

Liste alphabétique des composantes d'électroniques

1 x Arduino Mega 2560 R3 :
http://arduino.cc/en/Main/ArduinoBoardMega2560
http://www.dx.com/fr/p/mega2560-r3-atmega2560-16au-control-board-w-usb-cable-for-arduino-400944
http://www.dx.com/p/improved-funduino-mega-2560-r3-module-compatible-w-official-arduino-mega-2560-r3-blue-black-256335
http://www.dx.com/p/mega-2560-r3-atmega2560-16au-board-usb-cable-for-arduino-black-blue-215579

1 x Base pour Voiture est un contenant de plastique avec son couvercle (Base Dia. 130mm, couvercle 153mm Hauteur 66mm)
1 x Planche de bois (Pin) de 90x40x18 mm pour fixer les moteurs de roulement a la base.
1 x Élastique pour fixer le capteur à ultrason au servomoteur.

1 x Bouton-poussoir 2 pattes, rouge, "Push Button Switches" BPS-09, 250V/0.3A :
http://www.dx.com/p/bps-09-plastic-phosphor-bronze-0-3a-250v-push-button-switches-black-silver-red-10-pcs-257469

1 x Buzzer actif 5V noir de 3.5V à 5.5V Current 25mA; Fréquence de 500Hz à 2300Hz SKU-381747
http://www.dx.com/fr/p/5v-active-buzzers-black-10-pcs-381747

1 x Capteur infra-rouge VS1838B (TSOP1838) :
http://www.dipmicro.com/store/VS1838B
http://dx.com/p/hx1838-pc638-diy-universal-electronic-component-infrared-receiver-silver-20-pcs-158341
http://www.electrodragon.com/product/infrared-dev-kit-controllernec-type-and-hx1838-receiver/
http://www.amazon.com/NEOMART-Raspberry-Infrared-Control-Receiver/dp/B00CW8WUGA

1 x 4 Capteurs infra-rouges d'évitement d'obstacle, carte contrôleur et 16 câbles :
http://www.dx.com/p/4-channel-infrared-obstacle-avoidance-sensor-module-for-smart-car-blue-213608

1 x Capteur ultrason (émetteur/récepteur) HR-SC04.
http://dx.com/p/hc-sr04-ultrasonic-sensor-distance-measuring-module-133696
http://www.dx.com/fr/p/hc-sr04-ultrasonic-sensor-distance-measuring-modules-blue-4-pcs-400214
http://www.robotshop.com/ca/fr/module-sonar-hc-sr04.html

1 x Carte d'extension Protoshield avec le Conseil du Pain Mini pour Arduino SKU-120447
http://www.dx.com/fr/p/protoshield-expansion-board-with-mini-bread-board-for-arduino-duemilanove-2009-120447

1 x Connecteur à Prise Baril 2.1mm, 30V/0.3A, femelle 3 brins fileté 1.4 cm avec écrou :
http://www.dx.com/p/dc-jack-adapter-with-screw-thread-10-piece-pack-122741

1 x Connecteur pour batterie 9 Volts avec cordons 6F22
http://www.dx.com/fr/p/high-quality-9v-6f22-battery-holder-with-leads-black-312177

1 x Contrôleur moteur L9110 pour 2 moteurs CC :
http://www.dx.com/fr/p/l9110-2-channel-motor-driver-module-red-green-2-5-12v-216851
http://www.dx.com/fr/p/l9110s-2-ch-motro-driving-board-module-deep-blue-300477
http://www.dx.com/fr/p/l9110-dc-stepper-motor-driver-controller-board-for-arduino-153951
http://www.dx.com/fr/p/l9110-dual-channel-h-bridge-motor-driver-module-for-arduino-black-157149

1 x Écran LCD LCD1602, 16 x 2, taille des caractères: 2.95x4.75, 5V :
http://www.dx.com/fr/p/dofly-cg06ng025-1602-character-lcd-screen-green-275771#.V3WBge2RuV4
http://dx.com/p/1602a-16-x-2-lines-white-character-lcd-module-w-blue-backlight-dc-5v-151978

16 x Entretoise Hexagonale en cuivre M3x10mm mâle-femelle fileté avec écroux et boulon 50 pièces SKU-148717
http://www.dx.com/p/m3x10mm-6-copper-diy-binding-post-terminals-golden-50-piece-pcs-148717

1 x Boîte de 300 M3 Nylon noir Vis Hexagonale Nut Spacer Stand-off SKU-440668
http://www.dx.com/fr/p/m3-nylon-black-hex-screw-nut-spacer-stand-off-varied-length-300-pcs-440668
Type          Long        Qt
Écrues        M3          80
Vis           M3,10mm     80
Male-Femele   M3,6mmx6mm  20
Male-Femele   M3,8mmx6mm  20
Male-Femele   M3,10mmx6mm 20
Male-Femele   M3,12mmx6mm 10
Femele-Femele M3,6mm      20
Femele-Femele M3,8mm      20
Femele-Femele M3,10mm     20
Femele-Femele M3,12mm     10

1 x Interrupteur "Switch" 6 pattes On/Off/On :
http://www.dx.com/fr/p/electrical-diy-power-control-6-pin-toggle-switch-red-silver-5-piece-pack-146106

2 x Moteur DC à deux axes avec ratio de 1:48, 3V~6V, 100rpm avec ses roues jaunes
http://www.dx.com/fr/p/tt-02-diy-car-model-tt-motor-encoder-w-wheel-black-yellow-257135
http://www.dx.com/p/dual-axis-reducer-motor-for-smart-tt-car-yellow-silver-dc-3-6v-185017
http://www.dx.com/p/diy-tt-motor-wheel-for-four-wheel-drive-car-model-yellow-black-66mm-diameter-4-pcs-222634
http://www.dx.com/fr/p/tt-02-diy-car-model-tt-motor-encoder-w-wheel-black-yellow-257135

2 x Moteur DC et réducteur 6V 110rpm, GM15-N20VA-08220-150-10D, avec roues et fixation SKU-379464
http://www.dx.com/fr/p/diy-dc-6-0v-110rpm-gear-motor-with-mounting-bracket-rubber-tire-black-379464

2 x Condansateur 220 nF (224) pour les moteurs.
http://www.dx.com/fr/p/hongyang-20pf-105-1uf-50v-leaded-multilayer-ceramic-capacitor-10-x18-pcs-303275

1 x Pile 9V 6LR61 :
http://www.dx.com/p/duracell-9v-mn1604-6lr61-alkaline-battery-gold-black-101015

1 x Radiateurs thermique en aluminium bleu (1.5 cm x 1.5 cm x 0.8 cm) SKU-376917
http://www.dx.com/fr/p/aluminum-flash-memory-heat-dissipation-heatsinks-blue-8-pcs-376917

1 x Régulateur de voltage L7805CV, 5 Volts, In de 8 à 20 Volts, TO-220 :
http://www.dx.com/fr/p/jtron-l7805cv-three-terminal-voltage-stabilizer-silver-black-10-pcs-375926

1 x Roulette à Bille Tamiya (paire) RB-Tam-11  :
http://octopart.com/70144-tamiya-7986354
http://proto-pic.co.uk/tamiya-70144-ball-caster-kit-2-casters/
http://www.robotshop.com/ca/fr/ball-caster-tamiya.html

1 x Servomoteur Tower Pro SG-90 (Mini) de 4.8V à6.0V SKU-337848 :
http://www.dx.com/fr/p/sg90-universal-9g-servo-motors-w-accessories-for-r-c-robot-helicopter-blue-yellow-10-pcs-337848
http://www.dx.com/fr/p/towerpro-sg90-9g-mini-servo-with-accessories-12859
http://www.dx.com/fr/p/towerpro-sg90-mini-plastic-gear-steering-servo-3-pcs-set-187776
http://www.dx.com/fr/p/tower-pro-sg90-9g-gear-steering-servo-6-pcs-188549

1 x Télécommande type Mini MP3 :
http://dx.com/p/ir-remote-control-diy-kit-for-arduino-1-x-cr2025-136284

1 x Transformateur 110V à 9V, 1A, câble 100cm pour Arduino :
http://dx.com/p/Arduino-9v-1a-power-adapter-black-2-flat-pin-plug-100cm-cable-126288

Et des petits câbles électriques et connecteurs appropriés (Réf. : MB-940,
MB-910, MB-900, MB-102J, LS-MMPJ-6, LS-FFPJ-6, etc.).

Condensateurs céramiques baige 18 x 10 pièces 50V SKU-303275
http://www.dx.com/fr/p/hongyang-20pf-105-1uf-50v-leaded-multilayer-ceramic-capacitor-10-x18-pcs-303275
Condensateurs céramiques bleu 10 x 10 pièces 2KV SKU-354587
http://www.dx.com/fr/p/2-pin-ceramic-capacitors-set-blue-1100-pcs-354587
Fils de raccordement mâle/femelle 20cm (600 pièces, 6 couleurs x 100) :
http://www.dx.com/fr/p/tenying-1-pin-male-to-female-jumper-wire-dupont-cable-for-arduino-random-color-600-pcs-20cm-312541
Fils de raccordement mâle/mâle 20cm (600 pièces, 6 couleurs x 100) :
http://www.dx.com/fr/p/tenying-1-pin-male-to-male-jumper-wire-dupont-cable-for-arduino-random-color-600-pcs-20cm-312963
Paquet de 70 fils mâle/mâle de couleurs diverses(50x12cm, 10x15cm, 5x20cm, 5x24cm) :
http://dx.com/p/breadboard-jumper-wires-for-electronic-diy-70-cable-pack-80208
Fils de raccordement femelle/femelle 20cm (nappe de 10 couleurs, 40 fils)) :
http://dx.com/p/dupont-line-1p-1p-40-pack-20cm-length-121338
Fils de raccordement femelle/femelle 20cm (nappe de 10 couleurs, 40 fils)) :
http://dx.com/p/male-to-female-dupont-breadboard-jumper-wires-for-arduino-40-piece-pack-20cm-length-146935
Tête de connecteurs 2,54mm 1x40 Pin Breakaway, têtes droites (10 pièces x 40 broches) :
http://www.dx.com/p/2-54mm-1x40-pin-breakaway-straight-male-header-10-piece-pack-144191
Résistance de 1/4 Watt/1%, 1400 pièces (200 x : 10Ω, 47Ω, 100Ω, 150Ω, 220Ω, 470Ω, 330Ω:
http://www.dx.com/fr/p/1-4w-resistance-aluminum-film-resistors-multicolored-1400-pcs-298169
Résistance de 1/4 Watt/5% 270 pièces, 10 x 27 types : 100Ω, 110Ω, 130Ω, 160Ω,
180Ω, 200Ω, 220Ω, 240Ω, 270Ω, 300Ω, 330Ω, 360Ω, 390Ω, 430Ω, 510Ω, 560Ω, 680Ω, 750Ω,
820Ω, 910Ω, 1KΩ, 1.2KΩ, 1.5KΩ, 1.8KΩ, 2KΩ, 2.2KΩ, 2.4KΩ :
http://dx.com/p/jtron-1-4w-colored-ring-resistor-pack-100-ohm-2k-27-kinds-10-pcs-blue-sliver-270-pcs-288760
Autres liens en rapport avec le sujet :
http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ArduinoExpertSerie2
http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ArduinoExpertSerieCanTerminalPC
*/

//*****************************************************************************

//*****************************************************************************
// 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.
*/

/*
Câblage complet de l'Arduino avec les composantes du montage :

ARDUINO_USB                   = Par câble USB a un ordinateur
ARDUINO_PWR12V                =

ARDUINO_J0_1_RESET            = ARDUINO_JA2_8_A0
ARDUINO_J0_2_3_3V             =
ARDUINO_J0_3_5V_1             =
ARDUINO_J0_4_GND1             =
ARDUINO_J0_5_GND2             = BATTERIE_1_MOINS
ARDUINO_J0_6_VIN              = INTERRUPTEUR_1_BROCHE_2

ARDUINO_JA2_8_A0              = ARDUINO_J0_1_RESET (Kamikaze par télécommande)
ARDUINO_JA2_7_A1              =
ARDUINO_JA2_6_A2              =
ARDUINO_JA2_5_A3              =
ARDUINO_JA2_4_A4              =
ARDUINO_JA2_3_A5              =
ARDUINO_JA2_2_A6              =
ARDUINO_JA2_1_A7              =

ARDUINO_JA1_1_A8              = CONTROLE_IR_1_DO1
ARDUINO_JA1_2_A9              = CONTROLE_IR_1_DO2
ARDUINO_JA1_3_A10             = CONTROLE_IR_1_DO3
ARDUINO_JA1_4_A11             = CONTROLE_IR_1_DO4
ARDUINO_JA1_5_A12             = CONTROLE_MOTEUR_1_IN2
ARDUINO_JA1_6_A13             = CONTROLE_MOTEUR_1_IN1
ARDUINO_JA1_7_A14             = CONTROLE_MOTEUR_1_IN4
ARDUINO_JA1_8_A15             = CONTROLE_MOTEUR_1_IN3

ARDUINO_JP2_G2_GND5           =
ARDUINO_JP2_G1_GND4           =
ARDUINO_JP2_1_SS_CS_53        =
ARDUINO_JP2_3_SCK_52          =
ARDUINO_JP2_3_MOSI_51         =
ARDUINO_JP2_4_MISO_50         =
ARDUINO_JP2_5_49              =
ARDUINO_JP2_6_48              =
ARDUINO_JP2_7_47              = CAPTEUR_IR_0_OUT
ARDUINO_JP2_8_PWM_46          =
ARDUINO_JP2_9_PWM_45          =
ARDUINO_JP2_10_PWM_44         =
ARDUINO_JP2_11_43             =
ARDUINO_JP2_12_42             =
ARDUINO_JP2_13_41             =
ARDUINO_JP2_14_40             =
ARDUINO_JP2_15_39             =
ARDUINO_JP2_16_38             =
ARDUINO_JP1_1_37              =
ARDUINO_JP1_2_36              =
ARDUINO_JP1_3_35              =
ARDUINO_JP1_4_34              =
ARDUINO_JP1_5_33              =
ARDUINO_JP1_6_32              =
ARDUINO_JP1_7_31              =
ARDUINO_JP1_8_30              =
ARDUINO_JP1_9_29              =
ARDUINO_JP1_10_28             =
ARDUINO_JP1_11_27             =
ARDUINO_JP1_12_26             =
ARDUINO_JP1_13_25             =
ARDUINO_JP1_14_24             =
ARDUINO_JP1_15_23             =
ARDUINO_JP1_16_22             = RESISTANCE_100_Om_1_1, CABLE_PINCE_1_1, BOUTON_1_2
ARDUINO_JP1_V2_5V_3           = CABLE_PINCE_1_2
ARDUINO_JP1_V1_5V_2           =

ARDUINO_JC_1_SCL_INT2_21      =
ARDUINO_JC_2_SDA_INT3_20      =
ARDUINO_JC_3_RX1_INT4_19      =
ARDUINO_JC_4_TX1_INT5_18      =
ARDUINO_JC_5_RX2_17           =
ARDUINO_JC_6_TX2_16           =
ARDUINO_JC_7_RX3_15           =
ARDUINO_JC_8_TX3_14           =

ARDUINO_JL_1_PWM_RX0_0        =
ARDUINO_JL_2_PWM_TX0_1        =
ARDUINO_JL_3_PWM_INT0_2       = SONAR_1_ECHO
ARDUINO_JL_4_PWM_INT1_3       = SONAR_1_TRIG
ARDUINO_JL_5_PWM_4            = LCD_1_D4
ARDUINO_JL_6_PWM_5            = LCD_1_D5
ARDUINO_JL_7_PWM_6            = LCD_1_D6
ARDUINO_JL_8_PWM_7            = LCD_1_D7

ARDUINO_JH_1_PWM_8            = LCD_1_RS
ARDUINO_JH_2_PWM_9            = LCD_1_E
ARDUINO_JH_3_PWM_10           = SERVOMOTEUR_1_IN
ARDUINO_JH_4_PWM_11           =
ARDUINO_JH_5_PWM_12           = BUZZER_1_VIN
ARDUINO_JH_6_DEL_PWM_13       =
ARDUINO_JH_7_GND3             = BUZZER_1_GND
ARDUINO_JH_8_AREF             =

ARDUINO_ICSP1_1_MISO          =
ARDUINO_ICSP1_2_5V            =
ARDUINO_ICSP1_3_SCK           =
ARDUINO_ICSP1_4_MOSI          =
ARDUINO_ICSP1_5_RESET         =
ARDUINO_ICSP1_6_GND           =

ARDUINO_ICSP2_1_MISO          =
ARDUINO_ICSP2_2_5V            =
ARDUINO_ICSP2_3_SCK           =
ARDUINO_ICSP2_4_MOSI          =
ARDUINO_ICSP2_5_RESET         =
ARDUINO_ICSP2_6_GND           =

Câblage pour la batterie (de 6V~12V) :

BATTERIE_1_PLUS               = INTERRUPTEUR_1_BROCHE_1
BATTERIE_1_MOINS              = PRISE_JACK_1_GND, ARDUINO_J0_5_GND2

Câblage pour le bouton du capot :

BOUTON_1_1                    = BOUCLIER_UNO+5V
BOUTON_1_2                    = CABLE_PINCE_1_1
BOUTON_1_3                    =
BOUTON_1_4                    =
CABLE_PINCE_1_1               = RESISTANCE_100_Om_1_1
CABLE_PINCE_1_2               = ARDUINO_JP1_V2_5V_3
RESISTANCE_100_Om_1_1         = ARDUINO_JP1_16_22
RESISTANCE_100_Om_1_2         = CABLE_PINCE_1_2

Câblage pour le Buzzer :

BUZZER_1_VIN                  = ARDUINO_JH_5_PWM_12
BUZZER_1_GND                  = ARDUINO_JH_7_GND3

Câblage pour le capteur infrarouge utiliser avec la télécommande, sur le capot :

CAPTEUR_IR_0_OUT              = ARDUINO_JP2_7_47
CAPTEUR_IR_0_GND              = BOUCLIER_UNO_GND
CAPTEUR_IR_0_VIN              = BOUCLIER_UNO_5V

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

CAPTEUR_IR_1_OUT              = ARDUINO_A8
CAPTEUR_IR_1_VIN              = BOUCLIER_UNO_5V
CAPTEUR_IR_1_GND              = BOUCLIER_UNO_GND

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

CAPTEUR_IR_2_OUT              = ARDUINO_A9
CAPTEUR_IR_2_VIN              = BOUCLIER_UNO_5V
CAPTEUR_IR_2_GND              = BOUCLIER_UNO_GND

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

CAPTEUR_IR_3_OUT              = ARDUINO_A10
CAPTEUR_IR_3_VIN              = BOUCLIER_UNO_5V
CAPTEUR_IR_3_GND              = BOUCLIER_UNO_GND

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

CAPTEUR_IR_4_OUT              = ARDUINO_A11
CAPTEUR_IR_4_VIN              = BOUCLIER_UNO_5V
CAPTEUR_IR_4_GND              = BOUCLIER_UNO_GND

Câblage pour les deux moteur DC 6V 77RPM sur la :

CONTROLE_MOTEUR_1_VIN         = INTERRUPTEUR_1_BROCHE_2, INTERRUPTEUR_1_BROCHE_5
CONTROLE_MOTEUR_1_GND         = BATTERIE_1_MOINS
CONTROLE_MOTEUR_1_A_A         = ARDUINO_JA1_6_A13
CONTROLE_MOTEUR_1_A_B         = ARDUINO_JA1_6_A12
CONTROLE_MOTEUR_1_B_A         = ARDUINO_JA1_6_A15
CONTROLE_MOTEUR_1_B_B         = ARDUINO_JA1_6_A14
CONTROLE_MOTEUR_1_OUT1        = MOTEUR_1_PLUS
CONTROLE_MOTEUR_1_OUT2        = MOTEUR_1_MOINS
CONTROLE_MOTEUR_1_OUT3        = MOTEUR_2_PLUS
CONTROLE_MOTEUR_1_OUT4        = MOTEUR_1_MOINS

Câblage pour la prise Jack du capot :

PRISE_JACK_1_GND              = BATTERIE_1_MOINS
PRISE_JACK_1_PLUS             = INTERRUPTEUR_1_BROCHE_5
PRISE_JACK_1_MOINS            =

Câblage pour l'interrupteur capot :

INTERRUPTEUR_1_BROCHE_1       = BATTERIE_1_PLUS
INTERRUPTEUR_1_BROCHE_2       = INTERRUPTEUR_1_BROCHE_5, ARDUINO_J0_6_VIN, CONTROLE_MOTEUR_1_VIN
INTERRUPTEUR_1_BROCHE_3       =
INTERRUPTEUR_1_BROCHE_4       = PRISE_JACK_1_PLUS
INTERRUPTEUR_1_BROCHE_5       = INTERRUPTEUR_1_BROCHE_2, ARDUINO_J0_6_VIN, CONTROLE_MOTEUR_1_VIN
INTERRUPTEUR_1_BROCHE_6       =

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            = BOUCLIER_UNO_LCD_VSS
LCD_1_VDD broche 2            = BOUCLIER_UNO_LCD_VDD
LCD_1_VO  broche 3            = BOUCLIER_UNO_LCD_VO
LCD_1_RS  broche 4            = BOUCLIER_UNO_LCD_RS
LCD_1_RW  broche 5            = BOUCLIER_UNO_LCD_RW
LCD_1_E   broche 6            = BOUCLIER_UNO_LCD_E
LCD_1_D0  broche 7            =
LCD_1_D1  broche 8            =
LCD_1_D2  broche 9            =
LCD_1_D3  broche 10           =
LCD_1_D4  broche 11           = BOUCLIER_UNO_LCD_D4
LCD_1_D5  broche 12           = BOUCLIER_UNO_LCD_D5
LCD_1_D6  broche 13           = BOUCLIER_UNO_LCD_D6
LCD_1_D7  broche 14           = BOUCLIER_UNO_LCD_D7
LCD_1_A   broche 15           = BOUCLIER_UNO_LCD_A
LCD_1_K   broche 16           = BOUCLIER_UNO_LCD_K

Câblage pour les moteurs de roulement et leur condansateur :

MOTEUR_1_PLUS                 = CONDANSATEUR_220nF_1_PLUS, CONTROLE_MOTEUR_1_OUT1
MOTEUR_1_MOINS                = CONDANSATEUR_220nF_1_MOINS, CONTROLE_MOTEUR_1_OUT2
CONDANSATEUR_220nF_1_PLUS     = MOTEUR_1_PLUS
CONDANSATEUR_220nF_1_MOINS    = MOTEUR_1_MOINS

MOTEUR_2_PLUS                 = CONDANSATEUR_220nF_2_PLUS, CONTROLE_MOTEUR_1_OUT3
MOTEUR_2_MOINS                = CONDANSATEUR_220nF_2_MOINS, CONTROLE_MOTEUR_1_OUT4
CONDANSATEUR_220nF_2_PLUS     = MOTEUR_2_PLUS
CONDANSATEUR_220nF_2_MOINS    = MOTEUR_2_MOINS

Câblage pour le servo moteur 1 de la :

SERVOMOTEUR_1_GND             = BOUCLIER_UNO_GND
SERVOMOTEUR_1_VIN             = BOUCLIER_UNO_PLUS
SERVOMOTEUR_1_IN              = ARDUINO_JH_3_PWM_10

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

SONAR_1_VCC                   = BOUCLIER_UNO_PLUS
SONAR_1_TRIG                  = ARDUINO_JL_4_PWM_INT1_3
SONAR_1_ECHO                  = ARDUINO_JL_3_PWM_INT0_2
SONAR_1_GND                   = BOUCLIER_UNO_GND
*/

//*****************************************************************************

//*****************************************************************************
// Inclusion des librairies utilisées.
//*****************************************************************************
#include "IRremote.h"
/*
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 "Servo.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.
//*****************************************************************************
// En prévision d'un ARDUINO_RESET par télécommande ou bouton du capot.
const byte ARDUINO_RESET                = A0;

// Pour gérer l'action d'humains sur le bouton du capot.
const byte BOUTON_1_OUT                 = 22;

// Câblage pour le Buzzer sur 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             = 47;

// Broche des capteurs de distance infra-rouge 1 a 4 :
const byte CAPTEUR_IR_1_OUT             = A8;// Avant gauche.
const byte CAPTEUR_IR_2_OUT             = A9;// Arriere gauche.
const byte CAPTEUR_IR_3_OUT             = A10;// Arriere droite.
const byte CAPTEUR_IR_4_OUT             = A11;// Avant droite.

// Broche d'Arduino pour le controleur moteur 1 (double Pont en H).
const byte CONTROLE_MOTEUR_1_IN1        = A13;
const byte CONTROLE_MOTEUR_1_IN2        = A12;
const byte CONTROLE_MOTEUR_1_IN3        = A15;
const byte CONTROLE_MOTEUR_1_IN4        = A14;

// Câblage pour la DEL sur l'Arduino
const byte DEL_1_VIN                    = 13;

// Constantes des broches sur l'Arduino pour une carte LCD1602.
const byte LCD_1_RS                     = 8;// Écran LCD.
const byte LCD_1_E                      = 9;// Écran LCD.
const byte LCD_1_D4                     = 4;// Écran LCD.
const byte LCD_1_D5                     = 5;// Écran LCD.
const byte LCD_1_D6                     = 6;// Écran LCD.
const byte LCD_1_D7                     = 7;// Écran LCD.

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

// Broche d'Arduino pour le capteur a ultrason 2, le sonar.
const byte SONAR_1_TRIG                 = 3;
const byte SONAR_1_ECHO                 = 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  = 1.0;
const word MOTEUR_1_VITESSE_MINIMUM     = 120;// 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.
int BoutonTempsRebon                    = 50;

// Pour les 4 capteurs infrarouge de distabces aux 4 voins du véhicule.
int CapteursIR_1_Valeur                 = 0;// Avant Gauche.
int CapteursIR_2_Valeur                 = 0;// Arriere Gauche.
int CapteursIR_3_Valeur                 = 0;// Arriere Droite.
int CapteursIR_4_Valeur                 = 0;// Avant Droite.
int CapteursInfrarougesCoupure          = 512;// Valeure limites de 0 à 1023.

// 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                   = 42;

// 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;// En degré
// La valeur pour le temps requis pour les changements 1° d'angle.
int Servomoteur_1_Delai_1_Degre         = 10;// En milliseconde.
// 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;

// 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       = 400;// En centimètre.
// 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;
// Pour contrer l'imprécission des echos sonars, plusieur lectures pour une moyene.
int Sonar_1_NombreDeLecture             = 2;

// Variable des distances conditionnant les mouvements du robot.
int Distance1                           = 15;// En centimètre.
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       = 250;// En milliseconde.
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.
Servo 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);
  if (Moteur_1_Vitesse < Moteur_1_PointMort)
  {
    Moteur_1_Vitesse = Moteur_1_PointMort;
  }

  Moteur_2_Vitesse = map (Sonar_1_DistanceActuele, 0, Sonar_1_DistanceValideMaximum,
                          Moteur_2_PointMort, MOTEUR_2_VITESSE_MAXIMUM);
  if (Moteur_2_Vitesse < Moteur_2_PointMort)
  {
    Moteur_2_Vitesse = Moteur_2_PointMort;
  }

  if (Moteur_1_Vitesse > MOTEUR_1_VITESSE_MAXIMUM)
  {
    Moteur_1_Vitesse = MOTEUR_1_VITESSE_MAXIMUM;
  }

  if (Moteur_2_Vitesse > MOTEUR_2_VITESSE_MAXIMUM)
  {
    Moteur_2_Vitesse = MOTEUR_2_VITESSE_MAXIMUM;
  }
}
//*****************************************************************************

//*****************************************************************************
// FONCTION DeplacementAvancer
//*****************************************************************************
void DeplacementAvancer ()
{
  AjusterVitesseDesMoteurs ();

  // Pour le moteur 1.
  digitalWrite (CONTROLE_MOTEUR_1_IN1, HAUT);
  digitalWrite (CONTROLE_MOTEUR_1_IN2, BAS);
  // Pour le moteur 2.
  digitalWrite (CONTROLE_MOTEUR_1_IN3, HAUT);
  digitalWrite (CONTROLE_MOTEUR_1_IN4, BAS);
}
//*****************************************************************************

//*****************************************************************************
// 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);
  // Pour le moteur 2.
  digitalWrite (CONTROLE_MOTEUR_1_IN3, BAS);
  digitalWrite (CONTROLE_MOTEUR_1_IN4, BAS);
}
//*****************************************************************************

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

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

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

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

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

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

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

//*****************************************************************************
// FONCTION GererAfficherMoniteurSerie
//*****************************************************************************
void GererAfficherMoniteurSerie ()
{
  // Écriture dans le moniteur série de l'IDE d'Arduino des valeurs lues.
  Serial.print ("***********************************************************");
  Serial.println ();
  Serial.print (" TempsActuele = ");
  Serial.print (TempsActuele);
  Serial.println ();
  Serial.print ("*              : Distance : Angle");
  Serial.println ();
  Serial.print ("* Actueles     :   ");
  Serial.print (Sonar_1_DistanceActuele);
  Serial.print (" : ");
  Serial.print (Servomoteur_1_Angle);
  Serial.println ();
  Serial.print ("* Max. Trouver :   ");
  Serial.print (Sonar_1_DistanceMaximumTrouve);
  Serial.print (" : ");
  Serial.print (Sonar_1_DistanceMaximumTrouveAngle);
  Serial.println ();
  Serial.print ("* CapteursIR_1_Valeur           : ");
  Serial.print (CapteursIR_1_Valeur);
  Serial.println ();
  Serial.print ("* CapteursIR_2_Valeur           : ");
  Serial.print (CapteursIR_2_Valeur);
  Serial.println ();
  Serial.print ("* CapteursIR_3_Valeur           : ");
  Serial.print (CapteursIR_3_Valeur);
  Serial.println ();
  Serial.print ("* CapteursIR_4_Valeur           : ");
  Serial.print (CapteursIR_4_Valeur);
  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 ("* CodeSituation           = ");
  Serial.print (CodeSituation);
  Serial.println ();
}
//*****************************************************************************

//*****************************************************************************
// FONCTION GererAfficherEcranLCD
//*****************************************************************************
void GererAfficherEcranLCD ()
{
  // Écriture dans l'écran LCD des valeurs lues.
  // NoColonne 0123456789012345
  // Ligne 0 = 255 400 180 8888
  // Ligne 1 = 255 400 180   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 (Servomoteur_1_Angle);
  LCD_1.setCursor (12,0);
  LCD_1.print (map (CapteursIR_1_Valeur, 0, 1023, 0, 9));
  LCD_1.setCursor (13,0);
  LCD_1.print (map (CapteursIR_2_Valeur, 0, 1023, 0, 9));
  LCD_1.setCursor (14,0);
  LCD_1.print (map (CapteursIR_3_Valeur, 0, 1023, 0, 9));
  LCD_1.setCursor (15,0);
  LCD_1.print (map (CapteursIR_4_Valeur, 0, 1023, 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 (8,1);
  LCD_1.print (Sonar_1_DistanceMaximumTrouveAngle);
  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        :
Moins     : Diminuer l'angle verticale de un degré pour le sonar.
Plus      : augmente l'angle verticale de un degré pour le sonar.
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)
      {
        Boucler = NON;
        digitalWrite (DEL_1_VIN, Boucler);
        CodeSituation = 75;
        DeplacementArreter ();
      }
      else
      {
        Boucler = OUI;
        digitalWrite (DEL_1_VIN, Boucler);
        CodeSituation = 76;
      }
      break;
    case TelecommandeBoutonMode:
      Serial.print ("* TelecommandeBoutonMode = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 77;
      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:
      Serial.print ("* TelecommandeBoutonSon = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 78;
      Bip_1 ();
      break;
    case TelecommandeBoutonPlayPause:
      Serial.print ("* TelecommandeBoutonPlayPause = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      Bip_1 ();
      if (Boucler == OUI)
      {
        DeplacementArreter ();
        Boucler = NON;
        digitalWrite (DEL_1_VIN, Boucler);
        Serial.print ("* En attente d'une action d'humaine");
        Serial.println ();
        CodeSituation = 79;
      }
      else
      {
        Boucler = OUI;
        digitalWrite (DEL_1_VIN, Boucler);
        Serial.print ("* Poursuite du programme");
        Serial.println ();
        CodeSituation = 80;
      }
      break;
    case TelecommandeBoutonDebut:
      Serial.print ("* TelecommandeBoutonDebut = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 81;
      Bip_1 ();
      break;
    case TelecommandeBoutonFin:
      Serial.print ("* TelecommandeBoutonFin = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 82;
      Bip_1 ();
      break;
    case TelecommandeBoutonEQ:
      Serial.print ("* TelecommandeBoutonEQ = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 83;
      Bip_1 ();
      break;
    case TelecommandeBoutonMoins:
      Serial.print ("* TelecommandeBoutonMoins = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 84;
      Bip_1 ();
      break;
    case TelecommandeBoutonPlus:
      Serial.print ("* TelecommandeBoutonPlus = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 85;
      Bip_1 ();
      break;
    case TelecommandeBouton0:
      Serial.print ("* TelecommandeBouton0 = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 86;
      Bip_1 ();
      break;
    case TelecommandeBoutonRecycle:
      Serial.print ("* TelecommandeBoutonRecycle = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 87;
      Bip_1 ();
      break;
    case TelecommandeBoutonU_SD:
      Serial.print ("* TelecommandeBoutonU_SD = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 88;
      Bip_1 ();
      break;
    case TelecommandeBouton1:
      Serial.print ("* TelecommandeBouton1 = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 89;
      Bip_1 ();
      DeplacementAvancerGauche ();
      Boucler = NON;
      digitalWrite (DEL_1_VIN, Boucler);
      break;
    case TelecommandeBouton2:
      Serial.print ("* TelecommandeBouton2 = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 90;
      Bip_1 ();
      DeplacementAvancer ();
      Boucler = NON;
      digitalWrite (DEL_1_VIN, Boucler);
      break;
    case TelecommandeBouton3:
      Serial.print ("* TelecommandeBouton3 = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 91;
      Bip_1 ();
      DeplacementAvancerDroite ();
      Boucler = NON;
      digitalWrite (DEL_1_VIN, Boucler);
      break;
    case TelecommandeBouton4:
      Serial.print ("* TelecommandeBouton4 = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 92;
      Bip_1 ();
      DeplacementPivoterGauche ();
      Boucler = NON;
      digitalWrite (DEL_1_VIN, Boucler);
      break;
    case TelecommandeBouton5:
      Serial.print ("* TelecommandeBouton5 = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 93;
      Bip_1 ();
      DeplacementArreter ();
      Boucler = NON;
      digitalWrite (DEL_1_VIN, Boucler);
      break;
    case TelecommandeBouton6:
      Serial.print ("* TelecommandeBouton6 = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 94;
      Bip_1 ();
      DeplacementPivoterDroite ();
      Boucler = NON;
      digitalWrite (DEL_1_VIN, Boucler);
      break;
    case TelecommandeBouton7:
      Serial.print ("* TelecommandeBouton7 = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 95;
      Bip_1 ();
      DeplacementReculerGauche ();
      Boucler = NON;
      digitalWrite (DEL_1_VIN, Boucler);
      break;
    case TelecommandeBouton8:
      Serial.print ("* TelecommandeBouton8 = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 96;
      Bip_1 ();
      DeplacementReculer ();
      Boucler = NON;
      digitalWrite (DEL_1_VIN, Boucler);
      break;
    case TelecommandeBouton9:
      Serial.print ("* TelecommandeBouton9 = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 97;
      Bip_1 ();
      DeplacementReculerDroite ();
      Boucler = NON;
      digitalWrite (DEL_1_VIN, Boucler);
      break;
    default:
      Serial.print ("* Code de telecommande infrarouge inconnu = ");
      Serial.print (TelecommandeBoutonValeur);
      Serial.println ();
      CodeSituation = 98;
      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 CapteursInfrarouges
//*****************************************************************************
void CapteursInfrarouges ()
{
  CapteursIR_1_Valeur = analogRead (CAPTEUR_IR_1_OUT);
  CapteursIR_2_Valeur = analogRead (CAPTEUR_IR_2_OUT);
  CapteursIR_3_Valeur = analogRead (CAPTEUR_IR_3_OUT);
  CapteursIR_4_Valeur = analogRead (CAPTEUR_IR_4_OUT);
}
//*****************************************************************************

//*****************************************************************************
// 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;
  }
  if (Sonar_1_DistanceActuele < 0)
  {
    Sonar_1_DistanceActuele = 0;
  }
}
//*****************************************************************************

//*****************************************************************************
// FONCTION CapteurUltrasonLecture
//*****************************************************************************
void CapteurUltrasonLectures ()
{
  // Pour contrer l'imprécission des echos sonars, plus d'une lecture...
  int MoyenneDistanceEcho1 = 0;
  long TotalDistanceEcho1 = 0;

  for (int i = 0; i < Sonar_1_NombreDeLecture; i = i + 1)
  {
    CapteurUltrasonUneLecture ();
    TotalDistanceEcho1 = TotalDistanceEcho1 + Sonar_1_DistanceActuele;
  }

  MoyenneDistanceEcho1 = int (round (TotalDistanceEcho1 / Sonar_1_NombreDeLecture));
  Sonar_1_DistanceActuele = MoyenneDistanceEcho1;
}
//*****************************************************************************

//*****************************************************************************
// 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 GererDeplacements
//*****************************************************************************
void GererDeplacements ()
{
  CapteurUltrasonLectures ();
  CapteursInfrarouges ();
  AjusterVitesseDesMoteurs ();

  if (CapteursIR_1_Valeur < CapteursInfrarougesCoupure)
  {
    CodeSituation = 1;
    DeplacementPivoterDroite ();
  }

  else if (CapteursIR_2_Valeur < CapteursInfrarougesCoupure)
  {
    CodeSituation = 2;
    DeplacementPivoterGauche ();
  }

  else if (CapteursIR_3_Valeur < CapteursInfrarougesCoupure)
  {
    CodeSituation = 3;
    DeplacementAvancerGauche ();
  }

  else if (CapteursIR_4_Valeur < CapteursInfrarougesCoupure)
  {
    CodeSituation = 4;
    DeplacementAvancerDroite ();
  }

  else if (Sonar_1_DistanceActuele <= Distance1)
  {
    CodeSituation = 5;
    DeplacementArreter ();
    TrouverPlusGrandDegagement ();
  }

  else if ((Sonar_1_DistanceActuele > Distance1) and
           (Sonar_1_DistanceActuele <= Distance2))
  {
    CodeSituation = 6;
    Moteur_1_Vitesse = Moteur_1_PointMort;
    Moteur_2_Vitesse = Moteur_2_PointMort;
    DeplacementAvancer ();
  }

  else if ((Sonar_1_DistanceActuele > Distance2) and
           (Sonar_1_DistanceActuele <= Distance3))
  {
    CodeSituation = 7;
    Moteur_1_Vitesse = MOTEUR_1_VITESSE_MAXIMUM;
    Moteur_2_Vitesse = MOTEUR_2_VITESSE_MAXIMUM;
    DeplacementAvancer ();
  }

  else if ((Sonar_1_DistanceActuele > Distance3) and
           (Sonar_1_DistanceActuele <= Distance4))
  {
    CodeSituation = 8;
    Moteur_1_Vitesse = MOTEUR_1_VITESSE_MAXIMUM;
    Moteur_2_Vitesse = MOTEUR_2_VITESSE_MAXIMUM;
    DeplacementAvancer ();
  }

  else if (Sonar_1_DistanceActuele > Distance4)
  {
    CodeSituation = 9;
  }

  else
  {
    CodeSituation = 99;
  }
}
//*****************************************************************************

//*****************************************************************************
// 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.
  // IMPORTANT : régler le terminal côté PC avec la même valeur de
  // transmission.
  Serial.begin (115200);
  Serial.println ();
  Serial.println ();
  Serial.print ("***********************************************************");
  Serial.println ();
  Serial.print ("*                     ");
  Serial.print (NOM_DU_PROGRAMME);
  Serial.print ("                    *");
  Serial.println ();
  Serial.print ("*   Debut de la procedure d'initialisation du systeme...  *");
  Serial.println ();
  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_ET_RESISTENCE_INTERNE);
  // 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.
  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 ();

  // Pour l'éventualité ou l'on utilise le robot en mode télécommander.
  AjusterVitesseDesMoteurs ();

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

  // 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);
  pinMode (CONTROLE_MOTEUR_1_IN2, SORTIE);
  pinMode (CONTROLE_MOTEUR_1_IN3, SORTIE);
  pinMode (CONTROLE_MOTEUR_1_IN4, SORTIE);
  Serial.print ("* Broches du controleur des moteurs activer               *");
  Serial.println ();
  LCD_1.setCursor (0,1);
  LCD_1.print ("CONTROLE_MOTEUR_");

  // 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);
  Serial.print ("* Broches des capteurs de proximite activer               *");
  Serial.println ();
  LCD_1.setCursor (0,1);
  LCD_1.print ("CAPTEUR_IR_4_O");

  // Initialisation des servomoteur du sonar 1.
  Servomoteur_1.attach (SERVOMOTEUR_1_IN,
                        Servomoteur_1_FrequenceMinimum,
                        Servomoteur_1_FrequenceMaximum);

  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);
  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_DistanceValideMaximum = ");
  Serial.print (Sonar_1_DistanceValideMaximum);
  Serial.println ();
  Serial.print ("* Servomoteur_1_AnglePas        = ");
  Serial.print (Servomoteur_1_AnglePas);
  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 ();
  LCD_1.setCursor (0,1);
  LCD_1.print ("CodeSituation   ");

  // 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 ();
}
//*****************************************************************************

//*****************************************************************************
// 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.
  GererTempsAffichagesBoutons ();

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


Fichier « 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;


Fichier « 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

En souhaitant que vous y trouviez ce que vous cherchiez !

Bon montage !

L'ami René

Un pour tous, et tous pour un !

Share