Salut!
J'ai reconstruit mon proto. Pour ceux qui ont suivi, on faisait du signal de mes 5 capteurs un seul "code" type B00000. C'était lent et j'ai pensé à une astuce.
J'ai gardé 3 capteurs côte à côte, et un devant, il anticipe les virages 
(ouais je sais ... )
Le capteur de tête b0 (ou FRONT dans les commentaires) évite bien des calculs. S'il voit une ligne noire, on fonce, et basta.
Dès que b0 devient 1 (donc il n'est plus sur la ligne noire), on entame un switch case.
b1 b2 et b3 devraient me renvoyer un "code" type B000
Seulement, n'ayant pas vraiment encore tout bien compris (et ayant passé 1 journée et demi à tout démonter et recoller sur un nouveau châssis), je me retrouve avec des bizarreries inexploitables.
POUR RESUMER:
b0, du capteur FF est traité à part avec un if
b1 b2 et b3 devraient se retrouver dans un bon B000 pour pouvoir traiter les combinaisons en switch case.
Voici mon code
//LINE TRACKER BY KAMMO
//STEPPER, définition des pins
#define E1 10 // Enable PWM Pin for motor 1
#define E2 11 // Enable PWM Pin for motor 2
#define I1 8 // Control pin a for motor 1
#define I2 9 // Control pin b for motor 1
#define I3 5 // Control pin a for motor 2
#define I4 6 // Control pin b for motor 2
//Définition des pins
//Pins Capteurs: LL LC CC CR RR
byte PinFF = 7; //Front sensor
byte PinLL = 2; //LPin capteur Left Left
byte PinCC = 3; //Center Center
byte PinRR = 4; //Right Right
//Déclaration des variables de lecture binaire
boolean b3, b2, b1, b0;
byte b = 0;
void setup() {
Serial.begin(9600);
//Pins Moteurs
pinMode(E1, OUTPUT);
pinMode(E2, OUTPUT);
pinMode(I1, OUTPUT);
pinMode(I2, OUTPUT);
pinMode(I3, OUTPUT);
pinMode(I4, OUTPUT);
//Pins digitaux capteurs
pinMode ( PinLL , INPUT) ;
pinMode ( PinCC , INPUT) ;
pinMode ( PinRR , INPUT) ;
pinMode ( PinFF , INPUT) ;
delay(2000);
}
void loop() {
// Lire les valeurs des capteurs et en faire des valeurs binaires
b0 = (digitalRead (PinFF) == HIGH); // HIGH ou LOW suivant comment c'est configuré
b1 = (digitalRead (PinLL) == HIGH); // HIGH ou LOW suivant comment c'est configuré
b2 = (digitalRead (PinCC) == HIGH); // HIGH ou LOW suivant comment c'est configuré
b3 = (digitalRead (PinRR) == HIGH); // HIGH ou LOW suivant comment c'est configuré
// on construit un octet avec des 1 pour chaque booléen qui est à vrai
b = (b3 ? B1000 : B0) | (b2 ? B100 : B0) | (b1 ? B10 : B0) ;
print5bits(b); //fonction qui construit une chaine binaire de type B00000
if ((b0 = HIGH) && (b2 = HIGH)) {
//vitesse max
analogWrite(E1, 250);
analogWrite(E2, 250);
}
else {
//vitesse max
analogWrite(E1, 170);
analogWrite(E2, 170);
}
}
void print5bits(byte aByte)
{
Serial.println(F("B"));
for (int8_t aBit = 3; aBit >= 1; aBit--) {
Serial.println(bitRead(aByte, aBit) == 0 ? F("0") : F("1")); //
Serial.println();
Serial.print (b0,BIN);
Serial.println(aByte,BIN);
Serial.println(" ");
delay(500);
}
//si le capteur FRONT est sur la ligne, on bourre à fond les bananes
if (b0 == 0) {
// VITMAX();
Serial.println("A FOND LES BANANES");
}
else {
// VITMED(); //anticiper une manoeuvre en ralentissant
//on compare les possibilités
switch (aByte) {
case B011 :
Serial.println("Braquer à gauche");
break;
case B001 :
Serial.println("courbe à gauche");
break;
case B100 :
Serial.println("courbe à droite");
break;
case B110 :
Serial.println("braquer à droite");
break;
case B111 : //tout blanc=hors piste
Serial.println("hors piste");
break;
case B000 : //intersection, impossible d'avancer
Serial.println("intersection, impossible d'avancer");
break;
}
}}
// VITMED();
//}
//On compare le résultat
//1= blanc 0=ligne noire
//B1234 1=G 2=C 3=D 4=F
/*switch (aByte) {
//SANS VIRAGE ////////////////////
case B1000: //virage en approche
VITMED();
TOUTDROIT(); //
break;
case B11111: //sortie de circuit=marche arrière
VITMED();
ARRIERE();
break;
//VIRAGES
case B0001:
VIRAGE90(00011);
break;
case B11000:
VIRAGE90(11000);
break;
//EPINGLES //////////////////////
case B00001:
EPINGLE(00001);
break;
case B10000:
EPINGLE(10000);
break;
//VIRAGES à droite/////////////////
case B10011: //vir droite 15deg
VIRAGEDROITE(15);
break;
case B10111: //vir40
VIRAGEDROITE(40);
break;
case B00111: //vir60
VIRAGEDROITE(60);
break;
case B01111: //vir75
VIRAGEDROITE(75);
break;
//VIRAGES à gauche//////////////////
case B11001: //vir gauche 15deg
VIRAGEGAUCHE(15);
break;
case B11101: //vir40
VIRAGEGAUCHE(40);
break;
case B11100: //vir60
VIRAGEGAUCHE(60);
break;
case B11110: //vir75
VIRAGEGAUCHE(75);
break;
default: //commande inconnue
ARRET();
break;
}//fin de switchcase
}
// Fonctions différentielles
void TOUTDROIT() { //pour aller tout droit
//vitesse max
analogWrite(E1, 200);
analogWrite(E2, 200);
//marche avant
digitalWrite(I1, HIGH);
digitalWrite(I2, LOW);
digitalWrite(I3, HIGH);
digitalWrite(I4, LOW);
}
void ARRIERE() { //pour reculer
//vitesse moyenne
analogWrite(E1, 100);
analogWrite(E2, 100);
//marche arr
digitalWrite(I1, LOW);
digitalWrite(I2, HIGH);
digitalWrite(I3, LOW);
digitalWrite(I4, HIGH);
}
void ARRET() { //stopper
//vitesse zero
COUPDEFREIN();
analogWrite(E1, 0);
analogWrite(E2, 0);
//moteur éteints
digitalWrite(I1, LOW);
digitalWrite(I2, LOW);
digitalWrite(I3, LOW);
digitalWrite(I4, LOW);
}
void VIRAGE90(byte sens) { // virage 90°
COUPDEFREIN(); //un bon coup de patins
//vitesse max
analogWrite(E1, 120);
analogWrite(E2, 120);
//pivoter
switch (sens) {
case 00011:
digitalWrite(I1, HIGH);
digitalWrite(I2, LOW);
digitalWrite(I3, LOW);
digitalWrite(I4, HIGH);
break;
case 11000:
digitalWrite(I1, LOW);
digitalWrite(I2, HIGH);
digitalWrite(I3, HIGH);
digitalWrite(I4, LOW);
break;
}
}
//épingle
void EPINGLE(byte sens) {
COUPDEFREIN(); //un bon coup de patins
switch (sens) {
case 00001:
analogWrite(E1, 155);
analogWrite(E2, 40);
digitalWrite(I1, HIGH);
digitalWrite(I2, LOW);
digitalWrite(I3, LOW);
digitalWrite(I4, HIGH);
break;
case 10000:
analogWrite(E1, 40);
analogWrite(E2, 155);
digitalWrite(I1, LOW);
digitalWrite(I2, HIGH);
digitalWrite(I3, HIGH);
digitalWrite(I4, LOW);
break;
}
}
void VIRAGEGAUCHE(byte angle) { //tourner en fonction d'un angle
COUPDEFREIN(); //un bon coup de patins
//définir la vitesse de la roue gauche
int vitesse = map(angle, 0, 90, 255, 0); //détermine la vitesse de la roue intérieure proportionnellement à l'angle
analogWrite(E1, vitesse);
analogWrite(E2, 200);
//marche avant
digitalWrite(I1, HIGH);
digitalWrite(I2, LOW);
digitalWrite(I3, HIGH);
digitalWrite(I4, LOW);
}
void VIRAGEDROITE (byte angle) {
COUPDEFREIN(); //un bon coup de patins
//définir la vitesse de la roue gauche
int vitesse = map(angle, 0, 90, 255, 0); //détermine la vitesse de la roue intérieure proportionnellement à l'angle
analogWrite(E1, 200);
analogWrite(E2, vitesse);
//marche avant
digitalWrite(I1, HIGH);
digitalWrite(I2, LOW);
digitalWrite(I3, HIGH);
digitalWrite(I4, LOW);
}
/////////////GESTION DE LA VITESSE
void VITMAX() { //met la vitesse au max
analogWrite(E1, 255);
analogWrite(E2, 255);
}
void VITMED() { //vitesse à moitié
analogWrite(E1, 125);
analogWrite(E2, 125);
}
*/
Il doit encore traîner des tas de commentaires à effacer, désolé pour le désordre.
Merci
