Maison du Libre | Brest

Outils pour utilisateurs

Outils du site

Piste : • stagejava
lespetitshackers:robots

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentesRévision précédente
Prochaine révision		Révision précédente
lespetitshackers:robots [2014/03/29 09:21] – [le code de la séance] fjeanlespetitshackers:robots [2024/04/16 22:20] (Version actuelle) – modification externe 127.0.0.1
Ligne 1: Ligne 1:
 +====== Objectif de l'activité ======
 +
 +Construction d'un robot autonome au comportement simple :
 +  * il avance tout droit au démarrage
 +  * s'il détecte un obstacle devant lui il s'arrête
 +  * il fait une mesure de distance à droite, puis une à gauche
 +  * il tourne et part tout droit dans la direction où il a mesuré la plus grande distance
 +  * ... et on recommence...
 +
 +Pour Les Petits Hackers, il s'agit d'apprendre, en construisant et en programmant ce robot, les principes de base des circuits électriques, du fonctionnement des micro-contrôleurs, de bricoler avec des composants électroniques, des capteurs, des fers à souder, des moteurs, des leds, des pistolets à colle...
 +Et évidemment d'apprendre aussi des rudiments de programmation : variables, boucles, boucles conditionnelles, fonctions...
 +====== Public concerné =====
 +
 +Un peu tout le monde... le public de l'atelier Petits Robots est constitué de jeunes âgés de 10-11 ans à 14 ans, des collégiens donc.  
 +
 +Pour cette année 2013-2014, les inscriptions sont closes ; l'atelier compte neuf Petits Hackers, donc neuf robots en construction.
 +
 +Nous sommes entre 3 et 4 animateurs ; notre expérience montre qu'un tel taux d'encadrement, un adulte pour 3 jeunes, est nécessaire au bon déroulement de l'activité. 
 +
 +Nous essayons de faire en sorte que l'atelier fonctionne en mode collaboratif entre les jeunes : ceux qui vont plus vite sur une tâche aident les autres à la finir. Ce principe fonctionne assez bien.
 +
 +====== Matériel utilisé ======
 +
 +Une plateforme avec un chassis à deux roues motrices et une roue traînante, un Arduino Uno, shield moteur, capteur ultrason, servo-moteur, leds... Le reste en fonction des évolutions que les jeunes veulent expérimenter pour perfectionner le fonctionnement de leur robot. On parle de capteurs infra-rouge, de buzzers, etc.
 +
 +
 +====== Lieu et horaires ======
 +
 +En 2013-2014, tous les samedis de 10h00 à 12h00, à Pen ar Créac'h
 +
 +
 +====== Premiers pas : un grand classique ======
 +
 +blink, bien sûr !
 +
 +On regarde un Arduino Uno, on essaie d'expliquer simplement de quoi il s'agit. On s'en sert pour alimenter une breadboard, on met une led, puis deux, on fait attention et on met des résistances en série où il faut, une pour chaque led, on modifie le programme pour en mettre encore une autre, on modifie les ordres de clignotement, on fait des chenillards à trois, quatre, cinq leds, on se dit qu'un sapin pour décembre ça serait sympa...
 +
 +On en profite pour expliquer le principe des résistances, à quoi ça sert (diminuer la force du courant), le principe de la différence de potentiel entre "GND" et le 'pin' d'alimentation et le principe de l'intensité du courant
 +
 +<note>Les noms de variables c'est du //no-limit// à cet âge là. Dès la première séance les leds s'appellent pabel, laide, moche... LOL</note>
 +
 +====== Que faire avec un potentiomètre ? ======
 +
 +Explication du principe du potentiomètre : une résistance variable. Donc on a maintenant une résistance qui doit nous permettre de faire varier l'intensité lumineuse des leds.
 +
 +On apprend à lire les caractéristiques, à les rechercher éventuellement sur internet. En une à deux séances, on en vient à proposer un montage qui va permettre de lire la valeur de la résistance sur un terminal série au fur et à mesure que l'on manipule le potentiomètre.
 +
 +<note important>Les Petits Hackers sont amenés à réfléchir par eux même à la réalisation du circuit avec le matériel : ils font donc des essais, et les adultes les guident mais ne font pas à leur place. C'est plus long (2 à 3 séances pour les deux circuits qui suivent), mais ça leur permet de mieux comprendre... et on a tout notre temps... Souvent on se retrouve à dessiner les possibilités au tableau et ils essaient ensuite de le faire //en vrai//. 
 +
 +Les schémas ci-dessous sont donc le **résultat** des recherches des enfants, pas un modèle qui leur serait distribué en début de séance ; c'est plutôt un guide pour les adultes</note>
 +===== * Premier circuit =====
 +
 +Explication de la manière dont on manipule une entrée analogique. Faire varier l'intensité de la lumière émise par la led et lire la valeur de la résistance sur le terminal
 +
 +
 +{{ :lespetitshackers:01fadepotarserial.png?nolink&500 |}}
 +Circuit 01fadepotarserial
 +
 +
 +Le code Arduino correspondant :
 +    
 +    AnalogInLPH
 +    Demonstration de la lecture d'un signal analogique sur A0 reliee a un 
 +    potentiometre qui fait varier l'intensite lumineuse d'une led. 
 +    On peut lire la valeur sur un terminal serie (0 - 1023)
 +    
 +    Le circuit:
 +    * patte centrale du potentiomètre sur A0
 +    * une patte latérale sur GND
 +    * l'autre patte latérale sur +5V
 +    * LED anode (long) reliée à la patte centrale du potentiomètre 
 +      avec une résistance en serie
 +    * LED cathode (court) reliee au GND
 +    
 +    voir le circuit  01FadePotarSerial.fzz
 +    
 +    
 +   int sensorPin = A0;    // pin du potentiometre
 +   int sensorValue = 0;  // la variable pour stocker la valeur (0 - 1023)
 +   
 +   void setup() {
 +     Serial.begin(9600); // ouverture de la liaison serie
 +   }
 +   
 +   void loop() {
 +     // lecture de la valeur a la sortie du potentiometre:
 +     sensorValue = analogRead(sensorPin); 
 +   
 +     // On peut faire facilement la conversion de la valeur 
 +     // analogique (0 - 1023)
 +     // en valeur de tension de courant (0 - 5V) :
 +     //float voltage = sensorValue * (5.0 / 1023.0);
 +     
 +     
 +     // impression du résultat sur le terminal serie
 +     Serial.print("sensor = " );                       
 +     Serial.println(sensorValue);
 +     //Serial.print("tension = " );                       
 +     //Serial.print(voltage);
 +     //Serial.println("V ");
 +  
 +     // on attend un peu pour la suivante
 +     delay(200); 
 +    
 +    }
 +
 +
 +===== * Deuxième Circuit =====
 +
 +Cette fois on va réutiliser la valeur lue en sortie du potentiomètre pour faire clignoter la led avec un pas de temps variable.
 +On veut montrer aux Petits Hackers comment on peut réutiliser avec l'Arduino une valeur générée par un composant quelconque pour modifier le comportement d'autres composants dans le circuit.
 +
 +<note tip>D'après notre expérience, ça marche mieux si on commence les séances par l'examen du code ; on annonce l'objectif, ce que l'on veut que le montage fasse, puis on dissèque le code pour comprendre comment faire et enfin on passe au dessin du circuit, puis au montage</note>
 +
 +
 +
 +{{ :lespetitshackers:02fadeblinkpotarserial.png?nolink&500 |}}
 +Circuit 02fadeblinkpotarserial
 +
 +Le code Arduino correspondant :
 +
 +    
 +     AnalogFadeBlinkLPH
 +     Demonstration de la lecture d'un signal analogique sur A0 reliee a un 
 +     potentiometre qui fait varier l'intensite lumineuse d'une led. 
 +     On peut lire la valeur sur un terminal serie (0 - 1023) ou (0 - 5V)
 +     
 +     La valeur du sensor sert aussi a faire clignoter une LED reliee au 
 +     pin 13 et l'intervalle du clignotement depend de la valeur lue sur A0
 +     
 +     Le circuit:
 +     * patte centrale du potentiomètre sur A0
 +     * une patte latérale sur GND
 +     * l'autre patte latérale sur +5V
 +     * LED1 anode (long) reliée à la patte centrale du potentiomètre
 +     * LED1 cathode (court) relièe au GND
 +     * LED2 anode sur le pin 13
 +     * LED2 cathode sur le GND
 +     
 +     voir le circuit  02FadeBlinkPotarSerial.fzz
 +     
 +     
 +    
 +    
 +    int sensorPin = A0;    // pin du potentiometre
 +    int sensorValue = 0;  // la variable pour stocker la valeur (0 - 1023)
 +    int ledPin = 13; // pin de la LED à faire clignoter
 +    float voltage = 0;
 +    
 +    void setup() {
 +      Serial.begin(9600); // ouverture de la liaison serie
 +      pinMode(ledPin, OUTPUT);
 +    }
 +    
 +    void loop() {
 +      // lecture de la valeur a la sortie du potentiometre:
 +      sensorValue = analogRead(sensorPin); 
 +      
 +      // allume ledPin :
 +      digitalWrite(ledPin, HIGH);  
 +      // on attend <sensorValue> millisecondes :
 +      delay(sensorValue);          
 +      // éteind ledPin :        
 +      digitalWrite(ledPin, LOW);   
 +      
 +      // On peut faire facilement la conversion de la valeur 
 +      // analogique (0 - 1023)
 +      // en valeur de tension de courant (0 - 5V) :
 +      voltage = sensorValue * (5.0 / 1023.0);
 +      
 +      // impression du résultat sur le terminal serie
 +      Serial.print("sensor = " );                       
 +      Serial.println(sensorValue);
 +      Serial.print("tension = " );                       
 +      Serial.print(voltage);
 +      Serial.println("V ");
 +      
 +      // on attend le temps d'un clignotement pour la suivante
 +      delay(sensorValue);
 +    
 +    }
 +
 +====== Mesurer des distances avec le son ======
 +
 +Maintenant que l'on sait comment gérer des entrées et des sorties et que l'on sait comment récupérer des valeurs sur un terminal série, on peut commencer à jouer avec un émetteur/récepteur à ultrasons ("pinger"). On va utiliser un grand standard, le HC-SR04 que l'on trouve facilement et qui n'est pas cher.
 +
 +On va mesurer la distance entre le pinger et un obstacle placé face à lui, et on va faire afficher cette distance sur l'écran de l'ordinateur connecté à l'arduino, dans un terminal série.
 +
 +
 +Le pinger émet un signal ultrason inaudible puis il en reçoit l'écho lorsque le son rebondit sur un objet quelconque. Tout ça va très vite, à la vitesse du son dans l'air c'est à dire à 343.5 m/s à 20°C. Donc le son met 29,1 microsecondes à parcourir 1 cm (29µs/cm)
 +
 +Pour mesurer à quelle distance se trouve l'objet du capteur il faut bien sûr d'abord mesurer le temps écoulé entre l'émission du ping et la réception de l'écho ; appelons ce temps "dt" que l'on exprime en microsecondes (µs). Il faut maintenant considérer que le temps écoulé dt est celui qu'a mis le ping pour atteindre l'objet ET revenir sur notre capteur : dt est donc le temps nécessaire à un aller-retour ! Donc le temps nécessaire à notre mesure est la moitié de dt.
 +
 +Et donc la distance sera (dt/2)*29,1
 +
 +On a fait un code basé sur celui de [[http://trollmaker.com/article3/arduino-and-hc-sr04-ultrasonic-sensor]]
 +
 +    /*
 +     HC-SR04 Pinger et deux leds (rouge et verte)
 +     pour indiquer si on est au-dessus ou au dessous
 +     d'une distance limite que l'on fixe.
 +     Ne pas oublier les résistances sur les leds
 +     */
 +    
 +    #define trigPin 13
 +    #define echoPin 12
 +    #define led 11
 +    #define led2 10
 +    
 +    void setup() {
 +      Serial.begin (9600);
 +      pinMode(trigPin, OUTPUT);
 +      digitalWrite(trigPin, LOW);
 +      
 +      pinMode(echoPin, INPUT);
 +      
 +      pinMode(led, OUTPUT);
 +      pinMode(led2, OUTPUT);
 +    }
 +    
 +    void loop() {
 +      long duree, distance;
 +      
 +      digitalWrite(trigPin, HIGH);
 +      delayMicroseconds(10); 
 +      digitalWrite(trigPin, LOW);
 +      
 +      duree = pulseIn(echoPin, HIGH);
 +      
 +      /* Le son va à la vitesse de 340m/s ; il lui faut donc 29 microsecondes
 +      pour parcourir 1cm. Notre ping va jusqu'à l'obstacle, puis revient jusqu'au
 +      capteur, il parcourt donc la distance deux fois : il faut donc diviser
 +      la durée par deux
 +      */
 +      distance = (duree / 2) / 29.1;
 +      
 +      if (distance < 7) {  // On va allumer ou éteindre les leds
 +        digitalWrite(led,HIGH); // la rouge s'allume, 
 +        digitalWrite(led2,LOW); // et la verte s'éteint
 +    }
 +      else {
 +        digitalWrite(led,LOW); // la rouge s'éteint
 +        digitalWrite(led2,HIGH); // la verte s'allume
 +      }
 +      if (distance >= 200 || distance <= 0){ // attention aux limites du capteur
 +        Serial.println("Out of range");
 +      }
 +      else {
 +        Serial.print(distance);
 +        Serial.println(" cm");
 +      }
 +      delay(100); // on attend un peu 
 +    }
 +
 +
 +
 +
 +====== le code de la séance ======
 +==On met ici un peu en vrac les codes à télécharger en séance==
 +
 +
 +
 +==Un code de découverte des fonctions==
 +
 +On part de ça et on en construit d'autres pour faire danser le robot
 +
 +
 +    // Construction de fonctions simples avec les moteurs et 
 +    // mise en mouvement en utilisant les fonctions
 +    
 +    int DIR2 = 4;  // Direction rotation Moteur 2
 +    int SP2 = 5;   // Vitesse Moteur 2
 +    
 +    int SP1 = 6;   // Vitesse Moteur 1
 +    int DIR1 = 7;  // Direction rotation Moteur 1
 +    
 +    // Les pin du HCSR04
 +    #define trigPin 11
 +    #define echoPin 12
 +    
 +    // Des pin pour des leds
 +    #define led 13
 +    
 +    
 +    void setup() {
 +    
 +      // Tous les pin moteur sont des sorties
 +      pinMode(4, OUTPUT);  
 +      pinMode(5, OUTPUT);
 +      pinMode(6, OUTPUT);
 +      pinMode(7, OUTPUT);
 +      
 +      // Le pin d'émission du capteur Ultrason
 +      pinMode(trigPin, OUTPUT);
 +      digitalWrite(trigPin, LOW);
 +      
 +      // Le pin de reception du capteur ultrason
 +      pinMode(echoPin, INPUT);
 +      
 +      // Config des pin led
 +      pinMode(led, OUTPUT);
 +    
 +    }
 +    
 +    int vitesse = 200 ;
 +    
 +    // Les fonctions de mouvement
 +    void AVANCE(int vitesse) {
 +      digitalWrite(DIR1,LOW); // Moteur 1 Gauche : HIGH Arrière & LOW Avant
 +      analogWrite(SP1,vitesse); // Moteur 1 à fond
 +      
 +      digitalWrite(DIR2,LOW); // Moteur 2 Gauche : HIGH Arrière & LOW Avant
 +      analogWrite(SP2,vitesse); // Moteur 2 à fond
 +    }
 +    
 +    void loop(){
 +      AVANCE(vitesse) ;
 +      
 +    }
 +
 +
 +== Des fonctions sans delay() ==
 +
 +On fait marcher le robot en utilisant les fonctions dans la void loop() avec le capteur ultrason et on n'utilise plus la fonction delay()
 +
 +
 +    // Fonctionnement du robot avec fonctions
 +      
 +     // Constantes des moteurs
 +     #define DIR2 4  // Direction rotation Moteur 2
 +     #define SP2  5   // Vitesse Moteur 2
 +     #define SP1  6   // Vitesse Moteur 1
 +     #define DIR1 7  // Direction rotation Moteur 1
 +     
 +     // Constantes pin du capteur US HCSR04
 +     #define trigPin 11
 +     #define echoPin 12
 +      
 +     // Declaration du servomoteur
 +     #include <Servo.h> 
 +     Servo flo;  
 +     int pos = 0;     
 +     
 +     // Des pin pour des leds
 +     #define led 13
 +      
 +     //la valeur de la vitesse
 +     #define speed1 100 // vitesse moteur droit
 +     #define speed2 100 // vitesse moteur gauche
 +     
 +     //variables pour la detection des obstacles
 +     const int obstacle = 7;
 +     long distG = 0;
 +     long distD = 0;
 +     long repere = 0;
 +     
 +     
 +     
 +     //gestion des intervalles de temps
 +     long currentMillisMove = 0;
 +     long currentMillisG = 0;
 +     long currentMillisD = 0;
 +     long previousMillis = 0; // 
 +     long interval = 1000; // 1 seconde
 +      
 +    void setup() {
 +      
 +       // Tous les pin moteur sont des sorties
 +       pinMode(4, OUTPUT);  
 +       pinMode(5, OUTPUT);
 +       pinMode(6, OUTPUT);
 +       pinMode(7, OUTPUT);
 +        
 +       // Le pin d'émission du capteur Ultrason
 +       pinMode(trigPin, OUTPUT);
 +       digitalWrite(trigPin, LOW);
 +       Serial.begin (9600);
 +        
 +       // Le pin de reception du capteur ultrason
 +       pinMode(echoPin, INPUT);
 +        
 +       // Config des pin led
 +       pinMode(led, OUTPUT);
 +       
 +       // Config du servo sur pin 9
 +       flo.attach(9);  
 +    }
 +      
 +      
 +     // Les fonctions de mouvement
 +     //fonction pour avancer
 +     void AVANCE(int lavitesse1,int lavitesse2) {
 +       digitalWrite(DIR1,HIGH); // Moteur 2 Gauche : HIGH Avant & LOW Arrière
 +       analogWrite(SP1,lavitesse1); // Moteur 1 à fond
 +        
 +       digitalWrite(DIR2,HIGH); // Moteur 2 Gauche : HIGH Avant & LOW Arrière
 +       analogWrite(SP2,lavitesse2); // Moteur 2 à fond
 +     }
 +     // fonction pour reculer
 +     void RECULE(int lavitesse1,int lavitesse2) {
 +       digitalWrite(DIR1,LOW); // Moteur 2 Gauche : HIGH Avant & LOW Arrière
 +       analogWrite(SP1,lavitesse1); // Moteur 1 à fond
 +        
 +       digitalWrite(DIR2,LOW); // Moteur 2 Gauche : HIGH Avant & LOW Arrière
 +       analogWrite(SP2,lavitesse2); // Moteur 2 à fond
 +     }
 +      
 +     // fonction pour tourner sur place
 +     void SUR_PLACE_G(int lavitesse1,int lavitesse2) {
 +       digitalWrite(DIR1,HIGH); // Moteur 2 Gauche : HIGH Avant & LOW Arrière
 +       analogWrite(SP1,lavitesse1); // Moteur 1 à fond
 +        
 +       digitalWrite(DIR2,LOW); // Moteur 2 Gauche : HIGH Avant & LOW Arrière
 +       analogWrite(SP2,lavitesse2); // Moteur 2 à fond
 +     }
 +     // fonction pour tourner sur place
 +     void SUR_PLACE_D(int lavitesse1,int lavitesse2) {
 +       digitalWrite(DIR1,LOW); // Moteur 2 Gauche : HIGH Avant & LOW Arrière
 +       analogWrite(SP1,lavitesse1); // Moteur 1 à fond
 +       
 +       digitalWrite(DIR2,HIGH); // Moteur 2 Gauche : HIGH Avant & LOW Arrière
 +       analogWrite(SP2,lavitesse2); // Moteur 2 à fond
 +     }
 +      
 +     // fonction pour détecter
 +     /* Le son va à la vitesse de 340m/s ; il lui faut donc 29 microsecondes
 +      pour parcourir 1cm. Notre ping va jusqu'à l'obstacle, puis revient jusqu'au
 +      capteur, il parcourt donc la distance deux fois : il faut donc diviser
 +      la durée par deux. Soit 58 ms / cm.
 +     */ 
 +     int DETECTE () {
 +       int duree ;
 +       digitalWrite(trigPin, HIGH);
 +       delayMicroseconds(10); 
 +       digitalWrite(trigPin, LOW);
 +       duree = pulseIn(echoPin, HIGH);
 +       return(duree / 58) ;
 +     }
 +     // fonction pour tourner la tete
 +     void TETE (int p) {
 +     flo.write(p); 
 +     }
 +    
 +    void loop(){
 +     
 +      TETE (67);
 +      //Si on voit un obstacle à moins de dist.obst cm on s'arrete
 +      repere = DETECTE();
 +      if (repere < obstacle) {
 +        
 +        currentMillisMove = millis();
 +        while(millis() < currentMillisMove + interval) AVANCE (0,0);
 +        
 +        // Puis on recule 
 +        currentMillisMove = millis();
 +        while(millis() < currentMillisMove + (interval/2)) RECULE (100, 100);
 +        
 +        // on tourne la tete a gauche
 +        currentMillisG = millis();
 +        while(millis() < currentMillisG + interval)  {
 +          TETE(180);
 +          distG = DETECTE();
 +        }
 +        
 +        // on tourne la tete a droite
 +        currentMillisD = millis();
 +        while(millis() < currentMillisD + interval)  {
 +          TETE(0);
 +          distD = DETECTE();      
 +        }
 +        
 +        //
 +        SUR_PLACE_D(100,100);
 +        delay(500);
 +      }
 +    
 +      AVANCE(speed1, speed2); 
 +    
 +    }
 +
 +== Et le code final == 
 +
 +Normalement, moyennant des réglages sur les prises moteurs et les vitesses, ce code ci fonctionne
 +
 +    // Fonctionnement du robot avec fonctions
 +      
 +     // Constantes des moteurs
 +     #define DIR2 4  // Direction rotation Moteur 2
 +     #define SP2  5   // Vitesse Moteur 2
 +     #define SP1  6   // Vitesse Moteur 1
 +     #define DIR1 7  // Direction rotation Moteur 1
 +     
 +     // Constantes pin du capteur US HCSR04
 +     #define trigPin 11
 +     #define echoPin 12
 +      
 +     // Declaration du servomoteur
 +     #include <Servo.h> 
 +     Servo flo;  
 +     int pos = 0;     
 +     
 +     // Des pin pour des leds
 +     #define led 13
 +      
 +     //la valeur de la vitesse
 +     #define speed1 100 // vitesse moteur droit
 +     #define speed2 100 // vitesse moteur gauche
 +     
 +     //variables pour la detection des obstacles
 +     const int obstacle = 7;
 +     //long distG = 0;
 +     //long distD = 0;
 +     long repere = 0;
 +     int k = 0;
 +     
 +     
 +     
 +     //gestion des intervalles de temps
 +     long currentMillisMove = 0;
 +     long currentMillisG = 0;
 +     long currentMillisD = 0;
 +     long previousMillis = 0; 
 +     long currentMillisV = 0;
 +     long interval = 1000; // 1 seconde
 +      
 +    void setup() {
 +      
 +       // Tous les pin moteur sont des sorties
 +       pinMode(4, OUTPUT);  
 +       pinMode(5, OUTPUT);
 +       pinMode(6, OUTPUT);
 +       pinMode(7, OUTPUT);
 +        
 +       // Le pin d'émission du capteur Ultrason
 +       pinMode(trigPin, OUTPUT);
 +       digitalWrite(trigPin, LOW);
 +       Serial.begin (9600);
 +        
 +       // Le pin de reception du capteur ultrason
 +       pinMode(echoPin, INPUT);
 +        
 +       // Config des pin led
 +       pinMode(led, OUTPUT);
 +       
 +       // Config du servo sur pin 9
 +       flo.attach(9);  
 +    }
 +      
 +      
 +     // Les fonctions de mouvement
 +     //fonction pour avancer
 +     void AVANCE(int lavitesse1,int lavitesse2) {
 +       digitalWrite(DIR1,HIGH); // Moteur 2 Gauche : HIGH Avant & LOW Arrière
 +       analogWrite(SP1,lavitesse1); // Moteur 1 à fond
 +        
 +       digitalWrite(DIR2,HIGH); // Moteur 2 Gauche : HIGH Avant & LOW Arrière
 +       analogWrite(SP2,lavitesse2); // Moteur 2 à fond
 +     }
 +     // fonction pour reculer
 +     void RECULE(int lavitesse1,int lavitesse2) {
 +       digitalWrite(DIR1,LOW); // Moteur 2 Gauche : HIGH Avant & LOW Arrière
 +       analogWrite(SP1,lavitesse1); // Moteur 1 à fond
 +        
 +       digitalWrite(DIR2,LOW); // Moteur 2 Gauche : HIGH Avant & LOW Arrière
 +       analogWrite(SP2,lavitesse2); // Moteur 2 à fond
 +     }
 +      
 +     // fonction pour tourner sur place
 +     void SUR_PLACE_G(int lavitesse1,int lavitesse2) {
 +       digitalWrite(DIR1,HIGH); // Moteur 2 Gauche : HIGH Avant & LOW Arrière
 +       analogWrite(SP1,lavitesse1); // Moteur 1 à fond
 +        
 +       digitalWrite(DIR2,LOW); // Moteur 2 Gauche : HIGH Avant & LOW Arrière
 +       analogWrite(SP2,lavitesse2); // Moteur 2 à fond
 +     }
 +     // fonction pour tourner sur place
 +     void SUR_PLACE_D(int lavitesse1,int lavitesse2) {
 +       digitalWrite(DIR1,LOW); // Moteur 2 Gauche : HIGH Avant & LOW Arrière
 +       analogWrite(SP1,lavitesse1); // Moteur 1 à fond
 +       
 +       digitalWrite(DIR2,HIGH); // Moteur 2 Gauche : HIGH Avant & LOW Arrière
 +       analogWrite(SP2,lavitesse2); // Moteur 2 à fond
 +     }
 +      
 +     // fonction pour détecter
 +     /* Le son va à la vitesse de 340m/s ; il lui faut donc 29 microsecondes
 +      pour parcourir 1cm. Notre ping va jusqu'à l'obstacle, puis revient jusqu'au
 +      capteur, il parcourt donc la distance deux fois : il faut donc diviser
 +      la durée par deux. Soit 58 ms / cm.
 +     */ 
 +     int DETECTE () {
 +       int duree ;
 +       digitalWrite(trigPin, HIGH);
 +       delayMicroseconds(10); 
 +       digitalWrite(trigPin, LOW);
 +       duree = pulseIn(echoPin, HIGH);
 +       return(duree / 58) ;
 +     }
 +     // fonction pour tourner la tete
 +     void TETE (int p) {
 +     flo.write(p); 
 +     }
 +    
 +    void loop(){
 +     
 +      TETE (67);
 +      //Si on voit un obstacle à moins de dist.obst cm on s'arrete
 +      repere = DETECTE();
 +      
 +      if (repere < obstacle) {
 +        
 +        // stoppe pendant interval
 +        currentMillisMove = millis();
 +        while(millis() < currentMillisMove + interval) AVANCE (0,0);
 +        
 +        // Puis on recule pendant interval/2
 +        currentMillisMove = millis();
 +        while(millis() < currentMillisMove + (interval/2)) RECULE (100, 100);
 +    
 +        // stoppe pendant interval
 +        currentMillisMove = millis();
 +        while(millis() < currentMillisMove + 2*interval) AVANCE (0,0);   
 +        
 +        // on tourne la tete a gauche
 +        //currentMillisG = millis();
 +        //while(millis() < currentMillisG + interval/2)  {
 +          TETE(180);
 +          int distG = DETECTE();
 +          delay(600);
 +          //Serial.print("distG");Serial.println(distG);
 +        //}
 +        
 +        // on tourne la tete a droite
 +        //currentMillisD = millis();
 +        //while(millis() < currentMillisD + interval/2)  {
 +          TETE(0);
 +          int distD = DETECTE(); 
 +          delay(600);
 +          //Serial.print("distD");Serial.println(distD);    
 +        //}
 +        
 +        // on remet la tete droite
 +        TETE(67);
 +        
 +        int dist = distD - distG;
 +        if (dist >= 0) { 
 +        k=1;
 +      }
 +        else{
 +        k=2;
 +      }
 +        //Serial.print("k=");Serial.println(k);
 +        
 +        switch (k) {
 +        case 1:
 +          SUR_PLACE_D(100,100);
 +          delay(700);
 +          break;
 +        case 2:
 +          SUR_PLACE_G(100,100);
 +          delay(700);
 +          break;
 +        //default: 
 +          // if nothing else matches, do the default
 +          // default is optional
 +      }
 +    
 +        
 +    //    if (distD >= distG){
 +    //      currentMillisV =millis();
 +    //      while(millis() > currentMillisV + interval/3) {
 +    //        SUR_PLACE_D(100,100);
 +    //      }
 +    //    }
 +    //    else {
 +    //      currentMillisV =millis();
 +    //      while(millis() > currentMillisV + interval/3) {
 +    //        SUR_PLACE_G(100,100);
 +    //      }
 +    //    }
 +    
 +      }
 +    
 +      AVANCE(100, 100); 
 +    
 +    }
 +
 +
 +
  
Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki