//*****************************************************************************
// Programme Arduino : RobotN20_3xSonar
//*****************************************************************************
// Nom du programme pour l'afficher sur le terminal série et/ou de l'écran LCD.
const char NOM_DU_PROGRAMME [17] = "RobotN20_3xSonar";
/*
É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 : https://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 trois modules à ultrason, deux moteurs à courant continu, quatre
capteurs infrarouges avec sa carte contrôleur. Une télécommande et un capteur
infrarouge de type VS1838B permettent de le contrôler à distance et de
modifier plusieurs de ses paramètres. Il est aussi activable 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 sur les mesures qu'il
effectue et sur les paramètres moteurs qui en découle. 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.
Le présent code source inclus aussi la nomenclature de toutes les pièces et
au minimum un hyperlien pour ce procurer une description plus détaillée et la
pièce elle-même. Tout le câblage de toutes ces composantes est aussi listé. La
liste et description (lorsque disponible) des bibliothèques utilisées dans ce
code source.
Ce code source est largement compartimenté et chaque section et fonction
sont clairement délimitées par un entête. Il y a autant de texte et commentaire
que de code de programmation en soi.
*/
//*****************************************************************************
//*****************************************************************************
// Matériel requis ?
//*****************************************************************************
/*
Testé avec : l'éditeur compilateur Arduino 1.6.12.
Liste alphabétique des composantes d'électroniques
1 x Arduino Mega 2560 R3 :
https://arduino.cc/en/Main/ArduinoBoardMega2560
https://www.dx.com/fr/p/mega2560-r3-atmega2560-16au-control-board-w-usb-cable-for-arduino-400944
https://www.dx.com/p/improved-funduino-mega-2560-r3-module-compatible-w-official-arduino-mega-2560-r3-blue-black-256335
https://www.dx.com/p/mega-2560-r3-atmega2560-16au-board-usb-cable-for-arduino-black-blue-215579
1 x La base de la structure de la voiture et constitué d'une boîte de biscuit
Danois bleu recyclé et de son couvercle d'un diamêtre bas de près de 200 mm, haut
de 190 mm et d'une auteur de 75 mm. Trois bout de bois sont aussi utilisés (26x26x110
mm, 26x26x30 mm et 26x26x30 mm)
1 x Boîtier à 6 piles AA 1.5V (9V) et connecteur :
https://www.dx.com/fr/p/6-x-aa-batteries-holder-case-w-power-plug-for-arduino-152198
https://www.robotshop.com/ca/fr/support-batteries-6xaa-prise-baril.html
https://www.robotshop.com/ca/fr/support-pour-6-batteries-aa-avec-branchement-21-mm-adafruit.html
1 x Bouton-poussoir 2 pattes, rouge, "Push Button Switches" BPS-09, 250V/0.3A :
https://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
https://www.dx.com/fr/p/5v-active-buzzers-black-10-pcs-381747
1 x Capteur infra-rouge VS1838B (TSOP1838) :
https://www.dipmicro.com/store/VS1838B
https://dx.com/p/hx1838-pc638-diy-universal-electronic-component-infrared-receiver-silver-20-pcs-158341
https://www.electrodragon.com/product/infrared-dev-kit-controllernec-type-and-hx1838-receiver/
https://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 :
https://www.dx.com/p/4-channel-infrared-obstacle-avoidance-sensor-module-for-smart-car-blue-213608
3 x Capteur ultrason (émetteur/récepteur) HR-SC04.
https://dx.com/p/hc-sr04-ultrasonic-sensor-distance-measuring-module-133696
https://www.dx.com/fr/p/hc-sr04-ultrasonic-sensor-distance-measuring-modules-blue-4-pcs-400214
https://www.robotshop.com/ca/fr/module-sonar-hc-sr04.html
1 x Condensateur 3300uF électrolytique :
https://www.dx.com/fr/p/maitech-03120297-6-3v-3300uf-electrolytic-capacitors-green-10-pcs-318018
1 x Connecteur à Prise Baril 2.1mm mâle 2 brins SKU-302518 :
https://www.dx.com/fr/p/connector-male-dc-power-jack-plug-black-10-pcs-2-1-x-5-5-x-9mm-302518
1 x Connecteur à Prise Baril 2.1mm, 30V/0.3A, femelle 3 brins fileté 1.0 cm avec écrou :
https://www.dx.com/p/dc-jack-adapters-10-piece-pack-122746
1 x Contrôleur moteur L298N (H-Bridge) pour 2 moteurs CC ou 1 moteur Pas-A-Pas SKU-149662 :
https://dx.com/p/l298n-stepper-motor-driver-controller-board-module-blue-149662
https://www.robotshop.com/ca/fr/controleur-deux-moteurs-dc-l298.html
https://www.datasheetarchive.com/dlmain/Datasheets-5/DSA-95443.pdf
https://www.datasheetarchive.com/dlmain/Datasheets-25/DSA-480678.pdf
1 x Écran LCD LCD1602, 16 x 2, taille des caractères: 2.95x4.75, 5V :
https://www.dx.com/fr/p/dofly-cg06ng025-1602-character-lcd-screen-green-275771#.V3WBge2RuV4
https://dx.com/p/1602a-16-x-2-lines-white-character-lcd-module-w-blue-backlight-dc-5v-151978
1 x Boite d'entretoise Hexagonale Kit de Montage RB-Dfr-273 (16 entretoises requises)
https://www.robotshop.com/ca/fr/kit-montage-entretoise.html
• Entretoise femelle/femelle en nylon (M3 x 10 mm) x 10
• Entretoise femelle/femelle en nylon (M3 x 20 mm) x 10
• Entretoise femelle/femelle en nylon (M3 x 30 mm) x 10
• Entretoise femelle/femelle en cuivre (M3 x 10 mm) x 10
• Entretoise femelle/femelle en cuivre (M3 x 20 mm) x 10
• Entretoise femelle/femelle en cuivre (M3 x 30 mm) x 10
• Entretoise mâle/femelle en nylon (M3 x 6 mm) x 10
• Entretoise mâle/femelle en nylon (M3 x 10 mm) x 10
• Entretoise mâle/femelle en nylon (M3 x 20 mm) x 10
• Entretoise mâle/femelle en nylon (M3 x 30 mm) x 10
• Entretoise mâle/femelle en cuivre (M3 x 10 mm) x 10
• Entretoise mâle/femelle en cuivre (M3 x 20 mm) x 10
• Entretoise mâle/femelle en cuivre (M3 x 30 mm) x 10
• Vis Bombée Philips (M3 x 6 mm) x 200
• Écrou M3 x 100
1 x Boîte de 300 M3 Nylon noir Vis Hexagonale Nut Spacer Stand-off SKU-440668
https://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 :
https://www.dx.com/fr/p/electrical-diy-power-control-6-pin-toggle-switch-red-silver-5-piece-pack-146106
2 x Moteur DC et réducteur 6V 56rpm, GM12-N20VA-08220-298-10D, avec roues et fixation SKU-375485
https://www.dx.com/fr/p/diy-dc-6-0v-56rpm-gear-motor-with-mounting-bracket-rubber-tire-black-375485
1 x Planche d'expérimentation « BreadBoard » Micro (170 trous) ZY-107 :
https://www.robotshop.com/ca/fr/sfe-mini-planch-essais-170-points.html
https://www.robotshop.com/ca/fr/plaque-essais-sans-soudure-blanc-170-points.html
https://www.dx.com/p/mini-prototype-printed-circuit-board-breadboard-for-arduino-5-pcs-148443
2 x Potentiomètre 10KΩ trois pattes multitours :
https://dx.com/p/3296-potentiometer-3-pin-10kohm-adjustable-resistors-blue-10-pcs-161616
2 x Radiateurs thermique en aluminium bleu (1.5 cm x 1.5 cm x 0.8 cm) SKU-376917
https://www.dx.com/fr/p/aluminum-flash-memory-heat-dissipation-heatsinks-blue-8-pcs-376917
2 x Roulette à Bille Pololu 1/2 po. avec Bille en Métal Code de Produit : RB-Pol-93
https://www.robotshop.com/ca/fr/roulette-bille-pololu-05-po-metal.html
1 x Télécommande type Mini MP3 :
https://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 :
https://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
https://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
https://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) :
https://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) :
https://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) :
https://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)) :
https://dx.com/p/dupont-line-1p-1p-40-pack-20cm-length-121338
Fils de raccordement femelle/femelle 20cm (nappe de 10 couleurs, 40 fils)) :
https://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) :
https://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Ω:
https://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Ω :
https://dx.com/p/jtron-1-4w-colored-ring-resistor-pack-100-ohm-2k-27-kinds-10-pcs-blue-sliver-270-pcs-288760
*/
//*****************************************************************************
//*****************************************************************************
// Circuit à réaliser.
//*****************************************************************************
/*
Dans cette section, tous les branchements des composants du montage sont listés
par bloc et cela permet le "copier/coller" des blocs complets de texte pour une
pièce, d'un code source à un autre. Le libellé d'un connecteur d'une pièce et
ses spécificités sont précédés du nom court de la pièce; par exemple
« ARDUINO_A4_SDA », pour le connecteur analogique A4 qui est spécifique pour la
communication SDA 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.
*/
/*
Câblage de l'Arduino avec ses composante et planche d'expérimentation :
ARDUINO_USB = Par câble USB a un ordinateur
ARDUINO_PWR12V = En phase de test Adaptateur 9V, autonome piles 9V
ARDUINO_J0_1_RESET = ARDUINO_JA2_8_A0
ARDUINO_J0_2_3_3V =
ARDUINO_J0_3_5V_1 = (d1); (e1) -- (f1); (b1) -- (b8); (a8) -- (a12)
ARDUINO_J0_4_GND1 = (d2); (e2) -- (f2); (a2) -- (a10); (b10) -- (a13)
ARDUINO_J0_5_GND2 = (h19); (f19) -- (e19); (i19) -- (i16);
ARDUINO_J0_6_VIN = (h20); (f20) -- (e20); (i20) -- (j14); INTERRUPTEUR_1_VOUT
ARDUINO_JA2_8_A0 = ARDUINO_J0_1_RESET (Kamikaze par télécommande)
ARDUINO_JA2_7_A1 =
ARDUINO_JA2_6_A2 = SONAR_1_TRIG
ARDUINO_JA2_5_A3 = SONAR_1_ECHO
ARDUINO_JA2_4_A4 = SONAR_2_TRIG
ARDUINO_JA2_3_A5 = SONAR_2_ECHO
ARDUINO_JA2_2_A6 = SONAR_3_TRIG
ARDUINO_JA2_1_A7 = SONAR_3_ECHO
ARDUINO_JA1_1_A8 =
ARDUINO_JA1_2_A9 =
ARDUINO_JA1_3_A10 =
ARDUINO_JA1_4_A11 = CONTROLE_IR_1_DO1
ARDUINO_JA1_5_A12 = CONTROLE_IR_1_DO2
ARDUINO_JA1_6_A13 = CONTROLE_IR_1_DO3
ARDUINO_JA1_7_A14 = CONTROLE_IR_1_DO4
ARDUINO_JA1_8_A15 =
ARDUINO_JP2_G2_GND5 =
ARDUINO_JP2_G1_GND4 =
ARDUINO_JP2_1_53_SS_CS =
ARDUINO_JP2_3_52_SCK =
ARDUINO_JP2_3_51_MOSI =
ARDUINO_JP2_4_50_MISO =
ARDUINO_JP2_5_49 =
ARDUINO_JP2_6_48 =
ARDUINO_JP2_7_47 =
ARDUINO_JP2_8_46_PWM =
ARDUINO_JP2_9_45_PWM =
ARDUINO_JP2_10_44_PWM =
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 = LCD_1_D7
ARDUINO_JP1_12_26 = LCD_1_D6
ARDUINO_JP1_13_25 = LCD_1_D5
ARDUINO_JP1_14_24 = LCD_1_D4
ARDUINO_JP1_15_23 = LCD_1_E
ARDUINO_JP1_16_22 = LCD_1_RS
ARDUINO_JP1_V2_5V_3 =
ARDUINO_JP1_V1_5V_2 =
ARDUINO_JC_1_21_SCL_INT2 =
ARDUINO_JC_2_20_SDA_INT3 =
ARDUINO_JC_3_19_RX1_INT4 =
ARDUINO_JC_4_18_TX1_INT5 =
ARDUINO_JC_5_17_RX2 =
ARDUINO_JC_6_16_TX2 =
ARDUINO_JC_7_15_RX3 =
ARDUINO_JC_8_14_TX3 =
ARDUINO_JL_1_0_PWM_RX0 =
ARDUINO_JL_2_1_PWM_TX0 =
ARDUINO_JL_3_2_PWM_INT0 = (d6) -- BOUTON_1_2
ARDUINO_JL_4_3_PWM_INT1 = CAPTEUR_IR_0_OUT
ARDUINO_JL_5_4_PWM = CONTROLE_MOTEUR_1_ENA
ARDUINO_JL_6_5_PWM = CONTROLE_MOTEUR_1_IN1
ARDUINO_JL_7_6_PWM = CONTROLE_MOTEUR_1_IN2
ARDUINO_JL_8_7_PWM = CONTROLE_MOTEUR_1_ENB
ARDUINO_JH_1_8_PWM = CONTROLE_MOTEUR_1_IN3
ARDUINO_JH_2_9_PWM = CONTROLE_MOTEUR_1_IN4
ARDUINO_JH_3_10_PWM =
ARDUINO_JH_4_11_PWM =
ARDUINO_JH_5_12_PWM = BUZZER_1_VIN
ARDUINO_JH_6_13_PWM_DEL =
ARDUINO_JH_7_GND3 = BUZZER_1_GND
ARDUINO_JH_8_AREF =
ARDUINO_ICSP_1_MISO =
ARDUINO_ICSP_2_5V =
ARDUINO_ICSP_3_SCK =
ARDUINO_ICSP_4_MOSI =
ARDUINO_ICSP_5_RESET =
ARDUINO_ICSP_6_GND =
ARDUINO_ICSP1_1_MISO =
ARDUINO_ICSP1_2_5V =
ARDUINO_ICSP1_3_SCK =
ARDUINO_ICSP1_4_MOSI =
ARDUINO_ICSP1_5_RESET =
ARDUINO_ICSP1_6_GND =
Câblage pour le bouton :
BATTERIE_PLUS = CONNECTEUR_1_JACK_PLUS
BATTERIE_MOINS = CONNECTEUR_1_JACK_MOINS
Câblage pour le bouton :
BOUTON_1_1 = (j1)
BOUTON_1_2 = (e6); (d6) -- ARDUINO_JL_3_2_PWM_INT0
Résistance 100 Ohm 1 = (c6)
Résistance 100 Ohm 2 = (c2)
Câblage pour le Buzzer :
BUZZER_1_VIN = ARDUINO_JH_5_12_PWM
BUZZER_1_GND = ARDUINO_JH_7_GND3
Câblage pour le capteur infra-rouge utiliser avec la télécommande :
CAPTEUR_IR_0_OUT = ARDUINO_JL_4_3_PWM_INT1
CAPTEUR_IR_0_GND = (e13)
CAPTEUR_IR_0_VIN = (e12)
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 éviter une trop grande baisse de tension du aux moteurs :
Condensateur 2200uF 16V = (f14) -- (f16)
Câblage pour le connecteur JACK du courant (Batterie) :
CONNECTEUR_1_JACK_PLUS = INTERRUPTEUR_1_VIN_1
CONNECTEUR_1_JACK_MOINS = (a19); (e19) -- (f19); BATTERIE_MOINS; CONTROLE_MOTEUR_1_GND
CONNECTEUR_1_JACK_M_A_T = (Mise à la terre non utilisé)
Câblage pour le connecteur JACK du courant (Transformateur de courant 6 à 12 volts) :
CONNECTEUR_2_JACK_PLUS = INTERRUPTEUR_1_VIN_2
CONNECTEUR_2_JACK_MOINS = (a19); (e19) -- (f19); TRANSFORMATEUR_1_PLUS; CONTROLE_MOTEUR_1_GND
CONNECTEUR_2_JACK_M_A_T = (Mise à la terre non utilisé)
Câblage pour la carte controleure des capteurs de distance infra-rouge :
CONTROLE_IR_1_UR1_OUT = CAPTEUR_IR_1_OUT
CONTROLE_IR_1_UR1_VIN = CAPTEUR_IR_1_VIN
CONTROLE_IR_1_UR1_GND = CAPTEUR_IR_1_GND
CONTROLE_IR_1_UR2_OUT = CAPTEUR_IR_2_OUT
CONTROLE_IR_1_UR2_VIN = CAPTEUR_IR_2_VIN
CONTROLE_IR_1_UR2_GND = CAPTEUR_IR_2_GND
CONTROLE_IR_1_UR3_OUT = CAPTEUR_IR_3_OUT
CONTROLE_IR_1_UR3_VIN = CAPTEUR_IR_3_VIN
CONTROLE_IR_1_UR3_GND = CAPTEUR_IR_3_GND
CONTROLE_IR_1_UR4_OUT = CAPTEUR_IR_4_OUT
CONTROLE_IR_1_UR4_VIN = CAPTEUR_IR_4_VIN
CONTROLE_IR_1_UR4_GND = CAPTEUR_IR_4_GND
CONTROLE_IR_1_VIN = (g1)
CONTROLE_IR_1_GND = (g2)
CONTROLE_IR_1_DO4 = ARDUINO_A14
CONTROLE_IR_1_DO3 = ARDUINO_A13
CONTROLE_IR_1_DO2 = ARDUINO_A12
CONTROLE_IR_1_DO1 = ARDUINO_A11
Câblage pour les deux moteurs DC :
CONTROLE_MOTEUR_1_VIN = (d20); INTERRUPTEUR_1_VOUT
CONTROLE_MOTEUR_1_GND = (d19); CONNECTEUR_1_JACK_MOINS
CONTROLE_MOTEUR_1_5V =
CONTROLE_MOTEUR_1_ENA = ARDUINO_JL_5_4_PWM
CONTROLE_MOTEUR_1_IN1 = ARDUINO_JL_6_5_PWM
CONTROLE_MOTEUR_1_IN2 = ARDUINO_JL_7_6_PWM
CONTROLE_MOTEUR_1_ENB = ARDUINO_JL_8_7_PWM
CONTROLE_MOTEUR_1_IN3 = ARDUINO_JH_1_8_PWM
CONTROLE_MOTEUR_1_IN4 = ARDUINO_JH_2_9_PWM
CONTROLE_MOTEUR_1_OUT1 = Moteur1_VIN
CONTROLE_MOTEUR_1_OUT2 = Moteur1_GND
CONTROLE_MOTEUR_1_OUT3 = Moteur2_GND
CONTROLE_MOTEUR_1_OUT4 = Moteur2_VIN
Câblage de l'interrupteur :
INTERRUPTEUR_1_VIN_1 = CONNECTEUR_1_JACK_PLUS
INTERRUPTEUR_1_VOUT = (a20); CONTROLE_MOTEUR_1_VIN; ARDUINO_J0_6_VIN
INTERRUPTEUR_1_VIN_2 = CONNECTEUR_2_JACK_PLUS
Câblage de l'écran LCD LCD1602 :
LCD_1_VSS broche 1 = (i1)
LCD_1_VDD broche 2 = (i2)
LCD_1_VO broche 3 = (d9); POTENTIOMETRE_10K_1_OUT
LCD_1_RS broche 4 = ARDUINO_22
LCD_1_RW broche 5 = (d10)
LCD_1_E broche 6 = ARDUINO_23
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 = ARDUINO_24
LCD_1_D5 broche 12 = ARDUINO_25
LCD_1_D6 broche 13 = ARDUINO_26
LCD_1_D7 broche 14 = ARDUINO_27
LCD_1_A broche 15 = (i9); POTENTIOMETRE_10K_2_OUT
LCD_1_K broche 16 = (i10)
Câblage pour le potentiometre 10KOhm pour la valeur de la luminosité des
caractre sur l'écran LCD :
POTENTIOMETRE_10K_1_VIN = (c8); (e8) -- (f8)
POTENTIOMETRE_10K_1_OUT = (c89; LCD_1_VO
POTENTIOMETRE_10K_1_GND = (c10); (e10) -- (-f10)
Câblage pour le potentiometre 10KOhm pour la valeur de la luminosité du
rétroéclairage sur l'écran LCD :
POTENTIOMETRE_10K_2_VIN = (h8); (e8) -- (f8)
POTENTIOMETRE_10K_2_OUT = (h9); LCD_1_A
POTENTIOMETRE_10K_2_GND = (h10); (e10) -- (-f10)
Câblage pour les 3 modules à ultrason :
SONAR_1_VCC = (b12)
SONAR_1_TRIG = ARDUINO_JA2_6_A2
SONAR_1_ECHO = ARDUINO_JA2_5_A3
SONAR_1_GND = (b13)
SONAR_2_VCC = (c12)
SONAR_2_TRIG = ARDUINO_JA2_4_A4
SONAR_2_ECHO = ARDUINO_JA2_3_A5
SONAR_2_GND = (c13)
SONAR_3_VCC = (d12)
SONAR_3_TRIG = ARDUINO_JA2_2_A6
SONAR_3_ECHO = ARDUINO_JA2_1_A7
SONAR_3_GND = (d13)
Câblage pour le transformateur de courant externe (6 à 12 Volts) :
TRANSFORMATEUR_1_PLUS = CONNECTEUR_2_JACK_PLUS
TRANSFORMATEUR_1_MOINS = CONNECTEUR_2_JACK_MOINS
*/
//*****************************************************************************
//*****************************************************************************
// 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 :
https://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 :
https://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 : https://arduino.cc/fr/Main/LibrairieLCD
*/
#include "NotesDeMusique.h"
/*
Fichier contenant les définitions de notes de musique.
*/
#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.
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 = 2;
// 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 = 3;
// Broche des capteurs de distance infra-rouge 1 à 4 :
const byte CONTROLE_IR_1_DO1 = A11;// Avant gauche.
const byte CONTROLE_IR_1_DO2 = A12;// Arriere gauche.
const byte CONTROLE_IR_1_DO3 = A13;// Arriere droite.
const byte CONTROLE_IR_1_DO4 = A14;// Avant droite.
// Broche d'Arduino pour le controleur moteur 1 (double Pont en H).
const byte CONTROLE_MOTEUR_1_ENA = 4;
const byte CONTROLE_MOTEUR_1_IN1 = 5;
const byte CONTROLE_MOTEUR_1_IN2 = 6;
const byte CONTROLE_MOTEUR_1_ENB = 7;
const byte CONTROLE_MOTEUR_1_IN3 = 8;
const byte CONTROLE_MOTEUR_1_IN4 = 9;
// 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 = 22;// Écran LCD.
const byte LCD_1_E = 23;// Écran LCD.
const byte LCD_1_D4 = 24;// Écran LCD.
const byte LCD_1_D5 = 25;// Écran LCD.
const byte LCD_1_D6 = 26;// Écran LCD.
const byte LCD_1_D7 = 27;// Écran LCD.
// Broche d'Arduino pour les capteur à ultrason, les sonars.
const byte SONAR_1_TRIG = A2;
const byte SONAR_1_ECHO = A3;
const byte SONAR_2_TRIG = A4;
const byte SONAR_2_ECHO = A5;
const byte SONAR_3_TRIG = A6;
const byte SONAR_3_ECHO = A7;
//*****************************************************************************
//*****************************************************************************
// Déclaration des autres constantes de travail.
//*****************************************************************************
// Nombre de lignes et de colonnes de l'objet ECRAN_LCD.
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 = 100;// 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 le moniteur série d'Arduino (débogage).
boolean AfficherMoniteurSerie = NON;
boolean AfficherEcranLCD = OUI;
/*
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 à 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 = 9;
// Pour les 4 capteurs infrarouge de distabces aux 4 voins du véhicule.
int CapteurInfrarouge1 = 0;// Avant Gauche.
int CapteurInfrarouge2 = 0;// Avant Droite.
int CapteurInfrarouge3 = 0;// Arriere Gauche.
int CapteurInfrarouge4 = 0;// Arriere Droite.
int CapteursInfrarougesCoupure = 500; // Arbitraire entre 80 et 800.
// Recoit la valeur indicant la condition de déplacement en cours.
byte CodeSituation = 0;
// Contiend la vitesse moteur à applique et donc aussi la vitesse courante.
byte Moteur_1_PointMort = MOTEUR_1_VITESSE_MINIMUM;
byte Moteur_2_PointMort = MOTEUR_2_VITESSE_MINIMUM;
byte Moteur_1_Vitesse = Moteur_1_PointMort;
byte Moteur_2_Vitesse = Moteur_2_PointMort;
// Délai de fonctionnement des moteurs des roues pour pivoter le robot de 1°.
float MoteursDelaiUnDegre = 800;// En millisesonde.
int Sonar_1_DelaiEntreMesures = 10;
// Dernière valeur fournit par le sonar.
float Sonar_1_DistanceActuele = 0.0;
float Sonar_2_DistanceActuele = 0.0;
float Sonar_3_DistanceActuele = 0.0;
// Distance limite pour la fiabilité des mesure du sonar.
float Sonar_1_DistanceValideMaximum = 255.0;
float Sonar_2_DistanceValideMaximum = 255.0;
float Sonar_3_DistanceValideMaximum = 255.0;
// Variables pour établir la durée de la commande ping. Le résultat donnera la
// distance en pouces et/ou en centimètres :
float Sonar_1_DureeEchoSonar = 0.0;
float Sonar_2_DureeEchoSonar = 0.0;
float Sonar_3_DureeEchoSonar = 0.0;
// Pour contrer l'imprécission des echos sonars, plusieur lectures pour une moyene.
int Sonar_NombreDeLecture = 2;
// Variable des distances conditionnant les mouvements du robot.
float Distance1 = 10.0;
// Pour contenir la valeur du dernier bouton pressé sur la télécommande.
unsigned long TelecommandeBoutonValeur = 0;
// 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 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);
//*****************************************************************************
//*****************************************************************************
// FONCTION RepeterCaractere
//*****************************************************************************
void RepeterCaractere (byte NombreDeCaractere, String (LeCaractere))
{
for (byte i = 0; i < NombreDeCaractere; i = i + 1)
{
Serial.print (LeCaractere);
}
}
//*****************************************************************************
//*****************************************************************************
// FONCTION UneNoteDeMusique
//*****************************************************************************
void UneNoteDeMusique (int BUZZER_1_VIN, float noteFrequency, long noteDuration)
{
int x;
// 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 (x = 0; x < loopTime ; x = x + 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 GererAfficherMoniteurSerie
//*****************************************************************************
void GererAfficherMoniteurSerie ()
{
// Écriture dans le moniteur série de l'IDE d'Arduino des valeurs lues.
RepeterCaractere (80, "*");
Serial.println ();
Serial.print ("TempsActuele = ");
Serial.print (TempsActuele);
Serial.println ();
Serial.print ("Sonar_1_DistanceActuele = ");
Serial.print (Sonar_1_DistanceActuele);
Serial.println ();
Serial.print ("Sonar_2_DistanceActuele = ");
Serial.print (Sonar_2_DistanceActuele);
Serial.println ();
Serial.print ("Sonar_3_DistanceActuele = ");
Serial.print (Sonar_3_DistanceActuele);
Serial.println ();
Serial.print ("CapteurInfrarouge1 = ");
Serial.print (CapteurInfrarouge1);
Serial.println ();
Serial.print ("CapteurInfrarouge2 = ");
Serial.print (CapteurInfrarouge2);
Serial.println ();
Serial.print ("CapteurInfrarouge3 = ");
Serial.print (CapteurInfrarouge3);
Serial.println ();
Serial.print ("CapteurInfrarouge4 = ");
Serial.print (CapteurInfrarouge4);
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 = 400 400 400 9999
// Ligne 1 = 255 255 99
LCD_1.clear ();
LCD_1.setCursor (0,0);
LCD_1.print (int (Sonar_1_DistanceActuele));
LCD_1.setCursor (4,0);
LCD_1.print (int (Sonar_2_DistanceActuele));
LCD_1.setCursor (8,0);
LCD_1.print (int (Sonar_3_DistanceActuele));
LCD_1.setCursor (12,0);
LCD_1.print (map (CapteurInfrarouge1, 0 , 1023, 0, 9));
LCD_1.setCursor (13,0);
LCD_1.print (map (CapteurInfrarouge2, 0 , 1023, 0, 9));
LCD_1.setCursor (14,0);
LCD_1.print (map (CapteurInfrarouge3, 0 , 1023, 0, 9));
LCD_1.setCursor (15,0);
LCD_1.print (map (CapteurInfrarouge4, 0 , 1023, 0, 9));
LCD_1.setCursor (0,1);
LCD_1.print (Moteur_1_Vitesse);
LCD_1.setCursor (4,1);
LCD_1.print (Moteur_2_Vitesse);
LCD_1.setCursor (14,1);
LCD_1.print (CodeSituation);
}
//*****************************************************************************
//*****************************************************************************
// FONCTION GererAffichages
//*****************************************************************************
void GererAffichages ()
{
if (AfficherMoniteurSerie)
{
GererAfficherMoniteurSerie ();
}
if (AfficherEcranLCD)
{
GererAfficherEcranLCD ();
}
}
//*****************************************************************************
//*****************************************************************************
// FONCTION CapteursInfrarouges
//*****************************************************************************
void CapteursInfrarouges ()
{
CapteurInfrarouge1 = analogRead (CONTROLE_IR_1_DO1);
CapteurInfrarouge2 = analogRead (CONTROLE_IR_1_DO2);
CapteurInfrarouge3 = analogRead (CONTROLE_IR_1_DO3);
CapteurInfrarouge4 = analogRead (CONTROLE_IR_1_DO4);
}
//*****************************************************************************
//*****************************************************************************
// 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:
* https://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
*/
return 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;
}
// Élimination d'une éventuelle valeur négative.
if (Sonar_1_DistanceActuele < 0)
{
Sonar_1_DistanceActuele = 0;
}
// Lecture echo sonar 2
delayMicroseconds (2);
digitalWrite (SONAR_2_TRIG, HAUT);
delayMicroseconds (10);
digitalWrite (SONAR_2_TRIG, BAS);
Sonar_2_DureeEchoSonar = pulseIn (SONAR_2_ECHO, HAUT);
// convertir le temps en une distance
Sonar_2_DistanceActuele = ConvertionMicrosecondsEnCentimetres
(Sonar_2_DureeEchoSonar);
// Limiter la distance mesurée a la valeur de Sonar_1_DistanceValideMaximum.
if (Sonar_2_DistanceActuele > Sonar_2_DistanceValideMaximum)
{
Sonar_2_DistanceActuele = Sonar_2_DistanceValideMaximum;
}
// Élimination d'une éventuelle valeur négative.
if (Sonar_2_DistanceActuele < 0)
{
Sonar_2_DistanceActuele = 0;
}
// Lecture echo sonar 3
delayMicroseconds (2);
digitalWrite (SONAR_3_TRIG, HAUT);
delayMicroseconds (10);
digitalWrite (SONAR_3_TRIG, BAS);
Sonar_3_DureeEchoSonar = pulseIn (SONAR_3_ECHO, HAUT);
// convertir le temps en une distance
Sonar_3_DistanceActuele = ConvertionMicrosecondsEnCentimetres
(Sonar_3_DureeEchoSonar);
// Limiter la distance mesurée a la valeur de Sonar_1_DistanceValideMaximum.
if (Sonar_3_DistanceActuele > Sonar_3_DistanceValideMaximum)
{
Sonar_3_DistanceActuele = Sonar_3_DistanceValideMaximum;
}
// Élimination d'une éventuelle valeur négative.
if (Sonar_3_DistanceActuele < 0)
{
Sonar_3_DistanceActuele = 0;
}
}
//*****************************************************************************
//*****************************************************************************
// FONCTION CapteurUltrasonLecture
//*****************************************************************************
void CapteurUltrasonLectures ()
{
// Pour contrer l'imprécission des echos sonars, deux lecture et la moyene.
float EchosSonar1 [Sonar_NombreDeLecture];
float EchosSonar2 [Sonar_NombreDeLecture];
float EchosSonar3 [Sonar_NombreDeLecture];
float TotalDistanceEcho1 = 0.0;
float TotalDistanceEcho2 = 0.0;
float TotalDistanceEcho3 = 0.0;
float MoyenneDistanceEcho1 = 0.0;
float MoyenneDistanceEcho2 = 0.0;
float MoyenneDistanceEcho3 = 0.0;
Sonar_1_DistanceActuele = 0.0;
Sonar_2_DistanceActuele = 0.0;
Sonar_3_DistanceActuele = 0.0;
for (int i = 0; i < Sonar_NombreDeLecture; i = i + 1)
{
CapteurUltrasonUneLecture ();
EchosSonar1 [i] = Sonar_1_DistanceActuele;
TotalDistanceEcho1 = TotalDistanceEcho1 + EchosSonar1 [i];
EchosSonar2 [i] = Sonar_2_DistanceActuele;
TotalDistanceEcho2 = TotalDistanceEcho2 + EchosSonar1 [i];
EchosSonar3 [i] = Sonar_3_DistanceActuele;
TotalDistanceEcho3 = TotalDistanceEcho3 + EchosSonar3 [i];
}
MoyenneDistanceEcho1 = TotalDistanceEcho1 / Sonar_NombreDeLecture;
Sonar_1_DistanceActuele = MoyenneDistanceEcho1;
MoyenneDistanceEcho2 = TotalDistanceEcho2 / Sonar_NombreDeLecture;
Sonar_2_DistanceActuele = MoyenneDistanceEcho2;
MoyenneDistanceEcho3 = TotalDistanceEcho3 / Sonar_NombreDeLecture;
Sonar_3_DistanceActuele = MoyenneDistanceEcho3;
}
//*****************************************************************************
//*****************************************************************************
// FONCTION SortieTrouve
//*****************************************************************************
void SortieTrouve ()
{
// Pour affichage dans l'écran LCD.
LCD_1.clear ();
LCD_1.setCursor (0,0);
LCD_1.print ("* SortieTrouve *");
LCD_1.setCursor (0,1);
LCD_1.print (">>>>>> OK <<<<<<");
GererAffichages ();
R2D2_1 ();
Boucler = NON;
// 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);
}
//*****************************************************************************
//*****************************************************************************
// FONCTION AjusterVitesseDesMoteurs
//*****************************************************************************
void AjusterVitesseDesMoteurs ()
{
// Modifier la vitesse des moteurs 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_3_DistanceActuele, 0, Sonar_3_DistanceValideMaximum,
Moteur_2_PointMort, MOTEUR_2_VITESSE_MAXIMUM);
}
//*****************************************************************************
//*****************************************************************************
// 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 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 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 DeplacementAvancerDroite
//*****************************************************************************
void DeplacementAvancerDroite ()
{
// 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 DeplacementAvancerGauche
//*****************************************************************************
void DeplacementAvancerGauche ()
{
// 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 DeplacementReculerDroite
//*****************************************************************************
void DeplacementReculerDroite ()
{
// 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 DeplacementReculerGauche
//*****************************************************************************
void DeplacementReculerGauche ()
{
// 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 DeplacementPivoterGauche
//*****************************************************************************
void DeplacementPivoterGauche ()
{
// 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 DeplacementPivoterDroite
//*****************************************************************************
void DeplacementPivoterDroite ()
{
// 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 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 = 74;
DeplacementArreter ();
GererAffichages ();
R2D2_1 ();
Boucler = NON;
digitalWrite (DEL_1_VIN, Boucler);
// 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 = 75;
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 :
Plus :
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);
Serial.print ("* En attente d'une action d'humaine");
Serial.println ();
CodeSituation = 76;
DeplacementArreter ();
}
else
{
Boucler = OUI;
digitalWrite (DEL_1_VIN, Boucler);
Serial.print ("* Poursuite du programme");
Serial.println ();
CodeSituation = 77;
}
break;
case TelecommandeBoutonMode:
Serial.print ("* TelecommandeBoutonMode = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 78;
GererAffichages ();
DeplacementArreter ();
R2D2_1 ();
// 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 = 79;
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 = 80;
}
else
{
Boucler = OUI;
digitalWrite (DEL_1_VIN, Boucler);
Serial.print ("* Poursuite du programme");
Serial.println ();
CodeSituation = 81;
}
break;
case TelecommandeBoutonDebut:
Serial.print ("* TelecommandeBoutonDebut = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
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 ("Activer l'affichage sur port serie");
AfficherMoniteurSerie = AfficherMoniteurSerie - 1;
CodeSituation = 83;
Bip_1 ();
break;
case TelecommandeBoutonMoins:
Serial.print ("* TelecommandeBoutonMoins = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
Moteur_1_Vitesse = Moteur_1_PointMort - 10;
Moteur_2_Vitesse = Moteur_2_PointMort - 10;
CodeSituation = 84;
Bip_1 ();
break;
case TelecommandeBoutonPlus:
Serial.print ("* TelecommandeBoutonPlus = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
Moteur_1_Vitesse = Moteur_1_PointMort + 10;
Moteur_2_Vitesse = Moteur_2_PointMort + 10;
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 ();
Moteur_1_Vitesse = Moteur_1_PointMort;
Moteur_2_Vitesse = Moteur_2_PointMort;
DeplacementAvancerGauche ();
Boucler = NON;
digitalWrite (DEL_1_VIN, Boucler);
break;
case TelecommandeBouton2:
Serial.print ("* TelecommandeBouton2 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 90;
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:
Serial.print ("* TelecommandeBouton3 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 91;
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:
Serial.print ("* TelecommandeBouton4 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 92;
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:
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 ();
Moteur_1_Vitesse = Moteur_1_PointMort;
Moteur_2_Vitesse = Moteur_2_PointMort;
DeplacementPivoterDroite ();
Boucler = NON;
digitalWrite (DEL_1_VIN, Boucler);
break;
case TelecommandeBouton7:
Serial.print ("* TelecommandeBouton7 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 95;
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:
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);
CodeSituation = 96;
break;
case TelecommandeBouton9:
Serial.print ("* TelecommandeBouton9 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 97;
Bip_1 ();
Moteur_1_Vitesse = Moteur_1_PointMort;
Moteur_2_Vitesse = Moteur_2_PointMort;
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))
{
delay (BoutonTempsRebon);// Pour absorber les micro-coupures des rebonds).
// 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 GererTempsAffichageBoutons
//*****************************************************************************
void GererTempsAffichageBoutons ()
{
// 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 GererDeplacements
//*****************************************************************************
void GererDeplacements ()
{
CapteursInfrarouges ();
CapteurUltrasonUneLecture ();
AjusterVitesseDesMoteurs ();
if (analogRead (CONTROLE_IR_1_DO1) < CapteursInfrarougesCoupure)
{
CodeSituation = 1;
DeplacementPivoterDroite ();
}
else if (analogRead (CONTROLE_IR_1_DO2) < CapteursInfrarougesCoupure)
{
CodeSituation = 2;
DeplacementPivoterGauche ();
}
else if (analogRead (CONTROLE_IR_1_DO3) < CapteursInfrarougesCoupure)
{
CodeSituation = 3;
DeplacementAvancerGauche ();
}
else if (analogRead (CONTROLE_IR_1_DO4) < CapteursInfrarougesCoupure)
{
CodeSituation = 4;
DeplacementAvancerDroite ();
}
else if ((Sonar_1_DistanceActuele < Distance1) and
(Sonar_2_DistanceActuele < Distance1) and
(Sonar_3_DistanceActuele < Distance1))
{
if (Sonar_1_DistanceActuele > Sonar_3_DistanceActuele)
{
CodeSituation = 5;
DeplacementPivoterGauche ();
delay (UneSeconde);
}
else
{
CodeSituation = 6;
DeplacementPivoterDroite ();
delay (UneSeconde);
}
}
else if ((Sonar_1_DistanceActuele >= Distance1) and
(Sonar_2_DistanceActuele < Distance1) and
(Sonar_3_DistanceActuele < Distance1))
{
CodeSituation = 7;
DeplacementPivoterGauche ();
delay (UneSeconde);
}
else if ((Sonar_1_DistanceActuele < Distance1) and
(Sonar_2_DistanceActuele >= Distance1) and
(Sonar_3_DistanceActuele < Distance1))
{
CodeSituation = 8;
DeplacementAvancer ();
}
else if ((Sonar_1_DistanceActuele < Distance1) and
(Sonar_2_DistanceActuele < Distance1) and
(Sonar_3_DistanceActuele >= Distance1))
{
CodeSituation = 9;
DeplacementPivoterDroite ();
delay (UneSeconde);
}
else if ((Sonar_1_DistanceActuele >= Distance1) and
(Sonar_2_DistanceActuele < Distance1) and
(Sonar_3_DistanceActuele >= Distance1))
{
if (Sonar_1_DistanceActuele > Sonar_3_DistanceActuele)
{
CodeSituation = 10;
DeplacementAvancerGauche ();
}
else
{
CodeSituation = 11;
DeplacementAvancerDroite ();
}
}
else if ((Sonar_1_DistanceActuele >= Distance1) and
(Sonar_2_DistanceActuele >= Distance1) and
(Sonar_3_DistanceActuele < Distance1))
{
CodeSituation = 12;
DeplacementPivoterGauche ();
}
else if ((Sonar_1_DistanceActuele < Distance1) and
(Sonar_2_DistanceActuele >= Distance1) and
(Sonar_3_DistanceActuele >= Distance1))
{
CodeSituation = 13;
DeplacementPivoterDroite ();
}
else if (Sonar_1_DistanceActuele >= Distance1 and
Sonar_2_DistanceActuele >= Distance1 and
Sonar_3_DistanceActuele >= Distance1)
{
CodeSituation = 14;
DeplacementAvancer ();
}
else
{
CodeSituation = 99;
BiBip_1 ();
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.
// IMPORTANT : régler le terminal côté PC avec la même valeur de
// transmission.
Serial.begin (115200);
Serial.println ();
RepeterCaractere (80, "*");
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (31, " ");
Serial.print (NOM_DU_PROGRAMME);
RepeterCaractere (31, " ");
RepeterCaractere (1, "*");
Serial.println ();
RepeterCaractere (80, "*");
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 ("* Bouton S.V.P *");
// 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);
RepeterCaractere (1, "*");
RepeterCaractere (17, " ");
Serial.print ("Broche du bouton de la (BreadBoard) activer !");
RepeterCaractere (16, " ");
RepeterCaractere (1, "*");
Serial.println ();
RepeterCaractere (80, "*");
Serial.println ();
// Fixer le BUZZER_1_VIN en sortie.
pinMode (BUZZER_1_VIN, SORTIE);
Bip_1 ();
RepeterCaractere (1, "*");
RepeterCaractere (23, " ");
Serial.print ("Broche du (((Buzzer))) activer !");
RepeterCaractere (23, " ");
RepeterCaractere (1, "*");
Serial.println ();
RepeterCaractere (80, "*");
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 ();
RepeterCaractere (1, "*");
RepeterCaractere (12, " ");
Serial.print ("Broche du capteur infrarouge de telecommande activer !");
RepeterCaractere (12, " ");
RepeterCaractere (1, "*");
Serial.println ();
RepeterCaractere (80, "*");
Serial.println ();
// Active la DEL de l'Arduino.
pinMode (DEL_1_VIN, SORTIE);
digitalWrite (DEL_1_VIN, Boucler);
RepeterCaractere (1, "*");
RepeterCaractere (27, " ");
Serial.print ("DEL de la carte Arduino");
RepeterCaractere (28, " ");
RepeterCaractere (1, "*");
Serial.println ();
RepeterCaractere (80, "*");
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (12, " ");
Serial.print ("Utiliser la telecommande ou le bouton pour demarrer !");
RepeterCaractere (13, " ");
RepeterCaractere (1, "*");
Serial.println ();
RepeterCaractere (80, "*");
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);
RepeterCaractere (80, "*");
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (33, " ");
Serial.print ("DEL Activee");
RepeterCaractere (34, " ");
RepeterCaractere (1, "*");
Serial.println ();
// Activer les capteurs de distance infra-rouge 1 à 4 :
pinMode (CONTROLE_IR_1_DO1, ENTREE);
pinMode (CONTROLE_IR_1_DO2, ENTREE);
pinMode (CONTROLE_IR_1_DO3, ENTREE);
pinMode (CONTROLE_IR_1_DO4, ENTREE);
RepeterCaractere (1, "*");
RepeterCaractere (18, " ");
Serial.print ("Broches des capteurs de proximite activer");
RepeterCaractere (19, " ");
RepeterCaractere (1, "*");
Serial.println ();
LCD_1.setCursor (0,1);
LCD_1.print ("CAPTEUR_IR_4");
// Pour les moteurs de déplacement du véhicule sur les port de l'Arduino.
// Ajustement initial de la vitesse moteur 1 et 2, à l'arret.
// Moteur à l'arret, au cas ou.
pinMode (CONTROLE_MOTEUR_1_ENA, SORTIE);
pinMode (CONTROLE_MOTEUR_1_IN1, SORTIE);
pinMode (CONTROLE_MOTEUR_1_IN2, SORTIE);
pinMode (CONTROLE_MOTEUR_1_ENB, SORTIE);
pinMode (CONTROLE_MOTEUR_1_IN3, SORTIE);
pinMode (CONTROLE_MOTEUR_1_IN4, SORTIE);
RepeterCaractere (1, "*");
RepeterCaractere (18, " ");
Serial.print ("Broches du controleur des moteurs activer");
RepeterCaractere (19, " ");
RepeterCaractere (1, "*");
Serial.println ();
LCD_1.setCursor (0,1);
LCD_1.print ("CONTROLE_MOTEUR_");
// Pour le sonar 1, 2, et 3, activation des port de l'Arduino.
pinMode (SONAR_1_TRIG, SORTIE);
pinMode (SONAR_1_ECHO, ENTREE);
pinMode (SONAR_2_TRIG, SORTIE);
pinMode (SONAR_2_ECHO, ENTREE);
pinMode (SONAR_3_TRIG, SORTIE);
pinMode (SONAR_3_ECHO, ENTREE);
RepeterCaractere (1, "*");
RepeterCaractere (26, " ");
Serial.print ("Broches des sonars activer");
RepeterCaractere (26, " ");
RepeterCaractere (1, "*");
Serial.println ();
LCD_1.setCursor (0,1);
LCD_1.print ("SONAR_1_ECHO ");
// Message de la fin du processus d'initialisation du systeme.
RepeterCaractere (80, "*");
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (15, " ");
Serial.print ("Fin de la procedure d'initialisation du systeme.");
RepeterCaractere (15, " ");
RepeterCaractere (1, "*");
Serial.println ();
RepeterCaractere (80, "*");
Serial.println ();
RepeterCaractere (80, "*");
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (28, " ");
Serial.print ("Variable du programme");
RepeterCaractere (29, " ");
RepeterCaractere (1, "*");
Serial.println ();
RepeterCaractere (80, "*");
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("LCD_1_NOMBRE_DE_COLONNES = ");
Serial.print (LCD_1_NOMBRE_DE_COLONNES);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("LCD_1_NOMBRE_DE_LIGNES = ");
Serial.print (LCD_1_NOMBRE_DE_LIGNES);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("LCD_1_NOMBRE_DE_LIGNES = ");
Serial.print (LCD_1_NOMBRE_DE_LIGNES);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("MOTEUR_1_VITESSE_MINIMUM = ");
Serial.print (MOTEUR_1_VITESSE_MINIMUM);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("MOTEUR_2_VITESSE_MINIMUM = ");
Serial.print (MOTEUR_2_VITESSE_MINIMUM);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("MOTEUR_1_VITESSE_MAXIMUM = ");
Serial.print (MOTEUR_1_VITESSE_MAXIMUM);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("MOTEUR_2_VITESSE_MAXIMUM = ");
Serial.print (MOTEUR_2_VITESSE_MAXIMUM);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("AfficherEcranLCD = ");
Serial.print (AfficherEcranLCD);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("AfficherMoniteurSerie = ");
Serial.print (AfficherMoniteurSerie);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("Boucler = ");
Serial.print (Boucler);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("BoutonTempsRebon = ");
Serial.print (BoutonTempsRebon);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("CapteursInfrarougesCoupure = ");
Serial.print (CapteursInfrarougesCoupure);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("Moteur_1_PointMort = ");
Serial.print (Moteur_1_PointMort);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("Moteur_2_PointMort = ");
Serial.print (Moteur_2_PointMort);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("Moteur_1_Vitesse = ");
Serial.print (Moteur_1_Vitesse);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("Moteur_2_Vitesse = ");
Serial.print (Moteur_2_Vitesse);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("MoteursDelaiUnDegre = ");
Serial.print (MoteursDelaiUnDegre);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("Sonar_1_DelaiEntreMesures = ");
Serial.print (Sonar_1_DelaiEntreMesures);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("Sonar_1_DistanceValideMaximum = ");
Serial.print (Sonar_1_DistanceValideMaximum);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("Sonar_2_DistanceValideMaximum = ");
Serial.print (Sonar_2_DistanceValideMaximum);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("Sonar_3_DistanceValideMaximum = ");
Serial.print (Sonar_3_DistanceValideMaximum);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("Sonar_NombreDeLecture = ");
Serial.print (Sonar_NombreDeLecture);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("Distance1 = ");
Serial.print (Distance1);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("TempsAfficher_Delai = ");
Serial.print (TempsAfficher_Delai);
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (1, " ");
Serial.print ("CodeSituation = ");
Serial.print (CodeSituation);
Serial.println ();
RepeterCaractere (80, "*");
Serial.println ();
RepeterCaractere (80, "*");
Serial.println ();
RepeterCaractere (1, "*");
RepeterCaractere (3, " ");
Serial.print ("Fin de la procedure d'initialisation et debut de la boucle principale !");
RepeterCaractere (4, " ");
RepeterCaractere (1, "*");
Serial.println ();
RepeterCaractere (80, "*");
Serial.println ();
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);
AjusterVitesseDesMoteurs ();
TempsActuele = millis ();
TempsAfficher_Precedent = TempsActuele;
}
//*****************************************************************************
//*****************************************************************************
// 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.
GererTempsAffichageBoutons ();
if (Boucler == OUI)
{
GererDeplacements ();
}
}
//*****************************************************************************