Código de intermitencia

Hola a todos!! necesito un poco de ayuda. Os pongo en contexto.
El mundo de Arduino es nuevo para mi pero me embarco en todo lo que me parece interesante. Buscando por internet encontré un proyecto para minimizar el cableado de una moto. El post tiene el código realizado por el creador y va con Arduino nano, una placa de relés y pulsadores pull up.
Pues estoy parado en la parte de intermitentes, el código esta diseñado para pulsar el pulsador una vez pero no se queda parpadeando el intermitente y hay que mantenerlo pulsado para que haga la intermitencia.
Lo que me gustaría que hiciese es que cuando pulse el botón una vez empezase a parpadear y que cuando volviese a pulsarlo se pare el intermitente.
Alguien sería tan amable de ayudarme a modificar el código?
GRACIAS!!!
dejo adjunto el código y el enlace al post:
https://elmoto.net/showthread.php?t=4044

//INCLUDE LIBRARIES:-------------------------------------------------------------
#include <ClickButton.h>

// DEFINE INITIAL FUNCTION STATES: ----------------------------------------------
boolean runlightsActive = true;
boolean britesActive = false;
boolean brakeActive = false;
boolean leftTurnActive = false;
boolean rightTurnActive = false;
boolean hornActive = false;
boolean startActive = false;
boolean suspendRunlights = false;
boolean parkActive = false;
boolean hazzardActive = false;
//boolean killActive = false;
//boolean headlightActive = false;


// DEFINE INPUT PINS: -----------------------------------------------------------//
#define frontCtrlPin A0
#define britesCtrlPin 10
#define brakeCtrlPin 11
#define leftCtrlPin 12
#define rightCtrlPin A0
#define hornCtrlPin A1 
#define startCtrlPin A3


// DEFINE CLICKBUTTONS


ClickButton britesButton (britesCtrlPin, LOW, CLICKBTN_PULLUP);
ClickButton brakeButton (brakeCtrlPin, LOW, CLICKBTN_PULLUP);
ClickButton leftButton (leftCtrlPin, LOW, CLICKBTN_PULLUP);
ClickButton rightButton (rightCtrlPin, LOW, CLICKBTN_PULLUP);
ClickButton hornButton (hornCtrlPin, LOW, CLICKBTN_PULLUP);
ClickButton startButton (startCtrlPin, LOW, CLICKBTN_PULLUP);


// DEFINE RELAY PINS: -----------------------------------------------------------


#define runlightsPin 2
#define britesPin 3
#define brakePin 4
#define leftTurnPin 5
#define rightTurnPin 6
#define hornPin 7
#define startPin 8
//#define killPin 9
//#define headlightPin 


// DEFINE INITIAL RELAY STATES FOR TIMED FUNCTIONS: -----------------------------
int leftLight = HIGH;   
int rightLight = HIGH;


// DEFINE INITIAL MS COUNT FOR FUNCTIONS: ---------------------------------------
// will store last time LED was updated OR switch debonce
unsigned long leftTurnMs = 0;
unsigned long rightTurnMs = 0; 
unsigned long hazzardMs = 0;


unsigned long britesCtrlMs = 0;
unsigned long brakeCtrlMS = 0;
unsigned long leftCtrlMS = 0;
unsigned long rightCtrlMS = 0;
unsigned long hornCtrlMS = 0;
unsigned long startCtrlMS = 0;








// DEFINE CONSTANT INTERVALS:----------------------------------------------------
#define turnInterval 500 
#define hazzardInterval 200






// SETUP ///////////////////////////////////////////////////////////////////////


void setup() {


// SET INITIAL RELAY STATES TO AVOID MISFIRES AT STARTUP:------------------------
  digitalWrite (runlightsPin,LOW);
  digitalWrite (britesPin,HIGH);
  digitalWrite (brakePin,HIGH);
  digitalWrite (rightTurnPin, rightLight);
  digitalWrite (leftTurnPin, leftLight);
  digitalWrite (hornPin,HIGH);
  digitalWrite (startPin, HIGH);
  //digitalWrite (killPin, HIGH);
  //digitalWrite (headlightPin,HIGH);
  
/* / ACTIVATE INPUT BUTTION PULLUPS:----------------------------------------------- 
  digitalWrite (britesCtrlPin, HIGH);
  digitalWrite (brakeCtrlPin, HIGH);
  digitalWrite (leftCtrlPin, HIGH);
  digitalWrite (rightCtrlPin, HIGH);
  digitalWrite (hornCtrlPin, HIGH);
  digitalWrite (startCtrlPin, HIGH);  */
  
/* // DEFINE INPUT PINS:------------------------------------------------------------
  //pinMode(frontCtrlPin,INPUT);
  pinMode(britesCtrlPin,INPUT_PULLUP);
  pinMode(brakeCtrlPin,INPUT_PULLUP);
  pinMode(leftCtrlPin,INPUT_PULLUP);
  pinMode(rightCtrlPin,INPUT_PULLUP);
  pinMode(hornCtrlPin,INPUT_PULLUP);
  pinMode(startCtrlPin,INPUT_PULLUP);  */
  




  // Setup button timers (all in milliseconds / ms)
  // (These are default if not set, but changeable for convenience)
  //button1.debounceTime   = 20;   // Debounce timer in ms
  brakeButton.multiclickTime = 1000;  // Time limit for multi clicks
  startButton.longClickTime  = 1500; // time until "held-down clicks" register
  
// DEFINE OUTPUT PINS:-----------------------------------------------------------
  pinMode(runlightsPin, OUTPUT);
  pinMode(britesPin, OUTPUT);
  pinMode(brakePin, OUTPUT);
  pinMode(leftTurnPin, OUTPUT);
  pinMode(rightTurnPin, OUTPUT);  
  pinMode(hornPin, OUTPUT);
  pinMode(startPin, OUTPUT);
  //pinMode(killPin, OUTPUT);
  //pinMode(headlightPin, OUTPUT);
}




// MAIN LOOP ////////////////////////////////////////////////////////////////////
void loop()
{
  
// CHECK CONDITIONS FOR EACH FUNCTION STATE AND CALL APPROPRIATE FUNCTION ////////////////////////


readInputSwitches();


if (runlightsActive == true && suspendRunlights == false ){ runlightsOn();}
else{runlightsOff();}
  
if (britesActive == true){britesOn();}
else{britesOff();}
  
if (brakeActive == true){brakeLightsOn();}
else{brakeLightsOff();}
  
if (hornActive == true){hornOn();}
else{hornOff();}


if (startActive == true){
  starterOn();
  suspendRunlights = true;
}
else{
  starterOff();
  suspendRunlights = false;
}
  
if (leftTurnActive == true){
  leftTurnOn();
  rightTurnActive = false;
  parkActive = false;
  hazzardActive = false;
}
else if (rightTurnActive == true){
  rightTurnOn();
  leftTurnActive = false;
  parkActive = false;
  hazzardActive = false;
}
else if (hazzardActive == true){
  hazzardFlashers();
  leftTurnActive = false;
  rightTurnActive = false;
  parkActive = false;
}
else if (parkActive == true){
  parkingLightsOn();
  leftTurnActive = false;
  rightTurnActive = false;
  hazzardActive = false;
}
else {blinkersOff();}


  
  // TEST SEQUENCE TO CHECK FUNCTIONS WITHOUT BUTTONS


//leftTurnActive = true;


//rightTurnActive = true;


//hazzardActive = true;


//parkActive = true;


//brakeActive = true;


//headlightOn();


//britesActive = true;


//runlightsOff();


//hornActive = true;


//startActive = true;


}






//FUNCTIONS///////////////////////////////////////////////////////////////////




// READ INPUT SWITCHES


void readInputSwitches(){
  
//WITH CLICKBUTTON


britesButton.Update();
if (britesButton.depressed == true){britesActive = true;}
else britesActive = false;


leftButton.Update();


if (leftButton.depressed == true){leftTurnActive = true;}
else leftTurnActive = false;


rightButton.Update();
if (rightButton.depressed == true){rightTurnActive = true;}
else rightTurnActive = false;


brakeButton.Update();
if (brakeButton.depressed == true){brakeActive = true;}
else brakeActive = false;


hornButton.Update();
if (hornButton.depressed == true){hornActive = true;}
else hornActive = false;


startButton.Update();
if (startButton.depressed == true){startActive = true;}
else startActive = false;  
  
/*  WITHOUT CLICKBUTTON
if (digitalRead (britesCtrlPin) == LOW){britesActive = true;}
else britesActive = false;


if (digitalRead (leftCtrlPin) == LOW){leftTurnActive = true;}
else leftTurnActive = false;


if (digitalRead (rightCtrlPin) == LOW){rightTurnActive = true;}
else rightTurnActive = false;


if (digitalRead (brakeCtrlPin) == LOW){brakeActive = true;}
else brakeActive = false;


if (digitalRead (hornCtrlPin) == LOW){hornActive = true;}
else hornActive = false;


if (digitalRead (startCtrlPin) == LOW){startActive = true;}
else startActive = false;   */


}


// RUNNING LIGHTS: --------------------------------------------------------------


void runlightsOn(){
  digitalWrite(runlightsPin, LOW);
}


void runlightsOff(){
  digitalWrite(runlightsPin, HIGH);
}




// HIGHBEAM: -------------------------------------------------------------------


void britesOn(){
  digitalWrite(britesPin, LOW);
}


void britesOff(){
  digitalWrite(britesPin, HIGH);
}




// BRAKE LIGHTS: ---------------------------------------------------------------


void brakeLightsOn(){
  digitalWrite(brakePin, LOW);
}


void brakeLightsOff(){
  digitalWrite(brakePin, HIGH);
}




// LEFT TURN SIGNAL: ---------------------------------------------------------


void leftTurnOn(){
  unsigned long currentMs = millis();
  if(currentMs - leftTurnMs >= turnInterval) {
    // save the last time you blinked the LED 
    leftTurnMs = currentMs;   


    // if the LED is off turn it on and vice-versa:
    if (leftLight == HIGH)
      leftLight = LOW;
    else
      leftLight = HIGH;


    // set the LED with the ledState of the variable:
    digitalWrite(leftTurnPin, leftLight);
    digitalWrite(rightTurnPin, HIGH);
  }
}




// RIGHT TURN SIGNAL: ---------------------------------------------------------


void rightTurnOn(){
  unsigned long currentMs = millis();
  if(currentMs - rightTurnMs >= turnInterval) {
    // save the last time you blinked the LED 
    rightTurnMs = currentMs;   


    // if the LED is off turn it on and vice-versa:
    if (rightLight == HIGH)
      rightLight = LOW;
    else
      rightLight = HIGH;


    // set the LED with the ledState of the variable:
    digitalWrite(rightTurnPin, rightLight);
    digitalWrite(leftTurnPin, HIGH);
  }
}




// HAZZARD FLASHERS: -----------------------------------------------------------


void hazzardFlashers(){
  unsigned long currentMs = millis();
  if(currentMs - hazzardMs >= hazzardInterval) {
    // save the last time you blinked the LED 
    hazzardMs = currentMs;   


    // if the LED is off turn it on and vice-versa:     
    if (rightLight == HIGH)
      rightLight = LOW;
    else
      rightLight = HIGH;


    if (leftLight == HIGH)
      leftLight = LOW;
    else
      leftLight = HIGH;


    // set the LED with the ledState of the variable:
    digitalWrite(rightTurnPin, rightLight);
    digitalWrite(leftTurnPin, leftLight);
  }
}




// PARKING LIGHTS: -------------------------------------------------------------


void parkingLightsOn(){
  digitalWrite(rightTurnPin, LOW);
  digitalWrite(leftTurnPin, LOW);
}




// BLINKERS OFF: ---------------------------------------------------------------


void blinkersOff(){
  digitalWrite(rightTurnPin, HIGH);
  digitalWrite(leftTurnPin, HIGH);
}




// HORN: ------------------------------------------------------------------------


void hornOn(){
  digitalWrite(hornPin, LOW);
}


void hornOff(){
  digitalWrite(hornPin, HIGH);
}




// STARTER: ---------------------------------------------------------------------


void starterOn(){
  digitalWrite(startPin, LOW);
}


void starterOff(){
  digitalWrite(startPin, HIGH);
}




/* / KILLSWITCH: ------------------------------------------------------------------


void killOn(){
  digitalWrite(killPin, LOW);
}


void killOff(){
  digitalWrite(killPin, HIGH);
}
*/




/* / HEADLIGHT: ------------------------------------------------------------------


void headlightOn(){
  digitalWrite(headlightPin, LOW);
}


void headlightOff(){
  digitalWrite(headlightPin, HIGH);
}
*/



//  END OF CODE (FOR NOW)```

Primero que nada, por favor edita tu post y adjunta el código de acuerdo a las Normas del foro, punto7. Es para tu beneficio.

EDITADO

Para lo que quieres que haga estimo que solo basta con cambiar

leftButton.Update();
if (leftButton.depressed == true){leftTurnActive = true;}
else leftTurnActive = false;

rightButton.Update();
if (rightButton.depressed == true){rightTurnActive = true;}
else rightTurnActive = false;

por

leftButton.Update();
if (leftButton.depressed == true) leftTurnActive = !leftTurnActive;

rightButton.Update();
if (rightButton.depressed == true) rightTurnActive = !rightTurnActive;

y cuéntame si resultó como quieres.

Muchas gracias por el consejo sobre mi post y por la ayuda con el código. voy a probarlo y te comento si funciona como quiero.
Muchas gracias

Acabo de probarlo y funciona pero hay veces que tengo que pulsar varias veces para pararlo. le doy cuando el led de la placa de relés esta encendida no se apaga pulsando pero si pulso cuando esta pagada se apaga a la primera.

Edité la primer parte del post anterior porque estaba equivocado.

Después reviso el código y veo que puede ser, teneme paciencia.

Algunas redundancias en tu código.

  1. Para que usas esta variable y otras similares si la función ya te da el estado?
  if (startButton.depressed) {
    startActive = true;
  }
  else 
    startActive = false;

Si justamente startButton.depressed tiene el estado sea true o false? No esta mal, pero es redundante. Es como decir a = true o false y luego pones b = a y todas las comparaciones las haces con b.
Y repites ese criterio con cada switch o pulsador involucrado.

Mira lo que hace la librería

void ClickButton::Update()
{
  long now = (long)millis();      // get current time
  _btnState = digitalRead(_pin);  // current appearant button state

  // Make the button logic active-high in code
  if (!_activeHigh) _btnState = !_btnState;

  // If the switch changed, due to noise or a button press, reset the debounce timer
  if (_btnState != _lastState) _lastBounceTime = now;


  // debounce the button (Check if a stable, changed state has occured)
  if (now - _lastBounceTime > debounceTime && _btnState != depressed)
  {
    depressed = _btnState;              //<==== OBSERVA ESTO 
    if (depressed) _clickCount++;
  }

//<==== OBSERVA ESTO
Muestra que depressed dentro de la estructura se comporta como una variable que almacena el estado sin rebotes del pulsador.

Ahora bien en el caso este de Left y Right buttons claramente esta jusfificado usar otra variable para poder alternar su comportamiento.

  1. Ahora mira esto en tus definiciones
#define frontCtrlPin A0
#define rightCtrlPin A0

dos pines con el mismo pin asignado.

Además frontContrlPin no se usa para nada.
Asigne a rightCtrlPin a 13

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.