Projet ICN robot parlant 2018/2019
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...");
}
}
