OUAH ! Merci pour cette super réponse 
/>
J'ai commencé a écrire un code en suivant ton "plan" mais j'ai encore quelques question a propos de celui ci.
-La parti de code que tu a écrite est elle dans la fonction loop ? Ou bien c'est la fonction " loop " dans ton code qui fais office de loop ? ( si 'est le cas je ne savais pas que l'on pouvais mettre une boucle quelconque avant la boucle principal " loop " )
Oui, en effet, la fonction loop dans le squelette de code que je présente, correspond au corps du void loop() de l'arduino
donc ce n'est pas une nouvelle fonction.
En revanche, tu peux avoir une fonction avec une boucle sans problème, tant que tu l'appelle dans la "loop()" principale
mais il faut un autre nom bien sur.
-Je n'ai pas bien compris ce qu'il faudrait mettre dans les " else "
en fait, c'est une habitude que j'ai, mais ça n'est probablement pas nécéssaire. Ici, ce serait pour prévoir une action si on appuie sur l'une des touches que tu n'utilises pas par exemple. Mais si tu souhaites ne rien faire quand on appuie ou il ne faut pas, on peut carrément enlever les else()
- Pourquoi y'a t il un delay a la fin de la boucle " effectuer une action ?
ça aussi, c'est une habitude, sur le raspberry pi, comme le processeur fait plusieurs tâches, je mets un delay pour ne pas faire trop les appels trop souvent. Sur le Arduino, je le fais aussi, car les capteurs ont une fréquence de rafraichissement. Par exemple, mon capteur à ultra sons donne la distance 20 fois par seconde, donc si je regarde la distance toutes les millisecondes, je passerai mon temps à analyser la même valeur. donc je fais un delay(50) pour regarder la valeur toutes les 50ms, soit 20 fois par seconde.
Dans ton cas, à toi de voir, au pire si tu ne mets pas de delay, les commandes seront ré-évaluées très rapidement. Par contre il faudra des delay pour laisser le temps aux moteurs de bouger.
- Et enfin a quoi sert cela : effectuer(action); a la fin de ton code ?
delay(X);
L'idée ici, c'est que plutôt que de mettre les actions directement dans la boucle loop, j'ai fait une fonction qui fait quelquechose en fonction du paramètre. Du coup, effectuer(avancer) va appeller avancer().
effectuer(tourner_a_gauche) va appeller toutnerAGauche(), et ainsi de suite. La boucle lit donc la valeur de la télécomande, et si quelquechose est reçu, la variable action est modifiée.
Après avoir fait cela, j'appelle la fonction effectuer(action), qui se chargera d'avancer, reculer, tourner, etc, selon la valeur de action... Et si je n'ai rien reçu, ben on reste sur la précédente valeur de action, donc le robot continue à faire ce qu'il faisait.
L'intérêt c'est que tu peux aussi modifier la valeur de action dans les sous fonctions, par exemple, tu peux décider qu'après avoir tourné un certain temps, le robot s'arrête automatiquement de tourner (comme ça il tourne toujours d'un angle fixe à chaque fois, par exemple 45°), sauf si l'utilisateur ré-appuie sur le bouton "tourner"...
Maintenant l'un des deux delay est inutile, soit tu mets le delay dans loop(), soit dans effectuer(action).
De même, tu pourrais aussi bien intégrer le code de effectuer(action) directement dans loop. C'est juste une habitude que j'ai de faire des petits modules à chaque fois. ça permet par exemple de garder le même code de "effectuer(action)" pour différents robots, quel que soit le mode de contrôle... dans un cas action peut etre défini par la télécomande, dans l'autre par une fonction en utilisant des capteurs pour déterminer automatiquement ce qu'il faut faire.
Voila le code que j'ai commencé a écrire ( je n'ai rien mis dans l'action autonome pour l'instant pour ne pas trop embrouiller le code)
voici ce que je pense que devrait faire ton code :
#include <DistanceSRF04.h>
#include <IRremote.h>
int action;
int IRdelay = 40 ;
unsigned long Enavant = 0xA16E6C93 ;
unsigned long Tourneragauche = 0xA16E40BF ;
unsigned long Enarriere = 0xA16EE817 ;
unsigned long Tourneradroite = 0xA16E00FF ;
unsigned long Modeautonome = 0xA16EC03F ;
unsigned long Arret= ... ;//a toi d'addigner une touche pour l'arrêt des moteurs
int Avant ;
int Arriere ;
int TGauche ;
int TDroite ;
int Autonome ;
int Stop ;
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
int led = 13;
DistanceSRF04 Dist;
int distance;
int motor1Pin1 = 3; // pin 2 on L293D
int motor1Pin2 = 4;
int motor2Pin1 = 5; // pin 2 on L293D
int motor2Pin2 = 6; // pin 7 on L293D
int enablePin = 9;
int enable2Pin = 10;// pin 1 on L293D
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn();
Dist.begin(12,13);
// set all the other pins you're using as outputs:
pinMode(motor1Pin1, OUTPUT);
pinMode(motor1Pin2, OUTPUT);
pinMode(motor2Pin1, OUTPUT);
pinMode(motor2Pin2, OUTPUT);
pinMode(enablePin, OUTPUT);
pinMode(enable2Pin, OUTPUT);
// set enablePin high so that motor can turn on:
//digitalWrite(enablePin, HIGH); //si tu fais ça les moteurs ne s'arrêtent jamais!
//digitalWrite(enable2Pin, HIGH);//idem. Il faut faire le enable quand tu veux que le robot avance... Sauf si tu veux que ton robot soit toujours en mouvement.
}
/**
* Les fonctions ci dessous te permettent de ne pas répéter le code correspondant aux divers endroits. ça t'évite de devoir faire des copier coller.
* De plus, si tu utilises cette fonction, et que tu veux modifier les noms des variables ou autre, tu n'as qu'à modifier ici, et ce sera bon dans toute la suite du code!
* De manière générale, c'est une bonne habitude de faire des sous fonctions, et de t'appuyer dessus. Tu commences par une sous fonction, que tu testes à fond.
* Quand tu es sur que la sous fonction marche bien, tu peux t'en servir dans une nouvelle fonction, et ainsi de suite. ça te permet de valider à chaque étape.
* En plus ça fait un code propre, et clair, plus facile à lire!
*/
void startMotors()//démarre les moteurs
{
digitalWrite(enablePin, HIGH);
digitalWrite(enable2Pin, HIGH);
}
void stopMotors()//arrête les moteurs
{
digitalWrite(enablePin, LOW);
digitalWrite(enable2Pin, LOW);
}
void avancer() //le robot avancera jusqu'à nouvel ordre
{
startMotors();
digitalWrite(motor1Pin1, LOW); // set pin 2 on L293D low
digitalWrite(motor1Pin2, HIGH); // set pin 7 on L293D high
digitalWrite(motor2Pin1, LOW); // set pin 2 on L293D low
digitalWrite(motor2Pin2, HIGH);
}
void tournerGauche() //le robot tournera à gauche jusqu'à nouvel ordre
{
startMotors();
digitalWrite(motor1Pin1, LOW); // set pin 2 on L293D low
digitalWrite(motor1Pin2, HIGH); // set pin 7 on L293D high
digitalWrite(motor2Pin1, HIGH); // set pin 2 on L293D low
digitalWrite(motor2Pin2, LOW);
}
void tournerDroite()//le robot tournera à droite jusqu'à nouvel ordre
{
startMotors();
digitalWrite(motor1Pin1, HIGH); // set pin 2 on L293D low
digitalWrite(motor1Pin2, LOW); // set pin 7 on L293D high
digitalWrite(motor2Pin1, LOW); // set pin 2 on L293D low
digitalWrite(motor2Pin2, HIGH);
}
void reculer()//le robot reculera jusqu'à nouvel ordre
{
startMotors();
digitalWrite(motor1Pin1, HIGH); // set pin 2 on L293D low
digitalWrite(motor1Pin2, LOW); // set pin 7 on L293D high
digitalWrite(motor2Pin1, HIGH); // set pin 2 on L293D low
digitalWrite(motor2Pin2, LOW);
}
void loop()//boucle principale du programme
{
if (irrecv.decode(&results))
{
Serial.println(results.value, HEX);
irrecv.resume(); // Receive the next value
}
if(results.value == Enavant)
{
action = Avant ; //attention, tu avais mis action == Avant. ça n'aurait pas mis la valeur "Avant" dans action. == ça sert à voir si la valeur de gauche est égale à la valeur de droite. = tout seul sert à mettre la valeur de droite dans la variable de gauche. Attention à ne pas se tromper, ça ne fera pas d'érreur de compilation, mais le programme ne fonctionnera pas comme tu veux!
}
else if(results.value == Tourneragauche)
{
action = TGauche ;
}
else if(results.value == Tourneradroite)
{
action = TDroite ;
}
else if(results.value == Arriere)
{
action = Arriere ;
}
else if(results.value == Arret)//cas ou tu veux arrêter le robot dans son déplacement!
{
action = Stop ;
}
else if(results.value == Autonome)
{
action = Autonome ;
}
effectueraction(action);//si tu ne mets pas ça ici, le robot ne fera rien! dans ton exemple il aurait simplement avancé en continu.
}//ne pas oublier de fermer la fonction, il te manquait cela. Tu ne dois pas déclarer une fonction au sein d'une autre, à moins de savoir précisément pourquoi. Ici, tu n'en as pas besoin.
void effectueraction(int act)//tu avais oublié les parenthèses pour la fonction!!!
{
if (act == Avant)
{
avancer();
}
else if ( act == TGauche)
{
tournerGauche();
}
else if ( act == TDroite )
{
tournerDroite()
}
else if ( act == Arriere)
{
reculer();
}
else if ( act == Stop)
{
stopMotors();
}
else if(act == Autonome)
{
//traitements à faire en mode autonome , par exemple :
int dist=lireCapteurDistance();//la fonction lireCapteurDistance() doit être implémentée
if(dist<30)
{tournerGauche();}//c'est ici que tu vois l'intérêt d'avoir fait des fonctions : ça t'évite de retaper les 4 lignes pour activer les moteurs!
else
{avancer();}
}
}
Voila. Ce code devrait compiler, et en plus je t'ai corrigé d'autres erreurs. Regarde les commentaires, il y a certains points qu'il est très important de comprendre, sinon ça ne marchera pas.
En programmation, tu dois prendre ton temps, et y aller par étapes
C'est un conseil que je donne à mes étudiants : fais un petit bout, vérifie qu'il fonctionne comme il faut. Une fois que c'est fait, tu te sers de ce que tu as fait pour faire une chose un peu plus compliquée, et tu valides. Tu répètes l'opération autant de fois que c'est nécéssaire, et à la fin tu peux réussir à faire de gros programmes très complexes, si tu t'y prends ainsi,
petit à petit.
Avec le robot c'est pareil. Il faut d'abord faire fonctionner les moteurs, et quand c'est fait, tester les capteurs, puis ensuite faire une fonction pour avancer tout droit, la tester, etc etc...
Et à la fin tu fais tout on algorithme d'évitement d'obstacle, et tu peux programmer ton robot pour qu'il poursuive John Connor
