Projet ICN robot parlant 2018/2019
Version du 24 avril 2019 à 11:35
Projet robot parlant Gautier ICN 2018/2019
I/ PARTI MANUEL
Première étape; montage du robot (avec le manuel)(facile mais demande d'être minutieux)
2eme etape :soudure sur le robot des fils et branchement des fils sur la carte arduino
II/ PARTI PROGRAMMATION
Pour bien apprendre à travailler avec arduino je vous conseil ce site: https://openclassrooms.com/fr/courses/2778161-programmez-vos-premiers-montages-avec-arduino
Exemple de fonction utile:
setup() qui s'exécute qu'une fois ;
loop() qui s'exécute à l'infini ;
void (qui se met toujours devant loop et setup ) ;
pinMode() qui permet de définir une sortie en mode envoi d'électricité ou non ;
digitaWrite() qui envoie de l'électricité par une sortie ;
delay() qui met le programme en pause pendant un nombre défini de millisecondes.
switch :switch case contrôle le flux des programmes en permettant aux programmeurs de spécifier un code différent à exécuter dans diverses conditions.
Une instruction switch compare la valeur d'une variable aux valeurs spécifiées dans les instructions case.
break :quitte l'instruction switch et est généralement utilisé à la fin de chaque cas.
#define : est un composant C utile qui permet au programmeur de nommer une valeur constante avant la compilation du programme.
Serial.begin: Définit le débit de données en bits par seconde (bauds) pour la transmission de données en série.
default:
unsigned long: sont des variables de taille étendue pour le stockage de numéros et stockent 32 bits (4 octets).
Contrairement aux longs standards, les long unsigned ne stockent pas les nombres négatifs, ce qui les situe entre 0 et 4 294 967 295 (2 ^ 32 - 1).
for: L'instruction for est utilisée pour répéter un bloc d'instructions entre accolades.
Un compteur d’incrément est généralement utilisé pour incrémenter et terminer la boucle.
L'instruction for est utile pour toute opération répétitive et est souvent utilisée en combinaison avec des tableaux pour opérer sur des collections de données / pins.
pulseIn: Lit une impulsion ( HIGHou LOW) sur une broche.
Par exemple, si valueest HIGH, pulseIn()attend que la broche passe de LOWà HIGH, commence le chronométrage, puis attend que la broche disparaisse LOWet arrête le chronométrage.
Renvoie la durée de l'impulsion en microsecondes ou abandonne et renvoie 0 si aucune impulsion complète n'a été reçue dans le délai imparti.
if: Si
else: sinon
else if: sinon si
while: Une while boucle boucle en boucle de façon continue et infinie jusqu'à ce que l'expression entre parenthèses () devienne fausse.
/*Programme d'évitement d'obstacle sans contact*/
//initialisation // Constantes pour la navigation #define PROCHE 700 //de base 200 #define DANGER 400 // de base 100 #define AFOND 150 #define PRUDENT 50 #define NBMESURE 5 #define AJUSTE 1.05
// Constantes pour le sonar // pin 12 et 13 pour le capteur à ultrason const int ECHO_PIN=13; //(mettre la pin correspondante au capteur a ultrason) //pin numérique utilisé pour le capteur ultrasons. const int TRIGGER_PIN=12; const unsigned long MEASURE_TIMEOUT=25000UL; // 25ms = ~8m à 340m/s const float SOUND_SPEED=340.0/1000;
// Constantes pour le contrôleur de moteurs int pwmB = 3; int bin2 = 4; int bin1 = 5; int stby = 6; int ain1 = 7; int ain2 = 8; int pwmA = 9;
void avance(int v)//Déclare la fonction qui fait avancer le robot
{
Serial.println("Avant");
digitalWrite(stby, HIGH);//démarre les moteurs
digitalWrite(ain1, HIGH);//Lance le courant
digitalWrite(ain2, LOW);
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, v*AJUSTE);//Donne la puissance du moteur 1
analogWrite(pwmB, v);//Donne la puissance du moteur 2 (pour qu'il aille droit)
}
void recule(int v)//Déclare la fonction qui fait avancer le robot
{
Serial.println("Avant");
digitalWrite(stby, HIGH);//démarre les moteurs
digitalWrite(ain1, LOW);//Lance le courant
digitalWrite(ain2, HIGH);
digitalWrite(stby, HIGH);
digitalWrite(bin1, LOW);
digitalWrite(bin2, HIGH);
analogWrite(pwmA, v*AJUSTE);//Donne la puissance du moteur 1
analogWrite(pwmB, v);//Donne la puissance du moteur 2 (pour qu'il aille droit)
}
void arret(void)//Déclare la fonction qui fait stopper le robot
{
digitalWrite(stby, LOW);//arrête les moteurs
}
void tourneDroite(int v) //Déclare la fonction qui fait effectuer un tour au robot
{
Serial.println("TourneDroite");
digitalWrite(stby, HIGH);//démarre les moteurs
digitalWrite(ain1, LOW);//Lance le courant...
digitalWrite(ain2, HIGH);//et fait en sorte qu'un des moteurs tourne a l'envers pour que le robot tourne sur lui-même
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, v*AJUSTE);//Donne la puissance du moteur 1
analogWrite(pwmB, v);//Donne la puissance du moteur 2
}
void tourneGauche(int v) //Déclare la fonction qui fait effectuer un tour au robot
{
Serial.println("TourneDroite");
digitalWrite(stby, HIGH);//démarre les moteurs
digitalWrite(ain1, HIGH);//Lance le courant...
digitalWrite(ain2, LOW);//et fait en sorte qu'un des moteurs tourne a l'envers pour que le robot tourne sur lui-même
digitalWrite(stby, HIGH);
digitalWrite(bin1, LOW);
digitalWrite(bin2, HIGH);
analogWrite(pwmA, v*AJUSTE);//Donne la puissance du moteur 1
analogWrite(pwmB, v);//Donne la puissance du moteur 2
}
#if 0
void tour(void) //Déclare la fonction qui fait effectuer un tour au robot
{
Serial.println("Tour");
digitalWrite(stby, HIGH);//démarre les moteurs
digitalWrite(ain1, LOW);//Lance le courant...
digitalWrite(ain2, HIGH);//et fait en sorte qu'un des moteurs tourne a l'envers pour que le robot tourne sur lui-même
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, 131.125);//Donne la puissance du moteur 1
analogWrite(pwmB, 125);//Donne la puissance du moteur 2
delay(3750);//Donne le temps durant lequel le robot va tourner sur lui-même
digitalWrite(stby, LOW);//arrête les moteurs
}
+
void demitour(void)
{
Serial.println("DemiTour");
digitalWrite(stby, HIGH);//démarre les moteurs
digitalWrite(ain1, LOW);
digitalWrite(ain2, HIGH);
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, 131.125);
analogWrite(pwmB, 125);
delay(890);
digitalWrite(stby, LOW);
}
void quarttour(void)
{
Serial.println("QuartDeTour");
digitalWrite(stby, HIGH);//démarre les moteurs
digitalWrite(ain1, LOW);
digitalWrite(ain2, HIGH);
digitalWrite(stby, HIGH);
digitalWrite(bin1, HIGH);
digitalWrite(bin2, LOW);
analogWrite(pwmA, 131.125);
analogWrite(pwmB, 125);
delay(450);
digitalWrite(stby, LOW);
}
#endif
void setup() {
Serial.begin(9600);
pinMode(pwmB, OUTPUT);
pinMode(bin2, OUTPUT);
pinMode(bin1, OUTPUT);
pinMode(stby, OUTPUT);
pinMode(ain1, OUTPUT);
pinMode(ain2, OUTPUT);
pinMode(pwmA, OUTPUT);
/* Initialise les broches */
pinMode(TRIGGER_PIN, OUTPUT);
digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit être à LOW au repos
pinMode(ECHO_PIN, INPUT);
#if 0 int m=mesure(); avance(PRUDENT); delay(5000); arret(); exit(0); #endif }
void loop() {
int m=mesure();
// mettez votre code principal ici, pour exécuter à plusieurs reprises:
switch (m){ //utilisation de la condition switch
case 0: // l'obstacle est dans la zone DANGER
Serial.println("*DANGER*");
arret(); // on arrête le robot
delay(200);
recule(PRUDENT); // on le fait reculer un peu
delay(400);
recherche(); // on recherche la bonne voie
break;
case 1: //l'obstacle est dans la zone PROCHE
Serial.println("Attention...");
avance(PRUDENT); // on ralentit la vitesse
default:
avance(AFOND);
}
}
int mesure(){
//fonction qui mesure une distance avec le capteur
float cumul = 0; // variable de mesure
float moyenne = 0; //variable pour la moyenne
for (int t = 0; t < NBMESURE; t++) { // boucle pour effectuer les mesures
/* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche TRIGGER */
digitalWrite(TRIGGER_PIN, HIGH);
delayMicroseconds(10);
digitalWrite(TRIGGER_PIN, LOW);
/* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */
long measure = pulseIn(ECHO_PIN, HIGH, MEASURE_TIMEOUT);
/* 3. Calcul la distance à partir du temps mesuré */
float distance_mm = measure / 2.0 * SOUND_SPEED;
cumul += distance_mm;
}
moyenne=cumul/NBMESURE; //on calcule la moyenne des mesures
/* Affiche les résultats en cm */
Serial.print(F("Distance: "));
Serial.print(moyenne/10.0, 2);
Serial.print(F("cm, "));
if (moyenne<=(float)DANGER){//on teste si l'obstacle est dans la zone DANGER
return 0; //si oui, on retourne le code de danger
}
else if (moyenne>(float)DANGER && moyenne<=(float)PROCHE){//on teste s'il est dans la zone PROCHE
return 1; //si oui, on retourne le code de proche
}
else{ // Aucun obstacle proche
return 2; // on retourne le code de sans risque
}
}
void recherche(){
//fonction pour rechercher un passage
tourneGauche(AFOND); //on positionne le robot à gauche (facultatif)
delay(300);
int etat=0; //variable de test de possibilité d'avancer
while (etat!=2){ // tant que la distance n'est pas suffisante
etat=mesure(); // on effectue la mesure
Serial.println(etat);
tourneDroite(PRUDENT); //on fait tourner le robot
}
Serial.println("La voie est libre !");
//retour au programme principal
}
III/ FAIRE PARLER LE ROBOT
J'utilise ce site pour comprendre et suivre les étapes pour que mon robot puisse parler: https://learn.adafruit.com/adafruit-wave-shield-audio-shield-for-arduino/solder Et j'utilise le Kit Adafruit Wave Shield pour Arduino - v1.1 :
