Robot Ulysse

Voilà j'ai réussi en partit a faire suivre un objet a mon robot il peux le suivre en avancent ou en reculent

J'ai testé aussi a lui faire suivre un objet de gauche à droite , mais cela donne des a coup au robot , je croie que c'est un problème de delay( 100);

Je me demandé si il existé pas de remplacé les delay par une autre formule , ( oui ) car les delay donne un temps de déplacement.

Sinon voici la vidéo de ulysse:

http://www.youtube.com/watch?feature=player_detailpage&v=pRmPNGUCT7E#t=0s

Désolé pour la qualité de la vidéo , cela a été filmé avec mon téléphone portable ^^

est voici le programme, qui n'est pas fini a causse de la raison que j'ai donné plus haut ^^

#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

	}
   }
  }   
 }

Merci dydyouaki

Voilà se qui se passe quand je mais un objet ou ma mains devants le capteur eye:

je mais ma mains devant le capteur, je recule mas mains, est le robot avance ,

Je mais ma mains devants le capteur , est j'avance mas mains le robot recule.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Sinon je suis toujours sur sa programmation , j'ai fait en sorte que le code du capteur ,

des qui détecte mas mains ou autre sur la droite ou sur la gauche pour que le robot le suive ,

mais le robot fait des a-coup , comme si que les moteur coincé , mais se problème viens des delay

Donc du coup je ne c'est pas si le code est correcte ou si on peut l'amélioré voir le corrigé .

#21 Tuc

#22 seb03000

#23 seb03000

#24 dydyouaki

#25 seb03000

#26 dydyouaki

Répondre à ce sujet

0 utilisateur(s) li(sen)t ce sujet