Combinar libreria IR "Luis Llamas" con comandos "delay".

International Español Software
1

Buenas noches,

Llevo ya unos dias intentando combinar el uso de un mando IR y un sensor IR para controlar unos LED y me topo con el problema de que los comandos "delay' introducidos para que los LED realicen dibujos encendiendose y apagandose simultaneamente según el botón que se pulse en el mando, chocan con la lectura que realiza el sensor IR. Hay algún otro tipo de comandos que pueda usar que no me fastidien el funcionamiento del IR pero me permitan jugar con el encendido y apagado de los distintos LED?

Gracias.

2

Se supone que deberías de usar millis() en lugar de delay() y una máquina de estados. Pero no es trivial. En la consulta alarma temporizada en un mismo led al presionar un botón explico (más o menos) cómo hacerlo para el problema que plantean. Es bastante larga la explicación y no sé si te servirá. De todas formas, ¿puedes poner el código de lo que tienes hecho para ver si se te puede ayudar mejor?

3

IgnoranteAbsoluto:
Se supone que deberías de usar millis() en lugar de delay() y una máquina de estados. Pero no es trivial. En la consulta alarma temporizada en un mismo led al presionar un botón explico (más o menos) cómo hacerlo para el problema que plantean. Es bastante larga la explicación y no sé si te servirá. De todas formas, ¿puedes poner el código de lo que tienes hecho para ver si se te puede ayudar mejor?

int LED1 = 2;
int LED2 = 3;
int LED3 = 4;
int LED4 = 5;
int LED5 = 6;
int LED6 = 7;
int LED7 = 8;
int LED8 = 9;
int LED9 = 10;

const int KEY_1 =       ;
const int KEY_2 =       ;
const int KEY_3 =       ;
const int KEY_4 =       ;
const int KEY_5 =       ;
const int KEY_6 =       ;
const int KEY_7 =       ;
const int KEY_8 =       ;
const int KEY_9 =       ;
const int KEY_0 =       ;

const int RECV_PIN = 1;
IRrecv irrecv (RECV_PIN);
decode_results results;


void setup() {
  Serial.begin (9600);
  irrecv.enableIRIn();
  pinMode (LED1 , OUTPUT);
  pinMode (LED2 , OUTPUT);
  pinMode (LED3 , OUTPUT);
  pinMode (LED4 , OUTPUT);
  pinMode (LED5 , OUTPUT);
  pinMode (LED6 , OUTPUT);
  pinMode (LED7 , OUTPUT);
  pinMode (LED8 , OUTPUT);
  pinMode (LED9 , OUTPUT);
}

void loop() {
  if (irrecv.decode(&results));
  {
    switch (results.value)
    {
      case KEY_1:
         digitalWrite (LED1 , HIGH);
         delay (200);
         digitalWrite (LED1 , LOW);
         delay (200);
         digitalWrite (LED2 , HIGH);
         delay (200);
         digitalWrite (LED2 , LOW);
         delay (200);
         digitalWrite (LED3 , HIGH);
         delay (200);
         digitalWrite (LED3 , LOW);
         delay (200);
         digitalWrite (LED4 , HIGH);
         delay (200);
         digitalWrite (LED4 , LOW);
         delay (200);
         digitalWrite (LED5 , HIGH);
         delay (200);
         digitalWrite (LED5 , LOW);
         delay (200);
         digitalWrite (LED6 , HIGH);
         delay (200);
         digitalWrite (LED6 , LOW);
         delay (200);
         digitalWrite (LED7 , HIGH);
         delay (200);
         digitalWrite (LED7 , LOW);
         delay (200);
         digitalWrite (LED8 , HIGH);
         delay (200);
         digitalWrite (LED8 , LOW);
         delay (200);
         digitalWrite (LED9 , HIGH);
         delay (200);
         digitalWrite (LED9, LOW);
         break;
      case KEY_2:
      
         break;
      case KEY_3:

         break;
      case KEY_4:

         break;
      case KEY_5:

         break;
      case KEY_6:

         break;
      case KEY_7:

         break;
      case KEY_8:

         break;
      case KEY_9:

         break;
      case KEY_0:

         break;
         
     }
       irrecv.resume();
  }
    
}

Lo que pretendo hacer es que unos se enciendan simultaniamente segun pase el tiempo cuando se aprete un botón concreto del mando IR. Aún queda mucho programa por escribir, si jajajajajaj.

Gracias.

4

Bueno tienes 17 delays de 200 mseg o sea 17x200mseg = 3400 mseg o 3.4 seg.

Tu presionas KEY_1 y el sistema no responde hasta 3.4 seg después, eso es lo que quieres?

5

Bueno, lo que pretendo es que tras pulsar KEY_1 la secuencia de encendido y apago de leds se inicie. La secuencia va de encendido y apagado del led 1 a encedido y apagado del led 2 y así sucesivamente hasta el ultimo led.

Además no sé como compaginar el funcioniento de estos leds con el funcionamiento del sensor ir para que los delay no me fastidien la lectura ir.

Gracias.

6

¿Y qué quieres que hagan KEY_2, KEY_3, KEY_4, etc?

Porque hacerlo con una máquina de estado no es muy difícil, pero sí algo enrevesado. Y si no se tiene claro qué ha de hacer la máquina de estados es mucho más difícil.

7

Quiero que el resto de KEY_# realicen secuencias distintas.

Gracias.

8

Aquí tienes un boceto de máquina de estados que hace la secuencia que has puesto. Es para que te hagas una idea. Se podría optimizar y no tener tantos estados, teniendo objetos (con sus propias máquinas de estados y variables auxiliares) que se encarguen de las secuencias que quieres mostrar.

int LED1 = 2;
int LED2 = 3;
int LED3 = 4;
int LED4 = 5;
int LED5 = 6;
int LED6 = 7;
int LED7 = 8;
int LED8 = 9;
int LED9 = 10;

const int KEY_1 =       ;
const int KEY_2 =       ;
const int KEY_3 =       ;
const int KEY_4 =       ;
const int KEY_5 =       ;
const int KEY_6 =       ;
const int KEY_7 =       ;
const int KEY_8 =       ;
const int KEY_9 =       ;
const int KEY_0 =       ;

const int RECV_PIN = 1;
IRrecv irrecv (RECV_PIN);
decode_results results;

enum estado_t {
  ESTADO_ESPERANDO_IR,
  ESTADO_KEY_1_PASO_1,
  ESTADO_KEY_1_PASO_2,
  ESTADO_KEY_1_PASO_3,
  ESTADO_KEY_1_PASO_4,
  ESTADO_KEY_1_PASO_5,
  ESTADO_KEY_1_PASO_6,
  ESTADO_KEY_1_PASO_7,
  // Aquí falta por "declarar" todos los estados que necesites
}

estado_t estado = ESTADO_ESPERANDO_IR; // <-- para saber en qué estado está la máquina de estados (por defecto está esperando un comando IR)
unsigned long instanteCambio; // <-- para saber cuando se cambió de estado por última vez

void setEstado(estado_t nuevoEstado) {  // Función para cambiar de estado y actualizar el instante del cambio
  estado = nuevoEstado;
  instanteCambio = millis();
}

void setup() {
  Serial.begin (9600);
  irrecv.enableIRIn();
  pinMode (LED1 , OUTPUT);
  pinMode (LED2 , OUTPUT);
  pinMode (LED3 , OUTPUT);
  pinMode (LED4 , OUTPUT);
  pinMode (LED5 , OUTPUT);
  pinMode (LED6 , OUTPUT);
  pinMode (LED7 , OUTPUT);
  pinMode (LED8 , OUTPUT);
  pinMode (LED9 , OUTPUT);
}

void loop() {
  unsigned long transcurrido = millis() - instanteCambio; // Calculamos cuanto tiempo ha trascurrido desde el último cambio
  if (irrecv.decode(&results));
  {
    if (estado == ESTADO_ESPERANDO_IR) { // Sólo si está esperando un comando IR pasamos ha hacer algo, si no es así, lo descartamos
      switch (results.value)
      {
        case KEY_1: // En caso de ser el comando adecuado
           setEstado(ESTADO_KEY_1_PASO_1);  // Pasamos al estado del primer paso del comando
           break;

        case KEY_2:
           setEstado(ESTADO_KEY_2_PASO_1);
           break;
       
        case KEY_3:
           setEstado(ESTADO_KEY_3_PASO_1);
           break;

        case KEY_4:
           setEstado(ESTADO_KEY_4_PASO_1);
           break;

        case KEY_5:
           setEstado(ESTADO_KEY_5_PASO_1);
           break;

        case KEY_6:
           setEstado(ESTADO_KEY_6_PASO_1);
           break;

        case KEY_7:
           setEstado(ESTADO_KEY_7_PASO_1);
           break;

        case KEY_8:
           setEstado(ESTADO_KEY_8_PASO_1);
           break;

        case KEY_9:
           setEstado(ESTADO_KEY_9_PASO_1);
           break;

        case KEY_0:
           setEstado(ESTADO_KEY_0_PASO_1);
           break;
       }
    }
    irrecv.resume();
  }
   
  switch (estado) // Procesamos el estado actual
  {
    case ESTADO_ESPERANDO_IR: // Si está esperando a recibir algo, no hace nada
       break;

    case ESTADO_KEY_1_PASO_1: // Encender el LED1 y pasar a esperar a que pase el tiempo para apagar el LED1
       digitalWrite (LED1 , HIGH);
       setEstado(ESTADO_KEY_1_PASO_2); // Pasa al estado de esperar a apagar el LED1
       break;

    case ESTADO_KEY_1_PASO_2: // Esperamos a que pase el tiempo y entonces apagamos el LED1 y esperamos para encender el LED2
       if (transcurrido >= 200) {
         digitalWrite (LED1 , LOW);
         setEstado(ESTADO_KEY_1_PASO_3); // Pasa al estado de esperar a encender el LED2
       }
       break;

    case ESTADO_KEY_1_PASO_3: // Esperamos a que pase el tiempo y entonces encendemos el LED2 y esperamos para apagarlo
       if (transcurrido >= 200) {
         digitalWrite (LED2 , HIGH);
         setEstado(ESTADO_KEY_1_PASO_4); // Pasa al estado de esperar a apagar el LED2
       }
       break;

    case ESTADO_KEY_1_PASO_4: // Esperamos a que pase el tiempo y entonces apagamos el LED2 y esperamos para encender el LED3
       if (transcurrido >= 200) {
         digitalWrite (LED2 , LOW);
         setEstado(ESTADO_KEY_1_PASO_5); // Pasa al estado de esperar a encender el LED3
       }
       break;

    case ESTADO_KEY_1_PASO_5: // Esperamos a que pase el tiempo y entonces encendemos el LED2 y esperamos para apagarlo
       if (transcurrido >= 200) {
         digitalWrite (LED3 , HIGH);
         setEstado(ESTADO_KEY_1_PASO_6); // Pasa al estado de esperar a apagar el LED3
       }
       break;

    case ESTADO_KEY_1_PASO_6: // Esperamos a que pase el tiempo y entonces apagamos el LED3 y esperamos para encender el LED4
       if (transcurrido >= 200) {
         digitalWrite (LED3 , LOW);
         setEstado(ESTADO_KEY_1_PASO_7); // Pasa al estado de esperar a encender el LED4
       }
       break;

    case ESTADO_KEY_1_PASO_7: // Esperamos a que pase el tiempo y entonces encendemos el LED2 y esperamos para apagarlo
       if (transcurrido >= 200) {
         digitalWrite (LED4 , HIGH);
         setEstado(ESTADO_KEY_1_PASO_8); // Pasa al estado de esperar a apagar el LED4
       }
       break;

    case ESTADO_KEY_1_PASO_8: // Esperamos a que pase el tiempo y entonces apagamos el LED4 y esperamos para encender el LED5
       if (transcurrido >= 200) {
         digitalWrite (LED4 , LOW);
         setEstado(ESTADO_KEY_1_PASO_9); // Pasa al estado de esperar a encender el LED5
       }
       break;

    case ESTADO_KEY_1_PASO_9: // Esperamos a que pase el tiempo y entonces encendemos el LED2 y esperamos para apagarlo
       if (transcurrido >= 200) {
         digitalWrite (LED5 , HIGH);
         setEstado(ESTADO_KEY_1_PASO_10); // Pasa al estado de esperar a apagar el LED5
       }
       break;

    case ESTADO_KEY_1_PASO_10: // Esperamos a que pase el tiempo y entonces apagamos el LED5 y esperamos para encender el LED6
       if (transcurrido >= 200) {
         digitalWrite (LED5 , LOW);
         setEstado(ESTADO_KEY_1_PASO_11); // Pasa al estado de esperar a encender el LED6
       }
       break;

    case ESTADO_KEY_1_PASO_11: // Esperamos a que pase el tiempo y entonces encendemos el LED2 y esperamos para apagarlo
       if (transcurrido >= 200) {
         digitalWrite (LED6 , HIGH);
         setEstado(ESTADO_KEY_1_PASO_12); // Pasa al estado de esperar a apagar el LED6
       }
       break;

    case ESTADO_KEY_1_PASO_12: // Esperamos a que pase el tiempo y entonces apagamos el LED6 y esperamos para encender el LED7
       if (transcurrido >= 200) {
         digitalWrite (LED6 , LOW);
         setEstado(ESTADO_KEY_1_PASO_13); // Pasa al estado de esperar a encender el LED7
       }
       break;

    case ESTADO_KEY_1_PASO_13: // Esperamos a que pase el tiempo y entonces encendemos el LED2 y esperamos para apagarlo
       if (transcurrido >= 200) {
         digitalWrite (LED7 , HIGH);
         setEstado(ESTADO_KEY_1_PASO_14); // Pasa al estado de esperar a apagar el LED7
       }
       break;

    case ESTADO_KEY_1_PASO_14: // Esperamos a que pase el tiempo y entonces apagamos el LED7 y esperamos para encender el LED8
       if (transcurrido >= 200) {
         digitalWrite (LED7 , LOW);
         setEstado(ESTADO_KEY_1_PASO_15); // Pasa al estado de esperar a encender el LED8
       }
       break;

    case ESTADO_KEY_1_PASO_15: // Esperamos a que pase el tiempo y entonces encendemos el LED2 y esperamos para apagarlo
       if (transcurrido >= 200) {
         digitalWrite (LED8 , HIGH);
         setEstado(ESTADO_KEY_1_PASO_16); // Pasa al estado de esperar a apagar el LED8
       }
       break;

    case ESTADO_KEY_1_PASO_16: // Esperamos a que pase el tiempo y entonces apagamos el LED8 y esperamos para encender el LED9
       if (transcurrido >= 200) {
         digitalWrite (LED8 , LOW);
         setEstado(ESTADO_KEY_1_PASO_17); // Pasa al estado de esperar a encender el LED9
       }
       break;

    case ESTADO_KEY_1_PASO_17: // Esperamos a que pase el tiempo y entonces encendemos el LED2 y esperamos para apagarlo
       if (transcurrido >= 200) {
         digitalWrite (LED9 , HIGH);
         setEstado(ESTADO_KEY_1_PASO_18); // Pasa al estado de esperar a apagar el LED9
       }
       break;

    case ESTADO_KEY_1_PASO_18: // Esperamos a que pase el tiempo y entonces apagamos el LED9 y como es el último, pasamos al estado de espera
       if (transcurrido >= 200) {
         digitalWrite (LED9 , LOW);
         setEstado(ESTADO_ESPERANDO_IR); // Pasa al estado de esperar a recibir un nuevo comando de IR
       }
       break;

       // Aquí van más estados a tratar
  }
}
9

Que bueno. Escribir el programa como maquina de estados es muy util visto esto.

Muchas gracias por la ayuda y por la currada de este codigo!