Bonjour à tous.

Bon comme vous l'avez remarqué ( enfin je pense ) que je n'été pas
souvent sur le forum c'est dernier temps , normale d'une par j'ai du
supprimé mon blog , pour faire se forum , et j'ai beaucoup bossé sur le robot
Ulysse , j'ai ù pas mal de problèmes avec quelque module , mes c'est chose la , on été réglé.

Bon passons , voici la description , plus achat des pièce.

Alors chassie plateforme robot mobile 4 roues motrices Mon lien

Une carte Romeo Tout-en-un (ATMega328) rev 1.1 Mon lien

Une Carte Arduino Uno Rev 3 Mon lien

Une Pince en Aluminium (avec Servomoteurs) Dagu Mon lien

Un Kit télécommande Infrarouge pour Arduino + 2 capteur. Mon lien

Une batterie 9,2V 2200mAh pris sur une voiture télécommandé.( pas de lien ).

Un boitier pour 4 piles LR6-AA Mon lien

Un module de Répétition MP3 ''DFRduino Player'' Mon lien

Après les petite baffe sur les deux coté de mon robot , on été pris sur des PC usagé.

Voila je pense que j'ai fait le tour.

Voila , ce que fait le robot.

Mon robot et télécommandé ( bien vue non!!!! ) je contrôle mon robot , la pince , et aussi quelque voix ,
tous ça avec la télécommande.

Je conte lui rajouté une colonne ( un étage ) pour rajouté un écran LCD ,
qui me donnera l'heure et la date , et voir aussi a rajouter un Module

caméra et un Module Bluetooth Mon lien pour contrôlé le robot a distance, ou pour le traitement d'image , mes je suis pas sur de moi.

Voila je pense que j'ai tous dit , si vous avez des question hésité pas , ou des remarque à faire.

Je travaille toujours sur le programme de Ulysse.

Une foi que tous serra fini je métré des photo et une vidéo.

Il est super !

Merci Tuc

Derien c'est un plaisir de voir ton travail

Cool ton robot

merci celianvdb

avais un blog avant il me semble car ce robot je suivais la construction sur ton blog.

oui exacte javais bien un blog , mes il y a u trop de problème de connexion avec le blog et les module fonctionné a moitié , c'est pour cela que j'ai fait un forum dans une meilleur appréciation

Seb a écrit:oui exacte javais bien un blog , mes il y a u trop de problème de connexion avec le blog et les module fonctionné a moitié , c'est pour cela que j'ai fait un forum dans une meilleur appréciation

A oui c'est vrai je me souviens trop de problèmes de connexions ... ; )

oui mon blog robotique avais trop de problème de se coté là.

A oui c'est vrai

D’ailleurs je les supprimé le blog

étant néanmoins en robotique, je suis impressionné par Ulysse qui va certainement évolué. Bravo

Merci indilo pour le compliment

Re les amis.

Bon voilà après une longue absence je me suis remis sur mon robot ulysse , je viens de finir sa programmation

du coup je luis est rajouté 3 capteurs sharp , pour un mode autonome, j'ai constaté pas mal de

parasite sur un des capteurs, donc vais devoir travailler sur cela.

J'ai viré le boitier pour 4 piles LR6-AA pour la carte Arduino Uno Rev 3 qui serre pour

le contrôle de la pince, donc j'ai mis une batterie de 8V6 de 1200mAh

( c'est une batterie de réplique d'airsoft )

J'ai du remplacer aussi un des moteur du robot , qui lui avais un manque

de grésage, donc tous les pignon avais tous les dents de cassé.

J'ai rajouté deux LED supplémentaire.

Donc voici sa programmation que j'ai pus amélioré, optimisé est soigné:

Code:

#include
 
 //Capteur de Distance infrarouge IR Sharp GP2Y0A02YK0F
 int capteur = 5;
 int capteur2 = 4;
 int capteur3 = 3;

 // Variable pour lire la valeur des capteurs sur les broches analogique
 int val;
 int val2;
 int val3;

 //LED bleu, est rouge
 int LEDROUGE = 2;    // broche digitale pour la LEDROUGE 2
 int LEDBLEU = 3;    // broche digitale pour la LEDBLEU 3
 int LEDBLEU_AR = 4;// broche digitale pour la LEDBLEU_AR 4

 //Motoreducteur ( donc les moteurs du robot )
 const int EN1=6;
 const int EN2=5;
 const int IN1=7;
 const int IN2=4;
 
 // IR PIN module récepteur et variable
 int RECV_PIN = 11; // donc c'est le capteur infrarouge de la télécommande )
 IRrecv irrecv(RECV_PIN);
 decode_results results;
 
 //mode d'execution
 const int MODE_AUTO = 0;
 const int MODE_MANUEL = 1;
 int mode = MODE_MANUEL;

 const int MODE_STOP          = 10;
 const int MODE_AVANCE        = 11;
 const int MODE_RECULE        = 12;
 const int MODE_AV_RAPIDE      = 13;
 const int MODE_AR_RAPIDE      = 14;
 const int MODE_DROITE        = 15;
 const int MODE_GAUCHE        = 16;
 const int MODE_AV_DROITE      = 17;
 const int MODE_AV_GAUCHE      = 18;
 const int MODE_AR_DROITE      = 19;
 const int MODE_AR_GAUCHE      = 20;
 const int MODE_LED            = 21;
 int sous_mode_manuel = MODE_STOP;
 
  //Fonctions
 //motoréducteur pour le mode déplacement automatique
 void Moteur1(int pwm, boolean reverse)
{
 analogWrite(EN1,pwm); //Valeur_vitesse = 0 à l'arrêt, et 255 pour vitesse maximum
 if(reverse)
{
 digitalWrite(IN1,HIGH);
}
 else
{
 digitalWrite(IN1,LOW);
}
 }
 void Moteur2(int pwm, boolean reverse)
{
 analogWrite(EN2,pwm); //Valeur_vitesse = 0 à l'arrêt, et 255 pour vitesse maximum
 if(reverse)
{
 digitalWrite(IN2,HIGH);
}
 else
{
 digitalWrite(IN2,LOW);
}
 }
 
void setup()
{ 
 int i;
 for(int i=4;i<=7;i++)
 pinMode(i,OUTPUT); //Met les pin des moteurs 4,5,6,7 en mode sortie
 
 //LEDBLEU broche en mode sortie
 pinMode(LEDROUGE, OUTPUT);    // Déclare la LEDROUGE 2 en sortie
 pinMode(LEDBLEU,OUTPUT);  // Déclare la LEDBLEU 3 en sortie
 pinMode(LEDBLEU_AR,OUTPUT);  // Déclare la LEDBLEU_AR 4 en sortie
 
 Serial.begin(9600);
 
 // désactiver les deux moteurs par défaut
 digitalWrite(EN2,LOW);
 digitalWrite(EN1,LOW);
 
 // début de récepteur IR
 irrecv.enableIRIn();
}
 
void loop()
{
 int led_on =false;
 
 // Signal IR reçu
 if (irrecv.decode(&results))
{   
  // changement de mode par le Bouton rouge de la télécommande (POWER)
 //automatique  ou  manuel
 if(results.value==16580863)
{
 if (mode == MODE_AUTO)
 mode = MODE_MANUEL;
 else
 mode = MODE_AUTO;
}
 else if(mode == MODE_MANUEL)
{
 if(results.value==16597183)                            // Stop (FUNC / STOP) bouton de la télécommande
 sous_mode_manuel  = MODE_STOP;
   
 else if(results.value==16613503)                      //  (VOL +) bouton de la télécommande faire avancer le robot
 sous_mode_manuel  = MODE_AVANCE;
   
 else if(results.value==16617583)                    // (VOL-) bouton de la télécommande faire reculer le robot
 sous_mode_manuel  = MODE_RECULE;
   
 else if(results.value==16589023)                  // rotation gauche (<<) touche recule rapide de la télécommande
 sous_mode_manuel  = MODE_GAUCHE;
     
 else if(results.value==16605343)                // rotation droite (>>) bouton avance rapide la télécommande
 sous_mode_manuel  = MODE_DROITE;
   
 else if(results.value==16609423)              // avant droite  avec la touche ( ST/REPT ) de la télécommande
 sous_mode_manuel  = MODE_AV_DROITE;
   
 else if(results.value==16621663)            // avant gauche (playe) bouton  de la télécommande
 sous_mode_manuel  = MODE_AV_GAUCHE;
   
 else if(results.value==16601263)          // inverse à droite (HAUT) bouton de la télécommande
 sous_mode_manuel  = MODE_AR_DROITE;
   
 else if(results.value==16584943)        // inverse à gauche (BAS) bonton de la télécommande
 sous_mode_manuel  = MODE_AR_GAUCHE;
   
 else if(results.value==16625743)      //Allume la LED bleu avec la touche ( EQ ) de la télécommande
 sous_mode_manuel  = MODE_LED;
   
 if(results.value==16593103)        // Arrêt de la LED bleu avec la touche ( 0 ) de la télécommande
{
 digitalWrite(LEDBLEU_AR,LOW);
 digitalWrite(LEDBLEU,LOW);
 digitalWrite(LEDROUGE,LOW);
}
 }
 // recevoir la prochaine valeur
 irrecv.resume();
} 
 // mode automatique
 if(mode == MODE_AUTO)
{ 
 val = analogRead(capteur);    // lit la valeur du capteur SHARP
 val2 = analogRead(capteur2);  // lit la valeur du capteur2 SHARP
 val3 = analogRead(capteur3); // lit la valeur du capteur3 SHARP
 delay(100);
 
 // Si on est à moins de quelque cm d'un obstacle pour les trois capteurs
 if ((val >= 255) || (val2 >= 255) || (val3 >= 255)) // si on est à quelque cm d'un obstacle pour les 3 capteurs 
    {
    Moteur1(0,false);        //j'arrete le moteur 1
    Moteur2(0,false);        // j'arrete le moteur 2
    delay(350);            //j'attend 3,50 seconde
    Moteur1(255,false);    //J'avance tout droit moteur 1
    Moteur2(255,false);  // j'avance tout droit moteurs 2
    delay(500);          //la valeur à mettre reste à définir en fonction de la vitesse du robot
    Moteur1(255,false); //J'avance tout droit en metant les 1 moteurs
    Moteur2(255,true); //J'avance tout droit en metant les 2 moteurs
    }
    else
    {
    Moteur1(255,true);  //J'avance tout droit en metant les 1 moteurs
    Moteur2(255,false); //J'avance tout droit en metant les 2 moteurs
    }
    }
 else 
{
 Serial.println(results.value, DEC);
     
 switch (sous_mode_manuel) // Mode Manuel controle le robot avec la télécommande
{
 case MODE_LED:          //Allume les trois LED, les 2 led bleu, est rouge avec la touche ( EQ ) de la télécommande
 if (led_on)
{
 digitalWrite(LEDROUGE,LOW);
 digitalWrite(LEDBLEU,LOW);
 digitalWrite(LEDBLEU_AR,LOW);
 led_on = false;
}
 else
{
 digitalWrite(LEDROUGE,HIGH);
 digitalWrite(LEDBLEU,HIGH);
 digitalWrite(LEDBLEU_AR,HIGH);
 led_on = true;
}
  break;
  case MODE_STOP:                      // Stop (FUNC / STOP) bouton de la télécommande
  digitalWrite(EN2,LOW);              // roue droite  a l'arrêt
  digitalWrite(EN1,LOW);              // roue gauche a l'arrêt
  break;
  case MODE_AVANCE:                //  (VOL +) bouton de la télécommande faire avancer le robot
  motor(200,200);
  break;
  case MODE_RECULE:              // (VOL-) bouton de la télécommande faire reculer le robot
  motor(-200,-200);
  break;
  case MODE_DROITE:            // rotation droite (>>) bouton avance rapide la télécommande
  motor(250,-210);
  break;
  case MODE_GAUCHE:          // rotation gauche (<<) bouton avance rapide la télécommande
  motor(-250,210);
  break;
  case MODE_AV_DROITE:      // avant droite  avec la touche ( ST/REPT ) de la télécommande
  motor(200,150);
  break;
  case MODE_AV_GAUCHE:    // avant gauche (playe) bouton  de la télécommande
  motor(150,200);
  break;
  case MODE_AR_DROITE:  // inverse à droite (HAUT) bouton de la télécommande
  motor(255,255);
  break;
  case MODE_AR_GAUCHE:// inverse à gauche (BAS) bonton de la télécommande
  motor(-255,-255);
  break;   
}
 }
  }
 
 // fonction pour contrôler le moteur
void motor(int left, int right)
{
 // limiter la vitesse max
 if(left>255)left=255;            //gauche
 else if(left<-255)left=-255;    //gauche
 if(right>255)right=255;        //droite
 else if(right<-255)right=-255; //droite
 
 if(left>0)//gauche a l'arrét
{
 digitalWrite(IN1,HIGH);    // direction roue gauche avant
 analogWrite(EN1,left);    // vitesse de la roue gauche
}
 //inverser la roue gauche
 else if(left<0)
{
 digitalWrite(IN1,LOW);      // inverse à gauche en direction
 analogWrite(EN1,-left);    // vitesse de la roue gauche
}
 else     
{
 digitalWrite(EN1,LOW); // roue gauche a l'arrêt
}
 if(right>0)          // roue droite avant
{
 // direction de la roue droite avant
 digitalWrite(IN2,LOW);
 analogWrite(EN2,right);
}
 else if(right<0)      // roue droite en arrière
{
 digitalWrite(IN2,HIGH); // inverse à droite en direction
 analogWrite(EN2,-right);
}
 else     
{
 digitalWrite(EN2,LOW); // roue droite a l'arrêt
}
 }
 // FIN
 // SEB03000

Sa c'est le code pour la carte roméo ( donc mode autonome ou manuel ) ^^

Code:

#include
#include
#include
#include
#include
#define ArduinoPlayer_address 0x35  //Arduino Lecteur 0x35 adresse I2C (par défaut)

Servo servo1;  // créer un objet d'asservissement pour commander le servo1
Servo servo2; // créer un objet d'asservissement pour commander le servo2

int possition1 ;    // variable pour stocker la position1 d'asservissement
int possition2 = 90;  //variable pour stocker la position2 d'asservissement
int RECV_PIN = 5;
int current; //conserver la trace de la position actuelle du servo
int codeValue; //les code de la télécommande

IRrecv irrecv(RECV_PIN);
decode_results results;

int derniermp3 = 0; //declaration du dernier mp3 qui a était lu

void TwiSend(const char  *cmd)  //I2C Command
{
  char len = 0;
  len = strlen(cmd); //Calculer la longueur de la commande
  Wire.beginTransmission(ArduinoPlayer_address); // Arduino Lecteur adresse I2C
  while(len--)
  {
    Wire.send(*(cmd++));     
  }
  Wire.endTransmission();    // stop transmission
}

void jouermorceauscpecifique (int numeromp3)
{
  if (numeromp3 >= derniermp3)// si le numero du mp3 desirer est superieur ou egale au dernier mp3 jouer
  {
    for (int i=derniermp3; i < derniermp3; i++){ // boucle pour passer jusqu'au morceau voulu
TwiSend("\\:n\r\n"); // Play prochain
      derniermp3 = i;
    }
  }
  if (numeromp3 <= derniermp3)
  {
    for (int i=derniermp3; i > derniermp3; i--){ // boucle pour passer jusqu'au morceau voulu

TwiSend("\\:u\r\n"); // Play précédent
      derniermp3 = i;
    }
  }

}
void setup()
{
  Wire.begin(); // rejoindre le bus I2C (adresse en option pour le maître)
  Serial.begin(9600);            // lancer un port série sur le serial monitor 
  servo1.attach(7);            // attache le servo sur la broche 7 à l'objet d'asservissement
  servo1.write(possition1);  // mis en position1 de départ servo1
  servo2.attach(6);          // attache le servo sur la broche 6 à l'objet d'asservissement
  servo2.write(possition2);// mis en position2 de départ servo2
  irrecv.enableIRIn(); // Démarrer le récepteur
  delay(2000);//Attendez 2 secondes 
  Serial.println("Ready");
  TwiSend("\\:v 255\r\n");// régler le volume, de 0 (minimum) -255 (maximum)
}
void loop()
{
  Serial.println(results.value, DEC);

  if (irrecv.decode(&results))
  {
    codeValue = results.value;
    switch (codeValue)
    {
     
    case 16615543: // touche 4 de la télécomande ouvre la pince
      current  +=80;
      if (current > 180) current = 0;
      servo1.write(current);
      break;
     
     
    case 16582903:// bouton touche 1 de la télécommande ( envoie une parole prochain )
    jouermorceauscpecifique(4);
    TwiSend("\\:n\r\n");
    break;
     

  case 16599223:// bouton touche 3 de la télécommande ( envoie une parole précédente )
    jouermorceauscpecifique(4);
    TwiSend("\\:u\r\n");
      break;
     
  case 16586983:// bouton touche 7 de la télécommande ( pour monté le + volume )
    jouermorceauscpecifique(4);
    TwiSend("\\:v 255\r\n");
      break;
     
     
    case 16619623: // touche 6 de la télécommande ferme la pince
      current -=80;
      if (current < 0) current = 180;
      servo1.write(current);
      break;

    case 16591063: // touche 2 de la télécommande décend la pince
      current +=40;
      if (current > 180) current = 0;
      servo2.write(current);
      break;

    case 16607383: // touche 8 de la télécommande léve la pince
      current -=40;
      if (current < 0) current = 180;
      servo2.write(current);
      break;

      int sensorValue = analogRead(1); // analogique 1, a 10k
      while (sensorValue > 255) { //valeur peut être ajustée, 255 très sensible     
      sensorValue = analogRead(1); //lit la valeur du capteur à nouveau pour la boucle
      }
      servo1.write(possition2);
      current = possition2;
      servo1.write(possition1);
      current = possition1;
      servo2.write(possition2);
      current = possition2;
      servo2.write(possition1);
      current = possition1;
    }
    irrecv.resume();
  }
}

Est celui si , c'est le code pour la pince est pour l'effet des voix
commandé par la télécommande infrarouge donc la carte Arduino Uno Rev 3 ^^

Je ferré quelque vidéo très bientôt.

PS: le robot ulysse n'est pas encore fini d'être amélioré, je vous tiens informé.

Re les amies

Bon voilà, changement sur mon robot ulysse , j'ai viré la pince, plus les 3 capteurs infrarouge sharp ,

pour rajouter le capteur IR Compound Eye = ( IR œil composé )

Celui si:



J'ai fait un programme qui permet au capteur de suivre toute sorte de mouvement , se qui coince ,

c'est que je dois réalisé un programme qui me permettrai au robot ulysse , des qu'il détecte

un mouvement qu'il se déplace en le suivent ( c'est une chose assez compliquer a réalisé )

donc c'est en cours.

Mais si vous avais une idée ou un code qui me permettre de faire cela, je suis preneur.

Pour se qui est de la pince dagu je rajouterai un étage de plus, sur le robot ulysse.

Re les amis me re-voilà :

j'ai monté le capteur IR Compound Eye = ( IR œil composé ) plus le pont en H en guise de tourelle , pour que le capteur suis un objet ou ma mains , voici une photo:



Est voici le programme que j'ai pue faire , avec quelque bout de code que j'ai trouvais sur le net , cette programmation n'est pas fini , car le capteur lui , suis que les objet ou ma mains , mais le chassie lui , ne se déplace pas , donc je cherche la solution pour que le chassie puisse roulé en fonction de l'objet mis devants lui.

Code:

#include <Servo.h>

#define IRleft 1 // Compound Eye Left - analog input A1
#define IRright 3 // Compound Eye Right - analog input A3
#define IRup 0 // Compound Eye Up - analog input A0
#define IRdown 2 // Compound Eye Down - analog input A2
#define IRleds 2 // Compound Eye LEDs - digital output D2

#define panPin 3 // PAN Servo - digital output D3
#define tiltPin 5 // TILt Servo - digital output D5


int sServoPin = 6;
int sServoPin2 = 5;
int dServoPin = 7;
int dServoPin2 = 4;


void stopper(void)                    //Stop
{
  digitalWrite(sServoPin,LOW);
  digitalWrite(sServoPin2,LOW);   
} 
void advance(char b)          //le robot avance
{ 
  analogWrite (sServoPin,b); 
  digitalWrite(dServoPin,HIGH);
  analogWrite (sServoPin2,b); 
  digitalWrite(dServoPin2,HIGH);
}
void back_off (char b)        //le robot recule
{
  analogWrite (sServoPin,b); 
  digitalWrite(dServoPin,LOW);
  analogWrite (sServoPin2,b); 
  digitalWrite(dServoPin2,LOW);
}
void turn_L (char a)            //Tourne a gauche
{
  analogWrite (sServoPin,a);
  digitalWrite(dServoPin,HIGH);
  analogWrite (sServoPin2,a);
  digitalWrite(dServoPin2,LOW);
}
void turn_R (char a)            //Tourne a droite
{
  analogWrite (sServoPin,a);
  digitalWrite(dServoPin,LOW);
  analogWrite (sServoPin2,a);
  digitalWrite(dServoPin2,HIGH);
}

// defini les constants - define constants
byte LRscalefactor=15;  //facteur d'échelle - calibrer leurs moteurs - calibrage Selon le servos
byte UDscalefactor=15;  //facteur d'échelle - calibrer leurs moteurs - calibrage Selon le servo

// distance minimale pour déplacer la tête du capteur
int distancemax=255;    // valeur capteur pour l'entrée analogique

// distance qui provoque un décalage de gauche a droite
int bestdistance=400;  // valeur pour trouver expérimentale du capteur
int PanZero=78;        // stop servo di pan
int TiltZero=40;        //arrêter servo haut bas - asservissement d'inclinaison arrêt
int sMotorStop=90;      // servo gauche - Stop:
int dMotorStop=90;      // Arrêtez servo droit
int LRmax=170;          // Les valeurs max servo pan
int LRmin=10;            // Valeur min servo de pan
int UDmax=170;          // Max valore inclinable
int UDmin=10;            // min valore inclinable

// Définir le support de la variables - définir les variables globales
int pan=PanZero;
int tilt=TiltZero;
int panscale;
int tiltscale;
int sSpeed=sMotorStop;
int dSpeed=dMotorStop;
int panOld;
int tiltOld;
int distance;
int temp;

// Capteurs IR
int updown;
int leftright;
int leftIRvalue;
int rightIRvalue;
int upIRvalue;
int downIRvalue;

//Servomoteurs
Servo panLR;
Servo tiltUD;

void setup()
{
  // initialise et configure la broche servo
  // servos initialiser et configurer les broches

  panLR.attach(panPin);
  panLR.write(PanZero);
  tiltUD.attach(tiltPin);
  tiltUD.write(TiltZero);
 
 pinMode (IRleds,OUTPUT);
 int i;
 for(int i=4;i<=7;i++)
 pinMode(i,OUTPUT); //Met les pin des moteurs 4,5,6,7 en mode sortie
 
}

void loop()
{
  // servo régler la vitesse 
 
  panLR.write(pan);
  tiltUD.write(tilt);

  IReye();  // lire les valeurs du capteur
  IRfollow(); // suivi
}

void IReye()//===============================================================Lire IR œil composé================================================
{
  digitalWrite(IRleds,HIGH);                                  // allumer LED IR pour lire la lumière infrarouge TOTAL (ambiante + reflété)
  delay(4);                                                  // Prévoyez du temps pour phototransistors à répondre - aspetta par permettere LA Risposta dei phototransistors
  leftIRvalue=analogRead(IRleft);                            // TOTAL IR = AMBIENT IR + LED IR REFLECTED FROM OBJECT
  rightIRvalue=analogRead(IRright);                          // TOTAL IR = AMBIENT IR + LED IR REFLECTED FROM OBJECT
  upIRvalue=analogRead(IRup);                                // TOTAL IR = AMBIENT IR + LED IR REFLECTED FROM OBJECT
  downIRvalue=analogRead(IRdown);                            // TOTAL IR = AMBIENT IR + LED IR REFLECTED FROM OBJECT
  delay(2);
  digitalWrite(IRleds,LOW);                                  // éteindre LA LED IR pour lire la lumière infrarouge ambiant (IR de l'éclairage intérieur et la lumière du soleil)
  delay(4);                                                  // Prévoyez du temps pour répondre à phototransistors-aspetta par permettere LA Risposta dei phototransistors
  leftIRvalue=leftIRvalue-analogRead(IRleft);                // REFLECTED IR = TOTAL IR - AMBIENT IR
  rightIRvalue=rightIRvalue-analogRead(IRright);              // REFLECTED IR = TOTAL IR - AMBIENT IR
  upIRvalue=upIRvalue-analogRead(IRup);                      // REFLECTED IR = TOTAL IR - AMBIENT IR
  downIRvalue=downIRvalue-analogRead(IRdown);                // REFLECTED IR = TOTAL IR - AMBIENT IR

  distance=(leftIRvalue+rightIRvalue+upIRvalue+downIRvalue)/3;// la distance de l'objet est en moyenne illustrée - dans la distance de l'objet est la moyenne de la réflexion du capteur IR

}

void IRfollow ()//==============================================Suivre L'objet================================================================
{
  //servos a l'arrêt
  sSpeed=sMotorStop;
  dSpeed=dMotorStop;

  // si la valeur de retour est faible, cela signifie qu'il n'y a pas d'objet voisins
  // si la valeur lue est basse, il n'y a pas l'objet devant le capteur
    if (distance<distancemax)
  {
    // le capteur revient à la position repos - réinitialiser le capteur à position zéro
    if (pan>PanZero)pan=pan-1;
    if (pan<PanZero)pan=pan+1;
    if (tilt>TiltZero)tilt=tilt-1;
    if (tilt<TiltZero)tilt=tilt+1;

  }
  else
  {
    //-------------------------------------------------------------Suivre objet avec la tête------------------------------------------------
    panscale=(leftIRvalue+rightIRvalue)*LRscalefactor/10; //Facteur d'échelle - valeur d'échelle
    tiltscale=(upIRvalue+downIRvalue)*UDscalefactor/10; // Facteur d'échelle - valeur d'échelle

    // si la tête tourne vers la gauche
    if (leftIRvalue>rightIRvalue)
    {
      leftright=(leftIRvalue-rightIRvalue)*15/panscale;
      pan=pan-leftright;
    }
    // si la tête tourne à droite
    if (leftIRvalue<rightIRvalue)
    {
      leftright=(rightIRvalue-leftIRvalue)*15/panscale;
      pan=pan+leftright;
    }

    // si la tête est levé
    if (upIRvalue>downIRvalue)
    {
      updown=(upIRvalue-downIRvalue)*15/tiltscale;
      tilt=tilt+updown;
    }


    // si la tête et vaire le bas
    if (downIRvalue>upIRvalue)
    {
      updown=(downIRvalue-upIRvalue)*15/tiltscale;
      tilt=tilt-updown;
    }


    panOld=pan;
    tiltOld=tilt;
    if (pan<LRmin) pan=LRmin;
    if (pan>LRmax) pan=LRmax;
    if (tilt<UDmin)tilt=UDmin;
    if (tilt>UDmax)tilt=UDmax;

    //-------------------------------------------------------------Tournez le corps du robot des qui suis un objet--------------------------------------------
    // Si la tête tourne a plus de 60 degrés, exécute également le corps du robot
    temp=LRmax-panOld;
    if (temp<60)
    {
      sSpeed=sMotorStop-50+temp/2;
      dSpeed=dMotorStop-50+temp/2;
    }
    temp=panOld-LRmin;
    if (temp<60)
    {
      dSpeed=dMotorStop+50-temp/2;
      sSpeed=sMotorStop+50-temp/2;
    }

    //------------------------------------------------------Aller de l'avant ou vers l'arrière pour suivre l'objet------------------------------------
    // si l'objet est à une distance inférieure à la distance optimale, revenir à cette distance,
    // si la distance de l'objet est inférieure à la distance, déplacer le robot pour aller de nouveau à la même distance
    temp=distance-bestdistance;
    temp=abs(temp);

    if (temp>10)
    {
      temp=temp-10;
      if (distance>bestdistance)
      {
        dSpeed=dSpeed-temp/3;
        sSpeed=sSpeed+temp/3;

      }
      else
      {
        dSpeed=dSpeed+temp/3;
        sSpeed=sSpeed-temp/3;

      }
    }
  }
}

Donc le projet n'est pas fini , si vous avez la solution , je suis preneur.

Super évolution ! Tu as donc utilisé le capteur que je t'avais présenté :).
A mon avis, tu devrais garder la pince à l'avant, surélever le capteur ainsi que la tourelle afin de pouvoir utiliser en même temps le capteur et la pince pour, par exemple, faire saisir des objets qu'il aura détecter et qu'y sont de tel ou tel taille...

Salut Tuc.

Oui en effet j'avais pensé la même chose pour la pince , mais malgré cela , le chassie n'obtien pas assez de place ,

( est je pense faire un étage supplémentaire) ,

est par la suite changé les 4 motoréducteurs pour le poids , est risquerai d'être faiblard

Regarde bien, sur les côtés il y a des petits trous. Essaye de monter une plateforme et de monte le capteur par dessus tout en laissant la pince, non ?

Non même comme cela , le pond en H (la tourelle ) tapera la pince , il ni a pas de place , c'est pour cela que j'avais décidé de faire un niveaux supplémentaire

Mais merci tout de même tuc

Ah bon ? Dommage mais alors oui il va falloir changer les moteurs.

Code:


#include <Servo.h>

//Capteur infrarouge IR EYE
#define IRleft 1    // Compound Eye Left - analog input A1
#define IRright 3  // Compound Eye Right - analog input A3
#define IRup 0    // Compound Eye Up - analog input A0
#define IRdown 2  // Compound Eye Down - analog input A2
#define IRleds 2 // Compound Eye LEDs - digital output D2

//Déclaration des de servo ( suport de la tête du capteur pour le mouvement
#define panPin 3  // PAN Servo - digital output D3
#define tiltPin 8 // TILt Servo - digital output D8

//déclaration des Motoréducteurs
int MoteurPin = 6;
int MoteurPin2 = 5;
int dMoteurPin = 7;
int dMoteurPin2 = 4;

  //Fonctions
 //motoréducteur pour le mode déplacement automatique
 void Moteur1(int pwm, boolean reverse)
{
 analogWrite(MoteurPin,pwm); //Valeur_vitesse = 0 à l'arrêt, et 255 pour vitesse maximum
 if(reverse)
{
 digitalWrite(dMoteurPin,HIGH);
}
 else
{
 digitalWrite(dMoteurPin,LOW);
}
 }
 void Moteur2(int pwm, boolean reverse)
{
 analogWrite(MoteurPin2,pwm); //Valeur_vitesse = 0 à l'arrêt, et 255 pour vitesse maximum
 if(reverse)
{
 digitalWrite(dMoteurPin2,HIGH);
}
 else
{
 digitalWrite(dMoteurPin2,LOW);
}
 }

// defini les constants
byte LRscalefactor=10;  //facteur d'échelle - calibrer les moteurs - calibrage Selon le servo
byte UDscalefactor=10;  //facteur d'échelle - calibrer les moteurs - calibrage Selon le servo

// distance minimale pour le déplacement de la tête du capteur
int distancemax=255;    // valeur distant du capteur pour l'entrée analogique

// distance qui provoque un décalage de gauche a droite
int bestdistance=330;  // valeur pour trouver expérimentale du capteur
int PanZero=78;        // stop servo di pan
int TiltZero=40;      //arrêter servo haut bas - asservissement d'inclinaison arrêt
int LRmax=170;      // Les valeurs max servo pan
int LRmin=10;      // Valeur min servo de pan
int UDmax=170;    // Max valore inclinable du servo
int UDmin=10;    // min valore inclinable du servo

// Définir le support de la variables - définir les variables globales
int pan=PanZero;
int tilt=TiltZero;
int panscale;
int tiltscale;
int panOld;
int tiltOld;
int distance;
int temp;

// Capteurs infrarouge IR EYE
int updown;
int leftright;
int leftIRvalue;
int rightIRvalue;
int upIRvalue;
int downIRvalue;

//Servomoteurs
Servo panLR;
Servo tiltUD;

void setup()
{
  // initialise et configure la broche des servos
  panLR.attach(panPin);
  panLR.write(PanZero);
  tiltUD.attach(tiltPin);
  tiltUD.write(TiltZero);
 
 pinMode (IRleds,OUTPUT);
 int i;
 for(int i=4;i<=7;i++)
 pinMode(i,OUTPUT); //Met les pin des moteurs 4,5,6,7 en mode sortie
 
}

void loop()
{
  // servo régler pour la vitesse 
  panLR.write(pan);
  tiltUD.write(tilt);

  IReye();  // lire les valeurs du capteur
  IRfollow(); // suivi
}

void IReye()//===============================================================Lire IR œil composé================================================
{
  digitalWrite(IRleds,HIGH);                                    // allumer LED IR pour lire la lumière infrarouge TOTAL (ambiante + reflété)
  delay(2);                                                    // Prévoyez du temps pour phototransistors à répondre - aspetta par permettere LA Risposta dei phototransistors
  leftIRvalue=analogRead(IRleft);                              // TOTAL IR = AMBIENT IR + LED IR REFLECTED FROM OBJECT
  rightIRvalue=analogRead(IRright);                            // TOTAL IR = AMBIENT IR + LED IR REFLECTED FROM OBJECT
  upIRvalue=analogRead(IRup);                                  // TOTAL IR = AMBIENT IR + LED IR REFLECTED FROM OBJECT
  downIRvalue=analogRead(IRdown);                              // TOTAL IR = AMBIENT IR + LED IR REFLECTED FROM OBJECT
  delay(1);
  digitalWrite(IRleds,LOW);                                    // éteindre LA LED IR pour lire la lumière infrarouge ambiant (IR de l'éclairage intérieur et la lumière du soleil)
  delay(2);                                                    // Prévoyez du temps pour répondre à phototransistors-aspetta par permettere LA Risposta dei phototransistors
  leftIRvalue=leftIRvalue-analogRead(IRleft);                  // REFLECTED IR = TOTAL IR - AMBIENT IR
  rightIRvalue=rightIRvalue-analogRead(IRright);                // REFLECTED IR = TOTAL IR - AMBIENT IR
  upIRvalue=upIRvalue-analogRead(IRup);                        // REFLECTED IR = TOTAL IR - AMBIENT IR
  downIRvalue=downIRvalue-analogRead(IRdown);                  // REFLECTED IR = TOTAL IR - AMBIENT IR

  distance=(leftIRvalue+rightIRvalue+upIRvalue+downIRvalue)/3;// la distance de l'objet est en moyenne illustrée - dans la distance de l'objet est la moyenne de la réflexion du capteur IR

}

void IRfollow ()//==============================================Suivre L'objet================================================================
{
        // stop les Motoréducteur
        MoteurPin;
        MoteurPin2;
        dMoteurPin;
        dMoteurPin2;
       
        // si la valeur de retour est faible, cela signifie qu'il n'y a pas d'objet voisins
        // si la valeur lue est basse, il n'y a pas l'objet devant le capteur
        if (distance<distancemax)
  {
        // le capteur revient à la position repos - réinitialiser le capteur à position zéro
        if (pan>PanZero)pan=pan-1;
        if (pan<PanZero)pan=pan+1;
        if (tilt>TiltZero)tilt=tilt-1;
        if (tilt<TiltZero)tilt=tilt+1;

  }
  else
  {
        //-------------------------------------------------------------Suivre objet avec la tête------------------------------------------------
        panscale=(leftIRvalue+rightIRvalue)*LRscalefactor/10; //Facteur d'échelle - valeur d'échelle
        tiltscale=(upIRvalue+downIRvalue)*UDscalefactor/10; // Facteur d'échelle - valeur d'échelle

        // si la tête tourne vers la gauche
        if (leftIRvalue>rightIRvalue)
        {
        leftright=(leftIRvalue-rightIRvalue)*10/panscale;
        pan=pan==-leftright;


        }
       
        // si la tête tourne à droite
        if (leftIRvalue<rightIRvalue)
        {
        leftright=(rightIRvalue-leftIRvalue)*10/panscale;
        pan=pan+leftright;
       

        }

        // si la tête est levé
        if (upIRvalue>downIRvalue)
        {
        updown=(upIRvalue-downIRvalue)*10/tiltscale;
        tilt=tilt+updown;
        }

       
        // si la tête et vaire le bas
        if (downIRvalue>upIRvalue)
        {
        updown=(downIRvalue-upIRvalue)*10/tiltscale;
        tilt=tilt-updown;
        }

        panOld=pan;
        tiltOld=tilt;
        if (pan<LRmin) pan=LRmin;
        if (pan>LRmax) pan=LRmax;
        if (tilt<UDmin)tilt=UDmin;
        if (tilt>UDmax)tilt=UDmax;

        //-------------------------------------------------------------Tournez le corps du robot des qui suis un objet--------------------------------------------
        // Si la tête tourne a plus de 60 degrés, exécute également le déplacement du corps du robot
        temp=LRmax-panOld;
        if (temp<10)
        {
        }

         
        temp=panOld-LRmin;
        if (temp<10)
        {
        }


        //------------------------------------------------------Aller de l'avant ou vers l'arrière pour suivre l'objet------------------------------------
        // si l'objet est à une distance inférieure à la distance optimale, revenir à cette distance,
        // si la distance de l'objet est inférieure à la distance, déplacer le robot pour aller de nouveau à la même distance
        temp=distance-bestdistance;
        temp=abs(temp);

        if (temp>1)
        {
        temp=temp-1;
        if (distance>bestdistance)
        {
         
        Moteur1(250,false);      //j'avance le moteur 1
        Moteur2(250,true);      // j'avance le moteur 2
        delay(100);            //j'attend 1 seconde
 
        Moteur1(0,false);      //j'arréte le moteur 1
        Moteur2(0,true);      // j'arréte le moteur 2
       
        }
        else
        {
         
        Moteur1(250,true);        //j'avance le moteur 1
        Moteur2(250,false);      // j'avance le moteur 2
        delay(100);
 
        Moteur1(0,true);        //j'arréte le moteur 1
        Moteur2(0,false);      // j'arréte le moteur 2

    }
  }
  } 
 }



Il y a aussi les fonctions millis() et micros().

Salut seb, il y a quelques temps, tu as dis ceci 

Seb0300 a écrit:J'ai viré le boitier pour 4 piles LR6-AA

Comment l'as-tu branché à Arduino car, avant d'en commander un j'aimerais savoir ;)

Bonjour Tuc

Tu relie tous les files + des motoreducteur ( file rouge )

Même chose pour les files noir - des motoreducteur

une foie que cela est fait, tu les réunie sur la borne de la carte roméo, ou une Shield contrôleur,

puis tu alimente ta carte avec une batterie , moi c'est une batterie de 9,2V 2200mAh

ou tu peut l’alimenté avec une batterie de 7,4V 2200mAh , ça passe

Voilà j’espère que j'ai répondu a tes questions  sans bafouiller

Je suis obligé d'avoir les 2 ? Le boîtier pour pile ne suffit pas ?

Non juste la batterie , car je trouve que le boitier a pile ne suffi pas de plus les pile s’épuise très vite ,

mais aussi ne donne pas assez de puissance aux moteurs

Mais, comment recharger la batterie LIPO ? Je penses que pour le début, vu que je n'ai plus beaucoup, je vais prendre ceci vu que, rempli, elle a l'effet d'une pile 9V et que l'arduino doit être fournit d'un minimum de 5V.

Dites moi si je me trompes :/

Pour recharger la batterie Lipo, tu a un embout qui te permet d'enclencher l'embout du

chargeur pour le recharger.

Ensuite pour le Boitier à 6 piles LR6-AA je pence que cela suffira , mais bien entendu si tu alimente

que les moteur avec.

Le boitier pour pile ne suffit pas pour alimenter les moteurs, des capteurs et la carte Arduino ?
Voilà les caractéristiques des moteurs : 2 moteurs CC 6V 210 mA hors charge et 2.4 A de courant de pic à 7.2 V

Désolé Tuc pour ce manque de retard pour ta question.

Je pense que cela ne suffira pas , il y aura pas assez d’énergie pour faire fonctionné tous cela,

( je peut me trompé aussi ).