Problemas con leds que titilan y no deberían hacerlo

Estimados,
He copiado de una revista este código que les dejo que lo que hace es leer el estado de dos sensores IRC y si alguno se acciona pasa el semáforo de verde a rojo. Si se acciona el otro pasa de rojo a amarillo y luego a verde.
Hasta acá todo funciona muy bien pero el detalle es que los leds en vez de quedar encendido titilan y no entiendo porque?
Podrían ayudarme? GRACIAS!!!!

int sensePin1 = A0;
int sensePin2 = A1;
int RED = 22;
int YELLOW = 24;
int GREEN = 28;


void setup() {
  Serial.begin(9600);
  pinMode(RED, OUTPUT);
  pinMode(YELLOW, OUTPUT);
  pinMode(GREEN, OUTPUT);
}
enum SIGNALSTATES
{
  ST_GREEN,
  ST_RED1,
  ST_RED2,
  ST_YELLOW,
};

SIGNALSTATES signalState = ST_GREEN;

void loop() {
  int valA1 = analogRead(sensePin1);
  int valA2 = analogRead(sensePin2);
  Serial.println(valA1);
  Serial.println(valA2);
  delay(300);

  switch (signalState)
  {
    case ST_GREEN:
      if (valA1 < 500 && valA2 > 500) {
        signalState = ST_RED1;
      }
      else if (valA1 > 500 && valA2 < 500) {
        signalState = ST_RED2;
      }
      digitalWrite(GREEN, LOW);
      digitalWrite(RED, HIGH);
      digitalWrite(YELLOW, HIGH);
      Serial.println("GREEN");
      break;

    case ST_RED1:
      if (valA1 > 500 && valA2 < 500) {
        signalState = ST_YELLOW;
      }
      digitalWrite(GREEN, HIGH);
      digitalWrite(RED, LOW);
      digitalWrite(YELLOW, HIGH);
      Serial.println("RED1");
      break;

    case ST_RED2:
      if (valA1 < 500 && valA2 > 500) {
        signalState = ST_YELLOW;
      }
      digitalWrite(GREEN, HIGH);
      digitalWrite(RED, LOW);
      digitalWrite(YELLOW, HIGH);
      Serial.println("RED2");
      break;

    case ST_YELLOW:
      if (valA1 > 500 && valA2 > 500) {
        signalState = ST_GREEN;
      }
      digitalWrite(GREEN, HIGH);
      digitalWrite(RED, HIGH);
      digitalWrite(YELLOW, LOW);
      delay(1000);
      Serial.println("Yellow");
      break;
  }
}



Todo depende de los dos sensores IR, los tienes conectados entre 0 y 5V no es cierto con cursor a A1 y el otro potenciómetro a A2.
Los sensores IR deberían tener su barrera o sea, hablo de un emisor y un receptro. Ese receptor es digital o sea SI o NO, LOW o HIGH, algo muy próximo a 0 o a 1023 pero no entiendo para que usa analgoRead(sensorPin) cuando un digitalRead(sensorPin) era mucho mejor.

int sensePin1 = A0;
int sensePin2 = A1;
int RED       = 22;
int YELLOW    = 24;
int GREEN     = 28;
int valA1, valA2;


void setup() {
  Serial.begin(9600);
  pinMode(sensePin1, INPUT);
  pinMode(sensePin2, INPUT);
  pinMode(RED   , OUTPUT);
  pinMode(YELLOW, OUTPUT);
  pinMode(GREEN , OUTPUT);
}
enum SIGNALSTATES {
  ST_GREEN,
  ST_RED1,
  ST_RED2,
  ST_YELLOW,
};

SIGNALSTATES signalState = ST_GREEN;

void loop() {
  valA1 = digitalRead(sensePin1);
  valA2 = digitalRead(sensePin2);
  Serial.println(valA1);
  Serial.println(valA2);
  delay(300);

  switch (signalState)   {
    case ST_GREEN:
                  if (valA1 == LOW && valA2 == HIGH) {
                      signalState = ST_RED1;
                  }
                  else if (valA1 == HIGH && valA2 == LOW) {
                          signalState = ST_RED2;
                  }
                  digitalWrite(GREEN  , LOW);
                  digitalWrite(RED    , HIGH);
                  digitalWrite(YELLOW , HIGH);
                  Serial.println("GREEN");
                  break;

    case ST_RED1:
                  if (valA1 == HIGH && valA2 == LOW) {
                      signalState = ST_YELLOW;
                  }
                  digitalWrite(GREEN  , HIGH);
                  digitalWrite(RED    , LOW);
                  digitalWrite(YELLOW , HIGH);
                  Serial.println("RED1");
                  break;

    case ST_RED2:
                  if (valA1 == LOW && valA2 == HIGH) {
                      signalState = ST_YELLOW;
                  }
                  digitalWrite(GREEN  , HIGH);
                  digitalWrite(RED    , LOW);
                  digitalWrite(YELLOW , HIGH);
                  Serial.println("RED2");
                  break;

    case ST_YELLOW:
                  if (valA1 == HIGH && valA2 == HIGH) {
                      signalState = ST_GREEN;
                  }
                  digitalWrite(GREEN  , HIGH);
                  digitalWrite(RED    , HIGH);
                  digitalWrite(YELLOW , LOW);
                  delay(1000);
                  Serial.println("Yellow");
                  break;
  }
}

Dime si funciona igual o sigue parpadeando.

Así tal cual está con digitalRead, funciona igual que el anterior. Siguen titilando

Consulta, puede que las salidas se reseteen por algún motivo y esto genere que los leds destellen?

¿No tendrás interferencia de la luz ambiente?

El código está bien.

Lo que no entiendo del código es para qué discrimina cuál sensor cambia a rojo si la secuencia es la misma en ambos casos (con la salvedad que solo cambia la salida por consola).

Tenes un sensor de entrada y otro de salida. Cuando pasa por el primer sensor entrada, activa el semáforo a rojo y cuando llega al otro pone este en amarillo y luego del delay en verde.
Que puede provocar que los leds titilen dentro del loop? Algo de ahí, en el bucle los resetea o les hace algo que los hace destellar.

¿Y si "ingresa" al revés tiene que hacer lo mismo?
Por eso no entiendo cual es el sentido de discriminar, porque la secuencia de LEDs para un lado u otro es la misma, solo cambia lo que sale por serial.

El código es correcto, no hay forma que parpadeen por culpa del código, por eso te pregunté

Otra cosa no se me ocurre.

Si, del lado que ingrese activa y saliendo desactiva el semáforo. La verdad que no entiendo que es lo que los hace titilar. Pueden ser los sensores IR ??? No, la interferencia de luz debería bajar los valores del IR y no lo hacen.

Si, pueden ser los sensores.

Si tienes puedes probar con 2 pulsadores simulando a los sensores, vas a ver que funciona bien.

El delay() en la opcion yellow es innecesario y puede traerte problemas (no es causa de parpadeo, aclaro)

Ayer probé quitando directamente los sensores y el problema persiste. Me parece que es un tema más de reseteo de puertos. No tengo idea como hacer funcionar correctamente este diseño. Se te ocurre otro? El delay para el paso de amarillo a verde es un tema para que el que venga atrás baje la velocidad y no se estampe contra el tren de adelante. Estos circuitos deberían trabajar encadenados.

Resolví el problema cambiando todos los leds y reescribiendo el código. Alguna de las dos cosas tuvo efecto!

Pues el código no era el problema porque lo probé salvo que como no tengo los IR probé con pulsadores.

Sube el código nuevo así vemos las diferencias (y queda como ayuda para que alguien que tenga el mismo problema).

Saludos

Para mi las condiciones deberias ponerlas luego del delay, permitiendo que se cumplan y que al menos permanezcan 1 seg y luego si, se da la condicion pasa a otro estado.
Al ponerlas al comienzo vives saltando de estado en estado.

int sensePin1 = A0;
int sensePin2 = A1;
int RED = 6;
int YELLOW = 5;
int GREEN = 3;
int POWER = 8;

unsigned long wentYellowTime;

void setup() {
  pinMode(sensePin1, INPUT);
  pinMode(sensePin2, INPUT);
  pinMode(RED, OUTPUT);
  pinMode(YELLOW, OUTPUT);
  pinMode(GREEN, OUTPUT);
  pinMode(POWER, OUTPUT);

  signalgreen();
  digitalWrite(POWER, HIGH);

}

enum SIGNALSTATES
{
  ST_GREEN,
  ST_RED1,
  ST_RED2,
  ST_YELLOW,
};
SIGNALSTATES signalState = ST_GREEN;


void loop() {
  int valA1 = digitalRead(sensePin1);
  int valA2 = digitalRead(sensePin2);
  delay(200);

  switch (signalState)
  {
    case ST_GREEN:
      if (valA1 == LOW && valA2 == HIGH) {
        signalred();
        signalState = ST_RED1;
      }
      if (valA1 == HIGH && valA2 == LOW) {
        signalred();
        signalState = ST_RED2;
      }
      break;

    case ST_RED1:
      if (valA1 == HIGH && valA2 == LOW) {
        signalyellow();
        signalState = ST_YELLOW;
      }
      break;

    case ST_RED2:
      if (valA1 == LOW && valA2 == HIGH) {
        signalyellow();
        signalState = ST_YELLOW;
      }
      break;

    case ST_YELLOW:
      if (millis() - wentYellowTime > 5000 or valA1 == LOW or valA2 == LOW) {
        signalgreen();
        signalState = ST_GREEN;
      }
      break;
  }
}

void signalgreen() {
  digitalWrite(GREEN, LOW);
  digitalWrite(RED, HIGH);
  digitalWrite(YELLOW, HIGH);
}


void signalred() {
  digitalWrite(GREEN, HIGH);
  digitalWrite(RED, LOW);
  digitalWrite(YELLOW, HIGH);
}


void signalyellow() {
  wentYellowTime = millis();

  digitalWrite(GREEN, HIGH);
  digitalWrite(RED, HIGH);
  digitalWrite(YELLOW, LOW);
}

A mi criterio había un problema con los pines análogos en vez de digitales y por otro lado algún problema con los juegos de leds.

Los pines análogos puedes usarlos como digitales de modo que no puede haber problema.
No se qué problema puedes tener con los LEDs y no digo que yo tengo la razón, pero es lo mismo que un pin I/O que puede ser usado como PWM te de problemas.
Los pines hoy tienen multiplicidad de funciones, y debes creer que los analogicos menos A6 y A7 en el NANO funcionan perfectamente como I/Os (entrada/salida digital).

Ver Analog input pins

¿De casualidad probaste los LEDs individualmente?
¿No seran LEDs intermitentes?

Me mataste.. no sabía que existían!!

Si, hace años!

Mirá, por ejemplo Led 5mm Intermitente...

Los pruebo con una batería y funcionan bien, los pongo en el arduino y titilan. No recuerdo haber comprado ese tipo de leds. El tema que realicé el cambio de leds por otros que tenía guardados y funcionan ok.