Projet ICN robot parlant 2018/2019

Version du 24 avril 2019 à 13:37

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 : https://www.google.com/shopping/product/1?q=kit+Adafruit+Wave+Shield+pour+Arduino+-+v1.1&client=ms-android-samsung&biw=412&bih=652&tbs=vw:l,ss:44&prmd=sivn&prds=num:1,of:1,epd:15594950604929701068,paur:ClkAsKraX59nDazOXY9qSFMHlDclp4GBwRTiBT-BHcM9LYLNYGSlZZEpXNhEQN6mfYKT3XpWVnv0Y7fgutzNiEFiFXYwCwSslsdnrlxy4Mh-ijnzEIEftXHenhIZAFPVH72yU2k2ksjnwmZ8KScQrCTH96Vz9A,prmr:1,pid:15594950604929701068,cs:1

Média:https://www.adafruit.com/product/94