Contador con control infrarrojo

Estimados saludos a todos, les comento estoy ayudando a una ONG para tener una barra de led que se apague a medida que corra el tiempo, para que los niños sepan cuanto de la terapia les queda, he logrado armar el hardware (que es lo mio) pero estoy detenido en la programación, logre dar el tiempo con la variable "long" y dejar el tiempo definido, pero me gustaría mediante un control IR poder setear el tiempo de cambio, no que quede fijo en el programa; osea si coloco en el control (encendido, 10, ok, cada led se apague en 10 minutos) como ejemplo. Y un otro botón para reiniciar todo.

Desde ahora muy agradecido por su tiempo...

La librería IRremote tiene ejemplos muy simples y útiles como para que resuelvas tu problema.
Porque no nos planteas el código que estas usando con ella y te guiamos.
Basicamente a menos que tengas un controla con 10 teclas y las identifiques 1 a 1 no podras hacer eso.
La otra posiblidades es que tengas un control con una o 2 teclas, una sube y la otra baja. cuando presioinas 1 sube y aumentas un contador y cuando lo haces con la otra bajas y lo decrementas.
Asi puedes comenzar con tu contador en 0 e ir subiendo hasta 10 y no pasarte y lo mismo con la tecla que lo hace descender.
Es solo una introducción.

Muchas gracias, lo del control puedo usar los dos e inclusive un RF, adjunto lo que tengo copiado hasta ahora. Ademas agrego la base para el conexionado, ahora le puse transistores y mayor cantidad de LED y de distintos colores, pero el principio es el mismo.

 const int PinInterruptor=8;//Entrada de sensor
unsigned long PreviousTime=0;//Using the unsigned long variable as expleined before
int InterruptorState=0;//Initialtating variables
int PreviousStateInterruptor=0;
int Led=2;//Variable used to count which LED will be the next on lighting
long TimeIntervalocadaLed=100000;//tiempo de encendido de los LED
int c=0;
void setup() {
 for(int x=2;x<8;x++){
  pinMode(x,OUTPUT); //Stablishing all the LEDs as outputs
 }
 pinMode(PinInterruptor,INPUT); //Interruptor del sensor
}

void loop() {
 unsigned long ActualTime=millis();//Knowing how long the program has been working
 if(ActualTime-PreviousTime>TimeIntervalocadaLed){ //Veryfing if has transcurred the required time to switvh on another LED
  PreviousTime=ActualTime;
  digitalWrite(Led,HIGH);//Lighting a new LED
  Led++;//Preparing to light the next one
  if(Led==7){ //Tiempo del LED FINAL
    delay(1000);
    c=0;
    while(c<8){
     for(int x=2;x<8;x++){
      digitalWrite(x,LOW);
     }
     delay(1000);
     for(int x=2;x<8;x++){
      digitalWrite(x,HIGH);
     } 
     delay(1000);
     c++;  
    }
  }
 }
 InterruptorState=digitalRead(PinInterruptor); //Read sensor state
  if(InterruptorState !=PreviousStateInterruptor){ //Puting all variables at zero if the state has changed
    for(int x=2;x<8;x++){
     digitalWrite(x,LOW);
    }
    Led=2;
    PreviousTime=ActualTime;
  }
  PreviousStateInterruptor=InterruptorState; //Stablishing the actual state as the previous one
}

Se que estas empezando y por ese motivo seré digamos considerador a la hora de juzgarte pero… observa esto:

 unsigned long ActualTime=millis();   // Esto habilita una linea para usar milli()
 if(ActualTime-PreviousTime>TimeIntervalocadaLed){ //Veryfing if has transcurred the required time to switvh on another LED
  PreviousTime=ActualTime;             // aca tomas el tiempo de millis()
  digitalWrite(Led,HIGH);//Lighting a new LED
  Led++;//Preparing to light the next one
  if(Led==7){ //Tiempo del LED FINAL
    delay(1000);                             // si vas a usar millis() que hace delay()?

Si usas millis() no uses delay(). Son como cosas opuestas.

Uno deja que el programa fluya (millis) y el otro lo detiene (delay)

Asi que todo de un lado o de otro.
Si eliges delay() olvidate de contestar a un IR o un comando de radio hasta que se termine la secuencia, por eso la respuesta es obvia, millis() y máquinas de estado

todo eso esta explicado en Documentación => Indice de temas tutoriales => millis y maquinas de estados

Leelo y luego conversamos.

Hola Mr_Markus. Un par de preguntas. ¿Cual el el tiempo mínimo y el máximo que quieres controlar? ¿Cuántos LED es el máximo que piensas poner? Lo pregunto porque, por ejemplo, si el tiempo máximo son 20 minutos, podrías poner 20 LED multiplexados.

Después, con un pulsador vas pulsando y encendiendo los LED uno a uno. Por cada LED que enciendas es un minuto. Si quieres contar 5 minutos, pulsas 5 veces y se encienden 5 LED. Una vez establecido el tiempo (un minuto por cada LED encendido), pulsas otro botón y entonces se encienden todos los LED (los veinte en este ejemplo) y según va transcurriendo el tiempo se van apagando. Si has "programado" 5 minutos, se apagaría un LED cada 15 segundos. Si programas 20 minutos se apagará uno cada minuto.

Para "reiniciarlo" podrías tener otro pulsador o el mismo con el que lo programas, si lo mantienes pulsado, te serviría para ponerlo a cero y volver a programarlo.

Para saber si está en marcha o no, yo haría que los LED parpadearan cuando estás configurando el tiempo y una vez que pones en marcha la cuenta regresiva mantenerlos fijo. Sobre todo si el tiempo que programas coincide con la cantidad de LED que tienes, ya que al estar todos encendidos no sabrías si está en marcha o todavía está en "modo programación".

Te ahorrarías el mando a distancia (que siempre se pierde), sería fácil de usar, puedes programar el tiempo que quieras (a intervalos de un minuto) y tienes una fácil visualización del tiempo que programas.

Claro está que todo esto lo haría usando millis() y máquinas de estado. En este mismo foro hay información de ello en español: Índice de temas Tutoriales es un post con la recopilación de tutoriales.

Me gusta tu proyecto pero, como habrás observado, no coincido con tu idea de cómo hacerlo. Te he dado una sugerencia sin que nadie me la pidiera.

Gracias por sus respuestas, quiero colocar 6 paneles de LEDS de alto brillo, que quede una barra de unos 60 cm de largo, la idea es colocarlo en una piscina donde los niños realizan terapias, por lo tanto el medico los introduce y lo acompaña, de ahí la necesidad que pueda controlarlo de forma remota, para no dejarlos solo.

El tiempo puede variar de 5 a 25 minutos.

Agradezco su comprensión con mi falta de programación, este es mi primer proyecto que requiere escribir el código completamente.

Atento a sus comentarios.

A que distancia estará el operador de los paneles? Tengo dudas de la eficacia de un sistema IR por la longitud de la pileta.
Podria ser un modulo nRF24 tal vez o bien BT pero creo que estariamos limitados en distancia tmb o WIFI.

Solo para el caso nRF24 no se aplica pero BT o WIFI podria usar un Celular y una App.

Por la situación que indicas creo que lo mejor seria por RF, ya que deben ser unos 30 metros, lo otro no se que tan buena opción seria el bluetooth, primero por tener un teléfono en una piscina temperada y los dedos mojados. Estaba pensando por ejemplo en un control como los de portones eléctricos o alarmas automotrices que fácilmente se puede colocar en una bolsa hermética.

Sigo atento...

Volvamos a algo mas simple. Aunque el nRF24 es pequeño y lo puedes acomodar no veo la manera de que hagas todo eso.
Seria mejor algo mas simple como un pulsador como los que he visto del tipo alarma y que del otro lado un receptor mas arduino haga lo que tenga que hacer con los paneles.
No recuerdo como se llama el TX y el RX pero el RX (receptor) tenia 4 canales y salian por pines. CUando alguien lo lea sabrá de lo que hablo.
Creo que tiene alcance suficiente.

Con el tema IR tendrias que hacer una prueba.. con algo, un control Remoto y el IR detector de Arduino a ver si lo ve a la distancia de 30 mts. No lo aseguro y tmb debería ser muy direccional.
Estas cosas se traducen en problemas.

Descartemos el celular por cuestiones de humedad a incomodidad.
Solo nos queda usar algo que no se daña en presencia de tanta humedad y del agua.

LO encontré!! No es una belleza pero es algo.
1set IC 2262/2272 4 canales 315Mhz llave inalámbrico Kits de Control remoto módulo receptor para arduino

Como verás tiene 4 botones y eso te permite subir bajar y dos cosas mas.

A ver que te parece. Tal vez exista algo mejor.

Enormemente agradecido, creo que no existe una mejor opción, es económico de reemplazar en caso de perdida, de buen tamaño, y con la cantidad de botones suficientes. Deje pedido un par por eBay para poder seguir avanzando...

Tengo la idea que dos botones permitan aumentar o disminuir el tiempo en incrementos de 5 minutos, y que estos se vayan reflejando en los led que se enciendan (6 led, 5 minutos cada uno) para la configuración inicial, después otro botón para confirmar el programa, y otro para inicio/pausa. Una vez corriendo el programa que el tiempo se refleje en todos los led y se apaguen a medida que se va descontando.

Estoy atento a sus comentarios.

Bien, ya he ayudado antes a alguien (o creo haberlo hecho) con uno similar.
No habrá problemas.

Hola a todos, pedí el modulo RF que habían mencionado, el problema fue que me llego otro... pero creo que fue para mejor, envés de ser de 4 vías (5v, TX, Rx y GND), me llego uno que funciona de modo directo, osea tiene 4 vías que pasan a HI cuando se presiona el botón que corresponde. El modulo es XD-YK04. Creo que facilita mucho el proyecto.

Atento a sus comentarios.

Si ese fue creo el que usó el otro forero.
Será muy simple considera todo como entradas de pulsadores, tal que se ponen en HIGH cuando se presionan.
Siempre estan en LOW y cuando presionas estan en HIGH. Es muy facil.

Estimados, esto es lo que he podido “lograr” hasta el momento… vendría a ser el setup del cronometro visual, cada vez que presiono el botón del control se enciende un led adicional y si pulso otro botón del control es en sentido descendente, la duda seria como, al presionar otro botón comience a correr otro programa y que este sea en función a la cantidad de pulsaciones dadas antes.

static const int EnablePin = 13;
int contador9, contador11; // Variables enteras.
int contador=0;     // Variable contador igual a cero
int cambio=5;
int inicio10;
int reinicio12;

#define pin9 9   // Pulsador control suma
#define pin11 11   // Pulsador control resta
#define pin10 10 // Pulsador inicio - pausa
#define pin12 12 // Reinicio

#define LED2 2
#define LED3 3
#define LED4 4
#define LED5 5
#define LED6 6
#define LED7 7


void setup() {
  pinMode(pin9, INPUT);     // El pin9 será entrada.
  pinMode(pin11, INPUT);     // El pin11 será entrada.
  pinMode(pin10, INPUT);     // El pin 10 será entrada.
  pinMode(pin12, INPUT);     // El pin 10 será entrada. 
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
  pinMode(LED5, OUTPUT);
  pinMode(LED6, OUTPUT);
  pinMode(LED7, OUTPUT);
  Serial.begin(9600);        // Para ver información en el Serial Monitor.
  pinMode (EnablePin, OUTPUT);    //Encender receptor, solo por comodidad de montaje
  digitalWrite (EnablePin, HIGH);
}

void loop() {
  contador9 = digitalRead(pin9); // Suma
  contador11 = digitalRead(pin11); // Resta
  inicio10 = digitalRead(pin10); // Inicio
  reinicio12 =digitalRead(pin12); //Reinicio

  
if (contador9 == HIGH) { 
  contador = contador + 5;  
  if (contador > 30) {
  contador=30;
  }
  
} 
if (contador11 == HIGH) { 
  contador = contador - 5;
  if (contador < 0) {
  contador=0;
  }
                             
} 

   Serial.print(contador);

  if (contador >= cambio*1){ // 5 minutos
   digitalWrite(LED2, HIGH); 
   }
      else
  {
   digitalWrite(LED2, LOW); 
  }
      if (contador >= cambio*2){ // 10 minutos
   digitalWrite(LED3, HIGH); 
   }
      else
  {
   digitalWrite(LED3, LOW); 
  }   
      if (contador >= cambio*3){ // 15 minutos
   digitalWrite(LED4, HIGH); 
   }
      else
  {
   digitalWrite(LED4, LOW); 
  }   
      if (contador >= cambio*4){ // 20 minutos
   digitalWrite(LED5, HIGH); 
   }
      else
  {
   digitalWrite(LED5, LOW);  
  }   
      if (contador >= cambio*5){ // 25 minutos
   digitalWrite(LED6, HIGH); 
   }
      else
  {
   digitalWrite(LED6, LOW); 
  }
      if (contador >= cambio*6){ // 30 minutos
   digitalWrite(LED7, HIGH); 
   }
      else
  {
   digitalWrite(LED7, LOW); 
  }   
   delay(300); // Retardo entre pulsaciones.

}

Muy agradecido como siempre por sus aportes…

Si usas delay() no te quejes que luego la cosa reaccione con lentitud.
Lee como usar millis() y máquinas de estado para que eso no ocurra. Esta en Documentación, indice de temas tutoriales.

Ok, lo había puesto solamente por que decían que eliminaba el efecto rebote del cambio de señal del interruptor....

Lo saco y pruebo

Una solucion simple es usar la librería Bounce.h

Y este es un ejemplo

#include <Bounce2.h>

#define BUTTON_PIN 2
#define LED_PIN 13

// Instantiate a Bounce object
Bounce debouncer = Bounce(); 

void setup() {

  // Setup the button with an internal pull-up :
  pinMode(BUTTON_PIN,INPUT_PULLUP);

  // After setting up the button, setup the Bounce instance :
  debouncer.attach(BUTTON_PIN);
  debouncer.interval(5); // interval in ms

  //Setup the LED :
  pinMode(LED_PIN,OUTPUT);

}

void loop() {
  // Update the Bounce instance :
  debouncer.update();

  // Get the updated value :
  int value = debouncer.read();

  // Turn on or off the LED as determined by the state :
  if ( value == LOW ) {
    digitalWrite(LED_PIN, HIGH );
  } 
  else {
    digitalWrite(LED_PIN, LOW );
  }

}

Esta todo hecho con millis() asi que le dices el tiempo que quieres para evitar los rebotes y lo hace sin consumirte tiempo del microcontrolador.
Te aconsejo que no uses tiempos superiores a 50 mseg para pulsadores comunes y si fueran reles entonces si puedes considerar mayores.