Robot Golbotth8

–.

Mise à jour le 25/02/2021 : Ce petit robot est destiné à vous initier à la programmation, nous l’appellerons Golbotth8. La construction de cet engin passe déjà par l’impression 3D, vous trouverez l’ensemble des fichiers STL sur notre site ainsi que la matière que nous avons utilisée et les différents conseils techniques. Vous aurez la possibilité de suivre des tutoriels sur Arduino avec ce module. Nous avons surtout essayé de minimiser le coût de l’ensemble.

Robot Golbotth8 -01 – RedOhm –

Sommaire :

Eclatée du robot
Matériel nécessaire à la construction du Robot Golbotth8
- Electronique
- Mécanique
Photo des differents elements
Ensemble des fichiers et des paramètres pour l’impression 3d
Fiche de montage
Tutoriel vidéo
- Principe de construction du robot Golbotth8
Programme 1 : Test pour les servomoteurs à rotation continue
Programme 2 : Les premiers essais de notre robot avec la seule utilisation du capteur incliné avant.
Retour au menu

Eclatée du robot

Eclatée vue d’ensemble robot Golbotth8 – RedOhm –

Retour au sommaire

Matériel nécessaire à la construction du Robot Golbotth8

Matériel électronique :

Carte Arduino MEGA 2560 : La carte Arduino Mega 2560 est basée sur un ATMega2560 cadencé à 16 MHz. Elle dispose de 54 E/S dont 14 PWM, 16 analogiques et 4 UARTs. Elle est idéale pour des applications exigeant des caractéristiques plus complètes que la Uno. Des connecteurs situés sur les bords extérieurs du circuit imprimé permettent d’enficher une série de modules.
- - Distributeur : Rs composant / Gotronic
  - Référence nomenclature RedOhm : g049
- Plus d’information sur la carte : Arduino Mega 2560 Rev3
- Information sur programmation : le langage Arduino

Module Grove Mega Shield V1.2 103020027 : Le module Grove Mega Shield de Seeedstudio est une carte d’interface permettant de raccorder facilement, rapidement et sans soudure les capteurs et les actionneurs Grove de Seeedstudio sur une carte compatible Arduino Mega. Il est compatible notamment avec les cartes Arduino Mega et Google ADK.Cette carte peut être divisée en 4 sections: le bouton de reset, la connectique d’alimentation, la partie digitale et la partie analogique. Elle est équipée de connecteurs 4 broches pour les entrées analogiques, les entrées-sorties logiques, les interfaces I2C et UART.
- Distributeur : Gotronic
- Référence nomenclature RedOhm : g050
Interrupteur à bascule Noir 1NO Marche-arrêt : Interrupteurs à bascule unipolaires Marquardt série 1900. Les interrupteurs à bascule 1900 sont adaptés à une utilisation dans des appareils de classe II et sont disponibles en trois options de profils compacts attrayants. Le corps de l’interrupteur à bascule à enduit de surface mat satiné s’enclenche rapidement dans les découpes du panneau de 0,75 à 3 mm d’épaisseur. Les ergots de fixation sur le boîtier de l’interrupteur garantissent en outre une excellente étanchéité. Les interrupteurs à bascule 1900 disposent de contacts en argent avec un format de commutation (marche-arrêt) 1 NO, d’une résistance de contact < 100 mΩ et d’une résistance d’isolation > 100 mΩ. La connexion électrique s’effectue par le biais des cosses languettes Faston / à raccordement rapide de 4,8 mm.
- - Intensité nominale élevée : 6 A
  - Courant d’appel élevé (capacitif) : 50 A
  - Connexion électrique : A cosses languettes Faston / à raccordement rapide de 4,8 mm
  - Inflammabilité : conforme à la norme UL 94 V-2
- Référence fabricant : 1901.1102
- Distributeur : Rs composant
- Référence RS composant : 607-7545
- Référence nomenclature RedOhm : g051
Télémètre à ultrasons Grove 101020010 : Ce télémètre compatible Grove permet de mesurer la distance sans contact à l’aide de transducteurs à ultrasons.
- Référence Gotronic : 31315
- Distributeur : Gotronic
- Référence nomenclature RedOhm : g052/ g053 / g054
- Affectation de :
  - g52 => Ultrasons avant pour le contrôle profondeur
    - Affectation sur la carte Mega Grove : Pin 6
  - g53 => Ultrasons arrière
    - Affectation sur la carte Mega Grove : Pin 8
  - g54 => Ultrasons de tourelle
    - Affectation sur la carte Mega Grove : Pin 10
- Plus d’information : Télémètre à ultrasons Grove 101020010
Servomoteur Feetech FS5113R à rotation continue disposant d’un couple élevé et d’une pignonnerie métallique.La roue FS5103R-W est spécialement adaptée à ce servomoteur.
- Alimentation : 4,8 à 6 Vcc.
- Course : 360°
- Couple : 12,5 kg.cm à 4,8 Vcc et de 14 kg.cm à 6 Vcc
- Vitesse à vide : 57 t/min à 4,8 Vcc et de 64 t/min à 6 Vcc
- Dimensions : 41 x 20 x 38 mm
- Poids : 56 gr.
- Référence Feetech : FS5113R
- Distributeur : Gotronic
- Référence nomenclature RedOhm : g060/g061

Led 8 mm RGB Grove V2.0 104020048 Ce module led RGB 8 mm est compatible Grove et permet d’obtenir une couleur au choix à partir d’une sortie d’une microcontrôleur (Arduino, Seeeduino, etc.). Possibilité de raccorder jusqu’à 1024 modules en cascade.
- Interface : série compatible Grove
- Alimentation : 5 Vcc
- Consommation : 20 mA
- Couleur : RGB
- Dimensions : 40 x 20 x 15 mm
- Version : 2.0
- Référence Seeedstudio : 104020048 (remplace 104030006)
- Distributeur : Gotronic
- Référence nomenclature RedOhm : g070/g071/g072
  - Affectation sur la carte Mega Grove : Pin 12-13

Matériel mécanique :

- Roue pour servomoteur FS5103R . Roue + pneu spécifiquement prévus pour se monter sur le servomoteur à rotation continue FS5103R .Le pneu caoutchouté inclus procure une bonne adhérence sur la plupart des sols.
  - - Diamètre : 70 mm
    - Épaisseur : 11 mm
  - Distributeur : Gotronic
  - Référence nomenclature RedOhm : g200/g201

Butée à billes 51105 Générique, Diamètre intérieur 25 mm, Diamètre extérieur 42 mm, Epaisseur 11 mm, Poids 0.054 kg
- Distributeur : 123Roulement
- Référence nomenclature RedOhm : g201

Retour au sommaire

Photo des differents elements

.

Retour au sommaire

Ensemble des fichiers et des paramètres pour l’impression 3d

Impression sur Zortrax M200 et M300

–

Golbotth8 – Pièce g010 tourelle – RedOhm –

–

Golbotth8 – Piece g011 base tourelle – RedOhm –

–

Golbotth8 – Piece g012 plateau pour chassis – RedOhm –

–

Golbotth8 – piece g017 support sonic – RedOhm –

Téléchargement de l’ensemble des fichiers stl pour le robot Golbotth8

Retour au sommaire

Tutoriel vidéo

Principe de construction du robot Golbotth8

Retour au sommaire

Programme 1 : Test pour la calibration des servomoteurs à rotation continue

–

/*
 * 
 * 
 * RedOhm
 * 
 * Programme de test pour la calibration des servomoteurs à 
 * rotation continue
 * 
 * 
 * Le 01/09/2018
 * H.Mazelin
 * 
 */




// Cette librairie permet à une carte Arduino de contrôler des servomoteurs
#include <Servo.h> 

// Variable qui enregistre l'état du signal pour activer le servomoteur
// par defaut la valeur est fixée à 1500 ce qui correspond en general à l'arret
// du servomoteur ( pour un servomoteur à rotation continue )
int temps = 1500;


// Variable pour le comptage en vue du rafraichissement de l'ecran 
int compteur=0; 

// Crée un objet de type "Servo", nommé -> monservo
Servo monServo;


/* 
 * Un programme Arduino doit impérativement contenir cette fonction .
 * Elle ne sera exécuter une seule fois au démarrage du microcontroleur
 * Elle sert à configurer globalement les entrées sorties  
 *  
 */

void setup()
{
    Serial.begin(9600);
    Serial.println("*====================================*");
    Serial.println("*                                    *");
    Serial.println("* Programme de test pour servomoteur *");
    Serial.println("*                                    *");
    Serial.println("*        à rotation continu          *");
    Serial.println("*=====================================");
    Serial.println("*                                    *");
    Serial.print("* valeur de deplacement par defaut -> ");
    Serial.println(temps);
    Serial.println("* w augmente la valeur par defaut de 10 ");
    Serial.println("* x diminue la valeur par defaut de 10 ");
    Serial.println("* a -> arret du servomoteur / v -> marche avant / r -> marche arriere ");
    Serial.println("                                     ");
    // associe la variable monservo de sa broche en autre la numero 3   
    monServo.attach(3);

    
    // Écrit une valeur en microsecondes (uS) sur le servo, 
    // la valeur par defaut etant 1500 ce qui correspond en
    // general à l'arret
    monServo.writeMicroseconds(temps);
}

/*
 *Le programme principal s’exécute par une boucle infinie appelée Loop () 
 * 
 */
void loop()
{
    //Obtenez le nombre d'octets (caractères) disponibles pour 
    //la lecture du port série.
    //dans notre cas soit la lettre w ou x ou a pour arret 
    //ou r pour arriere ou v pour avant  
    if(Serial.available())
    {
        char commande = Serial.read();
            // on modifie la vitesse de 10 microsecondes            
            // touche w et validation avec la touche entrée augmenter la vitesse 
            // vers l'avant ou on diminue si on est en arriere        
        if(commande == 'w')
            temps += 10; 
        else if(commande == 'x')
            // on modifie la vitesse de 10 microsecondes
            // touche x et validation avec la touche entrée augmenter la vitesse 
            // vers l'arriere ou on diminue si on est en avant              
            temps -= 10;  
            // touche a et validation avec la touche entrée pour arret 
            // du servo ( pour les servomoteurs rotation 360°
        else if (commande == 'a')
            {
            temps = 1500;
            Serial.println("Demande d'arret");
            }
            // touche v et validation avec la touche entrée pour avant  
            // du servo ( pour les servomoteurs rotation 360°
        else if (commande == 'v')
            temps = 1600;
            // touche v et validation avec la touche entrée pour arriere  
            // du servo ( pour les servomoteurs rotation 360°
        else if (commande == 'r')
            temps = 1400;
        // comptage du nombre de passage pour le rappel des commandes
        // sur l'ecran        
        compteur=compteur+1; 
        
        //x > y (x est supérieur à y)
        //si le resultat et vrais alors on rappelle les commandes de 
        //pilotage du servomoteur 
        if(compteur > 28)
        {
          Serial.println("*====================================*");
          Serial.println("*                                    *");
         Serial.println("* Programme de test pour servomoteur *");
         Serial.println("*                                    *");
         Serial.println("*        à rotation continu          *");
         Serial.println("*=====================================");
         Serial.println("*                                    *");
         Serial.print("* valeur de deplacement par defaut -> ");
         Serial.println(temps);
         Serial.println("* w augmente la valeur par defaut de 10 ");
         Serial.println("* x diminue la valeur par defaut de 10 ");
         Serial.println("* a -> arret du servomoteur / v -> marche avant / r -> marche arriere "); 
         Serial.println("                                     ");
         compteur = 0;
        }
        // x <= y (x est inférieur ou égal à y)
        // si le resultat et vrais alors on ne fait rien
        else if (compteur <=28)
        {

          
        }

                   

        // envoie de la valeur au servomoteur pour 
        monServo.writeMicroseconds(temps);
      
        
        // retour de la valeur envoyée au servomoteur sur l'ecran du 
        // pc 
        Serial.print("Valeur de la vitesse de deplacement -> ");
        Serial.println(temps, DEC);
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

* RedOhm

* Programme de test pour la calibration des servomoteurs à

* rotation continue

* Le 01/09/2018

* H.Mazelin

// Cette librairie permet à une carte Arduino de contrôler des servomoteurs

#include <Servo.h>

// Variable qui enregistre l'état du signal pour activer le servomoteur

// par defaut la valeur est fixée à 1500 ce qui correspond en general à l'arret

// du servomoteur ( pour un servomoteur à rotation continue )

int temps = 1500;

// Variable pour le comptage en vue du rafraichissement de l'ecran

int compteur=0;

// Crée un objet de type "Servo", nommé -> monservo

Servo monServo;

* Un programme Arduino doit impérativement contenir cette fonction .

* Elle ne sera exécuter une seule fois au démarrage du microcontroleur

* Elle sert à configurer globalement les entrées sorties

void setup()

{

Serial.begin(9600);

Serial.println("*====================================*");

Serial.println("* *");

Serial.println("* Programme de test pour servomoteur *");

Serial.println("* *");

Serial.println("* à rotation continu *");

Serial.println("*=====================================");

Serial.println("* *");

Serial.print("* valeur de deplacement par defaut -> ");

Serial.println(temps);

Serial.println("* w augmente la valeur par defaut de 10 ");

Serial.println("* x diminue la valeur par defaut de 10 ");

Serial.println("* a -> arret du servomoteur / v -> marche avant / r -> marche arriere ");

Serial.println(" ");

// associe la variable monservo de sa broche en autre la numero 3

monServo.attach(3);

// Écrit une valeur en microsecondes (uS) sur le servo,

// la valeur par defaut etant 1500 ce qui correspond en

// general à l'arret

monServo.writeMicroseconds(temps);

}

*Le programme principal s’exécute par une boucle infinie appelée Loop ()

void loop()

{

//Obtenez le nombre d'octets (caractères) disponibles pour

//la lecture du port série.

//dans notre cas soit la lettre w ou x ou a pour arret

//ou r pour arriere ou v pour avant

if(Serial.available())

{

char commande = Serial.read();

// on modifie la vitesse de 10 microsecondes

// touche w et validation avec la touche entrée augmenter la vitesse

// vers l'avant ou on diminue si on est en arriere

if(commande == 'w')

temps += 10;

else if(commande == 'x')

// on modifie la vitesse de 10 microsecondes

// touche x et validation avec la touche entrée augmenter la vitesse

// vers l'arriere ou on diminue si on est en avant

temps -= 10;

// touche a et validation avec la touche entrée pour arret

// du servo ( pour les servomoteurs rotation 360°

else if (commande == 'a')

{

temps = 1500;

Serial.println("Demande d'arret");

}

// touche v et validation avec la touche entrée pour avant

// du servo ( pour les servomoteurs rotation 360°

else if (commande == 'v')

temps = 1600;

// touche v et validation avec la touche entrée pour arriere

// du servo ( pour les servomoteurs rotation 360°

else if (commande == 'r')

temps = 1400;

// comptage du nombre de passage pour le rappel des commandes

// sur l'ecran

compteur=compteur+1;

//x > y (x est supérieur à y)

//si le resultat et vrais alors on rappelle les commandes de

//pilotage du servomoteur

if(compteur > 28)

{

Serial.println("*====================================*");

Serial.println("* *");

Serial.println("* Programme de test pour servomoteur *");

Serial.println("* *");

Serial.println("* à rotation continu *");

Serial.println("*=====================================");

Serial.println("* *");

Serial.print("* valeur de deplacement par defaut -> ");

Serial.println(temps);

Serial.println("* w augmente la valeur par defaut de 10 ");

Serial.println("* x diminue la valeur par defaut de 10 ");

Serial.println("* a -> arret du servomoteur / v -> marche avant / r -> marche arriere ");

Serial.println(" ");

compteur = 0;

}

// x <= y (x est inférieur ou égal à y)

// si le resultat et vrais alors on ne fait rien

else if (compteur <=28)

{

}

// envoie de la valeur au servomoteur pour

monServo.writeMicroseconds(temps);

// retour de la valeur envoyée au servomoteur sur l'ecran du

// pc

Serial.print("Valeur de la vitesse de deplacement -> ");

Serial.println(temps, DEC);

}

Retour au sommaire

Programme 2 : Les premiers essais de notre robot avec la seule utilisation du capteur incliné avant.

/*
 * 
 * Le robot Golbotth8
 * 
 * Programme pour les premiers essais de notre robot 
 * avec la seule utilisation du capteur incliné avant. 
 * 
 * Le 06/10/2018
 * H-Mazelin - RedOhm -
 * 
 */

// Cette librairie permet à une carte Arduino de contrôler des servomoteurs
#include <Servo.h> 
// je charge la librairie Ultrasonic
// Cette bibliothèque permet à une carte Arduino de gerer
// le capteur ultrason 
// A savoir :
// Télécharger la Bibliothèque UltrasonicRanger de Github. 
// à installer dans la bibliothèque d'origine des fichiers
// de l'IDE Arduino voir le lien sur le site redohm
// Attention sur l'exemple fourni par Github il y a 
// une possibilité d 'erreur
#include "Ultrasonic.h"

// Crée un objet de type "Servo", nommé -> rouedroite
Servo rouedroite;
// Crée un objet de type "Servo", nommé -> rouegauche
Servo rouegauche;

// Declaration du nom du capteur et de la broche de raccordement 
// sur la carte Arduino
Ultrasonic ultrasonic(6);





// Variable qui enregistre l'état du signal pour activer le servomoteur
// par defaut la valeur est fixée à 1500 ce qui correspond en general à l'arret
// du servomoteur ( pour un servomoteur à rotation continue )
int arret = 1500;

// Variable d'etat pour l arret 
int arretetat = 0;



// Variable d'etat pour le lancement de la rampe en marche avant 
int lancement_rampe_avant = 0;

// variable vitesse et de direction pour le servomoteur droit
int tempsdroite;
// variable vitesse et de direction pour le servomoteur gauche
int tempsgauche;

// Declaration de la variable pour la rampe de demarrage
int valeur_de_vitesse_demarrage;

// Declaration de la variable pour le comptage de changement de direction
// en arriere
int changement_direction =0 ;




// Declaration de la variable pour la vitesse rampe de demarrage
// unsigned long-> déclare une variable de type long non signé
unsigned long rampedemarrage = millis();



/* 
 * Un programme Arduino doit impérativement contenir cette fonction .
 * Elle ne sera exécutée qu'une seule fois au démarrage du microcontroleur
 * Elle sert à configurer globalement les entrées sorties *  
 */


void setup() {



    Serial.begin(9600); 
 // associe la variable rouedroite à sa broche numero 3   
  rouedroite.attach(3);
    // associe la variable rouegauche à sa broche numero 5 
  rouegauche.attach(5);

 // Écrit une valeur en microsecondes (uS) sur le servo, 
 // la valeur par defaut etant 1500 ce qui correspond en
 // general à l'arret
 rouedroite.writeMicroseconds(arret);  
  rouegauche.writeMicroseconds(arret); 

   arretetat=0;

 delay (5000);  


  

}

void loop() {

  // variable du type long 
  // Declare la variable mesure_de_la_valeur_en_centimeters
  // Rappel sur la fonction d'une variable :On peut définir une variable comme
  // une boite ou l’on stocke des balles .Une variable est une boite ou 
  // l’on stocke un nombre ,et comme il existe une multitude de nombres:
  // Exemple entiers ,décimaux etc …Il faut donc assigner un type à cette
  // variable .
  long mesure_de_la_valeur_en_centimeters;
  // Lecture de la valeur de notre capteur 
  mesure_de_la_valeur_en_centimeters = ultrasonic.MeasureInCentimeters();
  // attente pour mise en service capteur 
  delay(50);

  // 
  Serial.print (arretetat);
   Serial.print("  Valeur de la roue droite=> ");
    Serial.println (tempsdroite);


  //
    
    // =======================================================
    // demarrage du robot si le capteur ne detecte pas d'obstacle
    // en dessous de 5cm 
    // demarrage avec rampe d'acceleration afin d'eviter 
    // le patinage
    // =======================================================
    if ((mesure_de_la_valeur_en_centimeters>=5)&& ( lancement_rampe_avant == 0))
    {

    lancement_rampe_avant = 1;
    Serial.println("demande de marche avant");
    marche_avant_avec_rampe();
    arretetat = 0;   
    }

    else if ((mesure_de_la_valeur_en_centimeters>=5) && ( lancement_rampe_avant == 1))
    {
    rouedroite.writeMicroseconds(1400);
    rouegauche.writeMicroseconds (1600); 
    arretetat = 0;  
    }


    // ======================================
    // Gestion d'un obstacle arret d'urgence 
    // ======================================
    else if ((mesure_de_la_valeur_en_centimeters <=5)&&(arretetat==0))

    {
   Serial.println ("Gestion d'un obstacle arret d'urgence ");
    Serial.println ("(mesure_de_la_valeur_en_centimeters <=5)&&(arretetat=0)" );
     Serial.print("Attention obstacle à =>");
      Serial.println(mesure_de_la_valeur_en_centimeters);
   
   // envoie de la valeur au 2 servomoteurs pour le 
   // demarrage avec rampe d'acceleration 
   rouedroite.writeMicroseconds(1500);
   rouegauche.writeMicroseconds (1500); 
   // remise à zero de la variable pour pouvoir redemarrer
   // avec la rampe de demarrage avant 
   lancement_rampe_avant = 0;
   arretetat = 1;
   delay (2000);
      
    }

    else if  (((mesure_de_la_valeur_en_centimeters <=5)&&(arretetat==1))&&(changement_direction<3))
    {
    Serial.println ("========================================");
    Serial.println ("       Je recule et je tourne           ");
    Serial.println ("               *****                    ");
    Serial.print   ("Attention obstacle à =>");
    Serial.println(mesure_de_la_valeur_en_centimeters);  
    Serial.println ("========================================");
    Serial.println ("                                        ");
    Serial.println ("                                        ");
    arretetat=0;
   // si on genere un arret d'urgence alors on doit redemarrer 
   // la rampe d'acceleration 
   lancement_rampe_avant = 0;
   // on verifie le nombre de fois que l'on recule
   changement_direction = changement_direction +1 ;
   Serial.print("changement_direction =>");
    Serial.println (changement_direction);
   


    /*
     *                   -Etape 1-
     * 
     * je recule vers la droite  
     * pendant 2 secondes 
     * puis je recule en ligne droite 
     * pendant 2 secondes 
     * puis en avant en ligne droite 
     * pendant 2 secondes
     */
    if (  changement_direction == 1)
    {
    Serial.println ("****************************************");
    Serial.println (" Variable de temps = 2000               ");
    Serial.println ("          ETAPE 1                       ");
    Serial.println (" - Je recule vers la droite             ");
    Serial.println (" - Pendant 2 secondes                   ");
    Serial.println (" - Puis je recule en ligne droite       ");
    Serial.println (" - Pendant 2 secondes                   ");
    Serial.println (" - Puis en avant  en ligne droite       ");
    Serial.println (" - Pendant 2 secondes                   ");
    Serial.println ("****************************************");
    Serial.println ("                                        ");
    // recule vers la droite 
    rouedroite.writeMicroseconds(1540);
    rouegauche.writeMicroseconds (1400); 
    delay (2000);
    // Puis je recule en ligne droite  
    rouedroite.writeMicroseconds(1600);
    rouegauche.writeMicroseconds (1400);
    delay (2000); 
    // Puis j'avance en operant une virage sur la gauche   
    rouedroite.writeMicroseconds(1400);
    rouegauche.writeMicroseconds (1540);
    delay (2000); 
    }

    /*
     *                   -Etape 2-
     * 
     * je recule vers la droite  
     * pendant 5 secondes 
     * 
     */
   
    else if (  changement_direction == 2)
    {
    Serial.println ("****************************************");
    Serial.println (" Variable de temps = 4000               ");
    Serial.println ("          ETAPE 2                       ");
    Serial.println (" - Je recule vers la droite             ");
    Serial.println (" - Pendant 5 secondes                   ");
    Serial.println ("****************************************");
    Serial.println ("                                        ");
    // recule vers la droite 
    rouedroite.writeMicroseconds(1530);
    rouegauche.writeMicroseconds (1400);
    // Met le programme en pause pendant la durée (6000 en millisecondes) 
    delay (5000);
    
    }
    
    /*
     *                   -Etape 3-
     * 
     * je recule vers la droite  
     * pendant 6 secondes 
     * 
     */
    else if (  changement_direction >= 3)
    {
    Serial.println ("****************************************");
    Serial.println (" Variable de temps = 6000               ");
    Serial.println ("          ETAPE 3                       ");
    Serial.println (" - Je recule vers la droite             ");
    Serial.println (" - Pendant 6 secondes                   ");
    Serial.println ("****************************************");
    Serial.println ("                                        ");
    // recule vers la droite 
    rouedroite.writeMicroseconds(1540);
    rouegauche.writeMicroseconds (1400); 
    // Met le programme en pause pendant la durée (6000 en millisecondes) 
    delay (6000);
    }

      
    }
    
   // 
   // Si on détecte un obstacle à moins de 5 cm
   // et que si la variable arrêt est égale à un
   // et si le nombre de fois que l'on a reculé et supérieur à trois 
   // on recule et on change de direction en reculant
   //
   else if  (((mesure_de_la_valeur_en_centimeters <=5)&&(arretetat==1))&&(changement_direction>=3))
   {
   // information pour l'operateur via le moniteur
   Serial.println ("==================================================");
   Serial.println (" Je recule et je tourne en changeant de direction ");
   Serial.println ("==================================================");
   rouedroite.writeMicroseconds(1600);
    rouegauche.writeMicroseconds (1420); 
   // Met le programme en pause pendant la durée (4000 en millisecondes)  
   delay (4000);
   changement_direction = 0;
   // si on genere un arret d'urgence alors on doit redemarrer 
   // la rampe d'acceleration 
   lancement_rampe_avant = 0; 
   // mise a zero de la variable 
   arretetat=0;
    
   }
   
   

}

//
// sous programme pour la rampe d'acceleration 
//
void marche_avant_avec_rampe()
{

 
   // forçage de la variable valeur_de_vitesse_demarrage a = 0
   valeur_de_vitesse_demarrage = 0 ;
   // Les boucles while bouclent indéfiniment, jusqu'à ce que la condition
   // ou l'expression entre les parenthèses ( ) devient fausse. Quelque chose
   // doit modifier la variable testée, sinon la boucle while ne se terminera 
   // jamais. Cela peut être dans votre code, soit une variable incrémentée
   // , ou également une condition externe
   // dans notre programme la variable testée = valeur_de_vitesse_demarrage
   while(valeur_de_vitesse_demarrage <= 100)

    {

    // valeur de la base de temps 1 -> 1000ms soit 1 seconde
    // la ligne if  effectue la difference entre le temps actuel et le 
    // temps de debut de boucle .Cette derniere n'est interrompue que lorsque 
    // cette difference = 1000 millisecondes soit 1 seconde 
    if ((millis ()-rampedemarrage>50)& ( valeur_de_vitesse_demarrage <= 100))
 
     {
         rampedemarrage=millis();
         // incrementation de la variable valeur de 1 soit -> valeur = valeur+1
         valeur_de_vitesse_demarrage =valeur_de_vitesse_demarrage+10;
     
         // Affichage sur le moniteur serie des informations
         //
         Serial.print("valeur de la vitesse de demarrage =>"); 
         Serial.print(valeur_de_vitesse_demarrage);
         Serial.print(" valeur de la pente de demarrage a droite =>");
         Serial.print(tempsdroite);
         Serial.print("  ");
         Serial.println(tempsgauche);
         
         // calcul pour la marche avant pour la roue gauche avec acceleration
         tempsgauche = arret + valeur_de_vitesse_demarrage  ;
         // calcul pour la marche avant pour la roue droite avec acceleration
         tempsdroite = arret - valeur_de_vitesse_demarrage  ;  
         
         // envoie de la valeur au 2 servomoteurs pour le 
         // demarrage avec rampe d'acceleration 
         rouedroite.writeMicroseconds(tempsdroite);
         rouegauche.writeMicroseconds (tempsgauche);
 
     }

    } 
  
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

* Le robot Golbotth8

* Programme pour les premiers essais de notre robot

* avec la seule utilisation du capteur incliné avant.

* Le 06/10/2018

* H-Mazelin - RedOhm -

// Cette librairie permet à une carte Arduino de contrôler des servomoteurs

#include <Servo.h>

// je charge la librairie Ultrasonic

// Cette bibliothèque permet à une carte Arduino de gerer

// le capteur ultrason

// A savoir :

// Télécharger la Bibliothèque UltrasonicRanger de Github.

// à installer dans la bibliothèque d'origine des fichiers

// de l'IDE Arduino voir le lien sur le site redohm

// Attention sur l'exemple fourni par Github il y a

// une possibilité d 'erreur

#include "Ultrasonic.h"

// Crée un objet de type "Servo", nommé -> rouedroite

Servo rouedroite;

// Crée un objet de type "Servo", nommé -> rouegauche

Servo rouegauche;

// Declaration du nom du capteur et de la broche de raccordement

// sur la carte Arduino

Ultrasonic ultrasonic(6);

// Variable qui enregistre l'état du signal pour activer le servomoteur

// par defaut la valeur est fixée à 1500 ce qui correspond en general à l'arret

// du servomoteur ( pour un servomoteur à rotation continue )

int arret = 1500;

// Variable d'etat pour l arret

int arretetat = 0;

// Variable d'etat pour le lancement de la rampe en marche avant

int lancement_rampe_avant = 0;

// variable vitesse et de direction pour le servomoteur droit

int tempsdroite;

// variable vitesse et de direction pour le servomoteur gauche

int tempsgauche;

// Declaration de la variable pour la rampe de demarrage

int valeur_de_vitesse_demarrage;

// Declaration de la variable pour le comptage de changement de direction

// en arriere

int changement_direction =0 ;

// Declaration de la variable pour la vitesse rampe de demarrage

// unsigned long-> déclare une variable de type long non signé

unsigned long rampedemarrage = millis();

* Un programme Arduino doit impérativement contenir cette fonction .

* Elle ne sera exécutée qu'une seule fois au démarrage du microcontroleur

* Elle sert à configurer globalement les entrées sorties *

void setup() {

Serial.begin(9600);

// associe la variable rouedroite à sa broche numero 3

rouedroite.attach(3);

// associe la variable rouegauche à sa broche numero 5

rouegauche.attach(5);

// Écrit une valeur en microsecondes (uS) sur le servo,

// la valeur par defaut etant 1500 ce qui correspond en

// general à l'arret

rouedroite.writeMicroseconds(arret);

rouegauche.writeMicroseconds(arret);

arretetat=0;

delay (5000);

}

void loop() {

// variable du type long

// Declare la variable mesure_de_la_valeur_en_centimeters

// Rappel sur la fonction d'une variable :On peut définir une variable comme

// une boite ou l’on stocke des balles .Une variable est une boite ou

// l’on stocke un nombre ,et comme il existe une multitude de nombres:

// Exemple entiers ,décimaux etc …Il faut donc assigner un type à cette

// variable .

long mesure_de_la_valeur_en_centimeters;

// Lecture de la valeur de notre capteur

mesure_de_la_valeur_en_centimeters = ultrasonic.MeasureInCentimeters();

// attente pour mise en service capteur

delay(50);

Serial.print (arretetat);

Serial.print(" Valeur de la roue droite=> ");

Serial.println (tempsdroite);

// =======================================================

// demarrage du robot si le capteur ne detecte pas d'obstacle

// en dessous de 5cm

// demarrage avec rampe d'acceleration afin d'eviter

// le patinage

// =======================================================

if ((mesure_de_la_valeur_en_centimeters>=5)&& ( lancement_rampe_avant == 0))

{

lancement_rampe_avant = 1;

Serial.println("demande de marche avant");

marche_avant_avec_rampe();

arretetat = 0;

}

else if ((mesure_de_la_valeur_en_centimeters>=5) && ( lancement_rampe_avant == 1))

{

rouedroite.writeMicroseconds(1400);

rouegauche.writeMicroseconds (1600);

arretetat = 0;

}

// ======================================

// Gestion d'un obstacle arret d'urgence

// ======================================

else if ((mesure_de_la_valeur_en_centimeters <=5)&&(arretetat==0))

{

Serial.println ("Gestion d'un obstacle arret d'urgence ");

Serial.println ("(mesure_de_la_valeur_en_centimeters <=5)&&(arretetat=0)" );

Serial.print("Attention obstacle à =>");

Serial.println(mesure_de_la_valeur_en_centimeters);

// envoie de la valeur au 2 servomoteurs pour le

// demarrage avec rampe d'acceleration

rouedroite.writeMicroseconds(1500);

rouegauche.writeMicroseconds (1500);

// remise à zero de la variable pour pouvoir redemarrer

// avec la rampe de demarrage avant

lancement_rampe_avant = 0;

arretetat = 1;

delay (2000);

}

else if (((mesure_de_la_valeur_en_centimeters <=5)&&(arretetat==1))&&(changement_direction<3))

{

Serial.println ("========================================");

Serial.println (" Je recule et je tourne ");

Serial.println (" ***** ");

Serial.print ("Attention obstacle à =>");

Serial.println(mesure_de_la_valeur_en_centimeters);

Serial.println ("========================================");

Serial.println (" ");

arretetat=0;

// si on genere un arret d'urgence alors on doit redemarrer

// la rampe d'acceleration

lancement_rampe_avant = 0;

// on verifie le nombre de fois que l'on recule

changement_direction = changement_direction +1 ;

Serial.print("changement_direction =>");

Serial.println (changement_direction);

* -Etape 1-

* je recule vers la droite

* pendant 2 secondes

* puis je recule en ligne droite

* pendant 2 secondes

* puis en avant en ligne droite

* pendant 2 secondes

if ( changement_direction == 1)

{

Serial.println ("****************************************");

Serial.println (" Variable de temps = 2000 ");

Serial.println (" ETAPE 1 ");

Serial.println (" - Je recule vers la droite ");

Serial.println (" - Pendant 2 secondes ");

Serial.println (" - Puis je recule en ligne droite ");

Serial.println (" - Pendant 2 secondes ");

Serial.println (" - Puis en avant en ligne droite ");

Serial.println (" - Pendant 2 secondes ");

Serial.println ("****************************************");

Serial.println (" ");

// recule vers la droite

rouedroite.writeMicroseconds(1540);

rouegauche.writeMicroseconds (1400);

delay (2000);

// Puis je recule en ligne droite

rouedroite.writeMicroseconds(1600);

rouegauche.writeMicroseconds (1400);

delay (2000);

// Puis j'avance en operant une virage sur la gauche

rouedroite.writeMicroseconds(1400);

rouegauche.writeMicroseconds (1540);

delay (2000);

}

* -Etape 2-

* je recule vers la droite

* pendant 5 secondes

else if ( changement_direction == 2)

{

Serial.println ("****************************************");

Serial.println (" Variable de temps = 4000 ");

Serial.println (" ETAPE 2 ");

Serial.println (" - Je recule vers la droite ");

Serial.println (" - Pendant 5 secondes ");

Serial.println ("****************************************");

Serial.println (" ");

// recule vers la droite

rouedroite.writeMicroseconds(1530);

rouegauche.writeMicroseconds (1400);

// Met le programme en pause pendant la durée (6000 en millisecondes)

delay (5000);

}

* -Etape 3-

* je recule vers la droite

* pendant 6 secondes

else if ( changement_direction >= 3)

{

Serial.println ("****************************************");

Serial.println (" Variable de temps = 6000 ");

Serial.println (" ETAPE 3 ");

Serial.println (" - Je recule vers la droite ");

Serial.println (" - Pendant 6 secondes ");

Serial.println ("****************************************");

Serial.println (" ");

// recule vers la droite

rouedroite.writeMicroseconds(1540);

rouegauche.writeMicroseconds (1400);

// Met le programme en pause pendant la durée (6000 en millisecondes)

delay (6000);

}

// Si on détecte un obstacle à moins de 5 cm

// et que si la variable arrêt est égale à un

// et si le nombre de fois que l'on a reculé et supérieur à trois

// on recule et on change de direction en reculant

else if (((mesure_de_la_valeur_en_centimeters <=5)&&(arretetat==1))&&(changement_direction>=3))

{

// information pour l'operateur via le moniteur

Serial.println ("==================================================");

Serial.println (" Je recule et je tourne en changeant de direction ");

Serial.println ("==================================================");

rouedroite.writeMicroseconds(1600);

rouegauche.writeMicroseconds (1420);

// Met le programme en pause pendant la durée (4000 en millisecondes)

delay (4000);

changement_direction = 0;

// si on genere un arret d'urgence alors on doit redemarrer

// la rampe d'acceleration

lancement_rampe_avant = 0;

// mise a zero de la variable

arretetat=0;

}

// sous programme pour la rampe d'acceleration

void marche_avant_avec_rampe()

{

// forçage de la variable valeur_de_vitesse_demarrage a = 0

valeur_de_vitesse_demarrage = 0 ;

// Les boucles while bouclent indéfiniment, jusqu'à ce que la condition

// ou l'expression entre les parenthèses ( ) devient fausse. Quelque chose

// doit modifier la variable testée, sinon la boucle while ne se terminera

// jamais. Cela peut être dans votre code, soit une variable incrémentée

// , ou également une condition externe

// dans notre programme la variable testée = valeur_de_vitesse_demarrage

while(valeur_de_vitesse_demarrage <= 100)

{

// valeur de la base de temps 1 -> 1000ms soit 1 seconde

// la ligne if effectue la difference entre le temps actuel et le

// temps de debut de boucle .Cette derniere n'est interrompue que lorsque

// cette difference = 1000 millisecondes soit 1 seconde

if ((millis ()-rampedemarrage>50)& ( valeur_de_vitesse_demarrage <= 100))

{

rampedemarrage=millis();

// incrementation de la variable valeur de 1 soit -> valeur = valeur+1

valeur_de_vitesse_demarrage =valeur_de_vitesse_demarrage+10;

// Affichage sur le moniteur serie des informations

Serial.print("valeur de la vitesse de demarrage =>");

Serial.print(valeur_de_vitesse_demarrage);

Serial.print(" valeur de la pente de demarrage a droite =>");

Serial.print(tempsdroite);

Serial.print(" ");

Serial.println(tempsgauche);

// calcul pour la marche avant pour la roue gauche avec acceleration

tempsgauche = arret + valeur_de_vitesse_demarrage ;

// calcul pour la marche avant pour la roue droite avec acceleration

tempsdroite = arret - valeur_de_vitesse_demarrage ;

// envoie de la valeur au 2 servomoteurs pour le

// demarrage avec rampe d'acceleration

rouedroite.writeMicroseconds(tempsdroite);

rouegauche.writeMicroseconds (tempsgauche);

}

Retour au sommaire