Code...


Voici le code actuel utilisé par le robot, je vous rappelle que se sont mes premières lignes de code, alors merci de votre indulgence. Le code est à améliorer, mais pour le moment c'est celui là!



// prog robot IBT 009   007 + parechoc

#include <Servo.h>
#include "Ultrasonic.h"
#include <Time.h>   

const int RL_EN=6;
const int PWM1D=5;
const int PWM2D=4;
const int PWM1G=3;
const int PWM2G=2;
const int BRUSHLESS=7;
const int APPUI=0;                                // constante état du BP - appui sur niveau bas
const int PAS_APPUI=1;                      // constante état du BP - relâché sur niveau haut
const int BP=1;                                     //declaration constante de broche
int ETAT_BP;                                      // variable d'état du bouton poussoir
int vit_lame=1601;                               //acceleration lames vitesse max à 2200 et mini à 1600
int dist_lateral=35;
int dist_face=25;
int X=0;

long Temp_Reference_avance;  
long Temp_Reference_recul;
long Temp_Reference_droite;
long Temp_Reference_gauche;
long delai_avance=40000;                     //60000=1minute
long delai_recul=15000;
long delai_droite=15000;
long delai_gauche=15000;
Servo cont_brushless;

#define  TRIG_PIN_A  8
#define  ECHO_PIN_B  9
Ultrasonic OurModule_G(TRIG_PIN_A, ECHO_PIN_B);
#define  TRIG_PIN_C  10
#define  ECHO_PIN_D  11
Ultrasonic OurModule_M(TRIG_PIN_C, ECHO_PIN_D);
#define  TRIG_PIN_E  12
#define  ECHO_PIN_F  13
Ultrasonic OurModule_D(TRIG_PIN_E, ECHO_PIN_F);

void setup() 
{
pinMode(BP, INPUT);                                          //met la broche en entree
digitalWrite(BP, HIGH) ;                                     // activation du pullup de la broche en entrée
cont_brushless.attach(BRUSHLESS);
pinMode(BRUSHLESS, OUTPUT);
Temp_Reference_avance=millis();
Temp_Reference_recul=millis();
Temp_Reference_droite=millis();
Temp_Reference_gauche=millis();
//lancement de la coupe
delay (5000);
ROB_CUT_ON();
delay (7000);

pinMode(RL_EN, OUTPUT);
pinMode(PWM1D, OUTPUT);
pinMode(PWM2D, OUTPUT);
pinMode(PWM1G, OUTPUT);
pinMode(PWM2G, OUTPUT);
digitalWrite(RL_EN, HIGH);

AVANCE();
delay (500);

}


void loop()
{
AVANCE();

   while ( (OurModule_D.Ranging(CM)) < dist_lateral & (OurModule_D.Ranging(CM)) < (OurModule_G.Ranging(CM)))
  {
   droite();
  delay(100);
                 while ( (OurModule_M.Ranging(CM)) < dist_face )
                {
                recul();
                delay(100);
                }
              }

 while ( (OurModule_G.Ranging(CM)) < dist_lateral & (OurModule_G.Ranging(CM)) < (OurModule_D.Ranging(CM)))
 
  {
   gauche();
  delay(100);
                while ( (OurModule_M.Ranging(CM)) < dist_face )
                {
                recul();
                delay(100);
                }
              }


 while ( (OurModule_M.Ranging(CM)) < dist_face )
  {
   recul();
                delay(100);
               }



}

void AVANCE()
{
analogWrite(PWM1D,255);
analogWrite(PWM2D,0);
 
analogWrite(PWM1G,0);
analogWrite(PWM2G,255);
ETAT_BP=digitalRead(BP);    // lit l'état du BP et met la valeur 0/1 dans la variable
 
if (ETAT_BP==APPUI)
{       // si l'état du BP est appuyé (càd si variable état BP = 0)

   recul();
     delay(100);
}
else
{       // sinon (càd si variable état bp=1)
 
}

if (millis()>(Temp_Reference_avance+delai_avance))
 {   
                recul();
  delay(100);
                Temp_Reference_avance=Temp_Reference_avance+delai_avance;
 }

}

void droite()
{
analogWrite(PWM1D,200);
analogWrite(PWM2D,0);
 
analogWrite(PWM1G,0);
analogWrite(PWM2G,0);
ETAT_BP=digitalRead(BP);    // lit l'état du BP et met la valeur 0/1 dans la variable
 
if (ETAT_BP==APPUI)
{       // si l'état du BP est appuyé (càd si variable état BP = 0)

   recul();
     delay(100);
}
else
{       // sinon (càd si variable état bp=1)
 
}

}

void gauche()
{
analogWrite(PWM1D,0);
analogWrite(PWM2D,0);
 
analogWrite(PWM1G,0);
analogWrite(PWM2G,200);
ETAT_BP=digitalRead(BP);    // lit l'état du BP et met la valeur 0/1 dans la variable
 
if (ETAT_BP==APPUI)
{       // si l'état du BP est appuyé (càd si variable état BP = 0)

   recul();
     delay(100);
}
else
{       // sinon (càd si variable état bp=1)
 
}
               
}

void recul()
{
 
if (X==0)
{
 
analogWrite(PWM1D,0);
analogWrite(PWM2D,0);
 
analogWrite(PWM1G,0);
analogWrite(PWM2G,0);
delay(200);

analogWrite(PWM1D,70);
analogWrite(PWM2D,140);
 
analogWrite(PWM1G,140);
analogWrite(PWM2G,0);
delay(700);

analogWrite(PWM1D,70);
analogWrite(PWM2D,140);
 
analogWrite(PWM1G,0);
analogWrite(PWM2G,0);
delay(550);
X=1;
}
else
{
analogWrite(PWM1D,0);
analogWrite(PWM2D,0);
 
analogWrite(PWM1G,0);
analogWrite(PWM2G,0);
delay(200);

analogWrite(PWM1D,70);
analogWrite(PWM2D,140);
 
analogWrite(PWM1G,140);
analogWrite(PWM2G,0);
delay(700);

analogWrite(PWM1D,0);
analogWrite(PWM2D,0);
 
analogWrite(PWM1G,140);
analogWrite(PWM2G,0);
delay(550);
X=0;
}

analogWrite(PWM1D,0);
analogWrite(PWM2D,0);
 
analogWrite(PWM1G,0);
analogWrite(PWM2G,0);
delay(150);
if (millis()>(Temp_Reference_recul+delai_recul))
  {   
                analogWrite(PWM1D,0);
                analogWrite(PWM2D,0);
 
                analogWrite(PWM1G,0);
                analogWrite(PWM2G,0);
                delay(200);           
   
                analogWrite(PWM1D,175);
                analogWrite(PWM2D,0);
 
                analogWrite(PWM1G,0);
                analogWrite(PWM2G,175);
                delay(1050);
                analogWrite(PWM1D,0);
                analogWrite(PWM2D,0);
 
                analogWrite(PWM1G,0);
                analogWrite(PWM2G,0);
                delay(50);
                Temp_Reference_recul=Temp_Reference_recul+delai_recul;
 }
}



void ROB_CUT_ON()    //demarrage de la coupe
{
  cont_brushless.writeMicroseconds(1470); // génère initialisation du controleur
  delay (2000);     //attente de 2 secondes pour initialisation du controleur
 int robcuton;
   for(robcuton = 1470 ; robcuton <= vit_lame; robcuton+=1)  //acceleration vitesse max à 2200 et mini à 1600
   {
    
     cont_brushless.writeMicroseconds(robcuton);
 
   }
  delay(3000);
  cont_brushless.writeMicroseconds((robcuton-19));   //-15 pas de changement ** -21 bien  **-24 arret moteur  


}



enfin un projet avec le code !!!! ;-)

Modification...

Si le robot devrait être modifié, j'opterais pour une caisse ronde ( moins d'accrochage aux obstacles),
des moteurs de tractions en 24v, 3 disques et 3 moteurs de coupe (augmentation de son diamètre de coupe et peu de consommation des batteries en plus), sur 4 roues au lieu de 3 ( meilleur stabilité dans les terrains accidenté), gestion du terrain par le programme (optimiser les passages au même endroit et faire une grille de tonte). Toutes ces modifs dans une prochaine version!

Autonomie et poids...

Vu le dimensionnement des moteurs de traction, j'ai ajouté une batterie supplémentaire
afin d'augmenter l'autonomie du robot. Les moteurs étant suffisamment puissant pour
pouvoir transporter 2 batteries au plomb! La première batterie étant une batterie de récupération,
je ne connais pas sa performance, la seconde est neuve. Autonomie plus de 40 minutes. 



Batterie scotché sur son dos pour les essais...

Pare-choc !!!

Installation de 2 pare-choc contact à l'avant, pour les obstacles trop bas pour les capteurs US.




Les pare-chocs sont montés sur charnières pour pouvoir se relever lors
d'une marche arrière sans tout arracher !