Projet ICN robot parlant 2018/2019

Version du 19 décembre 2018 à 14:30

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 /* 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.

• /

 int pwmB = 3;
int bin2 = 4;
int bin1 = 5;
int stby = 6;
int ain1 = 7;
int ain2 = 8;
int pwmA = 9;
void avancer(void)//Déclare la fonction qui fait avancer le robot
{
  Serial.println("Avant");
  digitalWrite(ain1, HIGH);//Lance le courant
  digitalWrite(ain2, LOW);
  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 (pour qu'il aille droit)
}

void tour(void) //Déclare la fonction qui fait effectuer un tour au robot
{
  Serial.println("Tour");
  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("Tour");
  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("Tour");
  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);
}

 /*
 Programme d'évitement d'obstacle sans contact
 */
 //pin 12 et 13 pour le capteur à ultrason
 #define PROCHE 20
 #define DANGER 10
 #define AFOND 200
 #define PRUDENT 50
 #define NBMESURE 5
 #define VSON 59
 //initialisation
 int pinSRF= 13; //(mettre la pin correspondante au capteur a ultrason) //pin numérique utilisé pour le capteur ultrasons.

 void setup() {
 Serial.begin(9600);
 avance(AFOND); //on démarre le robot
 Serial.begin(9600);
  pinMode(pwmB, OUTPUT);
  pinMode(bin2, OUTPUT);
  pinMode(bin1, OUTPUT);
  pinMode(stby, OUTPUT);
  pinMode(ain1, OUTPUT);
  pinMode(ain2, OUTPUT);
  pinMode(pwmA, OUTPUT);
  tour(); // Exécute la fonction du tour
  avancer();
  demitour();
  avancer(); 
  tour();
 }

void loop() {

 // mettez votre code principal ici, pour exécuter à plusieurs reprises:
 switch (mesure()){ //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(200);
     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);
 }
 }

//fonctions

 int mesure(){
 //fonction qui mesure une distance avec le capteur
 unsigned long mesure = 0; // variable de mesure
 unsigned long cumul = 0; //variable pour la moyenne
 for (int t = 0; t < NBMESURE; t++) { // boucle pour effectuer les mesures
   pinMode (pinSRF, OUTPUT); //on prépare le pin pour envoyer le signal
   digitalWrite(pinSRF, LOW); //on commence à l'état bas
   delayMicroseconds(2); //on attend que le signal soit clair
   digitalWrite(pinSRF, HIGH);//mise à l'état haut
   delayMicroseconds(10); //pendant 10 µs
   digitalWrite(pinSRF, LOW); //mise à l'état bas
   pinMode(pinSRF, INPUT); //on prépare le pin pour recevoir un état
   mesure = pulseIn(pinSRF, HIGH); // fonction pulseIn qui attend un état haut et renvoie le temps d'attente
   cumul+=mesure; //on cumule les mesures
   delay(50); //attente obligatoire entre deux mesures
 }
 mesure=cumul/NBMESURE; //on calcule la moyenne des mesures
 mesure=mesure/VSON;//on transforme en cm
 
 if (mesure<=DANGER){//on teste si l'obstacle est dans la zone DANGER
   return 0; //si oui, on retourne le code de danger
 }
 else if (mesure>DANGER && mesure<=PROCHE){//on teste s'il est dans la zone PROCHE
   return 1; //si oui, on retourne le code de 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
   tourneDroite(PRUDENT); //on fait tourner le robot
 }
 Serial.println("La voie est libre !");
 //retour au programme principal
 }
 void arret(){
 Serial.println("Je stoppe");
 //fonction d'arrêt des moteurs
 }
 void avance(int v){
 Serial.print("J'avance");
 affiche(v);
 //fonctin de mise en route des deux moteurs dans le sens avant
 // on utilise la variable v pour le pilotage PWM
 }
 void recule(int v){
 Serial.print("Je recule");
 affiche(v);
 //fonctin de mise en route des deux moteurs dans le sens arrière
 // on utilise la variable v pour le pilotage PWM
 }
 void tourneDroite(int v){
 Serial.print("Je tourne a droite");
 affiche(v);
 //fonction de rotation à droite : un moteur dans un sens, l'autre dans le sens opposé
 // on utilise la variable v pour le pilotage PWM
 }
 void tourneGauche(int v){
 Serial.print("Je tourne a gauche");
 affiche(v);
 //fonction de rotation à gauche : un moteur dans un sens, l'autre dans le sens opposé
 // on utilise la variable v pour le pilotage PWM
 }
 void affiche(int v){
 //fonction complémentaire d'affichage
 if (v==AFOND){
   Serial.println(" a fond !");
 }
 else{
   Serial.println(" prudemment...");
 }
 }