//*****************************************************************************
// Programme Arduino : NanoCD6pMoteursJauneMiniServo1xSon
//*****************************************************************************
// Nom du programme pour l'afficher sur le terminal série.
const char NOM_DU_PROGRAMME [41] = "NanoCD6pMoteursJauneMiniServo1xSon";
/*
É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 à courant
continu, un servomoteur avec un capteur à ultrason pour déterminer les
déplacements en évitant les obstacles, un capteur infrarouge pour recevoir les
signaux d'une télécommande permettent de le contrôler à distance et de modifier
plusieurs de ses paramètres. Il est aussi activé par un bouton directement sur
le capot du robot et via la planche d'expérimentation. Le moniteur série peut-
être activié par la télécommande et il faut que le câble USB soi branché, il
affiche des informations de base sur le véhicule. Le tout démarre avec l'appui
du bouton « Power » de la télécommande ou du bouton sur la planche le capot du
robot. Pour ce qui est des fonctions liées aux boutons de la télécommande, voir
la section du code « FONCTION GererBoutonTeleCommande » ici plus bas.
*/
//*****************************************************************************
//*****************************************************************************
// Matériel requis ?
//*****************************************************************************
/*
Testé avec : l'éditeur compilateur Arduino 1.6.10
Liste Alphabétique des composantes d'électroniques
1 x Arduino Nano 328 V3.0:
https://arduino.cc/en/Main/ArduinoBoardNano
https://dx.com/p/nano-v3-0-avr-atmega328-p-20au-module-board-usb-cable-for-arduino-118037
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 "Push Button Switches" :
https://www.dx.com/p/diy-push-button-micro-switch-green-159042
https://www.dx.com/p/r16-503-16mm-2-pin-push-button-switch-red-black-220v-5-piece-pack-123926
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 électromagnétique MN-EB-BUZPS Passive.
https://www.dx.com/p/rmg-12075dc5v-30ma-active-electromagnetic-buzzers-black-5-pcs-dc-5v-309550
https://www.dx.com/p/rmg-3v9505-30ma-active-electromagnetic-buzzers-black-5-pcs-dc-3v-309395
https://dx.com/p/3v-electromagnetic-buzzers-for-diy-project-black-5pcs-148650
https://dx.com/p/meeeno-mn-eb-buzps-passive-buzzer-module-orange-black-202512
1 x Capteur infra-rouge VS1838B (TSOP1838) :
https://dx.com/p/tsop1838-ir-infrared-37-9khz-receiver-18m-range-2-7-5-5v-135045
https://dx.com/p/hx1838-pc638-diy-universal-electronic-component-infrared-receiver-silver-20-pcs-158341
https://www.dipmicro.com/store/VS1838B
1 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 Connecteur Pour Batterie 9 Volts BH-06 :
https://www.dx.com/p/9v-safe-pu-leather-stainless-steel-battery-buckle-black-red-10-pack-142018
https://www.robotshop.com/ca/fr/connecteur-batterie-9v-bh-06.html
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 Interrupteur "Toggle Switch" 6 pattes :
https://www.dx.com/p/jtron-diy-toggle-switch-102-single-joint-6-pin-on-on-silver-blue-5-piece-pack-269203
https://www.dx.com/p/jtron-diy-6-pin-toggle-switch-on-on-blue-silver-5-piece-pack-266971
2 x Moteur DC à deux axes avec ratio de 1:48, 3V~6V, 100rpm.
https://www.dx.com/p/dual-axis-reducer-motor-for-smart-tt-car-yellow-silver-dc-3-6v-185017
https://www.dx.com/fr/p/tt-02-diy-car-model-tt-motor-encoder-w-wheel-black-yellow-257135
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.dx.com/p/mini-prototype-printed-circuit-board-breadboard-for-arduino-5-pcs-148443
1 x Servomoteur Tower Pro SG90 (Mini) et accessoires :
https://dx.com/p/towerpro-sg90-mini-plastic-gear-steering-servo-3-pcs-set-187776
1 x Support à pivot pour Servomoteur Tower Pro SG90 (Mini) et accessoires :
https://dx.com/p/camera-platform-mount-for-2-4ghz-5-8ghz-aircraft-fpv-black-133591
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.).
Fils de raccordement pour le bricolage électronique (65 pièces) :
https://dx.com/p/breadboard-jumper-wires-for-electronic-diy-65-cable-pack-118826
Paquet de 40 fils mono brian male femelle de 20cm :
https://dx.com/p/male-to-female-dupont-breadboard-jumper-wires-for-arduino-40-piece-pack-20cm-length-146935
Paquet de 40 fils mono brian femelle femelle de 20cm :
https://dx.com/p/dupont-line-1p-1p-40-pack-20cm-length-121338
Paquet de 70 fils mono brian male male de 12 à 24cm :
https://dx.com/p/breadboard-jumper-wires-for-electronic-diy-70-cable-pack-80208
Breadboard Jumper Cord Kit pour Arduino (140 pièces) :
https://dx.com/p/breadboard-jumper-wire-cord-kit-for-arduino-diy-140-piece-pack-138220
2,54mm 1x40 Pin Breakaway tête droite (10 Pieces) :
https://www.dx.com/p/2-54mm-1x40-pin-breakaway-straight-male-header-10-piece-pack-144191
Résistance de 1/4 Watt (de 100 Ohm ~ 2.4 KOhm), Kit de 270 :
https://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 :
https://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ArduinoExpertSerie2
https://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.
Plaque d'expérimentation « BreanBoard » :
Pour identifier les trous d'une plaque d'expérimentation « BreanBoard », c'est
comme dans le jeu de bataille navale "Battle Ship". Les lignes sont identifiées
pas des numéros. Pour un BreanBoard MB-104, les lignes vont de 1 à 63 et les
colonnes sont identifiées par les lettres "a" a "j" plus deux colonnes avec les
signes « + » et « - » à gauche (G) et à droite (D). Donc (i10) indique le trou
à l'intersection de la colonne « i » avec la ligne numéro « 10 ». Pour une
broche des colonnes négatives ou GND, c'est par exemple (-51G) pour la colonne
du négatif à gauche et sur la ligne 51 et c'est (+51D) pour la colonne du
positif à droit et sur la ligne 51. Dans des situation simple ou évidnte on
utilise aussi pour une broche des colonnes négatives ou GND, par exemple (-5V)
et c'est (+5V) dans le cas ou c'est du courant 5 Volts qui allimante ces
colonnes. Les parenthèses « ( » et « ) », c'est pour bien spécifier une
position de trou de la planche d'expérimentation.
*/
/*
Le circuit : (Voir la page Web :...)
Câblage de l'Arduino Nano R3.0 sur une planche d'expérimentation MB-104 :
ARDUINO_12_MISO dans (c62) et ARDUINO_13_SCK_DEL dans le trou (g62), etc.
ARDUINO_1_TX =
ARDUINO_0_RX =
ARDUINO_RST1 =
ARDUINO_GND1 = (j8), (f8) -- (d8), (g8) -- (g11)
ARDUINO_2_INT1 = BOUTON_1_OUT_3
ARDUINO_3_INT2_OC2B_PWM = (a11) -- CAPTEUR_IR_0_OUT
ARDUINO_4_T0_XCK =
ARDUINO_5_T1_OC0B_PWM = CONTROLE_MOTEUR_1_ENA
ARDUINO_6_AIN0_OC0A_PWM = CONTROLE_MOTEUR_1_ENB
ARDUINO_7_AIN1 = SONAR_1_TRIG
ARDUINO_8_CLK0_ICP1 = SONAR_1_ECHO
ARDUINO_9_OC1A_PWM = SERVOMOTEUR_1_IN
ARDUINO_10_OC1B_SS_PWM =
ARDUINO_11_OC2_MOSI_PWM =
ARDUINO_12_MISO = BUZZER_1_VIN
ARDUINO_USB = Câble USB à l'ordinateur;
ARDUINO_13_SCK_DEL = DEL_1_VIN;
ARDUINO_3_3V =
ARDUINO_AREF = ARDUINO_A0
ARDUINO_A0 = ARDUINO_AREF
ARDUINO_A1 = CONTROLE_MOTEUR_1_IN1
ARDUINO_A2 = CONTROLE_MOTEUR_1_IN2
ARDUINO_A3 = CONTROLE_MOTEUR_1_IN3
ARDUINO_A4_SDA = CONTROLE_MOTEUR_1_IN4
ARDUINO_A5_SCL = ARDUINO_RST2
ARDUINO_A6 =
ARDUINO_A7 =
ARDUINO_5V = (j9), (f9) -- (d9), (donne du 5V)
ARDUINO_RST2 = ARDUINO_A5_SCL
ARDUINO_GND2 = (b17, (d17) -- (f17)
ARDUINO_VIN = (b16, (d16) -- (f15)
ARDUINO_GND =
ARDUINO_OC2A_MOSI =
ARDUINO_5V =
ARDUINO_MISO =
ARDUINO_SCK =
ARDUINO_RESET =
Câblage pour une pile de 6V~9V sur la planche d'expérimentation :
BATTERIE_9V_PLUS = INTERRUPTEUR_1_2
BATTERIE_9V_MOINS = (f17)
Câblage pour le bouton 4 pattes sur la planche d'expérimentation :
BOUTON_1_OUT_1 = (d9); (i9) -- ARDUINO_2_INT1
BOUTON_1_OUT_2 = (d11); (j7) -- (+7D)
Résistance_100_Ohm_1_1 = (f11)
Résistance_100_Ohm_1_2 = (e11)
Câblage pour le Buzzer sur la planche d'expérimentation et l'Arduino :
BUZZER_1_VIN = (i10), (j10) -- ARDUINO_12_MISO
BUZZER_1_GND = (i8)
Câblage pour le capteur infra-rouge utiliser avec la télécommande, sur la
planche d'expérimentation :
CAPTEUR_IR_0_OUT = (h13), (f13) -- ARDUINO_3_INT2_OC2B_PWM
CAPTEUR_IR_0_GND = (a8)
CAPTEUR_IR_0_VIN = (b5)
Résistance_100_Ohm_2_1 = (a5)
Résistance_100_Ohm_2_2 = (a8)
// Pour éviter une trop grande baisse de tension du au servomoteur :
Condensateur 2200uF 16V + = (j15)
Condensateur 2200uF 16V - = (j17)
Câblage pour le connecteur d'un transformateur 6V~12V de la planche d'expérimentation :
CONNECTEUR_2.1MM_PLUS = INTERRUPTEUR_1_1
CONNECTEUR_2.1MM_MOINS = (a17)
Câblage pour les deux Moteur DC a deux axe avec un ratio de 1:48, 3V~6V, 100RPM
sur la planche d'expérimentation :
CONTROLE_MOTEUR_1_VIN = (c16); +6V~12V
CONTROLE_MOTEUR_1_GND = (c17); -6V~12V;
CONTROLE_MOTEUR_1_5V = (j9)
CONTROLE_MOTEUR_1_ENA = ARDUINO_5_T1_OC0B_PWM
CONTROLE_MOTEUR_1_IN1 = ARDUINO_A1
CONTROLE_MOTEUR_1_IN2 = ARDUINO_A2
CONTROLE_MOTEUR_1_ENB = ARDUINO_6_AIN0_OC0A_PWM
CONTROLE_MOTEUR_1_IN3 = ARDUINO_A3
CONTROLE_MOTEUR_1_IN4 = ARDUINO_A4_SDA
CONTROLE_MOTEUR_1_OUT1 = Moteur1_VIN
CONTROLE_MOTEUR_1_OUT2 = Moteur1_GND
CONTROLE_MOTEUR_1_OUT3 = Moteur2_VIN
CONTROLE_MOTEUR_1_OUT4 = Moteur2_GND
Câblage pour l'interrupteur 3 positions de la planche d'expérimentation :
INTERRUPTEUR_1_1 = (d16)
INTERRUPTEUR_1_2 = BATTERIE_9V_PLUS
INTERRUPTEUR_1_3 = CONNECTEUR_2.1MM_PLUS
INTERRUPTEUR_1_4 = (a16)
INTERRUPTEUR_1_5 =
INTERRUPTEUR_1_6 =
INTERRUPTEUR_1_7 =
INTERRUPTEUR_1_8 =
Câblage pour le servo moteur 1 de la planche d'expérimentation :
Servomoteur_1_GND = CONTROLE_MOTEUR_1_GND
Servomoteur_1_VIN = CONTROLE_MOTEUR_1_5V
Servomoteur_1_IN = ARDUINO_9_OC1A_PWM
Câblage pour les modules a ultrason, sur l'Arduino :
SONAR_1_VCC = (b9)
SONAR_1_TRIG = ARDUINO_7_AIN1
SONAR_1_ECHO = ARDUINO_8_CLK0_ICP1
SONAR_1_GND = (b8)
*/
//*****************************************************************************
//*****************************************************************************
// 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 "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 : https://arduino.cc/fr/Main/LibrairieServo
*/
#include "TelecommandeValeurBoutons.h"
/*
Fichier contenant la valeur envoyée pour chaque boutons de la télécommande.
*/
//*****************************************************************************
//*****************************************************************************
// Déclaration des constantes de base pour franciser le code source.
//*****************************************************************************
/*
Par convention, pour nommer une constante, nous utiliserons des noms écrits
tout en majuscule, en capitale, ce qui facilitera leur repérage et rendra le
code plus facilement compréhensible. Le mot devant notre nom de constante
indique à l'Arduino l'espace mémoire à réserver pour stocker cette donnée.
Après le nom de notre constante, on lui attribue sa valeur.
*/
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « ENTREE » est l'équivalent du paramètre « INPUT ». Ce paramètre est
pour prépare l'Arduino a recevoir une tension électrique pour ce connecteur, sur
ce port de communication, sur ce "pin".
*/
const byte ENTREE = INPUT;
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « ENTREE_ET_RESISTENCE_INTERNE » est l'équivalent du paramètre
« INPUT_PULLUP ». Ce paramètre est pour prépare l'Arduino en activant sa
résistance interne et a recevoir une tension électrique pour ce connecteur,
sur ce port de communication, sur ce "pin".
*/
const byte ENTREE_ET_RESISTENCE_INTERNE = INPUT_PULLUP;
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « SORTIE » est l'équivalent du paramètre « OUTPUT ». Ce paramètre
est pour prépare l'Arduino a émettre une tension électrique pour ce connecteur,
sur ce port de communication, sur ce "pin".
*/
const byte SORTIE = OUTPUT;
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « HAUT » est l'équivalent du paramètre « HIGH ». Ce paramètre fait
que l'Arduino maintiendra un voltage haut sur ce connecteur, soit 3.3 Volts,
soit 5 Volts, selon sa propre tension d'alimentation. En électronique, cela
correspondra aux valeurs logiques « 1 », « Oui », ou « Vrai », etc.
*/
const byte HAUT = HIGH;
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « BAS » est l'équivalent du paramètre « LOW ». Ce paramètre fait
que l'Arduino maintiendra un voltage bas sur ce connecteur, soit 0 Volt. En
électronique, cela correspondra aux valeurs logiques « 0 », « Non », ou
« Faut », etc.
*/
const byte BAS = LOW;
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « NON » est l'équivalent du paramètre « false », cela
correspondra aux valeurs logiques « 0 », « Non », ou « Faut », etc.
*/
const byte NON = false;
/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « OUI » est l'équivalent du paramètre « true », cela
correspondra aux valeurs logiques « 1 », « Oui », ou « Vrai », etc.
*/
const byte OUI = true;
//*****************************************************************************
//*****************************************************************************
// Déclaration des constantes des connecteurs Arduino.
//*****************************************************************************
// Broche d'Arduino pour la référence de la puissance électrique.
const byte ARDUINO_IOREF = A0;
// En prévision d'un ARDUINO_RESET par télécommande.
const byte ARDUINO_RESET = A5;
// 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 d'Arduino pour le controleur moteur 1 (double Pont en H).
const byte CONTROLE_MOTEUR_1_IN1 = A1;
const byte CONTROLE_MOTEUR_1_IN2 = A2;
const byte CONTROLE_MOTEUR_1_IN3 = A3;
const byte CONTROLE_MOTEUR_1_IN4 = A4;
const byte CONTROLE_MOTEUR_1_ENA = 5;
const byte CONTROLE_MOTEUR_1_ENB = 6;
// Câblage pour la DEL verte sur la planche d'expérimentation et l'Arduino
const byte DEL_1_VIN = 13;
// Broche d'Arduino pour le servomoteur 1.
const byte SERVOMOTEUR_1_IN = 9;
// Broche d'Arduino pour le capteur a ultrason 2, le sonar.
const byte SONAR_1_TRIG = 7;
const byte SONAR_1_ECHO = 8;
//*****************************************************************************
//*****************************************************************************
// Déclaration des autres constantes de travail.
//*****************************************************************************
// 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 = 150;// 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);
*/
const float MOTEURS_VITESSE_ECART_TYPE = 0.95;
const word MOTEUR_2_VITESSE_MINIMUM = 160;// 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;
/*
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 = 9;
// 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°.
int MoteursDelaiUnDegre = 0;
// Valeur de la lecture de la puissance de référence du courant électrique.
float ReferencePuissance = 0.0;
// 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;
// Largeur impulsion pour position 0° ServoCommand TowerPro MG996R et GS90.
int Servomoteur_1_FrequenceMinimum = 500;
// largeur impulsion pour position 180° ServoCommand TowerPro MG996R et GS90.
int Servomoteur_1_FrequenceMaximum = 2000;
int Sonar_1_DelaiEntreMesures = Servomoteur_1_AnglePas * 15;
// Dernière valeur fournit par le sonar.
int Sonar_1_DistanceActuele = 0;
int Sonar_1_DistanceMaximumTrouve = 0;
int Sonar_1_DistanceMaximumTrouveAngle = 0;
// Distance limite pour la fiabilité des mesure du sonar.
int Sonar_1_DistanceValideMaximum = 400;
// Variables pour établir la durée de la commande ping. Le résultat donnera la
// distance en pouces et/ou en centimètres :
int Sonar_1_DureeEchoSonar = 0;
int Sonar_1_LargeureChampDeBalayage = Servomoteur_1_AngleMaximum -
Servomoteur_1_AngleMinimum;
// Pour contrer l'imprécission des echos sonars, plusieur lectures pour une moyene.
int Sonar_1_NombreDeLecture = 5;
// Variable des distances conditionnant les mouvements du robot.
int Distance1 = 13.0;
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;
//*****************************************************************************
//*****************************************************************************
// 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;
// Pour le contrôle du servomoteur 1 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 AjusterVitesseDesMoteurs
//*****************************************************************************
void AjusterVitesseDesMoteurs ()
{
// Modifier la vitesse des moteurs CC selon la distance devant le véhicule.
Moteur_1_Vitesse = map (Sonar_1_DistanceActuele, 0,
Sonar_1_DistanceValideMaximum,
Moteur_1_PointMort,
MOTEUR_1_VITESSE_MAXIMUM);
Moteur_2_Vitesse = map (Sonar_1_DistanceActuele, 0,
Sonar_1_DistanceValideMaximum,
Moteur_2_PointMort,
MOTEUR_2_VITESSE_MAXIMUM);
// Délai de fonctionnement des moteurs des roues pour pivoter le robot de 1°.
MoteursDelaiUnDegre = int (UneSeconde / ((Moteur_1_PointMort +
Moteur_2_PointMort) /
Servomoteur_1_AnglePas));
}
//*****************************************************************************
//*****************************************************************************
// 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, HAUT);
digitalWrite (CONTROLE_MOTEUR_1_IN2, BAS);
analogWrite (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
// Pour le moteur 2.
digitalWrite (CONTROLE_MOTEUR_1_IN3, BAS);
digitalWrite (CONTROLE_MOTEUR_1_IN4, BAS);
analogWrite (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************
//*****************************************************************************
// FONCTION DeplacementAvancerGauche
//*****************************************************************************
void DeplacementAvancerGauche ()
{
// Pour le moteur 1.
digitalWrite (CONTROLE_MOTEUR_1_IN1, BAS);
digitalWrite (CONTROLE_MOTEUR_1_IN2, BAS);
analogWrite (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
// Pour le moteur 2.
digitalWrite (CONTROLE_MOTEUR_1_IN3, HAUT);
digitalWrite (CONTROLE_MOTEUR_1_IN4, BAS);
analogWrite (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************
//*****************************************************************************
// FONCTION DeplacementReculerDroite
//*****************************************************************************
void DeplacementReculerDroite ()
{
// Pour le moteur 1.
digitalWrite (CONTROLE_MOTEUR_1_IN1, BAS);
digitalWrite (CONTROLE_MOTEUR_1_IN2, HAUT);
analogWrite (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
// Pour le moteur 2.
digitalWrite (CONTROLE_MOTEUR_1_IN3, BAS);
digitalWrite (CONTROLE_MOTEUR_1_IN4, BAS);
analogWrite (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************
//*****************************************************************************
// FONCTION DeplacementReculerGauche
//*****************************************************************************
void DeplacementReculerGauche ()
{
// Pour le moteur 1.
digitalWrite (CONTROLE_MOTEUR_1_IN1, BAS);
digitalWrite (CONTROLE_MOTEUR_1_IN2, BAS);
analogWrite (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
// Pour le moteur 2.
digitalWrite (CONTROLE_MOTEUR_1_IN3, BAS);
digitalWrite (CONTROLE_MOTEUR_1_IN4, HAUT);
analogWrite (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************
//*****************************************************************************
// FONCTION DeplacementPivoterGauche
//*****************************************************************************
void DeplacementPivoterGauche ()
{
// Pour le moteur 1.
digitalWrite (CONTROLE_MOTEUR_1_IN1, BAS);
digitalWrite (CONTROLE_MOTEUR_1_IN2, HAUT);
analogWrite (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
// Pour le moteur 2.
digitalWrite (CONTROLE_MOTEUR_1_IN3, HAUT);
digitalWrite (CONTROLE_MOTEUR_1_IN4, BAS);
analogWrite (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************
//*****************************************************************************
// FONCTION DeplacementPivoterDroite
//*****************************************************************************
void DeplacementPivoterDroite ()
{
// Pour le moteur 1.
digitalWrite (CONTROLE_MOTEUR_1_IN1, HAUT);
digitalWrite (CONTROLE_MOTEUR_1_IN2, BAS);
analogWrite (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
// Pour le moteur 2.
digitalWrite (CONTROLE_MOTEUR_1_IN3, BAS);
digitalWrite (CONTROLE_MOTEUR_1_IN4, HAUT);
analogWrite (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************
//*****************************************************************************
// FONCTION 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.
Serial.print ("***********************************************************");
Serial.println ();
Serial.print ("Sonar_1_DistanceActuele : ");
Serial.print (Sonar_1_DistanceActuele);
Serial.println ();
Serial.print ("Servomoteur_1_Angle : ");
Serial.print (Servomoteur_1_Angle);
Serial.print ("Sonar_1_DistanceMaximumTrouve : ");
Serial.print (Sonar_1_DistanceMaximumTrouve);
Serial.println ();
Serial.print ("Sonar_1_DistanceMaximumTrouveAngle : ");
Serial.print (Sonar_1_DistanceMaximumTrouveAngle);
Serial.println ();
Serial.print ("* ReferencePuissance : ");
Serial.print (ReferencePuissance);
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 GererAffichages
//*****************************************************************************
void GererAffichages ()
{
if (AfficherMoniteurSerie)
{
GererAfficherMoniteurSerie ();
}
}
//*****************************************************************************
//*****************************************************************************
// FONCTION GererBoutonMarcheArret
//*****************************************************************************
void GererBoutonMarcheArret ()
/*
Gestion de l'utilisation d'un bouton sur la planche d'expérimentation.
*/
{
int EtatBouton = digitalRead (BOUTON_1_OUT);
if (EtatBouton == HAUT)
{
if (Boucler == OUI)
{
CodeSituation = 73;
DeplacementArreter ();
GererAffichages ();
R2D2_1 ();
Boucler = NON;
digitalWrite (DEL_1_VIN, Boucler);
// L'angle du servomoteur du sonar initialisé a 90°.
Servomoteur_1.write (Servomoteur_1_AngleCentre);
delay (UneSeconde);
// Configurer le port Arduino pour un RESET par télécommande.
pinMode (ARDUINO_RESET, SORTIE);
// Activer la broche ARDUINO_RESET.
digitalWrite (ARDUINO_RESET, BAS);
delay (UneSeconde);
}
else
{
CodeSituation = 74;
Bip_1 ();
Boucler = OUI;
digitalWrite (DEL_1_VIN, Boucler);
}
while (EtatBouton == HAUT)
{
delay (BoutonTempsRebon);// Pour absorber les micro-coupures des rebonds.
EtatBouton = digitalRead (BOUTON_1_OUT);
}
}
}
//*****************************************************************************
//*****************************************************************************
// FONCTION GererBoutonTeleCommande
//*****************************************************************************
void GererBoutonTeleCommande ()
/*
Gérer l'utilisation d'une télécommande type MP3 avec capteur infrarouge.
Ici tous les boutons de la télécommande sont listés et la majorité ont un
effet sur le déroulement de de la boucle principale ou sur les paramètres de
fonctionnement du moteur ou les deux la fois et la touche « Mode » est
l'actionneur de la broche RESET de la carte Arduino, donc du redémarrage du
Système complet.
En synthèse les boutons font :
Power : Active/désactive la boucle principale du programme, arrêt moteur.
Mode : Bouton kamikaze qui utilise la broche RESET de la carte Arduino.
Son :
PlayPause : Fait une pause des moteurs, comme un arrêt sur image.
Debut :
Fin :
EQ : Inversé l'état de cette variable, basculer On/Off Off/On.
Moins : Diminuer Moteur_1_PointMort et Moteur_2_PointMort de 10.
Plus : Ogmenter Moteur_1_PointMort et Moteur_2_PointMort de 10.
0 :
Recycle :
U_SD :
1 : Déplacement, Avancer en tournant à Gauche, une roue tourne.
2 : Déplacement, Avancer en ligne droite, les deux roues tournent.
3 : Déplacement, Avancer en tournant à Droit, une roue tourne.
4 : Déplacement, Pivoter en tournant à Gauche, les deux roues tournent.
5 : Déplacement, Arrêt sur place les deux roues s'arrêtent.
6 : Déplacement, Pivoter en tournant à Droit, les deux roues tournent.
7 : Déplacement, Reculer en tournant à Gauche, une roue tourne.
8 : Déplacement, Reculer en ligne droite, une roue tourne.
9 : Déplacement, Reculer en tournant à Droit, une roue tourne.
default : Une télécommande génère beaucoup d'autres codes qui sont inutiles ici.
*/
{
if (Capteur_IR_0.decode (&Capteur_IR_0_Results))
{
// Récupérer la valeur de la touche de la télécommande.
TelecommandeBoutonValeur = Capteur_IR_0_Results.value;
Capteur_IR_0.resume ();
switch (TelecommandeBoutonValeur)
{
case TelecommandeBoutonPower:
Serial.print ("* TelecommandeBoutonPower = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
Bip_1 ();
if (Boucler == OUI)
{
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;
GererAffichages ();
DeplacementArreter ();
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;
// Inversé l'état de cette variable, basculer On/Off Off/On.
AfficherMoniteurSerie = AfficherMoniteurSerie - 1;
Bip_1 ();
break;
case TelecommandeBoutonMoins:
Serial.print ("* TelecommandeBoutonMoins = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 84;
Moteur_1_PointMort = Moteur_1_PointMort - 10;
Moteur_2_PointMort = Moteur_2_PointMort - 10;
if (Moteur_1_PointMort < 0)
{
Moteur_1_PointMort = 0;
Moteur_2_PointMort = 0;
}
Bip_1 ();
break;
case TelecommandeBoutonPlus:
Serial.print ("* TelecommandeBoutonPlus = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 85;
Moteur_1_PointMort = Moteur_1_PointMort + 10;
Moteur_2_PointMort = Moteur_2_PointMort + 10;
if (Moteur_1_PointMort > MOTEUR_1_VITESSE_MAXIMUM)
{
Moteur_1_PointMort = MOTEUR_1_VITESSE_MAXIMUM;
Moteur_2_PointMort = MOTEUR_2_VITESSE_MAXIMUM;
}
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 ();
AjusterVitesseDesMoteurs ();
DeplacementAvancerGauche ();
Boucler = NON;
digitalWrite (DEL_1_VIN, Boucler);
break;
case TelecommandeBouton2:
Serial.print ("* TelecommandeBouton2 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 90;
Bip_1 ();
AjusterVitesseDesMoteurs ();
DeplacementAvancer ();
Boucler = NON;
digitalWrite (DEL_1_VIN, Boucler);
break;
case TelecommandeBouton3:
Serial.print ("* TelecommandeBouton3 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 91;
Bip_1 ();
AjusterVitesseDesMoteurs ();
DeplacementAvancerDroite ();
Boucler = NON;
digitalWrite (DEL_1_VIN, Boucler);
break;
case TelecommandeBouton4:
Serial.print ("* TelecommandeBouton4 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 92;
Bip_1 ();
AjusterVitesseDesMoteurs ();
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 ();
AjusterVitesseDesMoteurs ();
DeplacementPivoterDroite ();
Boucler = NON;
digitalWrite (DEL_1_VIN, Boucler);
break;
case TelecommandeBouton7:
Serial.print ("* TelecommandeBouton7 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 95;
Bip_1 ();
AjusterVitesseDesMoteurs ();
DeplacementReculerGauche ();
Boucler = NON;
digitalWrite (DEL_1_VIN, Boucler);
break;
case TelecommandeBouton8:
Serial.print ("* TelecommandeBouton8 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 96;
Bip_1 ();
AjusterVitesseDesMoteurs ();
DeplacementReculer ();
Boucler = NON;
digitalWrite (DEL_1_VIN, Boucler);
break;
case TelecommandeBouton9:
Serial.print ("* TelecommandeBouton9 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 97;
Bip_1 ();
AjusterVitesseDesMoteurs ();
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 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 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 EchosSonar1 [Sonar_1_NombreDeLecture];
long TotalDistanceEcho1 = 0;
int MoyenneDistanceEcho1 = 0;
for (int i = 0; i < Sonar_1_NombreDeLecture; i = i + 1)
{
CapteurUltrasonUneLecture ();
EchosSonar1 [i] = Sonar_1_DistanceActuele;
TotalDistanceEcho1 = TotalDistanceEcho1 + EchosSonar1 [i];
}
MoyenneDistanceEcho1 = int (TotalDistanceEcho1 / Sonar_1_NombreDeLecture);
Sonar_1_DistanceActuele = MoyenneDistanceEcho1;
}
//*****************************************************************************
//*****************************************************************************
// FONCTION CapAuPlusGrandDegagement
//*****************************************************************************
void CapAuPlusGrandDegagement ()
{
CodeSituation = 47;
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)
{
DeplacementPivoterGauche ();
Servomoteur_1_Angle = Servomoteur_1_Angle - Servomoteur_1_AnglePas;
}
else
{
DeplacementPivoterDroite ();
Servomoteur_1_Angle = Servomoteur_1_Angle + Servomoteur_1_AnglePas;
}
Servomoteur_1.write (Servomoteur_1_Angle);
delay (MoteursDelaiUnDegre);
GererAffichages ();
}
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 (UneSeconde / 2);
while (Servomoteur_1_Angle <= Servomoteur_1_AngleMaximum)
{
Servomoteur_1.write (Servomoteur_1_Angle);
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;
delay (Sonar_1_DelaiEntreMesures);
GererAffichages ();
}
Servomoteur_1_Angle = Sonar_1_DistanceMaximumTrouveAngle;
Servomoteur_1.write (Servomoteur_1_Angle);
DeplacementArreter ();
delay (UneSeconde / 2);
CapAuPlusGrandDegagement ();
}
//*****************************************************************************
//*****************************************************************************
// FONCTION SortieTrouve
//*****************************************************************************
void SortieTrouve ()
{
DeplacementArreter ();
Servomoteur_1.write (Servomoteur_1_AngleCentre);
delay (UneSeconde);
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 GererDeplacements
//*****************************************************************************
void GererDeplacements ()
{
ReferencePuissance = mapFloat (analogRead (ARDUINO_IOREF), 0, 1023, 0.0, 5.0);
GererAffichages ();
GererBoutons ();
CapteurUltrasonLectures ();
AjusterVitesseDesMoteurs ();
if (Sonar_1_DistanceActuele <= Distance1)
{
CodeSituation = 6;
DeplacementReculer ();
}
else if ((Sonar_1_DistanceActuele > Distance1) and
(Sonar_1_DistanceActuele <= Distance2))
{
CodeSituation = 7;
DeplacementArreter ();
TrouverPlusGrandDegagement ();
AjusterVitesseDesMoteurs ();
DeplacementAvancer ();
}
else if ((Sonar_1_DistanceActuele > Distance2) and
(Sonar_1_DistanceActuele <= Distance3))
{
CodeSituation = 8;
DeplacementAvancer ();
}
else if ((Sonar_1_DistanceActuele > Distance3) and
(Sonar_1_DistanceActuele <= Distance4))
{
CodeSituation = 9;
DeplacementAvancer ();
}
else if (Sonar_1_DistanceActuele > Distance4)
{
CodeSituation = 10;
DeplacementArreter ();
SortieTrouve ();
}
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 (NOM_DU_PROGRAMME);
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 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);
// 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 ();
// Fixer le BUZZER_1_VIN en sortie.
pinMode (BUZZER_1_VIN, SORTIE);
Bip_1 ();
// Active la DEL de l'Arduino.
pinMode (DEL_1_VIN, SORTIE);
digitalWrite (DEL_1_VIN, Boucler);
Serial.print ("***********************************************************");
Serial.println ();
Serial.print ("* Attante : Telecommande (Power) ou Bouton MarcheArret... *");
Serial.println ();
Serial.print ("***********************************************************");
Serial.println ();
// Boucle pour éviter qu'un ancien programme chargé ne s'exécute avec un
// nouveau montage installé, en attente du chargement du nouveau programme.
// Jusqu'ici, c'est le minimum qui est activé, le reste des connexions
// seront activé après la boucle d'attente.
while (Boucler == NON)
{
GererBoutons ();
}
digitalWrite (DEL_1_VIN, Boucler);
// Activer la broche analogique de l'Arduino pour la lecture de la pouissance
// du caurant électrique de référence.
pinMode (ARDUINO_IOREF, ENTREE);
// 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_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);
// Initialisation des servomoteur du sonar 1.
Servomoteur_1.attach (SERVOMOTEUR_1_IN, Servomoteur_1_FrequenceMinimum,
Servomoteur_1_FrequenceMaximum);
// L'angle du servomoteur du sonar initialisé a 90°.
Servomoteur_1.write (Servomoteur_1_AngleCentre);
delay (UneSeconde / 3);
// Pour le sonar, activation des port de l'Arduino.
pinMode (SONAR_1_TRIG, SORTIE);
pinMode (SONAR_1_ECHO, ENTREE);
// 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 ("***********************************************************");
Moteur_1_Vitesse = Moteur_1_PointMort;
Moteur_2_Vitesse = Moteur_2_PointMort;
TrouverPlusGrandDegagement ();
}
//*****************************************************************************
//*****************************************************************************
// FONCTION LOOP = Boucle sans fin = coeur du programme.
//*****************************************************************************
// La fonction loop() s'exécute sans fin en boucle aussi longtemps que
// l'Arduino est sous tension.
void loop()
{
// Ici les instructions à exécuter par le programme principal.
GererBoutons ();
if (Boucler == OUI)
{
GererDeplacements ();
}
}
//*****************************************************************************