Diferenciar pulso corto y largo en una entrada

hola, tengo un problema con este código, agradecería que pudieran ayudarme.
Quisiera que el valor de dos salidas varíen, dependiendo del tiempo que se ha mantenido su pulsador correspondiente pulsado, en la salida tengo un led que se ilumina por un tiempo.
Tengo dos problemas:
1- No puedo pulsar dos veces seguidas el mismo pulsador, para poder pulsar uno dos veces tengo que pulsar el otro entre medias.
2- el led del pulzador IZQ no enciende.

Gracias de antemano.


float pulso_dcho;
float pulso_izq;

float tiempo1 = 0;
float tiempo2 = 0;
int led_dcho = 9;
int led_izq = 11;

void setup ()
{
  Serial.begin (9600);
}

void loop ()
{
  // derecho
  pulso_dcho = pulseIn (8, HIGH, 100000000);
  tiempo1 = pulso_dcho / 1000000;

   if (tiempo1 < 0.35) {                     // si tiempo pulso izquierdo es menor de 0.35 seg
    Serial.print (" pulso_dcho corto: ");   
    Serial.print (tiempo1);
    Serial.println (" segundos");
    digitalWrite (led_dcho, HIGH);          // encendemos led
    delay(200);                             //esperamos  0.20 segundos
    digitalWrite (led_dcho, LOW);           //apagamos led

  }

    else if (tiempo1 > 0.35) {                    // si tiempo pulso izquierdo es mayor de 0.35 seg
     Serial.print ("pulso_dcho largo: ");
     Serial.print (tiempo1);
     Serial.println (" segundos");
     digitalWrite (led_dcho, HIGH);          // encendemos led
     delay(700);                            //esperamos  0.70 segundos
     digitalWrite (led_dcho, LOW);           //apagamos led
    }
    
      else if (tiempo1 = 0.35) {                    // si tiempo pulso izquierdo es igual de 0.35 seg
        Serial.print ("pulso_dcho largo: ");
        Serial.print (tiempo1);
        Serial.println (" segundos");
        digitalWrite (led_dcho, HIGH);          // encendemos led
        delay(700);                            //esperamos  0.70 segundos
        digitalWrite (led_dcho, LOW);           //apagamos led
     }
  
    // izquerdo
   pulso_izq = pulseIn (10, HIGH, 100000000);
   tiempo2 = pulso_izq / 1000000;

   if (tiempo2 < 0.35) {                    // si tiempo pulso izquierdo es menor de 0.35 seg
     Serial.print (" pulso_izq corto: ");
     Serial.print (tiempo2);
     Serial.println (" segundos");
     digitalWrite (led_izq, HIGH);          // encendemos led
      delay(200);                            //esperamos  0.20 segundos
      digitalWrite (led_izq, LOW);           //apagamos led
    }
      else if (tiempo2 > 0.35) {                    // si tiempo pulso izquierdo es mayor de 0.35 seg
       Serial.print ("pulso_izq largo: ");
        Serial.print (tiempo2);
         Serial.println (" segundos");
         digitalWrite (led_izq, HIGH);          // encendemos led
         delay(700);                            //esperamos  0.70 segundos
         digitalWrite (led_izq, LOW);           //apagamos led
       }
         else if (tiempo2 = 0.35) {                    // si tiempo pulso izquierdo es igual de 0.35 seg
          Serial.print ("pulso_izq largo: ");
           Serial.print (tiempo2);
           Serial.println (" segundos");
           digitalWrite (led_izq, HIGH);          // encendemos led
           delay(700);                            //esperamos  0.70 segundos
           digitalWrite (led_izq, LOW);           //apagamos led
                      
   }
  }

Para no cambiarte la forma en que lo has encarado (me refiero a usar pulseIn()) te marco un par de cosas.

El 3er parámetro de pulseIn() es el timeout o tiempo de espera.
Tu has puesto un timeout de 100000000 useg, o sea, 100 seg (lo que es 1 min 40 seg) por lo tanto cada vez que llamas a pulseIn() se queda 1 min 40 seg esperando que pulses un botón.

Yo empezaría por reducir el timeout, total a la velocidad en que se ejecuta el código es difícil que no detecte una pulsación (en este caso particular, la cosa cambia si el programa es más complejo). Por defecto, sin poner el 3er parámetro, espera 1 seg (pero puedes poner menos tiempo si lo prefieres).

Por otro lado haces 3 comparaciones, < 0.35, > 0.35 e = 0.35 pero, si lo piensas bien, si no es menor a 0.35 entonces solo puede ser mayor o igual.
Luego, ya que la secuencia es la misma en ambos casos, solo necesitas hacer esto

if (tiempo1 < 0.35) {                     // si tiempo pulso izquierdo es menor de 0.35 seg
    Serial.print (" pulso_dcho corto: ");   
    Serial.print (tiempo1);
    Serial.println (" segundos");
    digitalWrite (led_dcho, HIGH);          // encendemos led
    delay(200);                             //esperamos  0.20 segundos
    digitalWrite (led_dcho, LOW);           //apagamos led
}
else  {                    // si tiempo pulso izquierdo es mayor o igual a 0.35 seg
     Serial.print ("pulso_dcho largo: ");
     Serial.print (tiempo1);
     Serial.println (" segundos");
     digitalWrite (led_dcho, HIGH);          // encendemos led
     delay(700);                            //esperamos  0.70 segundos
     digitalWrite (led_dcho, LOW);           //apagamos led
}

y lo mismo para el otro botón

Gatul gracias por la respuesta, al reducir el código como me sugeriste el led izquierdo si enciende.( cuando vi tu sugerencia , entendí que no hay que rizar el rizo).
Pero el fallo de los pulsadores sigue igual, no puedo pulsar el mismo dos veces e incluso he visto que al bajar "timeout" , da un pulso cada vez que termina el ciclo de espera de 0,00 segundos , primero con pulsador derecho y pasado otro ciclo con el izquierdo,asi indefinidamente.

dejo el código modificado pero sin cambiar el tiempo de espera.

float pulso_dcho;
float pulso_izq;
float tiempo1 = 0;
float tiempo2 = 0;
int led_dcho = 9;
int led_izq = 11;

void setup (){
 
  Serial.begin (9600);
}

void loop (){
  
  // derecho
  pulso_dcho = pulseIn (8, HIGH,100000000);
  tiempo1 = pulso_dcho / 1000000;
  
   if (tiempo1 < 0.35) {                     // si tiempo pulso izquierdo es menor de 0.35 seg
    Serial.print (" pulso_dcho corto: ");   
    Serial.print (tiempo1);
    Serial.println (" segundos");
    digitalWrite (led_dcho, HIGH);          // encendemos led
    delay(200);                             //esperamos  0.20 segundos
    digitalWrite (led_dcho, LOW);           //apagamos led

  }
    else   {                    // si tiempo pulso izquierdo es mayor o igual a 0.35 seg
        Serial.print ("pulso_dcho largo: ");
        Serial.print (tiempo1);
        Serial.println (" segundos");
        digitalWrite (led_dcho, HIGH);          // encendemos led
        delay(700);                            //esperamos  0.70 segundos
        digitalWrite (led_dcho, LOW);           //apagamos led
    }
    
    
  
    // izquerdo
   pulso_izq = pulseIn (10, HIGH,100000000);
   tiempo2 = pulso_izq / 1000000;

   if (tiempo2 < 0.35) {                    // si tiempo pulso izquierdo es menor de 0.35 seg
     Serial.print (" pulso_izq corto: ");
     Serial.print (tiempo2);
     Serial.println (" segundos");
     digitalWrite (led_izq, HIGH);          // encendemos led
     delay(200);                            //esperamos  0.20 segundos
     digitalWrite (led_izq, LOW);           //apagamos led
    }
      else {                                 // si tiempo pulso izquierdo es mayor o igual a 0.35 seg
          Serial.print ("pulso_izq largo: ");
         Serial.print (tiempo2);
         Serial.println (" segundos");
         digitalWrite (led_izq, HIGH);          // encendemos led
         delay(700);                            //esperamos  0.70 segundos
         digitalWrite (led_izq, LOW);           //apagamos led
     }
  }

Le pusiste una resistencia a masa a los pines de los botones?

si cada pulsador

Creo que el pulso que se genera solo no afectara si le pongo un tiempo de espera de un par de minutos, debido a que los pulsadores serán accionados en intervalos de no más de 1 minuto.
El problema que si me afecta es que no puedo accionar el mismo pulsador seguido varias veces.
Graxias de nuevo.

He reescrito tu código usando lo que siempre uso que es medir flancos, cuando pasas de 0 a 1 es el momento en que presionas el pulsador y cuando sueltas pasa de 1 a 0.
Solamente viendo los flancos no te quedas esperando a que pulseIn que para mi es una mala función o mejor dicho, se suele emplear mal justamente por el ABUSO del timeout.
Acá no hay timeout y no pierdo nada.
Lo unico para mejor es que la rutina que prende los leds podria estar en una maquina de estados pero no vale la pena

float tpulso1, dpulso1;
float tpulso2, dpulso2;
const int bDerecho    = 8;
const int led_dcho    = 9;
const int bIzquierdo  = 10;
const int led_izq     = 11;
int estadoD, estadoDAnt = false;
int estadoI, estadoIAnt = false;
bool ledDcho, ledIzqdo;

void setup () {
  Serial.begin (9600);
  pinMode(bDerecho, INPUT);
  pinMode(bDerecho, INPUT);
  pinMode(led_dcho, OUTPUT);
  pinMode(led_izq, OUTPUT);
  
}

void loop () {
  // derecho
  estadoD = digitalRead(bDerecho);
  if (estadoD && !estadoDAnt) {
      tpulso1 = millis();
  }
  if (!estadoD && estadoDAnt) {
      dpulso1 = (millis() - tpulso1)/1000;
      //Serial.println("Duracion pulso dcho :" + String(dpulso1));
      ledDcho  = true;
      ledIzqdo = false;
  }
  estadoDAnt = estadoD;

  estadoI = digitalRead(bIzquierdo);
  if (estadoI && !estadoIAnt) {
      tpulso2 = millis();
  }
  if (!estadoI && estadoIAnt) {
      dpulso2 = (millis() - tpulso2)/1000;
      //Serial.println("Duracion pulso izqdo :" + String(dpulso2));
      ledDcho  = false;
      ledIzqdo = true;
  }
  estadoIAnt = estadoI;

  if (ledDcho)
      if (dpulso1 < 0.35) {
          Serial.println("pulso dcho corto: " + String(dpulso1) + " seg");
          prendoLed(200, 0);
      }
      else if (dpulso1 >= 0.35) {
              Serial.println("pulso dcho largo: " + String(dpulso1) + " seg");
              prendoLed(700, 0);
      }
   if (ledIzqdo)
      if (dpulso2 < 0.35) {
           Serial.println("pulso izquierdo corto: " + String(dpulso2) + " seg");
           prendoLed(200, 1);
      }
      else if (dpulso2 >= 0.35) {
              Serial.println("pulso izquierdo largo: " + String(dpulso2) + " seg");
              prendoLed(700, 1);
      }
  ledIzqdo = false;
  ledDcho  = false;
}

void prendoLed(int tiempo, int led) {

  int tmp = led==1?led_izq:led_dcho;
  digitalWrite (tmp, HIGH);          // encendemos led
  delay(tiempo);                    //esperamos  0.70 segundos
  digitalWrite (tmp, LOW);           //apagamos led
}

Muchas gracias Surbyte y Gatul por vuestra ayuda y consejos, el código ha funcionado perfecto, ahora intentare con el aprender las nuevas funciones y referencias como (millis _ String y crear void prendoled) para poder entender mejor el código.
Como principiante en este mundo tengo una duda, no se si puedo preguntarla aqui o debo crear otro tema,. Gracias por vuestra ayuda

Si, claro, agota tus dudas y nunca crees nuevos temas si estan relacionados con este.
Terminas un tema lo cierras o me avisas para hacerlo y luego puedes con otro que NADA tenga que ver con este.

Te explico cuál es el problema de tu código original.
Por un lado, no me había dado cuenta que nunca definiste los pines de los LED como salida (los otros 2 como por defecto son entradas, pasan).

Por otro, y también fue mala mía, pulseIn() si no detecta pulso devuelve 0. Entonces se cumplía tu igualdad a 0 y también mi < 0.35, y eso estaba mal porque 0 es ausencia de pulso.

Finalmente ¿por qué no reconoce doble pulsación?
Como te dije antes, el culpable es el timeout.

Suponte que pulsas el boton1.
Enciende el LED y espera 700 mseg sin hacer nada.
Luego espera 1 min 40 seg que pulses el boton2
Si no lo pulsas, enciende el LED (porque te daría un falso pulso de 0 seg) y espera 700 mseg.
Vuelve al principio del loop().

Y acá 2 detalles.
Enciende el LED de casualidad, porque como lo que debería ser salida sigue siendo entrada, al poner en HIGH se habilita la resistencia pull-up, y la corriente que circula por la resistencia permite (de pura suerte) que tu LED encienda. Al poner LOW se deshabilita la pull-up y el LED se apaga.

Segundo detalle.
¿Qué pasa si vuelves a pulsar el boton1, digamos, 20 seg después de la primera pulsación?
Nada, no pasa nada porque todavía no pasaron los 100 seg de espera para que pulses el boton2.
Y por eso mismo solo reacciona si primero pulsas el otro botón, porque al detectar la pulsación se da por terminado el tiempo de espera y el programa sigue su curso.

Lamento que antes no estaba con todas las luces y te pasé un código erróneo, que arrastró otros errores y que, si bien vi lo del timeout, no lo analicé en profundidad como ahora.
En mi defensa, aca en Bs. As. eran las 3 AM. :wink:

Saludos

Gatul no tienes que disculparte, agradezco la ayuda prestada y el echo de que me expliques los fallos que he tenido para que los entienda son de agradecer, tiene que ser muy dificil ayudarnos y más cuando somos novatos como mi caso, ya que en mi cabeza tengo la idea de lo que quiero que haga el código, y puede que no lo explique con todos los datos necesarios. Gracias nuevamente

Refiriéndome a la duda que le comenté a Surbyte, estoy montando un pinball para mi hijo y por no tener experiencia he creído que sería mejor hacer varios códigos y montar varias partes independientes:
Resumiendo

1_codigo. Bola extra ( para obtener una bola extra hay que llegar a 30 puntos los cuales se consiguen por medio de los pasillo donde unos suman y otros restan, al llegar a 30 puntos una bobina actúa abre una puerta y la bola se recupera cuando fallas)

2_codigo. Flipper( el código de surbyteque hemos tratado en este tema)

3_codigo. Dianas( para ganar la partida debes de dar a 10 dianas mínimo 1 vez)

Y almenos otro más para controlar algunos led y resetear la partida cuando se gane o pierda.

Pero he visto que si no consigo unificarlo todo tendré que usar varios arduinos. Mi pregunta es si es posible unificarlo todo y utilizar una sola placa o como se dice, empeze la casa por el tejado.

Gracias.

Por favor ahora que leo dianas no me digas que es el mismo tema!! por dios, no hagas doble posteo. Debes unir tus temas.

Ya cerré el otro hilo.

Ok, ,perdona por eso fue el preguntar, no estaba seguro.

Los códigos que tengo son estos, mi pregunta es si se pueden unir o es preferible hacerlo por separado. Gracias.

BOLA EXTRA

//VARIABLES CONTADOR

const int  pulsador_asc = 2;    // pin 2 como entrada para el contador de pulsos 
                                // ascendentes
const int  pulsador_des = 3;    // pin 3 como entrada para el contador de pulsos
                                // descendentes
                                
const int led_rojo = 4;          // Pin 4  como salida 
const int led_verde = 5;          // Pin 5  como salida 

int numero_pulsos = 30;


//VARIABLES PARA EL CONTADOR ASCENDIENTE

int contador            = 0;   // contador para el numero de veces presinados
int estado_pulsador_asc = 0;         // estado actual del pulsador
int lastButtonState_asc = 1;     // estado anterior del pulsador

//VARIABLES PARA EL CONTADOR DESCENDIENTE
// estas variables si puede ser cambiado

int estado_pulsador_des = 0;         // estado actual del pulsador
int lastButtonState_des = 1;     // estado anterior del pulsador

//VARIABLES PUERTA

const int puerta_pasillo = 6;
const int  pulsador_pasillo = 7;    // pin 7 como entrada para el contador de pulso 
int estado_pulsador_pasillo = 0;         // estado actual del pulsador
int lastButtonState_pasillo = 1;     // estado anterior del pulsador

void setup() {
  Serial.begin(9600);
  
 
  //SETUP CONTADOR
  pinMode(pulsador_asc, INPUT_PULLUP); //Resistencia de pullup interna
  pinMode(pulsador_des, INPUT_PULLUP); //Resistencia de pullup interna
  pinMode(led_rojo, OUTPUT);
  pinMode (led_verde,OUTPUT);

  //SETUP PUERTA
  pinMode(pulsador_pasillo, INPUT_PULLUP); //Resistencia de pullup interna
  pinMode (puerta_pasillo,OUTPUT);
  digitalWrite(puerta_pasillo,HIGH);
}

void loop(){
  //  almacenamos la lectura de la entrada de pin 3
  estado_pulsador_asc = digitalRead(pulsador_asc);
  estado_pulsador_des = digitalRead(pulsador_des);

  // comparar el estado del botón a su estado anterior
  if (estado_pulsador_asc != lastButtonState_asc) {
    // si el estado fue cambiado, incremente el conteo
    if (estado_pulsador_asc == HIGH) {
      // si el estado actual es alto, entonces 
      // que pase de off a on:
      contador++;
      Serial.println("+");
      Serial.print("numero de veces presionado");
      Serial.println(contador);
      delay(100);
    } 
  }
 lastButtonState_asc  = estado_pulsador_asc;
   // comparar el estado del botón a su estado anterior
  if (estado_pulsador_des != lastButtonState_des ) {
    // si el estado fue cambiado, decrementa el conteo
    if (estado_pulsador_des == HIGH) {
      // si el estado actual es alto, entonces 
      // que pase de off a on:
      contador -- ;
      contador -- ;
      contador -- ;
      contador -- ;
      contador -- ;
      Serial.println("-");
      Serial.print("numero de veces presionado");
      Serial.println(contador);
      delay(100);
    } 
  }
  //guarda el último estado actual como el ultimo estado
  //para el proximo bucle
  lastButtonState_des  = estado_pulsador_des;

  
  if (contador >= numero_pulsos) {
    digitalWrite(led_rojo, LOW);
    digitalWrite(led_verde,true); 
    if (estado_pulsador_pasillo >=1) {
     digitalWrite(puerta_pasillo, LOW);
     delay(1000);
      if(contador >= numero_pulsos) {
      contador = 0;
    } 
  }   
 }
estado_pulsador_pasillo = digitalRead(pulsador_pasillo);
  //estado_pulsador_des = digitalRead(pulsador_des);

  // comparar el estado del botón a su estado anterior
  if (estado_pulsador_pasillo != lastButtonState_pasillo) {
    // si el estado fue cambiado, incremente el conteo
    if (estado_pulsador_pasillo == HIGH) {
      // si el estado actual es alto, entonces 
      // que pase de off a on:
      //contador++;
      //Serial.println("+");
      //Serial.print("numero de veces presionado");
      //Serial.println(contador);
      //delay(100);
    } 
  }
 lastButtonState_pasillo  = estado_pulsador_pasillo;
   // comparar el estado del botón a su estado anterior
  //if (estado_pulsador_des != lastButtonState_des ) {
    // si el estado fue cambiado, decrementa el conteo
    //if (estado_pulsador_des == HIGH) {
      // si el estado actual es alto, entonces 
      // que pase de off a on:
      //contador--;
      //Serial.println("-");
      //Serial.print("numero de veces presionado");
      //Serial.println(contador);
      //delay(100);
    //} 
  //}
  //guarda el último estado actual como el ultimo estado
  //para el proximo bucle
 // lastButtonState_des  = estado_pulsador_des
        digitalWrite(puerta_pasillo,true);   
        digitalWrite(led_rojo, HIGH);
        digitalWrite(led_verde,false); 
  }

Codigo FLIPPER

float tpulso1, dpulso1;
float tpulso2, dpulso2;
const int bDerecho    = 8;
const int led_dcho    = 9;
const int bIzquierdo  = 10;
const int led_izq     = 11;
int estadoD, estadoDAnt = false;
int estadoI, estadoIAnt = false;
bool ledDcho, ledIzqdo;

void setup () {
  Serial.begin (9600);
  pinMode(bDerecho, INPUT);
  pinMode(bDerecho, INPUT);
  pinMode(led_dcho, OUTPUT);
  pinMode(led_izq, OUTPUT);
  
}

void loop () {
  // derecho
  estadoD = digitalRead(bDerecho);
  if (estadoD && !estadoDAnt) {
      tpulso1 = millis();
  }
  if (!estadoD && estadoDAnt) {
      dpulso1 = (millis() - tpulso1)/1000;
      //Serial.println("Duracion pulso dcho :" + String(dpulso1));
      ledDcho  = true;
      ledIzqdo = false;
  }
  estadoDAnt = estadoD;

  estadoI = digitalRead(bIzquierdo);
  if (estadoI && !estadoIAnt) {
      tpulso2 = millis();
  }
  if (!estadoI && estadoIAnt) {
      dpulso2 = (millis() - tpulso2)/1000;
      //Serial.println("Duracion pulso izqdo :" + String(dpulso2));
      ledDcho  = false;
      ledIzqdo = true;
  }
  estadoIAnt = estadoI;

  if (ledDcho)
      if (dpulso1 < 0.35) {
          Serial.println("pulso dcho corto: " + String(dpulso1) + " seg");
          prendoLed(200, 0);
      }
      else if (dpulso1 >= 0.35) {
              Serial.println("pulso dcho largo: " + String(dpulso1) + " seg");
              prendoLed(700, 0);
      }
   if (ledIzqdo)
      if (dpulso2 < 0.35) {
           Serial.println("pulso izquierdo corto: " + String(dpulso2) + " seg");
           prendoLed(200, 1);
      }
      else if (dpulso2 >= 0.35) {
              Serial.println("pulso izquierdo largo: " + String(dpulso2) + " seg");
              prendoLed(700, 1);
      }
  ledIzqdo = false;
  ledDcho  = false;
}

void prendoLed(int tiempo, int led) {

  int tmp = led==1?led_izq:led_dcho;
  digitalWrite (tmp, LOW);          // encendemos led
  delay(tiempo);                    //esperamos  0.70 segundos
  digitalWrite (tmp, HIFG);           //apagamos led
}

y codigo DIANAS

int premio= 12; // salida del comparador
int numero_entradas = 10 ; //Cantidad de pines a usar
int entrada[] = {13,14,15,16,17,20,21,22,23,24}; //Pines digitales para las entradas
bool estados[] = {false,false,false,false,false,false,false,false,false,false};
boolean salida= false;


void setup(){
 
  pinMode(premio, OUTPUT);
  for (int i = 0; i < numero_entradas; i++){ //Se configuran los pines como entradas
    pinMode(entrada[i], INPUT);
  }
}
void loop(){
 
  salida= true;
  for (int i = 0; i < numero_entradas; i++){ 
    if (digitalRead(entrada[i])== HIGH) estados[i]= true;
  }
   for (int i = 0; i < numero_entradas; i++){
   salida = salida && estados[i];
  }
  digitalWrite(premio,salida);
  
}

Se supone (como yo lo hago) que todo tiene el mismo objetivo. Si lo tiene entonces debes unir códigos para que todo responda a tu meta.
Por eso verás que SIEMPRE PREGONO que no se use delay(). Si en uno de los códigos tuvieras delay o esos while() que terminan actuando de la misma manera que el delay() al unir tus códigos solo verás que esa parte demora todo lo demás.

En el código que dice BOLA extra tienes delay(1000) y delay(100), ambas cosas no ccontribuirán a la fluidéz de las demas porciones de código DIANA y FLIPPER.

Gracias Surbyte, modificaré los delay() , le echaré un vistazo a millis().

Requiere de trabajo en particular quitar los delay() que te he indicado en cada caso, delay(100) y delay(1000) pero el código ahora tiene todos los códigos unidos

// BOLA
const int  pulsador_asc = 2;    // pin 2 como entrada para el contador de pulsos 
                                // ascendentes
const int  pulsador_des = 3;    // pin 3 como entrada para el contador de pulsos
                                // descendentes
                                
const int led_rojo      = 4;          // Pin 4  como salida 
const int led_verde     = 5;          // Pin 5  como salida 

int numero_pulsos       = 30;


//VARIABLES PARA EL CONTADOR ASCENDIENTE
int contador            = 0;   // contador para el numero de veces presinados
int estado_pulsador_asc = 0;         // estado actual del pulsador
int lastButtonState_asc = 1;     // estado anterior del pulsador

//VARIABLES PARA EL CONTADOR DESCENDIENTE
// estas variables si puede ser cambiado

int estado_pulsador_des     = 0;     // estado actual del pulsador
int lastButtonState_des     = 1;     // estado anterior del pulsador

//VARIABLES PUERTA

const int puerta_pasillo    = 6;
const int  pulsador_pasillo = 7;    // pin 7 como entrada para el contador de pulso 
int estado_pulsador_pasillo = 0;         // estado actual del pulsador
int lastButtonState_pasillo = 1;     // estado anterior del pulsador

float tpulso1, dpulso1;
float tpulso2, dpulso2;
const int bDerecho          = 8;
const int led_dcho          = 9;
const int bIzquierdo        = 10;
const int led_izq           = 11;
int estadoD, estadoDAnt     = false;
int estadoI, estadoIAnt     = false;
bool ledDcho, ledIzqdo;

int premio                  = 12; // salida del comparador
int numero_entradas         = 10 ; //Cantidad de pines a usar
int entrada[] = {13,14,15,16,17,20,21,22,23,24}; //Pines digitales para las entradas
bool estados[] = {false,false,false,false,false,false,false,false,false,false};
boolean salida= false;

void bola();
void flipper();
void dianas();

void setup () {
 
  Serial.begin(9600);
    
  //SETUP CONTADOR
  pinMode(pulsador_asc, INPUT_PULLUP); //Resistencia de pullup interna
  pinMode(pulsador_des, INPUT_PULLUP); //Resistencia de pullup interna
  pinMode(led_rojo, OUTPUT);
  pinMode (led_verde,OUTPUT);

  //SETUP PUERTA
  pinMode(pulsador_pasillo, INPUT_PULLUP); //Resistencia de pullup interna
  pinMode (puerta_pasillo,OUTPUT);
  digitalWrite(puerta_pasillo,HIGH);
  
  pinMode(premio, OUTPUT);
  for (int i = 0; i < numero_entradas; i++){ //Se configuran los pines como entradas
      pinMode(entrada[i], INPUT);
  }
}

void loop(){
  bola();
  flipper();
  dianas();
}  

void bola() {
  //  almacenamos la lectura de la entrada de pin 3
  estado_pulsador_asc = digitalRead(pulsador_asc);
  estado_pulsador_des = digitalRead(pulsador_des);

  // comparar el estado del botón a su estado anterior
  if (estado_pulsador_asc != lastButtonState_asc) {
      // si el estado fue cambiado, incremente el conteo
      if (estado_pulsador_asc == HIGH) {
          // si el estado actual es alto, entonces 
          // que pase de off a on:
          contador++;
          Serial.println("+");
          Serial.print("numero de veces presionado");
          Serial.println(contador);
          delay(100);   // quitar este delay usando millis()
      } 
  }
  lastButtonState_asc  = estado_pulsador_asc;
  // comparar el estado del botón a su estado anterior
  if (estado_pulsador_des != lastButtonState_des ) {
    // si el estado fue cambiado, decrementa el conteo
    if (estado_pulsador_des == HIGH) {
        // si el estado actual es alto, entonces 
        // que pase de off a on:
        contador -= 5;
        Serial.println("-");
        Serial.print("numero de veces presionado");
        Serial.println(contador);
        delay(100);         // quitar este delay usando millis()
     } 
  }
  // guarda el último estado actual como el ultimo estado
  // para el proximo bucle
  lastButtonState_des  = estado_pulsador_des;
 
  if (contador >= numero_pulsos) {
      digitalWrite(led_rojo, LOW);
      digitalWrite(led_verde,true); 
      if (estado_pulsador_pasillo >=1) {
          digitalWrite(puerta_pasillo, LOW);
          delay(1000); // quitar este delay usando millis()
          if (contador >= numero_pulsos) {
              contador = 0;
          } 
      }   
 }
  estado_pulsador_pasillo = digitalRead(pulsador_pasillo);
  //estado_pulsador_des = digitalRead(pulsador_des);

  // comparar el estado del botón a su estado anterior
  if (estado_pulsador_pasillo != lastButtonState_pasillo) {
    // si el estado fue cambiado, incremente el conteo
    if (estado_pulsador_pasillo == HIGH) {
      // si el estado actual es alto, entonces 
      // que pase de off a on:
      //contador++;
      //Serial.println("+");
      //Serial.print("numero de veces presionado");
      //Serial.println(contador);
      //delay(100);
    } 
  }
 lastButtonState_pasillo  = estado_pulsador_pasillo;
   // comparar el estado del botón a su estado anterior
  //if (estado_pulsador_des != lastButtonState_des ) {
    // si el estado fue cambiado, decrementa el conteo
    //if (estado_pulsador_des == HIGH) {
      // si el estado actual es alto, entonces 
      // que pase de off a on:
      //contador--;
      //Serial.println("-");
      //Serial.print("numero de veces presionado");
      //Serial.println(contador);
      //delay(100);
    //} 
  //}
  //guarda el último estado actual como el ultimo estado
  //para el proximo bucle
 // lastButtonState_des  = estado_pulsador_des
        digitalWrite(puerta_pasillo,true);   
        digitalWrite(led_rojo, HIGH);
        digitalWrite(led_verde,false); 
}
// FLIPPER

void flipper() {
  // derecho
  estadoD = digitalRead(bDerecho);
  if (estadoD && !estadoDAnt) {
      tpulso1 = millis();
  }
  if (!estadoD && estadoDAnt) {
      dpulso1 = (millis() - tpulso1)/1000;
      //Serial.println("Duracion pulso dcho :" + String(dpulso1));
      ledDcho  = true;
      ledIzqdo = false;
  }
  estadoDAnt = estadoD;

  estadoI = digitalRead(bIzquierdo);
  if (estadoI && !estadoIAnt) {
      tpulso2 = millis();
  }
  if (!estadoI && estadoIAnt) {
      dpulso2 = (millis() - tpulso2)/1000;
      //Serial.println("Duracion pulso izqdo :" + String(dpulso2));
      ledDcho  = false;
      ledIzqdo = true;
  }
  estadoIAnt = estadoI;

  if (ledDcho)
      if (dpulso1 < 0.35) {
          Serial.println("pulso dcho corto: " + String(dpulso1) + " seg");
          prendoLed(200, 0);
      }
      else if (dpulso1 >= 0.35) {
              Serial.println("pulso dcho largo: " + String(dpulso1) + " seg");
              prendoLed(700, 0);
      }
   if (ledIzqdo)
      if (dpulso2 < 0.35) {
           Serial.println("pulso izquierdo corto: " + String(dpulso2) + " seg");
           prendoLed(200, 1);
      }
      else if (dpulso2 >= 0.35) {
              Serial.println("pulso izquierdo largo: " + String(dpulso2) + " seg");
              prendoLed(700, 1);
      }
  ledIzqdo = false;
  ledDcho  = false;
}

void prendoLed(int tiempo, int led) {

  int tmp = led==1?led_izq:led_dcho;
  digitalWrite (tmp, LOW);          // encendemos led
  delay(tiempo);                    //esperamos  0.70 segundos
  digitalWrite (tmp, HIGH);           //apagamos led
}

// DIANAS
void dianas(){

  salida = true;
  for (int i = 0; i < numero_entradas; i++){ 
       if (digitalRead(entrada[i])== HIGH) 
           estados[i]= true;
  }
  for (int i = 0; i < numero_entradas; i++){
       salida = salida && estados[i];
  }
  digitalWrite(premio,salida);
}

Buenas, siento el no responder en estos días, he estado un poco atareado, me ha surgido un problema,cuando el pin 5 que es el led_verde esta en estado HIGH he observado que prende con muy poca intensidad y al medir voltaje la salida es de 2.2 v. Para hacer pruebas he sustituido el led por un modulo rele y este no actúa. Una vez cargado el código lo he conectado con una fuente de alimentación independiente de 1 amperios al arduino y a un solo rele, y tampoco me ha funcionado.¿ sabéis cual puede ser el Problema?
Gracias de antemano.

El rele es de estado inverso y para que funcione le cambio al código los "true" por "false" en el led_verde