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 -

Robot Golbotth8 -01 – RedOhm –

Sommaire :

 

 

..

separateur-redohm-001

  • Eclatée du robot

Eclatée vue d'ensemble robot Golbotth8 - RedOhm -

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

 

Retour au sommaire

.

separateur-redohm-001

  • 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.   

     

  • 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

.

separateur-redohm-001

  • Photo des differents elements 

.

Tourelle Tourelle

 

.

 

 

 

.

Retour au sommaire

separateur-redohm-001

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

Impression sur Zortrax M200 et M300

 

Golbotth8 - Pièce g010 tourelle

Golbotth8 – Pièce g010 tourelle – RedOhm –

 

Golbotth8 - Piece g011 base tourelle - RedOhm -

Golbotth8 – Piece g011 base tourelle – RedOhm –

 

Golbotth8 - Piece g012 plateau pour chassis - RedOhm -

Golbotth8 – Piece g012 plateau pour chassis – RedOhm –

 

Golbotth8 - piece g017 support sonic - RedOhm -

Golbotth8 – piece g017 support sonic – RedOhm –

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

.

Retour au sommaire

separateur-redohm-001

  • Tutoriel vidéo  

  • Principe de construction du robot Golbotth8

.

Retour au sommaire

 

separateur-redohm-001

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);
    }
}

.

Retour au sommaire

 

 

separateur-redohm-001

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);
 
     }

    } 
  
}

.

Retour au sommaire