Centrale clignotants

Bonjour,
je tente de me faire une centrale clignotants / warning / feu de stop pour l'intégrer sur ma future remorque cargo (livraison de paniers de légumes et marchés).
Les clignotants et feu fonctionnent en 12V, je passe par de la commande de relais.

J'utilise une la bibliothèque EZbutton pour connecter un combo de boutons de guidon pour moto.
Il y a un interrupteur ON/OFF/ON pour les clignotants.
Un interrupteur ON/OFF pour les warning.
Pour le test, j'ai un switch pour simuler l'appuie sur la poignée de frein.

J'ai réussi à faire la base, clignotants droit / gauche et feu de stop.
J'utilise millis() pour le clignotement gauche / droite dans une fonction.
1 relais par côté.

Mon petit soucis concerne la partie warning, je souhaite également utiliser une fonction avec la gestion des clignotments avec millis() mais dès que je remplace les digitalwrite / delay() mis directement de le loop(), plus rien ne fonctionne.
Quand j'essaye avec la fonction "ActionCligno" qui tourne avec le bouton ON/OFF/ON, plus rien ne fonctionne non plus.

Voici le code, si vous avez une piste...

#include <ezButton.h>

byte etatCligno = LOW;
unsigned long dateDernierChangement = 0;

//Parameters

//boutons
ezButton BtnClignoG(5);
ezButton BtnClignoD(6);
ezButton BtnWarning(7);
ezButton BtnFeuStop(8);

//relais
const int ClignoG = 2;
const int ClignoD = 3;
const int FeuStop = 4;

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  BtnClignoG.setDebounceTime(50);
  BtnClignoD.setDebounceTime(50);
  BtnWarning.setDebounceTime(50);
  BtnFeuStop.setDebounceTime(50);

  pinMode(ClignoG, OUTPUT);
  pinMode(ClignoD, OUTPUT);
  pinMode(FeuStop, OUTPUT);
}
void loop() {

  BtnClignoG.loop();
  BtnClignoD.loop();
  BtnWarning.loop();
  BtnFeuStop.loop();

  int BtnClignoGEtat = BtnClignoG.getState();
  int BtnClignoDEtat = BtnClignoD.getState();
  int BtnWarningEtat = BtnWarning.getState();
  int BtnFeuStopEtat = BtnFeuStop.getState();

  // vérification état des boutons
  if (BtnClignoG.isPressed())
    Serial.println("ON : Clignotant gauche");
  if (BtnClignoD.isPressed())
    Serial.println("ON : Clignotant droite");
  if (BtnWarning.isPressed())
    Serial.println("ON : Warning");
  if (BtnFeuStop.isPressed())
    Serial.println("ON : STOP");

  if (BtnClignoG.isReleased())
    Serial.println("OFF : Clignotant gauche");
  if (BtnClignoD.isReleased())
    Serial.println("OFF : Clignotant droite");
  if (BtnWarning.isReleased())
    Serial.println("OFF : Warning");
  if (BtnFeuStop.isReleased())
    Serial.println("OFF : STOP");

  //Gestion des relais
  //Feu Stop
  if (BtnFeuStopEtat == 1) {
    // le bouton est OFF
    digitalWrite(FeuStop, LOW);
  } else {
    // le bouton est ON
    digitalWrite(FeuStop, HIGH);
  }

  //Clignotant Gauche
  if (BtnClignoGEtat == 1) {
    // le bouton est OFF
    digitalWrite(ClignoG, LOW);
  } else {
    // le bouton est ON
    ActionCligno(ClignoG);
  }

  //Clignotant Droite
  if (BtnClignoDEtat == 1) {
    // le bouton est OFF
    digitalWrite(ClignoD, LOW);
  } else {
    // le bouton est ON
    ActionCligno(ClignoD);
  }

  //Warning
  if (BtnWarningEtat == 1) {
    // le bouton est OFF
  } else {
    // le bouton est ON
    digitalWrite(ClignoD, HIGH);
    digitalWrite(ClignoG, HIGH);
    delay(500);
    digitalWrite(ClignoD, LOW);
    digitalWrite(ClignoG, LOW);
    delay(500);
  }

}

void ActionCligno(int Cote)
{
  unsigned long dateCourante = millis();
  unsigned long intervalle = dateCourante - dateDernierChangement;

  if (etatCligno == HIGH && intervalle > 500) {
    // extinction de la DEL car elle est allumée (HIGH) et 500ms se sont écoulées
    etatCligno = LOW;
    digitalWrite(Cote, etatCligno);
    dateDernierChangement = dateCourante;
    Serial.println(etatCligno);
  }
  else if (etatCligno == LOW && intervalle > 250) {
    // allumage de la DEL car elle est éteinte (LOW) et 250ms se sont écoulées
    etatCligno = HIGH;
    digitalWrite(Cote, etatCligno);
    dateDernierChangement = dateCourante;
    Serial.println(etatCligno);
  }
}

void ActionWarning()
{
  unsigned long dateCourante = millis();
  unsigned long intervalle = dateCourante - dateDernierChangement;

  if (etatCligno == HIGH && intervalle > 500) {
    // extinction de la DEL car elle est allumée (HIGH) et 500ms se sont écoulées
    etatCligno = LOW;
    digitalWrite(ClignoG, etatCligno);
    digitalWrite(ClignoD, etatCligno);
    dateDernierChangement = dateCourante;
  }
  else if (etatCligno == LOW && intervalle > 250) {
    // allumage de la DEL car elle est éteinte (LOW) et 250ms se sont écoulées
    etatCligno = HIGH;
    digitalWrite(ClignoG, etatCligno);
    digitalWrite(ClignoD, etatCligno);
    dateDernierChangement = dateCourante;
  }
}

Merci d'avance

hello
attention, j'ai changé la vitesse de la liaison moniteur==>115200 bauds

#include <ezButton.h>

byte etatCligno = LOW;
unsigned long dateDernierChangement = 0;

//Parameters

//boutons
ezButton BtnClignoG(5);
ezButton BtnClignoD(6);
ezButton BtnWarning(7);
ezButton BtnFeuStop(8);

//relais
const int ClignoG = 2;
const int ClignoD = 3;
const int FeuStop = 4;

void setup() {
  //Init Serial USB
  Serial.begin(115200);
  BtnClignoG.setDebounceTime(50);
  BtnClignoD.setDebounceTime(50);
  BtnWarning.setDebounceTime(50);
  BtnFeuStop.setDebounceTime(50);

  pinMode(ClignoG, OUTPUT);
  pinMode(ClignoD, OUTPUT);
  pinMode(FeuStop, OUTPUT);
}
void loop() {

  BtnClignoG.loop();
  BtnClignoD.loop();
  BtnWarning.loop();
  BtnFeuStop.loop();

  int BtnClignoGEtat = BtnClignoG.getState();
  int BtnClignoDEtat = BtnClignoD.getState();
  int BtnWarningEtat = BtnWarning.getState();
  int BtnFeuStopEtat = BtnFeuStop.getState();

  // vérification état des boutons
  if (BtnClignoG.isPressed())
    Serial.println("ON : Clignotant gauche");
  if (BtnClignoD.isPressed())
    Serial.println("ON : Clignotant droite");
  if (BtnWarning.isPressed())
    Serial.println("ON : Warning");
  if (BtnFeuStop.isPressed())
    Serial.println("ON : STOP");

  if (BtnClignoG.isReleased())
    Serial.println("OFF : Clignotant gauche");
  if (BtnClignoD.isReleased())
    Serial.println("OFF : Clignotant droite");
  if (BtnWarning.isReleased())
    Serial.println("OFF : Warning");
  if (BtnFeuStop.isReleased())
    Serial.println("OFF : STOP");

  //Gestion des relais
  //Feu Stop
  if (BtnFeuStopEtat == 1) {
    // le bouton est OFF
    digitalWrite(FeuStop, LOW);
  } else {
    // le bouton est ON
    digitalWrite(FeuStop, HIGH);
  }

  //Clignotant Gauche
  if (BtnClignoGEtat == 1) {
    // le bouton est OFF
    digitalWrite(ClignoG, LOW);
  } else {
    // le bouton est ON
    ActionCligno(ClignoG);
  }

  //Clignotant Droite
  if (BtnClignoDEtat == 1) {
    // le bouton est OFF
    digitalWrite(ClignoD, LOW);
  } else {
    // le bouton est ON
    ActionCligno(ClignoD);
  }

  //Warning
  if (BtnWarningEtat == 1) {
    // le bouton est OFF
  } else {
    // le bouton est ON
    //Serial.println("appel action warning");
    ActionWarning();
    /*
    digitalWrite(ClignoD, HIGH);
    digitalWrite(ClignoG, HIGH);
    delay(500);
    digitalWrite(ClignoD, LOW); Serial.println(etatCligno);
    digitalWrite(ClignoG, LOW); Serial.println(etatCligno);
    delay(500);
    */
  }
}

void ActionCligno(int Cote) {
  //unsigned long dateCourante = millis();
  unsigned long intervalle = millis() - dateDernierChangement;

  if (etatCligno == HIGH && intervalle > 500) {
    // extinction de la DEL car elle est allumée (HIGH) et 100ms se sont écoulées
    etatCligno = LOW;
    digitalWrite(Cote, etatCligno);
    dateDernierChangement = millis();
    Serial.println(etatCligno);
  } else if (etatCligno == LOW && intervalle > 250) {
    // allumage de la DEL car elle est éteinte (LOW) et 200ms se sont écoulées
    etatCligno = HIGH;
    digitalWrite(Cote, etatCligno);
    dateDernierChangement = millis();
    Serial.println(etatCligno);
  }
}

void ActionWarning() {  //Serial.println("action warning");
  //unsigned long dateCourante = millis();
  unsigned long intervalle = millis() - dateDernierChangement;
  //Serial.print("interval");Serial.println( intervalle);
  if (etatCligno == HIGH && intervalle > 500) {
    // extinction de la DEL car elle est allumée (HIGH) et 100ms se sont écoulées
    etatCligno = LOW;
    digitalWrite(ClignoG, etatCligno);
    digitalWrite(ClignoD, etatCligno);
    dateDernierChangement = millis();
    Serial.print("Warning etat cligno");
    Serial.println(etatCligno);
  } else if (etatCligno == LOW && intervalle > 250) {
    // allumage de la DEL car elle est éteinte (LOW) et 200ms se sont écoulées
    etatCligno = HIGH;
    digitalWrite(ClignoG, etatCligno);
    digitalWrite(ClignoD, etatCligno);
    dateDernierChangement = millis();
    Serial.print("Warning etat cligno");
    Serial.println(etatCligno);
  }
}

Bonjour,
j'avais essayé avec ma fonction ActionWarning() à la place de digitalwrite() et delay().
Bizarrement, il n'y a que les led témoins de la carte relais qui s'allument très faiblement mais rien sur les clignotants.
Je fais une vidéo, ce sera plus parlant.

EDIT : voici la vidéo, on voit bien à la fin que la fonction warning n'allume pas les clignotants.
https://youtu.be/cESG_rDiZ2I

lorsque je regarde le moniteur, tout est ok

nota: as tu prévu le cas ou un bouton de commande clignotant est actionné et qu'ensuite tu demandes un warning ?

Je n'ai pas encore prévu ce cas, mais il faut d'abord que j'arrive à régler le problème des warning. :sweat_smile:

:thinking: :innocent:

#include <ezButton.h>

byte etatCligno = LOW;
unsigned long dateDernierChangement = 0;

//Parameters
//relais
const int ClignoG = 2;
const int ClignoD = 3;
const int FeuStop = 4;
//boutons
ezButton BtnClignoG(5);
ezButton BtnClignoD(6);
ezButton BtnWarning(7);
ezButton BtnFeuStop(8);

int BtnClignoGEtat = 0;
int BtnClignoDEtat = 0;
int BtnWarningEtat = 0;
int BtnFeuStopEtat = 0;

void setup() {
  //Init Serial USB
  Serial.begin(115200);
  BtnClignoG.setDebounceTime(50);
  BtnClignoD.setDebounceTime(50);
  BtnWarning.setDebounceTime(50);
  BtnFeuStop.setDebounceTime(50);

  pinMode(ClignoG, OUTPUT);
  pinMode(ClignoD, OUTPUT);
  pinMode(FeuStop, OUTPUT);
}
void loop() {

  BtnClignoG.loop();
  BtnClignoD.loop();
  BtnWarning.loop();
  BtnFeuStop.loop();
  // lecture des états des boutons
  BtnClignoGEtat = BtnClignoG.getState();
  BtnClignoDEtat = BtnClignoD.getState();
  BtnWarningEtat = BtnWarning.getState();
  BtnFeuStopEtat = BtnFeuStop.getState();

  // vérification état des boutons
  if (BtnClignoG.isPressed()) { Serial.println("ON : Clignotant gauche"); }
  if (BtnClignoD.isPressed()) { Serial.println("ON : Clignotant droite"); }
  if (BtnWarning.isPressed()) { Serial.println("ON : Warning"); }
  if (BtnFeuStop.isPressed()) { Serial.println("ON : STOP"); }
  if (BtnClignoG.isReleased()) { Serial.println("OFF : Clignotant gauche"); }
  if (BtnClignoD.isReleased()) { Serial.println("OFF : Clignotant droite"); }
  if (BtnWarning.isReleased()) { Serial.println("OFF : Warning"); }
  if (BtnFeuStop.isReleased()) { Serial.println("OFF : STOP"); }

  //Gestion des relais
  if (BtnFeuStopEtat == 1) { digitalWrite(FeuStop, LOW); }

  if ((BtnClignoGEtat == 1) && (BtnWarningEtat == 1)) { digitalWrite(ClignoG, LOW); }

  if ((BtnClignoDEtat == 1) && (BtnWarningEtat == 1)) { digitalWrite(ClignoD, LOW); }

  if ((BtnWarningEtat == 1) && (BtnClignoGEtat == 1) && (BtnClignoDEtat == 1)) {
    digitalWrite(ClignoG, LOW);
    digitalWrite(ClignoD, LOW);
  }




  //Gestion des relais
  if (BtnFeuStopEtat == 0) {
    digitalWrite(FeuStop, HIGH);
  } else {
    if (BtnClignoGEtat == 0) {
      ActionCligno(ClignoG);
    } else {
      if (BtnClignoDEtat == 0) {
        ActionCligno(ClignoD);
      } else {
        if (BtnWarningEtat == 0) { ActionWarning(); }
      }
    }
  }
}
void ActionCligno(int Cote) {
  unsigned long intervalle = millis() - dateDernierChangement;
  if (etatCligno == HIGH && intervalle > 1000) {
    etatCligno = LOW;
    digitalWrite(Cote, etatCligno);
    dateDernierChangement = millis();
    Serial.print("etatCligno ");
    Serial.print(Cote);
    Serial.print(" 0 ");
    Serial.println(etatCligno);  // eteinte court
  } else {
    if (etatCligno == LOW && intervalle > 250) {
      etatCligno = HIGH;  // allumage de la DEL
      digitalWrite(Cote, etatCligno);
      dateDernierChangement = millis();
      Serial.print("etatCligno ");
      Serial.print(Cote);
      Serial.print(" 1 ");
      Serial.println(etatCligno);  //allumée long
    }
  }
}

void ActionWarning() {
  BtnClignoGEtat = 1;
  BtnClignoDEtat = 1;
  unsigned long intervalle = millis() - dateDernierChangement;
  if (etatCligno == HIGH && intervalle > 1000) {
    etatCligno = LOW;
    digitalWrite(ClignoG, etatCligno);
    digitalWrite(ClignoD, etatCligno);
    dateDernierChangement = millis();
    Serial.print("Warning etat cligno 0 éteinte court ");
    Serial.println(etatCligno);  //
    //etatCligno = LOW;
  } else {
    if (etatCligno == LOW && intervalle > 250) {
      etatCligno = HIGH;
      digitalWrite(ClignoG, etatCligno);
      digitalWrite(ClignoD, etatCligno);
      dateDernierChangement = millis();
      Serial.print("Warning etat cligno 1  allumé long ");
      Serial.println(etatCligno);  //
                                   //etatCligno = HIGH;
    }
  }
}

Ah chouette, le warning fonctionne.
Je vais me pencher sur les conditions, il y a quelques comportements étranges (plus de cligno quand feux de stop, priorité entre cligno et warming).
Merci, je vais étudier à tête reposée et je poste le résultat final.

:thinking: :innocent:

warning prioritaire sur les clignotants et feu stop opérationnel.
clignotants ou warning acceptent le feu stop

#include <ezButton.h>

byte etatCligno = LOW;
unsigned long dateDernierChangement = 0;

//Parameters
//relais
const int ClignoG = 2;
const int ClignoD = 3;
const int FeuStop = 4;
//boutons
ezButton BtnClignoG(5);
ezButton BtnClignoD(6);
ezButton BtnWarning(7);
ezButton BtnFeuStop(8);

int BtnClignoGEtat = 0;
int BtnClignoDEtat = 0;
int BtnWarningEtat = 0;
int BtnFeuStopEtat = 0;

void setup() {
  //Init Serial USB
  Serial.begin(115200);
  BtnClignoG.setDebounceTime(50);
  BtnClignoD.setDebounceTime(50);
  BtnWarning.setDebounceTime(50);
  BtnFeuStop.setDebounceTime(50);

  pinMode(ClignoG, OUTPUT);
  pinMode(ClignoD, OUTPUT);
  pinMode(FeuStop, OUTPUT);
}
void loop() {

  BtnClignoG.loop();
  BtnClignoD.loop();
  BtnWarning.loop();
  BtnFeuStop.loop();
  // lecture des états des boutons
  BtnClignoGEtat = BtnClignoG.getState();
  BtnClignoDEtat = BtnClignoD.getState();
  BtnWarningEtat = BtnWarning.getState();
  BtnFeuStopEtat = BtnFeuStop.getState();

  // vérification état des boutons
  if (BtnClignoG.isPressed()) { Serial.println("ON : Clignotant gauche"); }
  if (BtnClignoD.isPressed()) { Serial.println("ON : Clignotant droite"); }
  if (BtnWarning.isPressed()) { Serial.println("ON : Warning"); }
  if (BtnFeuStop.isPressed()) { Serial.println("ON : STOP"); }
  if (BtnClignoG.isReleased()) { Serial.println("OFF : Clignotant gauche"); }
  if (BtnClignoD.isReleased()) { Serial.println("OFF : Clignotant droite"); }
  if (BtnWarning.isReleased()) { Serial.println("OFF : Warning"); }
  if (BtnFeuStop.isReleased()) { Serial.println("OFF : STOP"); }

  //Gestion des relais
  if (BtnFeuStopEtat == 1) { digitalWrite(FeuStop, LOW); }

  if ((BtnClignoGEtat == 1) && (BtnWarningEtat == 1)) { digitalWrite(ClignoG, LOW); }
  if ((BtnClignoDEtat == 1) && (BtnWarningEtat == 1)) { digitalWrite(ClignoD, LOW); }
  if ((BtnWarningEtat == 1) && (BtnClignoGEtat == 1) && (BtnClignoDEtat == 1)) {
    digitalWrite(ClignoG, LOW);
    digitalWrite(ClignoD, LOW);
  }

  //Gestion des relais
  if (BtnFeuStopEtat == 0) {
    digitalWrite(FeuStop, HIGH);
  }

  if (BtnWarningEtat == 0) {
    ActionWarning();
  } else {
    if (BtnClignoGEtat == 0) {
      ActionCligno(ClignoG);
    } else {
      if (BtnClignoDEtat == 0) {
        ActionCligno(ClignoD);
      }
    }
  }
}
  void ActionCligno(int Cote) {
    unsigned long intervalle = millis() - dateDernierChangement;
    if (etatCligno == HIGH && intervalle > 1000) {
      etatCligno = LOW;
      digitalWrite(Cote, etatCligno);
      dateDernierChangement = millis();
      Serial.print("etatCligno ");
      Serial.print(Cote);
      Serial.print(" 0 ");
      Serial.println(etatCligno);  // eteinte court
    } else {
      if (etatCligno == LOW && intervalle > 250) {
        etatCligno = HIGH;  // allumage de la DEL
        digitalWrite(Cote, etatCligno);
        dateDernierChangement = millis();
        Serial.print("etatCligno ");
        Serial.print(Cote);
        Serial.print(" 1 ");
        Serial.println(etatCligno);  //allumée long
      }
    }
  }

  void ActionWarning() {
    BtnClignoGEtat = 1;
    BtnClignoDEtat = 1;
    unsigned long intervalle = millis() - dateDernierChangement;
    if (etatCligno == HIGH && intervalle > 1000) {
      etatCligno = LOW;
      digitalWrite(ClignoG, etatCligno);
      digitalWrite(ClignoD, etatCligno);
      dateDernierChangement = millis();
      Serial.print("Warning etat cligno 0 éteinte court ");
      Serial.println(etatCligno);
    } else {
      if (etatCligno == LOW && intervalle > 250) {
        etatCligno = HIGH;
        digitalWrite(ClignoG, etatCligno);
        digitalWrite(ClignoD, etatCligno);
        dateDernierChangement = millis();
        Serial.print("Warning etat cligno 1  allumé long ");
        Serial.println(etatCligno);
      }
    }
  }

1 Like

Excellent, bon je n'ai même pas eu le temps de décortiquer le code d'avant :grinning: que la correction est déjà faite.

Il va falloir que je travaille mes conditions imbriquées, je manque un peu de logique...

Et sinon, une idée de ce qui bloquait les warnings avant vos corrections ?

tu appelais les if boutons pas actionné pour mettre lesclignotants à l'arret en meme temps que tu appelais le warning. ( dans la loop)

ah oui ! C'est ce que je disais, petite soucis avec la logiqiue :slight_smile: .
Merci encore

Quand je regarde la vidéo, le relais stop allume les trois sections (gauche centre droite). Je me demande comment ça fait quand tu freines avec un clignoteur enclanché ?

hello
as tu lu les posts qui suivent la video?

Hello,
j'ai enfin le temps de finaliser l'installation du bousin sur le vélo.
Mais, forcément, il y a un mais...

Je voulais utiliser les poignées de freins avec interrupteur qui permettent de couper l'assistance électrique pour allumer le feux de stop.
Le problème est que le "cycle analyst" qui contrôle le moteur envoie aussi 5v et quelques soit mes réglages, j'ai soit le stop toujours allumé soit la coupure de l'assistance qui ne fonctionne pas.

Est-ce qu'il y aurait une piste vers les input_pullup / pulldown ?

Merci et bon réveillon !

hello, il faut nous mettre un schéma du cablage d'origine de la poignée de frein avec l'indication des tensions présentes
et un schéma de ton cablage à toi .
je ne connais pas ta librairie "ezbutton": quel niveau correspond à "is pressed" (HIGHou LOW).
j'ai jeté un oeil sur la lib

bool ezButton::isPressed(void) {
	if(previousSteadyState == HIGH && lastSteadyState == LOW)
		return true;
	else
		return false;
}

elle attend de recevoir LOW pour déclarer is presed vrai.

est ce compatible avec le câblage de la poignée ?

nota, l'entrée est déclarée en pull up dans la lib

Voilà un schéma super basique du câblage.
Le courant passe quand j'appuie sur le frein.
C'est bon comme çà pour le code actuel arduino et pour le réglage du cycle analyst lorsque je ne branche que l'un ou l'autre.

Le problème vient sans doute plus de mon câble car je pars du bouton / frein en Y vers l'arduino d'un côté et vers le cycle analyst de l'autre, du coup le courant va au plus court.

Je vais peut-être devoir prévoir un autre bouton juste pour l'arduino.

02ae12ece73e206ea7c919e09df84a8bb6fccf05_2_666x500
Je pense que relier GND et +5V c'est pas une bonne idée.

Normalement, on réuni les GND des équipements et les signaux (s'ils sont bien en 5V).
Après coté Arduino et bien on regarde si c'est un 0 V ou un 5V que l'on récupère lorsqu'on appui sur la poignée.

J'ai marqué 5v sur le schéma au dessus du gnd mais c'est ce que je mesure entre le pin 8 et le gnd.
Je n'ai pas relier le 5v et le gnd.
Je vais remesuré demain, mais normalement, je récupère du 5v sur l'arduino.

si ton cablage est le suivant:


alors, tout va bien
par contre s ton cablage est celui ci:

rien ne va plus, il faut revoir le code arduino pour qu'il attende du +5V
donc supprimer les pull up, mattre des pull down extérieures et modifier le code ( virer la lib et lire l'état des boutons sans passer par cette lib qui ( je pense) attends du 5 V pour te dire que le Bouton est pressé.
en partant de tout ceci, peux tu vérifier et confirmer l'un ou l'autre schémé ?

J'avoue que je suis un peu perdu...
Quand le moteur n'est pas allumé, avec le code actuel, le stop s'allume lorsque le courant est coupé, l'arduino attend du 0v.
Quand je teste juste la partie cycle analyst, ce n'est pas +5v qui arrive mais +0,5v.
Je ne comprends plus rien.
Sur le cycle analyst, je peux régler un paramètre sur le signal du frein : low ou high. Il faut qu'il soit sur low pour que cela fonctionne (sans l'arduino connecté) et le signal qui arrive est bien du 0v.
Je vais peut-être partir sur une solution ou je rajoute le bouton. Je ne suis pas assez calé...