Bonjour cher J-M-L,
Un grand merci pour votre aide !
Tout est dans le code :
//*****************************************************************************
// Programme Arduino : RobotMega3Enco3Sonar
//*****************************************************************************
// Nom du programme pour l'afficher sur le terminal série et/ou de l'écran LCD.
const char NOM_DU_PROGRAMME [21] = "RobotMega3Enco3Sonar";
/*
Écrit par : L'ami René
Date : 2024-02-06
Ce code source est sous licence publique générale GNU (GNU General Public
Licence "GPL"), désignation « open source », ou « code source ouvert ».
Référence :
http://www.fsffrance.org/index.fr.html
Ce programme est un logiciel libre; vous pouvez le redistribuer et / ou le
modifier selon les termes de la licence GNU V2. Ce programme est distribué
dans l'espoir qu'il sera utile, mais SANS AUCUNE GARANTIE, sans même la
garantie implicite de COMMERCIALISATION ou D'ADAPTATION À UN USAGE
PARTICULIER. Voir la GNU General Public License, Version 2 pour plus de
détails.
Ce code source se veut didactique, c'est pourquoi les commentaires y prennent
une très grande place. Mais cela ne doit pas vous effrayez, au contraire, cela
devrait vous rassurez en facilitant la compréhension du code source.
Noter qu'en soi, ce code source est complet et autonome, car il inclut la liste
détaillée de toutes les composantes et la liste de tous les branchements entre
ces composantes !
Il ne vous manque que les dessins 3D pour l'impression de sa coque et de ses
pièces d'assemblage à imprimer en PLA sur une imprimante 3D que vous trouverez
à l'adresse suivante :
http://WebEstrie.com/robot/vehicule/RobotMega2xEnco3xSon/ (pas fait !)
*/
//*****************************************************************************
// Que fait ce programme ?
//*****************************************************************************
/*
Ce programme contrôle un véhicule robot à deux ou quatre roues motrices et une
série de capteurs pour se déplacer en temps réel intelligemment en évitant les
obstacles. Il utilise trois modules à ultrason, des moteurs à courant continu
et quatre photorésistances pour l'option de trouver la ou il y à le plus de
lumière.
Sur l'écran LCD et/ou dans le moniteur série, il affiche des informations de
base des capteurs et sur les paramètres de fonctionnement.
Une télécommande et un capteur infrarouge permettent de le contrôler à distance
et de modifier plusieurs de ses paramètres. Sur le panneau de contrôle du
véhicule robot, il y a aussi un encodeur avec bouton pour les même action et
pour navigation dans les menus des configurations et des paramétrages du robot
et vous pouvez sélectionner des options de fonctionnement. Il est aussi
activable par un bouton directement sur le panneau de contrôle du véhicule
robot.
Point important de ce logiciel pour le bon fonctionnement de ce véhicule robot
est qu'il termine sa phase d'initialisation par la calibration des moteurs
roues en rapport entre autres avec la puissance de son alimentation électrique,
batterie ou transformateur de courant,etc.
Comme beaucoup de paramètres varient grandement au cours de l'utilisation d'un
tel véhicule, il est illusoire de programmer en dure avec des valeurs
constantes pour la puissance des moteurs, de l'écart de la puissance entre deux
moteurs supposés identique, l'usure des mécanismes d'engrenage, de la
variabilité de la source d'énergie, de la taille des roues, du type
d'engrenage, ou l'absence d'engrenage, etc., etc. !
Cela est rendu possible par l'utilisation d'un encodeur rotatif par moteur, ce
qui permet de déterminer le début du mouvement des roues et donc de la puissance
requise pour entrainer ce mouvement. Par la suite, ces encodeurs peuvent nous
aider à déterminer un mouvement de rotation du véhicule de 45°, 90°, à gauche ou
à droite, etc.
Donc la fonction « CalibrerVitesseMinimaleDesMoteurs » et
« AjusterVitesseDesMoteurs » (en fonction de la distance d'obstacles) sont des
plus utiles et raffinées pour donner une élégance dans ses mouvements et une
grande souplesse de fonctionnement pour un tel véhicule robot autonome ! Je
vous recommande leur étude et leur compréhension pour les intégrer dans vos
propres projets !
*/
//*****************************************************************************
//*****************************************************************************
// Matériel requis ?
//*****************************************************************************
/*
Testé avec : l'éditeur compilateur Arduino 2.2.1.
Liste Alphabétique des composantes d'électroniques
1 x Arduino Mega 2560 R3 :
http://arduino.cc/en/Main/ArduinoBoardMega2560
https://fr.aliexpress.com/item/1005006448489951.html
https://fr.aliexpress.com/item/32864836449.html
6 x Batterie AA 1.5 vols :
https://fr.aliexpress.com/item/1005006387669116.html
https://fr.aliexpress.com/item/1005006384828726.html
https://fr.aliexpress.com/item/1005006072808203.html
1 x Boîtier à 6 piles AA 1.5V (9V) avec interrupteur et fils :
https://fr.aliexpress.com/item/1005004017931520.html
https://fr.aliexpress.com/item/1005006356512618.html
https://fr.aliexpress.com/item/1005005924631880.html
1 x Bouton poussoir, Micro interrupteur Normalement Ouvert "NO" :
https://fr.aliexpress.com/item/32711341102.html
https://fr.aliexpress.com/item/1005003989505144.html
https://fr.aliexpress.com/item/1005004066208352.html
1 x Buzzers Mini Piézo-Électriques Passive.
https://fr.aliexpress.com/item/1005006256552017.html
https://fr.aliexpress.com/item/1005002930525751.html
https://fr.aliexpress.com/item/1005004565293129.html
1 x Capteur infra-rouge VS1838B (TSOP1838) :
https://fr.aliexpress.com/item/1005006007931230.html
https://fr.aliexpress.com/item/1005005488538772.html
http://www.dipmicro.com/store/VS1838B
1 x Condansateur Électrolytiques en Aluminium 2200uF 16V pour fournir les moteurs :
https://fr.aliexpress.com/item/1005005464790655.html
https://fr.aliexpress.com/item/1005005673464788.html
https://fr.aliexpress.com/item/1005005682537727.html
1 x Connecteur d'alimentation 5.5x2.1mm cc mâle Type N pour le boîtier à 6 piles AA :
https://fr.aliexpress.com/item/1005003324016159.html
https://fr.aliexpress.com/item/1005006036710451.html
https://fr.aliexpress.com/item/32809663369.html
1 x Connecteur d'alimentation 5.5x2.1mm cc femelle Type A pour la batterie :
https://fr.aliexpress.com/item/1005003324016159.html
https://fr.aliexpress.com/item/1005005909680276.html
https://fr.aliexpress.com/item/1005005583190148.html
1 x Connecteur d'alimentation 5.5x2.1mm cc femelle Type B avec écrou et
antidésèrrement pour le transformateur 9V :
https://fr.aliexpress.com/item/1005003324016159.html
https://fr.aliexpress.com/item/1005005909680276.html
https://fr.aliexpress.com/item/1005005583190148.html
1 x Contrôleur moteur L298N (H-Bridge) pour 2 moteurs CC ou 1 moteur Pas-A-Pas () :
https://fr.aliexpress.com/item/1005004510885871.html
https://fr.aliexpress.com/item/32341874990.html
https://fr.aliexpress.com/item/32392774289.html
1 x DEL Rouge 5.8x8.7mm :
https://fr.aliexpress.com/item/1005003323707856.html
https://fr.aliexpress.com/item/1005005952395859.html
https://fr.aliexpress.com/item/1005003432647675.html
1 x DEL Verte 5.8x8.7mm :
https://fr.aliexpress.com/item/1005003323707856.html
https://fr.aliexpress.com/item/1005005952395859.html
https://fr.aliexpress.com/item/1005003432647675.html
2 x Disque codé Enprint 20 Ardu37, capteur de vitesse de moteur :
https://fr.aliexpress.com/item/1005001908600579.html
https://fr.aliexpress.com/item/1005001336311401.html
https://fr.aliexpress.com/item/32947632534.html
1 x Encodeur avec bouton sur circuit PCS :
https://fr.aliexpress.com/item/1005004907455524.html
https://fr.aliexpress.com/item/1005003300314049.html
https://fr.aliexpress.com/item/1005006332290643.html
2 x Encodeur HC-020K pour mesure de vitesse de moteur Jaune 6V :
https://fr.aliexpress.com/item/1005006176737810.html
https://fr.aliexpress.com/item/1005006164765058.html
https://fr.aliexpress.com/item/1005006420449202.html
ou
2 x Encodeur Photoélectrique avec Roue de Code à Disque 100 pas, 5V :
https://fr.aliexpress.com/item/1005005534364654.html
https://fr.aliexpress.com/item/1005005445455265.html
https://fr.aliexpress.com/item/32224660620.html
ou
2 x Moteur 6V avec Encodeur Photoélectrique :
https://fr.aliexpress.com/item/1005005234125215.html
https://fr.aliexpress.com/item/1005004110888400.html
https://fr.aliexpress.com/item/1005005713398408.html
https://fr.aliexpress.com/item/1005006213335546.html
1 x Écran LCD LCD2004 :
https://fr.aliexpress.com/item/1005006371702040.html
https://fr.aliexpress.com/item/32674601164.html
https://fr.aliexpress.com/item/1005006255534216.html
1 x Interrupteur à Bascule On/On, 6 Broches, 2 Positions, 3A/250V 125V, DPDT :
https://fr.aliexpress.com/item/1005006365101434.html
https://fr.aliexpress.com/item/1005006386779445.html
https://fr.aliexpress.com/item/1005006346449714.html
1 x Mini planche d'expérimentation « BreadBoard » Mini SYB-170, 170 trous 35x47x8.5mm.
https://fr.aliexpress.com/item/1005006456712969.html
https://fr.aliexpress.com/item/1005006232950695.html
https://fr.aliexpress.com/item/1005005780999096.html
2 x Moteur TT 130 à Double Arbre Jaune pour Voiture Intelligente, Engrenage de Robot.
https://fr.aliexpress.com/item/32988510791.html
https://fr.aliexpress.com/item/1005005973832962.html
https://fr.aliexpress.com/item/1005006221323967.html
4 x Photos résistances électroluminescentes :
50 = 3.78$
https://fr.aliexpress.com/item/1005005968714360.html
https://fr.aliexpress.com/item/1005006003964922.html
https://fr.aliexpress.com/item/1005006105047042.html
2 x Potentiomètre 10K trois pattes multitours :
https://fr.aliexpress.com/item/1005005227555972.html
https://fr.aliexpress.com/item/1005005686800626.html
https://fr.aliexpress.com/item/1005002294492193.html
1 x Résistance de 1/4 Watt (si vous préférez cela au "PullUp" du controleur) :
https://fr.aliexpress.com/item/1005002020611725.html
https://fr.aliexpress.com/item/1005001969271262.html
https://fr.aliexpress.com/item/1005006221871266.html
2 x Roues jaune pour moteur 5V jaune :
https://fr.aliexpress.com/item/32988510791.html
https://fr.aliexpress.com/item/1005005973832962.html
https://fr.aliexpress.com/item/1005001651643237.html
3 x Sonar Capteur ultrason (émetteur/récepteur) HR-SC04.
https://fr.aliexpress.com/item/4000899746914.html
https://fr.aliexpress.com/item/1005005630804519.html
https://fr.aliexpress.com/item/1005005314866486.html
1 x Télécommande universelle :
https://fr.aliexpress.com/item/4001053955330.html
https://fr.aliexpress.com/item/1005001360846809.html
https://fr.aliexpress.com/item/1005004479228888.html
1 x Transformateur 9V, 1A avec connecteur 5.5x2.5mm :
https://fr.aliexpress.com/item/1005004497000966.html
https://fr.aliexpress.com/item/1005003022363957.html
https://fr.aliexpress.com/item/1005006393726407.html
Autres liens en rapport avec le sujet :
1 x Câbles Dupon M-M, F-F et M-F :
https://fr.aliexpress.com/item/1005003021442186.html
https://fr.aliexpress.com/item/1005005231300375.html
https://fr.aliexpress.com/item/1005005924705004.html
1 x Câble d'extension, fil électrique allergique, 2 broches, 20 AWG corde
2468, 2x0.5mm, utilisation pour 9V à 24V :
https://fr.aliexpress.com/item/1005006075807377.html
https://fr.aliexpress.com/item/1005005565459721.html
https://fr.aliexpress.com/item/1005005626890017.html
1 x Condensateur électrolytique 6.3V1500UF à 450V150UF :
https://fr.aliexpress.com/item/1005006104970422.html
https://fr.aliexpress.com/item/1005003189675117.html
https://fr.aliexpress.com/item/1005006152274501.html
1 x Kit de connecteurs Dupont PCB, 1550 pièces, 2.54mm, broches mâles et femelles :
https://fr.aliexpress.com/item/4000006740596.html
1 x Pince coupe fil en acier au carbone, coupe-câble électronique bricolage :
https://fr.aliexpress.com/item/1005006034297985.html
1 x Pince à dénuder de précision et réglable, FS-D5Y :
https://fr.aliexpress.com/item/1005005876356584.html
https://fr.aliexpress.com/item/1005006408271255.html
1 x Pince à sertir série mersible SN-48BS 0.25-1.5mm 2/23-16AWG pour onglet 2.8 4.8 6.3 SM2.5 DuPont2.54 :
https://fr.aliexpress.com/item/1005005046405703.html
https://fr.aliexpress.com/item/1005005614121560.html
1 x Résistances à couche de carbone, 100 pièces/lot, 1/4W, de 1R à 10M Ohm :
https://fr.aliexpress.com/item/1005006207035114.html
https://fr.aliexpress.com/item/1005005681112858.html
https://fr.aliexpress.com/item/1005006203325326.html
*/
//*****************************************************************************
//*****************************************************************************
// Circuit à réaliser.
//*****************************************************************************
/*
Dans cette section, toutes les connexions des composantes du montage sont
listées, qu'ils soient utilisés ou non, et cela pour éviter tout oublie et
rendre le copier / coller par bloc complet pour une pièce, plus facile d'un
montage à l'autre. Le plus souvent possible le libellé de la pièce précédé du
nom court de la pièce est utilisé, par exemple « ARDUINO_A3 », pour la broche
analogique A3 d'une carte contrôleur Arduino Uno ou Mega, etc.
Pour les circuits des branchement en image avec Fritzing, voir la page Web :
http://WebEstrie.com/robot/vehicule/RobotMega2xEnco3xSon/ (pas fait !)
Câblage de l'Arduino Mega R3 avec les composantes :
ARDUINO_USB = Par câble USB à un ordinateur
ARDUINO_PWR7_A_12V = En phase de test Adaptateur 9V, autonome piles 9V (6xAA1.5V)
ARDUINO_IOREF =
ARDUINO_RESET = ARDUINO_A0 (Kamikaze par télécommande)
ARDUINO_3_3V =
ARDUINO_5V_1 =
ARDUINO_GND1 = DEL_2_VERTE_GND
ARDUINO_GND2 = CONTROLE_MOTEUR_1_GND;
ARDUINO_VIN = CONTROLE_MOTEUR_1_5V;
ARDUINO_A0 = ARDUINO_RECET (Kamikaze par télécommande ou bouton)
ARDUINO_A1 = PHOTO_RESISTANCE_1_OUT
ARDUINO_A2 = PHOTO_RESISTANCE_2_OUT
ARDUINO_A3 = PHOTO_RESISTANCE_3_OUT
ARDUINO_A4 = PHOTO_RESISTANCE_4_OUT
ARDUINO_A5 =
ARDUINO_A6 =
ARDUINO_A7 =
ARDUINO_A8 =
ARDUINO_A9 =
ARDUINO_A10 = SONAR_3_ECHO
ARDUINO_A11 = SONAR_3_TRIG
ARDUINO_A12 = SONAR_2_ECHO
ARDUINO_A13 = SONAR_2_TRIG
ARDUINO_A14 = SONAR_1_ECHO
ARDUINO_A15 = SONAR_1_TRIG
ARDUINO_SCL =
ARDUINO_SDA =
ARDUINO_AREF =
ARDUINO_GND3 = DEL_1_ROUGE_GND
ARDUINO_13_PWM_DEL = DEL_1_ROUGE_VCC
ARDUINO_12_PWM = BUZZER_1_VIN
ARDUINO_11_PWM = DEL_2_VERTE_VCC
ARDUINO_10_PWM = ENCODEUR_0_BOUTON
ARDUINO_9_PWM =
ARDUINO_8_PWM =
ARDUINO_7_PWM =
ARDUINO_6_PWM =
ARDUINO_5_PWM =
ARDUINO_4_PWM =
ARDUINO_3_PWM_INT1 = ENCODEUR_0_S2
ARDUINO_2_PWM_INT0 = ENCODEUR_0_S1
ARDUINO_1_PWM_TX0 =
ARDUINO_0_PWM_RX0 =
ARDUINO_14_PWM_TX3 =
ARDUINO_15_PWM_RX3 =
ARDUINO_16_PWM_TX2 =
ARDUINO_17_PWM_RX2 =
ARDUINO_18_PWM_TX1_INT5 = BOUTON_1_ETAT
ARDUINO_19_PWM_RX1_INT4 = ENCODEUR_2_SORTIE
ARDUINO_20_PWM_SDA_INT3 = ENCODEUR_1_SORTIE
ARDUINO_21_PWM_SCL_INT2 = CAPTEUR_IR_0_OUT
ARDUINO_5V_2 =
ARDUINO_5V_3 =
ARDUINO_22 = LCD_1_RS
ARDUINO_23 = LCD_1_E
ARDUINO_24 = LCD_1_D4
ARDUINO_25 = LCD_1_D5
ARDUINO_26 = LCD_1_D6
ARDUINO_27 = LCD_1_D7
ARDUINO_28 =
ARDUINO_29 =
ARDUINO_30 =
ARDUINO_31 =
ARDUINO_32 =
ARDUINO_33 =
ARDUINO_34 =
ARDUINO_35 =
ARDUINO_36 =
ARDUINO_37 =
ARDUINO_38 =
ARDUINO_39 =
ARDUINO_40 = CONTROLE_MOTEUR_1_IN2
ARDUINO_41 = CONTROLE_MOTEUR_1_IN4
ARDUINO_42 = CONTROLE_MOTEUR_1_IN1
ARDUINO_43 = CONTROLE_MOTEUR_1_IN3
ARDUINO_44_PWM = CONTROLE_MOTEUR_1_ENA
ARDUINO_45_PWM = CONTROLE_MOTEUR_1_ENB
ARDUINO_46_PWM =
ARDUINO_47 =
ARDUINO_48 =
ARDUINO_49 =
ARDUINO_40 =
ARDUINO_41 =
ARDUINO_42 =
ARDUINO_43 =
ARDUINO_44 =
ARDUINO_45 =
ARDUINO_46 =
ARDUINO_47 =
ARDUINO_48 =
ARDUINO_49 =
ARDUINO_50_MISO =
ARDUINO_51_MOSI =
ARDUINO_52_SCK =
ARDUINO_53_SS =
ARDUINO_GND4 =
ARDUINO_GND5 =
AREF
ARDUINO_RESET2 =
ARDUINO_SCK2 =
ARDUINO_MISO2 =
ARDUINO_GND6 =
ARDUINO_MOSI2 =
ARDUINO_5V4 =
ICSP
ARDUINO_RESET3 =
ARDUINO_SCK3 =
ARDUINO_MISO3 =
ARDUINO_GND6 =
ARDUINO_MOSI3 =
ARDUINO_5V5 =
Câblage pour le boitier des 6 batteries AA :
BATTERIES_1_VIN = CONNECTEUR_5MM_1_VIN
BATTERIES_1_GND = CONNECTEUR_5MM_1_GND
Câblage pour le Bouton sur le panneau de contrôle du véhicule robot :
BOUTON_1_ETAT = ARDUINO_18_PWM_TX1_INT5
BOUTON_1_GND = MINI_BB_GND
Câblage pour le Buzzer sur la planche d'expérimentation et l'Arduino :
BUZZER_1_VIN = ARDUINO_12_MISO
BUZZER_1_GND = MINI_BB_GND
Câblage pour le capteur infra-rouge utiliser avec la télécommande, sur la
planche d'expérimentation :
CAPTEUR_IR_0_OUT = ARDUINO_21_PWM_SCL_INT2
CAPTEUR_IR_0_GND = MINI_BB_GND
CAPTEUR_IR_0_VIN = MINI_BB_5V
Câblage d'un condansateur 2200uF 16V pour fournir les moteurs :
CONDENSATEUR_2200uF_16V_VCC = CONTROLE_MOTEUR_1_VIN
CONDENSATEUR_2200uF_16V_GND = CONTROLE_MOTEUR_1_GND
Câblage pour le connecteur 5mm Mâle pour la boîte de 6 batterie AA :
CONNECTEUR_BATTERIE_VIN = BATTERIES_1_VIN
CONNECTEUR_BATTERIE_GND = BATTERIES_1_GND
Câblage pour le connecteur 5mm femelle pour la boîte de 6 batterie AA :
CONNECTEUR_TRANSFORMATEUR_VIN = INTERRUPTEUR_1_ENTRE_1_VCC
CONNECTEUR_TRANSFORMATEUR_GND = INTERRUPTEUR_1_ENTRE_1_GND
Câblage pour le connecteur 5mm femelle pour le transformateur 9V :
CONNECTEUR_5MM_3_VIN = INTERRUPTEUR_1_ENTRE_2_VCC
CONNECTEUR_5MM_4_GND = INTERRUPTEUR_1_ENTRE_2_GND
Câblage pour les deux moteur DC 6V 77RPM sur la planche d'expérimentation :
CONTROLE_MOTEUR_1_VIN = INTERRUPTEUR_1_SORTIE_VCC (Batterie et chargeur 9V); CONDENSATEUR_2200uF_16V_VCC
CONTROLE_MOTEUR_1_GND = INTERRUPTEUR_1_SORTIE_GND (Batterie et chargeur 9V); ARDUINO_GND2; MINI_BB_GND; CONDENSATEUR_2200uF_16V_GND
CONTROLE_MOTEUR_1_5V = ARDUINO_VIN; MINI_BB_5V
CONTROLE_MOTEUR_1_ENA = ARDUINO_4_PWM
CONTROLE_MOTEUR_1_IN1 = ARDUINO_6_PWM
CONTROLE_MOTEUR_1_IN2 = ARDUINO_5_PWM
CONTROLE_MOTEUR_1_ENB = ARDUINO_7_PWM
CONTROLE_MOTEUR_1_IN3 = ARDUINO_9_PWM
CONTROLE_MOTEUR_1_IN4 = ARDUINO_8_PWM
CONTROLE_MOTEUR_1_OUT1 = MOTEUR_1_GND
CONTROLE_MOTEUR_1_OUT2 = MOTEUR_1_VIN
CONTROLE_MOTEUR_1_OUT3 = MOTEUR_2_GND
CONTROLE_MOTEUR_1_OUT4 = MOTEUR_2_VIN
Câblage pour la DEL verte sur la planche d'expérimentation et l'Arduino
DEL_1_ROUGE_VCC = ARDUINO_13_PWM_DEL;
DEL_1_ROUGE_GND = ARDUINO_GND3;
Câblage pour la DEL verte sur la planche d'expérimentation et l'Arduino
DEL_2_VERTE_VCC = ARDUINO_11_PWM;
DEL_2_VERTE_GND = ARDUINO_GND1;
Câblage pour l'encodeur panneau de contrôle :
ENCODEUR_0_GND = MINI_BB_GND
ENCODEUR_0_S1 = ARDUINO_2_PWM_INT0
ENCODEUR_0_S2 = ARDUINO_3_PWM_INT1
ENCODEUR_0_BOUTON = ARDUINO_10_PWM
ENCODEUR_0_VCC = MINI_BB_5V
Câblage pour les encodeurs des roues :
ENCODEUR_1_VCC = MINI_BB_GND
ENCODEUR_1_GND = MINI_BB_5V
ENCODEUR_1_SORTIE = ARDUINO_20_PWM_SDA_INT3
ENCODEUR_2_VCC = MINI_BB_GND
ENCODEUR_2_GND = MINI_BB_5V
ENCODEUR_2_SORTIE = ARDUINO_19_PWM_RX1_INT4
Câblage directe de la carte à écran LCD LCD1602-6Boutons sur la carte Arduino :
Diagramme : http://www.zartronic.fr/doc/E2/E2N1P193/LCD_Keypad_Shield_SCH.pdf
LCD_1_VSS broche 1 = MINI_BB_GND
LCD_1_VDD broche 2 = MINI_BB_5V
LCD_1_VO broche 3 = POTENTIOMETRE_10K_1_OUT
LCD_1_RS broche 4 = ARDUINO_22
LCD_1_RW broche 5 = MINI_BB_GND
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 = POTENTIOMETRE_10K_2_OUT
LCD_1_K broche 16 = MINI_BB_GND
Câblage pour l'interrupteur deux position et 6 broche :
INTERRUPTEUR_1_ENTRE_1_VCC = CONNECTEUR_BATTERIE_VIN
INTERRUPTEUR_1_ENTRE_1_GND = CONNECTEUR_BATTERIE_GND
INTERRUPTEUR_1_ENTRE_2_VCC = CONNECTEUR_TRANSFORMATEUR_VIN
INTERRUPTEUR_1_ENTRE_2_GND = CONNECTEUR_TRANSFORMATEUR_GND
INTERRUPTEUR_1_SORTIE_VCC = CONTROLE_MOTEUR_1_VIN
INTERRUPTEUR_1_SORTIE_GND = CONTROLE_MOTEUR_1_GND
Câblage sur la mini planche d'expérimentation (en synthèse car inutil de plus
de détails, cela n'est pas utiles, mais voir l'image de ma mini générique) :
MINI_BB_GND = (plusieur branchements pour les -)
MINI_BB_5V = (plusieur branchements pour les +)
Câblage pour les 2 moteur 6V avec réducteur :
MOTEUR_1_VCC = CONTROLE_MOTEUR_1_OUT1
MOTEUR_1_GND = CONTROLE_MOTEUR_2_OUT1
MOTEUR_2_VCC = CONTROLE_MOTEUR_3_OUT1
MOTEUR_2_GND = CONTROLE_MOTEUR_4_OUT1
Câblage pour les 4 photos résistances électroluminescentes :
PHOTO_RESISTANCE_1_OUT = ARDUINO_A1
PHOTO_RESISTANCE_1_VIN = MINI_BB_5V
PHOTO_RESISTANCE_2_OUT = ARDUINO_A2
PHOTO_RESISTANCE_2_VIN = MINI_BB_5V
PHOTO_RESISTANCE_3_OUT = ARDUINO_A3
PHOTO_RESISTANCE_3_VIN = MINI_BB_5V
PHOTO_RESISTANCE_4_OUT = ARDUINO_A4
PHOTO_RESISTANCE_4_VIN = MINI_BB_5V
Câblage pour le potentiometre 10KOhm pour la valeur de la luminosité des
caractre sur l'écran LCD :
POTENTIOMETRE_10K_1_VIN = MINI_BB_5V
POTENTIOMETRE_10K_1_OUT = LCD_1_VO
POTENTIOMETRE_10K_1_GND = MINI_BB_GND
Câblage pour le potentiometre 10KOhm pour la valeur de la luminosité du
rétroéclairage sur l'écran LCD :
POTENTIOMETRE_10K_2_VIN = MINI_BB_5V
POTENTIOMETRE_10K_2_OUT = LCD_1_A
POTENTIOMETRE_10K_2_GND = MINI_BB_GND
Câblage pour les 3 modules à ultrason :
SONAR_1_VCC = MINI_BB_5V
SONAR_1_TRIG = ARDUINO_A15
SONAR_1_ECHO = ARDUINO_A14
SONAR_1_GND = MINI_BB_GND
SONAR_2_VCC = MINI_BB_5V
SONAR_2_TRIG = ARDUINO_A13
SONAR_2_ECHO = ARDUINO_A12
SONAR_2_GND = MINI_BB_GND
SONAR_3_VCC = MINI_BB_5V
SONAR_3_TRIG = ARDUINO_11
SONAR_3_ECHO = ARDUINO_10
SONAR_3_GND = MINI_BB_GND
*/
//*****************************************************************************
//*****************************************************************************
// Inclusion des librairies utilisées.
//*****************************************************************************
#include "IRremote.h"
/*
Il s'agit de la bibliothèque IrRemote pour télécommande avec l'Arduino.
Pour télécharger depuis github :
http://github.com/shirriff/Arduino-IRremote
Cliquez sur le lien "Télécharger" en haut à droite, cliquez sur « Télécharger
au format Zip", pour obtenir un fichier zip. Décompressez-le et renommez le
répertoire « Shirriff-Arduino-irRemote-NNN » pour « irRemote ». Pour
l'installer, déplacer le répertoire de irRemote téléchargée dans votre dossier
des bibliothèque Arduino « ~/Arduino/libraries/IRremote ». Pour avoir accès à la
nouvelle bibliothèque, vous devez redémarrer l'éditeur Arduino. Pour plus de
détails sur la bibliothèque voir le wiki sur github ou le poste :
http://arcfn.com/2009/08/multi-protocol-infrared-remote-library.html blog
Copyright 2009-2012 Ken Shirriff
Merci à cette personne pour sa contribution !
*/
#include "LiquidCrystal.h"
/*
« Cette librairie permet à une carte Arduino de contrôler un afficheur LCD
alphanumérique standard à cristaux liquides basé sur le circuit intégré Hitachi
HD44780 (ou compatible), ce qui est le cas de la plupart des afficheurs
alphanumériques LCD disponibles. La librairie fonctionne aussi bien en mode 4
bits qu'en mode 8 bits (càd utilisant 4 ou 8 broches numériques en plus des
broches de contrôle RS, Enable et RW (optionnel)). Ainsi, en mode 4 bits,
6 broches numériques de la carte Arduino suffisent pour contrôler un afficheur
LCD alphanumérique.
Référence : http://arduino.cc/fr/Main/LibrairieLCD
*/
#include "NotesDeMusique.h"
/*
Fichier contenant les définitions de notes de musique.
*/
#include "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 cette broche, 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 cette broche, 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 cette broche, 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_ETAT = 18;
// Câblage pour le Buzzer sur la planche d'expérimentation et l'Arduino :
const byte BUZZER_1_VIN = 12;
// Broche d'Arduino pour recevoir le signale du capteur infrarouge de télécom.
const byte CAPTEUR_IR_0_OUT = 21;
// Broche d'Arduino pour le controleur moteur 1 (double Pont en H).
const byte CONTROLE_MOTEUR_1_ENA = 4;
const byte CONTROLE_MOTEUR_1_IN1 = 6;
const byte CONTROLE_MOTEUR_1_IN2 = 5;
const byte CONTROLE_MOTEUR_1_ENB = 7;
const byte CONTROLE_MOTEUR_1_IN3 = 9;
const byte CONTROLE_MOTEUR_1_IN4 = 8;
// Câblage pour la DEL verte sur la planche d'expérimentation et l'Arduino
const byte DEL_1_ROUGE_VCC = 13;
// Câblage pour la DEL verte sur la planche d'expérimentation et l'Arduino
const byte DEL_2_VERTE_VCC = 11;
// Câblage pour les encodeurs des roue de l'Arduino :
byte ENCODEUR_1_SORTIE = 20;// Interruption # 1
byte ENCODEUR_2_SORTIE = 19;// Interruption # 2
// Câblage pour l'encodeur panneau de contrôle :
byte ENCODEUR_0_S1 = 2;// Interruption # 4
byte ENCODEUR_0_S2 = 3;// Interruption # 5
byte ENCODEUR_0_BOUTON = 10;// Pour le bouton de l'encodeur
// Pour ce type d'encodeur, il faut définir le nombre d'impultion que transmet
// l'encodeur pour un seul mouvement à gauche ou adroite. Ce nombre dépend de
// votre encodeur, par défaut c'est 4 pour les produits de base pas cher.
byte ENCODEUR_0_PAS_PAR_CLIC = 4;
// 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.
// Broches pour les 4 photorésistances.
// Référence 90-154-0, CDS Photo Cell 5K - 0.5M. Comme la cellule débute à 5K,
// nous devons metre une résistance d'autant entre la seconde broche
// « *_SORTIE », le GND et la broche de l'Arduino :
const byte PHOTO_RESISTANCE_1_OUT = A1;
const byte PHOTO_RESISTANCE_2_OUT = A2;
const byte PHOTO_RESISTANCE_3_OUT = A3;
const byte PHOTO_RESISTANCE_4_OUT = A4;
// Broche d'Arduino pour les capteur à ultrason, les sonars.
const byte SONAR_1_TRIG = A15;
const byte SONAR_1_ECHO = A14;
const byte SONAR_2_TRIG = A13;
const byte SONAR_2_ECHO = A12;
const byte SONAR_3_TRIG = A11;
const byte SONAR_3_ECHO = A10;
//*****************************************************************************
//*****************************************************************************
// Déclaration des autres constantes de travail.
//*****************************************************************************
// Nombre de lignes et de colonnes de l'objet ECRAN_LCD.
const byte LCD_1_NombreDeColonnes = 20;
const byte LCD_1_NombreDeLignes = 4;
//*****************************************************************************
//*****************************************************************************
// 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;
// Recoit la valeur indicant la condition de déplacement en cours.
byte CodeSituation = 0;
// Variable de travail pour les encodeurs des moteurs :
unsigned int Encodeur_InterruptionUnTour = 20;
word Encodeur_Periode = 50;
byte Encodeur_45Degres = 2;
byte Encodeur_90Degres = 4;
unsigned long Encodeur_TempDeDepart = 0;
unsigned int Roue_1_UnPas = 360 / Encodeur_InterruptionUnTour;
unsigned int Roue_2_UnPas = Roue_1_UnPas;
volatile byte Encodeur_1_InterCompteur = 0;
volatile byte Encodeur_2_InterCompteur = 0;
volatile byte Encodeur_1_InterParMinute = 0;
volatile byte Encodeur_2_InterParMinute = 0;
unsigned int Encodeur_1_TourParMinute = 0;
unsigned int Encodeur_2_TourParMinute = 0;
// Variable du menu par l'encodeurs du panneau de commande sur le véhicule.
String EncodeurTexte = "";
long MenuPosition = 0;
// 200/255 est le maximum et le maximum est de 255/255 pour les moteur.
word Moteur_1_VitesseMinimum = 0;// C'est le plus bas possible.
word Moteur_1_VitesseMaximum = 255;// 255 est le plus haut possible.
word Moteur_2_VitesseMinimum = 0;// C'est le plus bas possible.
word Moteur_2_VitesseMaximum = 255;// 255 est le plus haut possible.
// Contiend la vitesse moteur à applique et donc aussi la vitesse courante.
byte Moteur_1_Vitesse = 0;
byte Moteur_2_Vitesse = 0;
// Délai de fonctionnement des moteurs des roues pour pivoter le robot de 1°.
float MoteursDelaiUnDegre = 800;// En millisesonde.
// Recoit la valeur indicant la luminosité détecté.
word PhotoResistance_1_Valeur = 0;
word PhotoResistance_2_Valeur = 0;
word PhotoResistance_3_Valeur = 0;
word PhotoResistance_4_Valeur = 0;
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 SonarDistanceValideMaximum = 400.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 = 5;
// Variable des distances conditionnant les mouvements du robot.
float Distance1 = 15.0;
float Distance2 = 30.0;
float Distance3 = 60.0;
float Distance4 = SonarDistanceValideMaximum;
// 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_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 GererAfficherMoniteurSerie
//*****************************************************************************
void GererAfficherMoniteurSerie ()
{
// Écriture dans le moniteur série de l'IDE d'Arduino des valeurs lues.
Serial.print ("***********************************************************");
Serial.println ();
Serial.print (" TempsActuele = ");
Serial.print (TempsActuele);
Serial.println ();
Serial.print ("* 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 ("* Moteur_1_Vitesse Mini/Actuel/Max = ");
Serial.print (Moteur_1_VitesseMinimum);
Serial.print (" ");
Serial.print (Moteur_1_Vitesse);
Serial.print (" ");
Serial.print (Moteur_1_VitesseMaximum);
Serial.println ();
Serial.print ("* Moteur_2_Vitesse Mini/Actuel/Max = ");
Serial.print (Moteur_2_VitesseMinimum);
Serial.print (" ");
Serial.print (Moteur_2_Vitesse);
Serial.print (" ");
Serial.print (Moteur_2_VitesseMaximum);
Serial.println ();
Serial.print ("* PhotoResistance_1_Valeur = ");
Serial.print (PhotoResistance_1_Valeur);
Serial.println ();
Serial.print ("* PhotoResistance_2_Valeur = ");
Serial.print (PhotoResistance_2_Valeur);
Serial.println ();
Serial.print ("* PhotoResistance_3_Valeur = ");
Serial.print (PhotoResistance_3_Valeur);
Serial.println ();
Serial.print ("* PhotoResistance_4_Valeur = ");
Serial.print (PhotoResistance_4_Valeur);
Serial.println ();
Serial.print ("Encodeur_1_TourParMinute = ");
Serial.print (Encodeur_1_TourParMinute);
Serial.println ();
Serial.print ("Encodeur_2_TourParMinute = ");
Serial.print (Encodeur_2_TourParMinute);
Serial.println ();
Serial.print ("* CodeSituation = ");
Serial.print (CodeSituation);
Serial.println ();
Serial.println ();
}
//*****************************************************************************
//*****************************************************************************
// FONCTION GererAfficherEcranLCD
//*****************************************************************************
void GererAfficherEcranLCD ()
{
// Écriture dans l'écran LCD des valeurs lues.
// NoColonne 00000000001111111111
// NoColonne 01234567890123456789
// Ligne 0 = 400 400 400 999
// Ligne 1 = 1023 1023 1023 1023
// Ligne 2 = 255 255 255 00
// Ligne 3 = 255 255 255 00 99999
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 (17, 0);
LCD_1.print (CodeSituation);
LCD_1.setCursor (0, 1);
LCD_1.print (PhotoResistance_1_Valeur);
LCD_1.setCursor (5, 1);
LCD_1.print (PhotoResistance_2_Valeur);
LCD_1.setCursor (10, 1);
LCD_1.print (PhotoResistance_3_Valeur);
LCD_1.setCursor (15, 1);
LCD_1.print (PhotoResistance_4_Valeur);
LCD_1.setCursor (0, 2);
LCD_1.print (Moteur_1_VitesseMinimum);
LCD_1.setCursor (4, 2);
LCD_1.print (Moteur_1_Vitesse);
LCD_1.setCursor (8, 2);
LCD_1.print (Moteur_1_VitesseMaximum);
LCD_1.setCursor (12, 2);
LCD_1.print (Encodeur_1_TourParMinute);
LCD_1.setCursor (0, 3);
LCD_1.print (Moteur_2_VitesseMinimum);
LCD_1.setCursor (4, 3);
LCD_1.print (Moteur_2_Vitesse);
LCD_1.setCursor (8, 3);
LCD_1.print (Moteur_2_VitesseMaximum);
LCD_1.setCursor (12, 3);
LCD_1.print (Encodeur_2_TourParMinute);
LCD_1.setCursor (15, 3);
LCD_1.print (MenuPosition);
}
//*****************************************************************************
//*****************************************************************************
// FONCTION GererAffichages
//*****************************************************************************
void GererAffichages ()
{
if (AfficherMoniteurSerie)
{
GererAfficherMoniteurSerie ();
}
if (AfficherEcranLCD)
{
GererAfficherEcranLCD ();
}
}
//*****************************************************************************
//*****************************************************************************
// 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 EncodeurConterInterruption_1
//*****************************************************************************
void EncodeurConterInterruption_1 ()
{
//Update count
Encodeur_1_InterParMinute = Encodeur_1_InterParMinute + 1;
Encodeur_1_InterCompteur = Encodeur_1_InterCompteur + 1;
}
//*****************************************************************************
//*****************************************************************************
// FONCTION EncodeurConterInterruption_2
//*****************************************************************************
void EncodeurConterInterruption_2 ()
{
//Update count
Encodeur_2_InterParMinute = Encodeur_2_InterParMinute + 1;
Encodeur_2_InterCompteur = Encodeur_2_InterCompteur + 1;
}
//*****************************************************************************
//*****************************************************************************
// FONCTION ConvertionMicrosecondsEnCentimetres
//*****************************************************************************
int ConvertionMicrosecondsEnCentimetres (int microseconds)
{
/*
La vitesse du son est de 340 metres par seconde ou 29 microsecondes par
centimètre. Le ping voyage aller et retour, de sorte à trouver la distance de
l'objet, nous prenons la moitié de la distance parcourue. Voir:
http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
*/
return microseconds / 29 / 2;// Donc division par 58.
}
//*****************************************************************************
//*****************************************************************************
// FONCTION LireCapteursUltrason_1
//*****************************************************************************
void LireCapteursUltrason_1 ()
{
/*
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 > SonarDistanceValideMaximum)
{
Sonar_1_DistanceActuele = SonarDistanceValideMaximum;
}
// Élimination d'une éventuelle valeur négative.
if (Sonar_1_DistanceActuele < 1)
{
Sonar_1_DistanceActuele = 1;
}
}
//*****************************************************************************
//*****************************************************************************
// FONCTION LireCapteursUltrason_2
//*****************************************************************************
void LireCapteursUltrason_2 ()
{
/*
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 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 > SonarDistanceValideMaximum)
{
Sonar_2_DistanceActuele = SonarDistanceValideMaximum;
}
// Élimination d'une éventuelle valeur négative.
if (Sonar_2_DistanceActuele < 1)
{
Sonar_2_DistanceActuele = 1;
}
}
//*****************************************************************************
//*****************************************************************************
// FONCTION LireCapteursUltrason_3
//*****************************************************************************
void LireCapteursUltrason_3 ()
{
/*
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 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 > SonarDistanceValideMaximum)
{
Sonar_3_DistanceActuele = SonarDistanceValideMaximum;
}
// Élimination d'une éventuelle valeur négative.
if (Sonar_3_DistanceActuele < 1)
{
Sonar_3_DistanceActuele = 1;
}
}
//*****************************************************************************
//*****************************************************************************
// FONCTION LireCapteursUltrasons
//*****************************************************************************
void LireCapteursUltrasons ()
{
// Pour contrer l'imprécission des echos sonars, deux lecture et la moyene.
byte i = 0;
float EchosSonar1 [Sonar_NombreDeLecture];
float EchosSonar2 [Sonar_NombreDeLecture];
float EchosSonar3 [Sonar_NombreDeLecture];
// Les lectures pour le sonar 1
i = 0;
LireCapteursUltrason_1 ();
EchosSonar1 [i] = Sonar_1_DistanceActuele;
while ((EchosSonar1 [i] ==! EchosSonar1 [i + 1]) and (i < Sonar_NombreDeLecture))
{
LireCapteursUltrason_1 ();
EchosSonar1 [i + 1] = Sonar_1_DistanceActuele;
if (EchosSonar1 [i] == EchosSonar1 [i + 1])
{
i = i + 1;
}
else
{
EchosSonar1 [i] = EchosSonar1 [i + 1];
}
}
// Les lectures pour le sonar 2
i = 0;
LireCapteursUltrason_2 ();
EchosSonar2 [i] = Sonar_2_DistanceActuele;
while ((EchosSonar2 [i] ==! EchosSonar2 [i + 1]) and (i < Sonar_NombreDeLecture))
{
LireCapteursUltrason_2 ();
EchosSonar2 [i + 1] = Sonar_2_DistanceActuele;
if (EchosSonar2 [i] == EchosSonar2 [i + 1])
{
i = i + 1;
}
else
{
EchosSonar2 [i] = EchosSonar2 [i + 1];
}
}
// Les lectures pour le sonar 3
i = 0;
LireCapteursUltrason_3 ();
EchosSonar3 [i] = Sonar_3_DistanceActuele;
while ((EchosSonar3 [i] ==! EchosSonar3 [i + 1]) and (i < Sonar_NombreDeLecture))
{
LireCapteursUltrason_3 ();
EchosSonar3 [i + 1] = Sonar_3_DistanceActuele;
if (EchosSonar3 [i] == EchosSonar3 [i + 1])
{
i = i + 1;
}
else
{
EchosSonar3 [i] = EchosSonar3 [i + 1];
}
}
}
//*****************************************************************************
//*****************************************************************************
// FONCTION LirePhotoResistances
//*****************************************************************************
void LirePhotoResistances ()
{
PhotoResistance_1_Valeur = analogRead (PHOTO_RESISTANCE_1_OUT);
PhotoResistance_2_Valeur = analogRead (PHOTO_RESISTANCE_2_OUT);
PhotoResistance_3_Valeur = analogRead (PHOTO_RESISTANCE_3_OUT);
PhotoResistance_4_Valeur = analogRead (PHOTO_RESISTANCE_4_OUT);
}
//*****************************************************************************
//*****************************************************************************
// FONCTION AjusterVitesseDesMoteurs
//*****************************************************************************
void AjusterVitesseDesMoteurs ()
{
// Modifier la vitesse des moteurs selon la distance globale devant le
// véhicule robot.
Moteur_1_Vitesse = map (Sonar_1_DistanceActuele,
0,
SonarDistanceValideMaximum,
Moteur_1_VitesseMinimum,
Moteur_1_VitesseMaximum);
Moteur_2_Vitesse = map (Sonar_3_DistanceActuele,
0,
SonarDistanceValideMaximum,
Moteur_2_VitesseMinimum,
Moteur_2_VitesseMaximum);
}
//*****************************************************************************
//*****************************************************************************
// FONCTION DeplacementArret
//*****************************************************************************
void DeplacementArreter ()
{
Moteur_1_Vitesse = 0;
Moteur_2_Vitesse = 0;
// Pour le moteur 1.
digitalWrite (CONTROLE_MOTEUR_1_IN1, BAS);
digitalWrite (CONTROLE_MOTEUR_1_IN2, BAS);
analogWrite (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
// Pour le moteur 2.
digitalWrite (CONTROLE_MOTEUR_1_IN3, BAS);
digitalWrite (CONTROLE_MOTEUR_1_IN4, BAS);
analogWrite (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************
//*****************************************************************************
// FONCTION DeplacementAvancer
//*****************************************************************************
void DeplacementAvancer ()
{
// Pour le moteur 1.
digitalWrite (CONTROLE_MOTEUR_1_IN1, HAUT);
digitalWrite (CONTROLE_MOTEUR_1_IN2, BAS);
analogWrite (CONTROLE_MOTEUR_1_ENA, Moteur_1_Vitesse);
// Pour le moteur 2.
digitalWrite (CONTROLE_MOTEUR_1_IN3, HAUT);
digitalWrite (CONTROLE_MOTEUR_1_IN4, BAS);
analogWrite (CONTROLE_MOTEUR_1_ENB, Moteur_2_Vitesse);
}
//*****************************************************************************
//*****************************************************************************
// FONCTION 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 DeplacementPivoterDroite45Degres
//*****************************************************************************
void DeplacementPivoterDroite45Degres ()
{
Encodeur_TempDeDepart = millis ();
Encodeur_1_InterCompteur = 0;
Encodeur_2_InterCompteur = 0;
Encodeur_1_InterParMinute = 0;
Encodeur_2_InterParMinute = 0;
Moteur_1_Vitesse = Moteur_1_VitesseMinimum;
Moteur_2_Vitesse = Moteur_2_VitesseMinimum;
TempsActuele = millis ();
TempsAfficher_Precedent = TempsActuele;
// 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);
while (Encodeur_2_InterCompteur < Encodeur_45Degres)
{
TempsActuele = millis ();
}
DeplacementArreter ();
}
//*****************************************************************************
//*****************************************************************************
// FONCTION DeplacementPivoterGauche45Degres
//*****************************************************************************
void DeplacementPivoterGauche45Degres ()
{
Encodeur_TempDeDepart = millis ();
Encodeur_1_InterCompteur = 0;
Encodeur_2_InterCompteur = 0;
Encodeur_1_InterParMinute = 0;
Encodeur_2_InterParMinute = 0;
Moteur_1_Vitesse = Moteur_1_VitesseMinimum;
Moteur_2_Vitesse = Moteur_2_VitesseMinimum;
TempsActuele = millis ();
TempsAfficher_Precedent = TempsActuele;
// 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);
while (Encodeur_1_InterCompteur < Encodeur_45Degres)
{
TempsActuele = millis ();
}
DeplacementArreter ();
}
//*****************************************************************************
//*****************************************************************************
// FONCTION DeplacementPivoterDroite90Degres
//*****************************************************************************
void DeplacementPivoterDroite90Degres ()
{
digitalWrite (DEL_2_VERTE_VCC, Boucler);
Encodeur_TempDeDepart = millis ();
Encodeur_1_InterCompteur = 0;
Encodeur_2_InterCompteur = 0;
Encodeur_1_InterParMinute = 0;
Encodeur_2_InterParMinute = 0;
Moteur_1_Vitesse = Moteur_1_VitesseMinimum;
Moteur_2_Vitesse = Moteur_2_VitesseMinimum;
TempsActuele = millis ();
TempsAfficher_Precedent = TempsActuele;
// 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);
while (Encodeur_2_InterCompteur < Encodeur_90Degres)
{
TempsActuele = millis ();
}
DeplacementArreter ();
}
//*****************************************************************************
//*****************************************************************************
// FONCTION DeplacementPivoterGauche90Degres
//*****************************************************************************
void DeplacementPivoterGauche90Degres ()
{
digitalWrite (DEL_2_VERTE_VCC, Boucler);
Encodeur_TempDeDepart = millis ();
Encodeur_1_InterCompteur = 0;
Encodeur_2_InterCompteur = 0;
Encodeur_1_InterParMinute = 0;
Encodeur_2_InterParMinute = 0;
Moteur_1_Vitesse = Moteur_1_VitesseMinimum;
Moteur_2_Vitesse = Moteur_2_VitesseMinimum;
TempsActuele = millis ();
TempsAfficher_Precedent = TempsActuele;
// 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);
while (Encodeur_1_InterCompteur < Encodeur_90Degres)
{
TempsActuele = millis ();
}
DeplacementArreter ();
}
//*****************************************************************************
//*****************************************************************************
// 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 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 : Bascule pour afficher ou non sur le terminal série de l'IDE Arduino
PlayPause : Fait une pause des moteurs, comme un arrêt sur image.
Debut : Vitess_1_PointMort et Vitess_2_PointMort - 10.
Fin : Vitess_1_PointMort et Vitess_2_PointMort + 10.
EQ :
Moins : Pivoter de 45° à gauche.
Plus : Pivoter de 45° à Droite.
0 :
Recycle : Pivoter de 90° à gauche.
U_SD : Pivoter de 90° à Droite.
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_2_VERTE_VCC, Boucler);
Serial.print ("* En attente d'une action d'humaine");
Serial.println ();
CodeSituation = 75;
DeplacementArreter ();
}
else
{
Boucler = OUI;
digitalWrite (DEL_2_VERTE_VCC, Boucler);
Serial.print ("* Poursuite du programme");
Serial.println ();
CodeSituation = 76;
}
break;
case TelecommandeBoutonMode:
Serial.print ("* TelecommandeBoutonMode = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 77;
Boucler = NON;
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 = 78;
AfficherMoniteurSerie = AfficherMoniteurSerie - 1;
Bip_1 ();
break;
case TelecommandeBoutonPlayPause:
Serial.print ("* TelecommandeBoutonPlayPause = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
Bip_1 ();
if (Boucler == OUI)
{
CodeSituation = 79;
Serial.print ("* En attente d'une action d'humaine");
Serial.println ();
DeplacementArreter ();
Boucler = NON;
digitalWrite (DEL_2_VERTE_VCC, Boucler);
}
else
{
CodeSituation = 80;
Serial.print ("* Poursuite du programme");
Serial.println ();
Boucler = OUI;
digitalWrite (DEL_2_VERTE_VCC, Boucler);
}
break;
case TelecommandeBoutonDebut:
Serial.print ("* TelecommandeBoutonDebut = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 81;
Bip_1 ();
Moteur_1_Vitesse = Moteur_1_VitesseMinimum - 10;
Moteur_2_Vitesse = Moteur_2_VitesseMinimum - 10;
break;
case TelecommandeBoutonFin:
Serial.print ("* TelecommandeBoutonFin = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 82;
Bip_1 ();
Moteur_1_Vitesse = Moteur_1_VitesseMinimum + 10;
Moteur_2_Vitesse = Moteur_2_VitesseMinimum + 10;
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 ();
CodeSituation = 84;
Boucler = NON;
Bip_1 ();
digitalWrite (DEL_2_VERTE_VCC, Boucler);
DeplacementPivoterGauche45Degres ();
break;
case TelecommandeBoutonPlus:
Serial.print ("* TelecommandeBoutonPlus = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 85;
Boucler = NON;
Bip_1 ();
digitalWrite (DEL_2_VERTE_VCC, Boucler);
DeplacementPivoterDroite45Degres ();
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;
Boucler = NON;
Bip_1 ();
digitalWrite (DEL_2_VERTE_VCC, Boucler);
DeplacementPivoterGauche90Degres ();
break;
case TelecommandeBoutonU_SD:
Serial.print ("* TelecommandeBoutonU_SD = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 88;
Boucler = NON;
Bip_1 ();
digitalWrite (DEL_2_VERTE_VCC, Boucler);
DeplacementPivoterDroite90Degres ();
break;
case TelecommandeBouton1:
Serial.print ("* TelecommandeBouton1 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 89;
Boucler = NON;
Bip_1 ();
digitalWrite (DEL_2_VERTE_VCC, Boucler);
Moteur_1_Vitesse = Moteur_1_VitesseMinimum;
Moteur_2_Vitesse = Moteur_2_VitesseMinimum;
DeplacementAvancerGauche ();
break;
case TelecommandeBouton2:
Serial.print ("* TelecommandeBouton2 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 90;
Boucler = NON;
Bip_1 ();
digitalWrite (DEL_2_VERTE_VCC, Boucler);
Moteur_1_Vitesse = Moteur_1_VitesseMinimum;
Moteur_2_Vitesse = Moteur_2_VitesseMinimum;
DeplacementAvancer ();
break;
case TelecommandeBouton3:
Serial.print ("* TelecommandeBouton3 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 91;
Boucler = NON;
Bip_1 ();
digitalWrite (DEL_2_VERTE_VCC, Boucler);
Moteur_1_Vitesse = Moteur_1_VitesseMinimum;
Moteur_2_Vitesse = Moteur_2_VitesseMinimum;
DeplacementAvancerDroite ();
break;
case TelecommandeBouton4:
Serial.print ("* TelecommandeBouton4 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 92;
Boucler = NON;
Bip_1 ();
digitalWrite (DEL_2_VERTE_VCC, Boucler);
Moteur_1_Vitesse = Moteur_1_VitesseMinimum;
Moteur_2_Vitesse = Moteur_2_VitesseMinimum;
DeplacementPivoterGauche ();
break;
case TelecommandeBouton5:
Serial.print ("* TelecommandeBouton5 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 93;
Boucler = NON;
Bip_1 ();
digitalWrite (DEL_2_VERTE_VCC, Boucler);
DeplacementArreter ();
break;
case TelecommandeBouton6:
Serial.print ("* TelecommandeBouton6 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 94;
Boucler = NON;
Bip_1 ();
digitalWrite (DEL_2_VERTE_VCC, Boucler);
Moteur_1_Vitesse = Moteur_1_VitesseMinimum;
Moteur_2_Vitesse = Moteur_2_VitesseMinimum;
DeplacementPivoterDroite ();
break;
case TelecommandeBouton7:
Serial.print ("* TelecommandeBouton7 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 95;
Boucler = NON;
Bip_1 ();
digitalWrite (DEL_2_VERTE_VCC, Boucler);
Moteur_1_Vitesse = Moteur_1_VitesseMinimum;
Moteur_2_Vitesse = Moteur_2_VitesseMinimum;
DeplacementReculerGauche ();
break;
case TelecommandeBouton8:
Serial.print ("* TelecommandeBouton8 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 96;
Boucler = NON;
Bip_1 ();
digitalWrite (DEL_2_VERTE_VCC, Boucler);
Moteur_1_Vitesse = Moteur_1_VitesseMinimum;
Moteur_2_Vitesse = Moteur_2_VitesseMinimum;
DeplacementReculer ();
break;
case TelecommandeBouton9:
Serial.print ("* TelecommandeBouton9 = ");
Serial.print (TelecommandeBoutonValeur);
Serial.println ();
CodeSituation = 97;
Boucler = NON;
Bip_1 ();
digitalWrite (DEL_2_VERTE_VCC, Boucler);
Moteur_1_Vitesse = Moteur_1_VitesseMinimum;
Moteur_2_Vitesse = Moteur_2_VitesseMinimum;
DeplacementReculerDroite ();
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 GererBoutonMarcheArret
//*****************************************************************************
void GererBoutonMarcheArret ()
/*
Gestion de l'utilisation d'un bouton sur la planche d'expérimentation.
*/
{
int EtatBouton = digitalRead (BOUTON_1_ETAT);
if (EtatBouton == BAS)
{
if (Boucler == OUI)
{
CodeSituation = 73;
DeplacementArreter ();
GererAffichages ();
R2D2_1 ();
Boucler = NON;
digitalWrite (DEL_2_VERTE_VCC, 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 = 74;
Bip_1 ();
Boucler = OUI;
digitalWrite (DEL_2_VERTE_VCC, Boucler);
}
while (EtatBouton == BAS)
{
delay (BoutonTempsRebon);// Pour absorber les micro-coupures des rebonds.
EtatBouton = digitalRead (BOUTON_1_ETAT);
}
}
}
//*****************************************************************************
//*****************************************************************************
// 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 + Encodeur_Periode))
{
TempsAfficher_Precedent = TempsActuele;
// La fréquence de lecture (Hz) est augmentée toutes les secondes.
// Ne pas traiter les interruptions pendant les calculs
detachInterrupt (digitalPinToInterrupt (ENCODEUR_1_SORTIE));
detachInterrupt (digitalPinToInterrupt (ENCODEUR_2_SORTIE));
// Notez que ce serait 60 * Encodeur_Periode / (Millis () - Encodeur_TempDeDepart) * impulsions si l'interruption est arrivé une fois par tour.
Encodeur_1_TourParMinute = (60 * Encodeur_Periode / Encodeur_InterruptionUnTour) / (millis () - Encodeur_TempDeDepart) * Encodeur_1_InterParMinute;
Encodeur_2_TourParMinute = (60 * Encodeur_Periode / Encodeur_InterruptionUnTour) / (millis () - Encodeur_TempDeDepart) * Encodeur_2_InterParMinute;
Encodeur_TempDeDepart = millis ();
Encodeur_1_InterParMinute = 0;
Encodeur_2_InterParMinute = 0;
GererAffichages ();
// Relancer le traitement des interruptions.
attachInterrupt (digitalPinToInterrupt (ENCODEUR_1_SORTIE), EncodeurConterInterruption_1, FALLING);
attachInterrupt (digitalPinToInterrupt (ENCODEUR_2_SORTIE), EncodeurConterInterruption_2, FALLING);
GererBoutons ();
}
}
//*****************************************************************************
//*****************************************************************************
// FONCTION GererDeplacements
//*****************************************************************************
void GererDeplacements ()
{
LirePhotoResistances ();
LireCapteursUltrasons ();
AjusterVitesseDesMoteurs ();
if (Sonar_1_DistanceActuele < Distance1 and
Sonar_2_DistanceActuele < Distance1 and
Sonar_3_DistanceActuele < Distance1)
{
Moteur_1_Vitesse = Moteur_1_VitesseMinimum;
Moteur_2_Vitesse = Moteur_2_VitesseMinimum;
if (Sonar_1_DistanceActuele > Sonar_3_DistanceActuele)
{
CodeSituation = 1;
DeplacementPivoterGauche90Degres ();
}
else
{
CodeSituation = 2;
DeplacementPivoterDroite90Degres ();
}
}
else if (Sonar_1_DistanceActuele >= Distance1 and
Sonar_2_DistanceActuele < Distance1 and
Sonar_3_DistanceActuele < Distance1)
{
CodeSituation = 3;
DeplacementAvancerGauche ();
}
else if (Sonar_1_DistanceActuele < Distance1 and
Sonar_2_DistanceActuele >= Distance1 and
Sonar_3_DistanceActuele < Distance1)
{
CodeSituation = 4;
DeplacementAvancer ();
}
else if (Sonar_1_DistanceActuele < Distance1 and
Sonar_2_DistanceActuele < Distance1 and
Sonar_3_DistanceActuele >= Distance1)
{
CodeSituation = 5;
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 = 6;
DeplacementPivoterGauche45Degres ();
}
else
{
CodeSituation = 7;
DeplacementPivoterDroite45Degres ();
}
}
else if ((Sonar_1_DistanceActuele >= Distance1) and
(Sonar_2_DistanceActuele >= Distance1) and
(Sonar_3_DistanceActuele < Distance1))
{
CodeSituation = 8;
DeplacementPivoterGauche ();
}
else if ((Sonar_1_DistanceActuele < Distance1) and
(Sonar_2_DistanceActuele >= Distance1) and
(Sonar_3_DistanceActuele >= Distance1))
{
CodeSituation = 9;
DeplacementPivoterDroite ();
}
else if (Sonar_1_DistanceActuele >= Distance1 and Sonar_1_DistanceActuele < Distance2 and
Sonar_2_DistanceActuele >= Distance1 and Sonar_2_DistanceActuele < Distance2 and
Sonar_3_DistanceActuele >= Distance1 and Sonar_3_DistanceActuele < Distance2)
{
CodeSituation = 10;
DeplacementAvancer ();
}
else if (Sonar_1_DistanceActuele >= Distance2 and Sonar_1_DistanceActuele < Distance3 and
Sonar_2_DistanceActuele >= Distance2 and Sonar_2_DistanceActuele < Distance3 and
Sonar_3_DistanceActuele >= Distance2 and Sonar_3_DistanceActuele < Distance3)
{
CodeSituation = 11;
DeplacementAvancer ();
}
else if (Sonar_1_DistanceActuele >= Distance3 and Sonar_1_DistanceActuele < Distance4 and
Sonar_2_DistanceActuele >= Distance3 and Sonar_2_DistanceActuele < Distance4 and
Sonar_3_DistanceActuele >= Distance3 and Sonar_3_DistanceActuele < Distance4)
{
CodeSituation = 12;
Moteur_1_Vitesse = Moteur_1_VitesseMaximum;
Moteur_2_Vitesse = Moteur_2_VitesseMaximum;
DeplacementAvancer ();
}
else if (Sonar_1_DistanceActuele >= Distance4 and
Sonar_2_DistanceActuele >= Distance4 and
Sonar_3_DistanceActuele >= Distance4)
{
CodeSituation = 13;
DeplacementAvancer ();
}
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 CalibrerVitesseMinimaleDesMoteurs
//*****************************************************************************
void CalibrerVitesseMinimaleDesMoteurs ()
{
/*
Point important de ce logiciel pour le bon fonctionnement de ce véhicule robot
est qu'il calibre ses moteurs roues en rapport entre autres avec la puissance
de son alimentation électrique, batterie ou transformateur de courant.
Comme beaucoup de paramètres varient grandement au cours de l'utilisation d'un
tel véhicule, il est illusoire de programmer en dure avec des valeurs
constantes pour la puissance des moteurs, de l'écart de la puissance entre deux
moteurs supposés identique, l'usure des mécanismes d'engrenage, de la
variabilité de la source d'énergie, de la taille des roues, du type
d'engrenage, ou l'absence d'engrenage, etc., etc. ! C'est pour ces raisons
qu'est fait cette fonction « CalibrerVitesseMinimaleDesMoteurs » et en
collaboration avec la fonction « AjusterVitesseDesMoteurs » pour ce qui est de
la distance d'obstacles. Ils sont des plus utiles et raffinées pour donner une
élégance dans ses mouvements et une grande souplesse de fonctionnement pour un
tel véhicule robot autonome ! Je vous recommande leur étude et leur
compréhension pour les intégrer dans vos propres projets !
Cela est rendu possible par l'utilisation d'un encodeur rotatif par moteur, ce
qui permet de déterminer le début du mouvement des roues et donc de la puissance
requise pour entrainer ce mouvement. Par la suite, ces encodeurs peuvent nous
aider à déterminer un mouvement de rotation du véhicule de 45°, 90°, à gauche ou
à droite, etc.
*/
int NbBoucleMaximum = 255;// Correspond au nombre maximal de valeur de réglages
int i = 0;
CodeSituation = 101;
Serial.print ("***********************************************************");
Serial.println ();
Serial.print ("*********** Debut de la calibration des moteurs ***********");
Serial.print ("***********************************************************");
Serial.println ();
LCD_1.clear ();
LCD_1.setCursor (0, 0);
LCD_1.print ("Calibration moteurs");
LCD_1.setCursor (0, 1);
LCD_1.print ("un instant S.V.P. !");
// Recherche de la puissance minimal pour que cache roues tourne un crant sur
// la roulette de son encodeur.
for (i = 0; i < NbBoucleMaximum; i = i + 1)
{
DeplacementAvancer ();
if (Encodeur_1_InterCompteur < Roue_1_UnPas)
{
Moteur_1_VitesseMinimum = Moteur_1_VitesseMinimum + 1;
}
if (Encodeur_2_InterCompteur < Roue_2_UnPas)
{
Moteur_2_VitesseMinimum = Moteur_2_VitesseMinimum + 1;
}
Moteur_1_Vitesse = Moteur_1_VitesseMinimum;
Moteur_2_Vitesse = Moteur_2_VitesseMinimum;
delay (10);
}
DeplacementArreter ();
CodeSituation = 102;
// Vérification que la puissance disponible est suffisant pour ce moteur,
// sinon affiche un message pertinent est affiché dans le terminal et sur
// l'écran LCD !
if (Moteur_1_VitesseMinimum >= NbBoucleMaximum)
{
CodeSituation = 103;
Boucler = NON;
BiBiBi_1 ();
Serial.print ("***********************************************************");
Serial.println ();
Serial.print ("*********Il manque de puissance pour le moteur 1 !*********");
Serial.print ("***********************************************************");
Serial.println ();
LCD_1.clear ();
LCD_1.setCursor (0, 0);
LCD_1.print ("Manque de puissance ");
LCD_1.setCursor (0, 1);
LCD_1.print (" pour le Moteur 1 ! ");
while (Boucler == NON)
{
GererBoutons ();
}
}
else
{
CodeSituation = 104;
// Vérification d'un éventuel écart entre la puissance requise pour mettre
// en mouvement chacune des roues du véhicule et si cela est requis, la
// vitesse maximale est ajustée et réduisant de l'écart entre les deux
// puissances minimales requises pour se mettre en mouvement.
if (Moteur_1_VitesseMinimum < Moteur_2_VitesseMinimum)
{
CodeSituation = 105;
Moteur_1_VitesseMaximum = 255 - (Moteur_2_VitesseMinimum - Moteur_1_VitesseMinimum);
}
}
// Vérification que la puissance disponible est suffisant pour ce moteur,
// sinon affiche un message pertinent est affiché dans le terminal et sur
// l'écran LCD !
if (Moteur_2_VitesseMinimum >= NbBoucleMaximum)
{
CodeSituation = 106;
Boucler = NON;
BiBiBi_1 ();
Serial.print ("***********************************************************");
Serial.println ();
Serial.print ("*********Il manque de puissance pour le moteur 2 !*********");
Serial.print ("***********************************************************");
Serial.println ();
LCD_1.clear ();
LCD_1.setCursor (0, 2);
LCD_1.print ("Manque de puissance ");
LCD_1.setCursor (0, 3);
LCD_1.print (" pour le Moteur 2 ! ");
while (Boucler == NON)
{
GererBoutons ();
}
}
else
{
CodeSituation = 107;
// Vérification d'un éventuel écart entre la puissance requise pour mettre
// en mouvement chacune des roues du véhicule et si cela est requis, la
// vitesse maximale est ajustée et réduisant de l'écart entre les deux
// puissances minimales requises pour se mettre en mouvement.
if (Moteur_2_VitesseMinimum < Moteur_1_VitesseMinimum)
{
CodeSituation = 108;
Moteur_2_VitesseMaximum = 255 - (Moteur_1_VitesseMinimum - Moteur_2_VitesseMinimum);
}
}
Boucler = OUI;
}
//*****************************************************************************
//*****************************************************************************
// 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);
// Boucle qui attend que le terminal "Serial" soi actif avant de poursuivre !
while (!Serial);
Serial.println ();
Serial.println ();
Serial.print ("***********************************************************");
Serial.println ();
Serial.print ("* ");
Serial.print (NOM_DU_PROGRAMME);
Serial.print (" *");
Serial.println ();
Serial.print ("* Debut de la procedure d'initialisation du systeme... *");
Serial.println ();
Serial.print ("***********************************************************");
Serial.println ();
// Le minimum de connecteurs en entrées et sorties d'activé par sécurité
// en cas de changement des port de connexion.
// Active la DEL de l'Arduino et la DEL Rouge du panneau de contrôle.
pinMode (DEL_1_ROUGE_VCC, SORTIE);
digitalWrite (DEL_1_ROUGE_VCC, OUI);
Serial.print ("* DEL de l'Arduino et DEL rouge du panneau de contrôle. *");
Serial.println ();
// Pour affichage dans l'écran LCD.
LCD_1.begin (LCD_1_NombreDeColonnes, LCD_1_NombreDeLignes);
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 ("Le Boutons du robot ");
LCD_1.setCursor (0,2);
LCD_1.print (" ou de la ");
LCD_1.setCursor (0,3);
LCD_1.print ("Telecommande S.V.P.!");
Serial.print ("* Ecran LCD Active et affichage du nom du programme *");
Serial.println ();
// Pour le bouton Marche/Arrêt sur la planche d'expérimentation.
// Configurer le port Arduino en entrée pour le bouton.
pinMode (BOUTON_1_ETAT, ENTREE_ET_RESISTENCE_INTERNE);
// Activer la résistance au plus PULLUP.
digitalWrite (BOUTON_1_ETAT, HAUT);
Serial.print ("* Broche du bouton sur le panneau de controle activer *");
Serial.println ();
// Fixer le BUZZER_1_VIN en sortie.
pinMode (BUZZER_1_VIN, SORTIE);
Bip_1 ();
Serial.print ("* Broche du Buzzer de l'Arduinobot activer *");
Serial.println ();
// Configurer le port Arduino en entrée pour le capteur infrarouge sur un port d'interruption.
pinMode (CAPTEUR_IR_0_OUT, ENTREE);
// Initialisation et début de la réception du capteur infrarouge.
Capteur_IR_0.enableIRIn ();
Serial.print ("* Broche du capteur infrarouge de telecommande activer *");
Serial.println ();
Serial.print("* Nompre de pas pour un rotation est de ");
Serial.print(ENCODEUR_0_PAS_PAR_CLIC);
Serial.print(". *");
Serial.println ();
// Pour le bouton Marche/Arrêt sur la planche d'expérimentation.
// Configurer le port Arduino en entrée pour le bouton.
pinMode (ENCODEUR_0_BOUTON, ENTREE_ET_RESISTENCE_INTERNE);
// Activer la résistance au plus PULLUP.
digitalWrite (ENCODEUR_0_BOUTON, HAUT);
Serial.print ("* Broche du bouton de l'encodeur sur panneau de controle *");
Serial.println ();
Serial.print ("***********************************************************");
Serial.println ();
Serial.print ("* Attante : Telecommande (Power) ou Bouton MarcheArret... *");
Serial.println ();
Serial.print ("***********************************************************");
Serial.println ();
// Boucle pour éviter qu'un ancien programme chargé ne s'exécute avec un
// nouveau montage installé, en attente du chargement du nouveau programme.
// Jusqu'ici, c'est le minimum qui est activé, le reste des connexions
// seront activé après la boucle d'attente.
while (Boucler == NON)
{
GererBoutons ();
}
// Prépare et activer la broche en sortie pour la DEL vert du panneau de contrôle.
pinMode (DEL_2_VERTE_VCC, SORTIE);
digitalWrite (DEL_2_VERTE_VCC, OUI);
Serial.print ("* DEL verte du paneau de contrôle prépare et activé. *");
Serial.println ();
// Configurer les ports Arduino en entrée pour les capteurs électroluminesentes.
pinMode (PHOTO_RESISTANCE_1_OUT, ENTREE);
pinMode (PHOTO_RESISTANCE_2_OUT, ENTREE);
pinMode (PHOTO_RESISTANCE_3_OUT, ENTREE);
pinMode (PHOTO_RESISTANCE_4_OUT, 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, à 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);
Serial.print ("* Broches du controleur des moteurs activer *");
Serial.println ();
// Pour les encodeurs des moteurs de déplacement du véhicule sur l'Arduino.
pinMode (ENCODEUR_1_SORTIE, ENTREE);
pinMode (ENCODEUR_2_SORTIE, ENTREE);
// Interruption 21 et 20, acrochées de sorte que le détecteur IR est connecté sur
// les Triggers de CHUTE (changement de HAUT à BAS).
attachInterrupt (digitalPinToInterrupt (ENCODEUR_1_SORTIE), EncodeurConterInterruption_1, FALLING);
attachInterrupt (digitalPinToInterrupt (ENCODEUR_2_SORTIE), EncodeurConterInterruption_2, FALLING);
// 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);
Serial.print ("* Broches des sonars activer *");
Serial.println ();
// Message de la fin du processus d'initialisation du systme.
Serial.print ("***********************************************************");
Serial.println ();
Serial.print ("* Fin de la procedure d'initialisation du systeme... *");
Serial.println ();
Serial.print ("***********************************************************");
Serial.println ();
Serial.print ("***********************************************************");
Serial.println ();
Serial.print ("* Variable du programme *");
Serial.println ();
Serial.print ("***********************************************************");
Serial.println ();
Serial.print ("* Distance1 = ");
Serial.print (Distance1);
Serial.println ();
Serial.print ("***********************************************************");
Serial.println ();
Serial.print ("* CodeSituation = ");
Serial.print (CodeSituation);
Serial.println ();
Serial.print ("***********************************************************");
Serial.println ();
// Pour affichage dans l'écran LCD.
LCD_1.clear ();
LCD_1.setCursor (0,0);
LCD_1.print (">>>>>>>> OK <<<<<<<<");
LCD_1.setCursor (0,1);
LCD_1.print (">>>>>>>> GO <<<<<<<<");
delay (1000);
CalibrerVitesseMinimaleDesMoteurs ();
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.
// Condition de controle de l'affichage LCD par seconde pour éviter le
// syntillement de l'afficheur.
GererTempsAffichageBoutons ();
if (Boucler == OUI)
{
GererDeplacements ();
}
}
//*****************************************************************************
Je suis très novice pour ce qui est des circuits avec Fritzing (M-A-J des broche 17, 18 et 21) :
Cordialement,
L'ami René
