Lograr endender y apagar Led en dos formas diferentes

Metaconta · November 26, 2014, 1:53am

Hola:

Quiero encender y apagar un Led tanto enviado comandos por puerto serie o USB del Arduino UNO r3 y interruptores o pulsadores al mismo tiempo, es decir, si por el puerto serie envio este comando.

Led1_ON, se encienda el Led 1.
Si pulso el interruptor o pulsador, que haga lo mismo.

Aquí tengo algo del código, espero que se entienda, así se modifica o mejora cosas que aún no logro.

#include <EEPROM.h>

int estadoBoton1 = 0; // Guarda el estado del botón en HIGH o LOW.
int estadoBoton2 = 0;
char caracter; // Alacenas carácteres de entrada.
String comando;
int pinLed1 =  9;   // Declaramos la variable pin del Led.
int pinLed2 =  8;
int pinLed3 =  7;
int pinLed4 =  6;
int pinLed5 =  5;
int pinLed6 =  4;
int pinLed7 =  3;
int pinLed8 =  2;
int Direccion = 0; // Dirección de memoria de la EEPROM.
byte Dato; // Dato de la EEPROM.
byte Dato2;

void setup()
{
  pinMode(pinLed1, OUTPUT);  // Inicializa el pin del Led 1 como salida.
  pinMode(pinLed2, OUTPUT);
  pinMode(pinLed3, OUTPUT);
  pinMode(pinLed4, OUTPUT);
  pinMode(pinLed5, OUTPUT);
  pinMode(pinLed6, OUTPUT);
  pinMode(pinLed7, OUTPUT);
  pinMode(pinLed8, OUTPUT);
  pinMode(A0,INPUT); // Salida digital para el Led 1.
  Serial.begin(115200); // Puerto serie 115200 baudios.
  delay(200); // Retardo 0,2 segundos.
  Serial.println(EEPROM.read(Direccion),DEC); // Imprime en pantalla la dirección en decimal.
  Dato2 = EEPROM.read(Direccion); // Lee la dirección y lo almacena en la variable Dato2.
    
    // Lee los datos almacenados en al EEPROM al iniciar el programa.
    switch (Dato2) 
    {
    case B0:
    digitalWrite(pinLed1, HIGH); // Enciende el Led 1.
    break;
    
    case B1:
    digitalWrite(pinLed1, LOW); // Apaga el Led 1.
    break;
    }
}

void loop()
{
  /* Leyendo carácter a carácter lo que se resive por el canal del puerto serie
  y los voy concatenando uno tras otro en una cedena. */
  while (Serial.available()>0)
  {
    caracter= Serial.read();
    comando.concat(caracter);
    delay(10);
  }
   
  // Si los carácteres es recibido y verdadero.
  if (comando.equals("Led1_ON") == true)
  {
    digitalWrite(pinLed1, HIGH); // Enciende el Led 1.
    Serial.println("El comando es Led1_ON"); // Muestra este mensaje en pantalla.
    Dato = B0; // Dato binario se almacena en la variable Dato.
    EEPROM.write(Direccion, Dato); // Escribe dirección y dato en la EEPROM.
  }   
  
  // Si los carácteres es recibido y verdadero.
  if (comando.equals("Led1_OFF")== true)
  {
    digitalWrite(pinLed1, LOW); // Apaga el Led 1.
    Serial.println("El comando es Led11_OFF"); // Muestra este mensaje en pantalla.
    Dato = B1; // Dato binario se almacena en la variable Dato.    
    EEPROM.write(Direccion, Dato); // Escribe dirección y dato en la EEPROM.
  }  
  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando="";
  
  // Interruptor físico.
  estadoBoton1 = digitalRead(A0);
  // Si detecta que el botón está pulsado, se enciende el Led 1.
  if (estadoBoton1 == HIGH)
    {
      digitalWrite(pinLed1, HIGH);
    }
  // Si no, no.
  else
    {
      digitalWrite(pinLed1, LOW);
    }  
}

Saludo.

gepd · November 26, 2014, 3:40am

He simplificado un poco lo que tenías, según lo que entendí debería ser algo más o menos así:
(sólo he modificado la función loop)

void loop()
{
  /* Leyendo carácter a carácter lo que se recibe por el canal del puerto serie
  y los voy concatenando uno tras otro en una cadena. */
  while (Serial.available()>0)
  {
    caracter= Serial.read();
    comando.concat(caracter);
    delay(10);
  }

  // Interruptor físico.
  estadoBoton1 = digitalRead(A0);
   
  
  if (comando.equals("Led1_ON") == true || estadoBoton1 == HIGH){         // Si los carácteres es recibido y verdadero o se ha presionado el botón físico.
    digitalWrite(pinLed1, HIGH);                                          // Enciende el Led 1.
    
    if(sizeof(comando) > 0){                                              // Si fue enviado por Serial
      Serial.println("El comando es Led1_ON");                            // Muestra este mensaje en pantalla.
      Dato = B0;                                                          // Dato binario se almacena en la variable Dato.
      EEPROM.write(Direccion, Dato);                                      // Escribe dirección y dato en la EEPROM.
    }
  }else if (comando.equals("Led1_OFF")== true || estadoBoton1 == LOW){    // Si los carácteres es recibido y verdadero o se ha presionado el botón físico..
    digitalWrite(pinLed1, LOW);                                           // Apaga el Led 1.
    
    if(sizeof(comando) > 0){                                              // Si fue enviado por Serial
      Serial.println("El comando es Led11_OFF");                          // Muestra este mensaje en pantalla.
      Dato = B1;                                                          // Dato binario se almacena en la variable Dato.    
      EEPROM.write(Direccion, Dato);                                      // Escribe dirección y dato en la EEPROM.
    }
  }  
  
  comando="";                                                             // Limpiamos la cadena para volver a recibir el siguiente comando.
}

Metaconta · November 26, 2014, 5:26am

Gracias por la ayuda.

Me ocurre dos cosas. Cuando le das al serial de Arduino IDE, me aparece todo el rato el mensaje uno tras otro, sin parar y tampoco me responde las intrucciones que les envío como por ahí para que cambie de estado.

El mensaje que aparece es este todo el rato.
El comando es Led1_ON

A pesar que el botón físico si funciona, los comandos Led1_ON y Led1_OFF no hacen nada.

El código es este:

#include <EEPROM.h>

int estadoBoton1 = 0; // Guarda el estado del botón en HIGH o LOW.
int estadoBoton2 = 0;
int estadoBoton3 = 0;
int estadoBoton4 = 0;
int estadoBoton5 = 0;
int estadoBoton6 = 0;
int estadoBoton7 = 0;
int estadoBoton8 = 0;
char caracter; // Alacenas carácteres de entrada.
String comando;
int pinLed1 =  9;   // Declaramos la variable pin del Led.
int pinLed2 =  8;
int pinLed3 =  7;
int pinLed4 =  6;
int pinLed5 =  5;
int pinLed6 =  4;
int pinLed7 =  3;
int pinLed8 =  2;
int Direccion = 0; // Dirección de memoria de la EEPROM.
byte Dato; // Dato de la EEPROM.
byte Dato2;

void setup()
{
  pinMode(pinLed1, OUTPUT);  // Inicializa el pin del Led 1 como salida.
  pinMode(pinLed2, OUTPUT);
  pinMode(pinLed3, OUTPUT);
  pinMode(pinLed4, OUTPUT);
  pinMode(pinLed5, OUTPUT);
  pinMode(pinLed6, OUTPUT);
  pinMode(pinLed7, OUTPUT);
  pinMode(pinLed8, OUTPUT);
  pinMode(A0,INPUT); // Salida digital para el Led 1.
  pinMode(A1,INPUT);
  pinMode(A2,INPUT);
  pinMode(A3,INPUT);
  pinMode(A4,INPUT);
  pinMode(A5,INPUT);
  Serial.begin(115200); // Puerto serie 115200 baudios.
  delay(200); // Retardo 0,2 segundos.
  Serial.println(EEPROM.read(Direccion),DEC); // Imprime en pantalla la dirección en decimal.
  Dato2 = EEPROM.read(Direccion); // Lee la dirección y lo almacena en la variable Dato2.
    
    // Lee los datos almacenados en al EEPROM al iniciar el programa.
    switch (Dato2) 
    {
    case B0:
    digitalWrite(pinLed1, HIGH); // Enciende el Led 1.
    break;
    
    case B1:
    digitalWrite(pinLed1, LOW); // Apaga el Led 1.
    break;
    }
}

void loop()
{
  /* Leyendo carácter a carácter lo que se resive por el canal del puerto serie
  y los voy concatenando uno tras otro en una cedena. */
  while (Serial.available()>0)
  {
    caracter= Serial.read();
    comando.concat(caracter);
    delay(10);
  }
   
   // Interruptor físico.
  estadoBoton1 = digitalRead(A0);
   
  
  if (comando.equals("Led1_ON") == true || estadoBoton1 == HIGH){         // Si los carácteres es recibido y verdadero o se ha presionado el botón físico.
    digitalWrite(pinLed1, HIGH);                                          // Enciende el Led 1.
    
    if(sizeof(comando) > 0){                                              // Si fue enviado por Serial
      Serial.println("El comando es Led1_ON");                            // Muestra este mensaje en pantalla.
      Dato = B0;                                                          // Dato binario se almacena en la variable Dato.
      EEPROM.write(Direccion, Dato);                                      // Escribe dirección y dato en la EEPROM.
    }
  }else if (comando.equals("Led1_OFF")== true || estadoBoton1 == LOW){    // Si los carácteres es recibido y verdadero o se ha presionado el botón físico..
    digitalWrite(pinLed1, LOW);                                           // Apaga el Led 1.
    
    if(sizeof(comando) > 0){                                              // Si fue enviado por Serial
      Serial.println("El comando es Led11_OFF");                          // Muestra este mensaje en pantalla.
      Dato = B1;                                                          // Dato binario se almacena en la variable Dato.    
      EEPROM.write(Direccion, Dato);                                      // Escribe dirección y dato en la EEPROM.
    }
  }  
  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando="";
}

Saludos.

gepd · November 26, 2014, 8:43am

Pensé nuevamente una manera diferente de ejecutar el código. Lo primero es que tenía una duda sin embargo, hice una modificación de como funciona el botón para poder obtener los resultados que deseas, de otra manera, no se me ocurre como podría haber funcionado

En este momento el botón enciende o apaga el led cada vez que se presiona, y no como antes que lo mantenía encendido mientras se pulsaba y cuando lo soltabas se apagaba.

entonces ahora cuando presionas el botón si está apagado lo enciende, y viceversa, el monitor serial reescribe una variable global por lo cual si escribes Led1_ON y está encendido, se mantendrá así y si estaba apagada lo encenderá.

#include <EEPROM.h>

int estadoBoton1 = 0; // Guarda el estado del botón en HIGH o LOW.
int estadoBoton2 = 0;
int estadoBoton3 = 0;
int estadoBoton4 = 0;
int estadoBoton5 = 0;
int estadoBoton6 = 0;
int estadoBoton7 = 0;
int estadoBoton8 = 0;
char caracter; // Alacenas carácteres de entrada.
String comando;
int pinLed1 =  9;   // Declaramos la variable pin del Led.
int pinLed2 =  8;
int pinLed3 =  7;
int pinLed4 =  6;
int pinLed5 =  5;
int pinLed6 =  4;
int pinLed7 =  3;
int pinLed8 =  2;
int Direccion = 0; // Dirección de memoria de la EEPROM.
byte Dato; // Dato de la EEPROM.
byte Dato2;
int ultimoEstado = 0;
int estado = 0;

void setup()
{
  pinMode(pinLed1, OUTPUT);  // Inicializa el pin del Led 1 como salida.
  pinMode(pinLed2, OUTPUT);
  pinMode(pinLed3, OUTPUT);
  pinMode(pinLed4, OUTPUT);
  pinMode(pinLed5, OUTPUT);
  pinMode(pinLed6, OUTPUT);
  pinMode(pinLed7, OUTPUT);
  pinMode(pinLed8, OUTPUT);
  pinMode(A0,INPUT); // Salida digital para el Led 1.
  pinMode(A1,INPUT);
  pinMode(A2,INPUT);
  pinMode(A3,INPUT);
  pinMode(A4,INPUT);
  pinMode(A5,INPUT);
  Serial.begin(115200); // Puerto serie 115200 baudios.
  delay(200); // Retardo 0,2 segundos.
  Serial.println(EEPROM.read(Direccion),DEC); // Imprime en pantalla la dirección en decimal.
  Dato2 = EEPROM.read(Direccion); // Lee la dirección y lo almacena en la variable Dato2.
    
    // Lee los datos almacenados en al EEPROM al iniciar el programa.
    switch (Dato2) 
    {
    case B0:
    digitalWrite(pinLed1, HIGH); // Enciende el Led 1.
    break;
    
    case B1:
    digitalWrite(pinLed1, LOW); // Apaga el Led 1.
    break;
    }
}

void loop()
{
  /* Leyendo carácter a carácter lo que se resive por el canal del puerto serie
  y los voy concatenando uno tras otro en una cedena. */
  while (Serial.available() > 0)
  {
    caracter= Serial.read();
    comando.concat(caracter);
    delay(10);
  }
   
   // Interruptor físico.
  estadoBoton1 = digitalRead(A0);

  if(estadoBoton1 == HIGH && ultimoEstado == LOW){
    estado = estado-1;
  }

  if(comando.equals("Led1_ON") == true){
    estado = 1;
    escribeProm(B0);
  }else if(comando.equals("Led1_OFF") == true){
    estado = 0;
    escribeProm(B1);
  }

  ultimoEstado = estadoBoton1;

  if(estado == 1){
    digitalWrite(pinLed1, HIGH);    
  }else{
    digitalWrite(pinLed1, LOW);    
  }

  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando="";
}

void escribeProm(byte = Dato){
  EEPROM.write(Direccion, Dato);  
}

si no te sirve por el modo de funcionamiento del botón, me avisas para ver como solucionarlo.

Metaconta · November 26, 2014, 4:21pm

Me sale este error.

Arduino: 1.5.8 (Windows 7), Placa:"Arduino Uno"

Led13.ino: In function 'void loop()':
Led13.ino:83:19: error: 'escribeProm' was not declared in this scope
Led13.ino:86:19: error: 'escribeProm' was not declared in this scope
Error de compilación

This report would have more information with
"Show verbose output during compilation"
enabled in File > Preferences.

Saludos.

Surbyte · November 26, 2014, 4:57pm

Esto va luego del loop

void escribeProm(byte = Dato){
  EEPROM.write(Direccion, Dato);  
}

gepd · November 26, 2014, 8:25pm

como lo dejé está luego del loop, cámbialo a antes del loop, y después de setup y prueba, aquí a mi me compiló bien como lo dejé previamente.

Metaconta · November 27, 2014, 3:37am

Hola:

Supuestamente es así.

#include <EEPROM.h>

int estadoBoton1 = 0; // Guarda el estado del botón en HIGH o LOW.
int estadoBoton2 = 0;
int estadoBoton3 = 0;
int estadoBoton4 = 0;
int estadoBoton5 = 0;
int estadoBoton6 = 0;
int estadoBoton7 = 0;
int estadoBoton8 = 0;
char caracter; // Alacenas carácteres de entrada.
String comando;
int pinLed1 =  9;   // Declaramos la variable pin del Led.
int pinLed2 =  8;
int pinLed3 =  7;
int pinLed4 =  6;
int pinLed5 =  5;
int pinLed6 =  4;
int pinLed7 =  3;
int pinLed8 =  2;
int Direccion = 0; // Dirección de memoria de la EEPROM.
byte Dato; // Dato de la EEPROM.
byte Dato2;
int ultimoEstado = 0;
int estado = 0;

void setup()
{
  pinMode(pinLed1, OUTPUT);  // Inicializa el pin del Led 1 como salida.
  pinMode(pinLed2, OUTPUT);
  pinMode(pinLed3, OUTPUT);
  pinMode(pinLed4, OUTPUT);
  pinMode(pinLed5, OUTPUT);
  pinMode(pinLed6, OUTPUT);
  pinMode(pinLed7, OUTPUT);
  pinMode(pinLed8, OUTPUT);
  pinMode(A0,INPUT); // Salida digital para el Led 1.
  pinMode(A1,INPUT);
  pinMode(A2,INPUT);
  pinMode(A3,INPUT);
  pinMode(A4,INPUT);
  pinMode(A5,INPUT);
  Serial.begin(115200); // Puerto serie 115200 baudios.
  delay(200); // Retardo 0,2 segundos.
  Serial.println(EEPROM.read(Direccion),DEC); // Imprime en pantalla la dirección en decimal.
  Dato2 = EEPROM.read(Direccion); // Lee la dirección y lo almacena en la variable Dato2.
    
    // Lee los datos almacenados en al EEPROM al iniciar el programa.
    switch (Dato2) 
    {
    case B0:
    digitalWrite(pinLed1, HIGH); // Enciende el Led 1.
    break;
    
    case B1:
    digitalWrite(pinLed1, LOW); // Apaga el Led 1.
    break;
    }
}

void escribeProm(byte = Dato){
  EEPROM.write(Direccion, Dato); 
  }

void loop()
{
  /* Leyendo carácter a carácter lo que se resive por el canal del puerto serie
  y los voy concatenando uno tras otro en una cedena. */
  while (Serial.available() > 0)
  {
    caracter= Serial.read();
    comando.concat(caracter);
    delay(10);
  }
   
   // Interruptor físico.
  estadoBoton1 = digitalRead(A0);

  if(estadoBoton1 == HIGH && ultimoEstado == LOW){
    estado = estado-1;
  }

  if(comando.equals("Led1_ON") == true){
    estado = 1;
    escribeProm(B0);
  }else if(comando.equals("Led1_OFF") == true){
    estado = 0;
    escribeProm(B1);
  }

  ultimoEstado = estadoBoton1;

  if(estado == 1){
    digitalWrite(pinLed1, HIGH);    
  }else{
    digitalWrite(pinLed1, LOW);    
  }

  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando="";
}

No funciona bien y el mensaje de estado no le llega. A veces funciona, si toco el botón físico, tampoco funciona.

Si que cuesta esto.

Saludos.

gepd · November 27, 2014, 4:21am

El mensaje no llega simplemente porque no lo he agregado, deberías intentar entender el código, aún sin ese mensaje, el led se enciende y se apaga. Lo que sucede con el botón, puede ser debido al rebote del mismo, he agregado un pequeño delay que debería solucionarlo:

#include <EEPROM.h>

int estadoBoton1 = 0; // Guarda el estado del botón en HIGH o LOW.
int estadoBoton2 = 0;
int estadoBoton3 = 0;
int estadoBoton4 = 0;
int estadoBoton5 = 0;
int estadoBoton6 = 0;
int estadoBoton7 = 0;
int estadoBoton8 = 0;
char caracter; // Alacenas carácteres de entrada.
String comando;
int pinLed1 =  13;   // Declaramos la variable pin del Led.
int pinLed2 =  8;
int pinLed3 =  7;
int pinLed4 =  6;
int pinLed5 =  5;
int pinLed6 =  4;
int pinLed7 =  3;
int pinLed8 =  2;
int Direccion = 0; // Dirección de memoria de la EEPROM.
byte Dato; // Dato de la EEPROM.
byte Dato2;
int ultimoEstado = 0;
int estado = 0;

void setup()
{
  pinMode(pinLed1, OUTPUT);  // Inicializa el pin del Led 1 como salida.
  pinMode(pinLed2, OUTPUT);
  pinMode(pinLed3, OUTPUT);
  pinMode(pinLed4, OUTPUT);
  pinMode(pinLed5, OUTPUT);
  pinMode(pinLed6, OUTPUT);
  pinMode(pinLed7, OUTPUT);
  pinMode(pinLed8, OUTPUT);
  pinMode(A0,INPUT); // Salida digital para el Led 1.
  pinMode(A1,INPUT);
  pinMode(A2,INPUT);
  pinMode(A3,INPUT);
  pinMode(A4,INPUT);
  pinMode(A5,INPUT);
  Serial.begin(115200); // Puerto serie 115200 baudios.
  delay(200); // Retardo 0,2 segundos.
  Serial.println(EEPROM.read(Direccion),DEC); // Imprime en pantalla la dirección en decimal.
  Dato2 = EEPROM.read(Direccion); // Lee la dirección y lo almacena en la variable Dato2.
    
    // Lee los datos almacenados en al EEPROM al iniciar el programa.
    switch (Dato2) 
    {
    case B0:
    digitalWrite(pinLed1, HIGH); // Enciende el Led 1.
    break;
    
    case B1:
    digitalWrite(pinLed1, LOW); // Apaga el Led 1.
    break;
    }
}

void escribeProm(byte = Dato){
  EEPROM.write(Direccion, Dato); 
  }

void loop()
{
  /* Leyendo carácter a carácter lo que se resive por el canal del puerto serie
  y los voy concatenando uno tras otro en una cedena. */
  while (Serial.available() > 0)
  {
    caracter= Serial.read();
    comando.concat(caracter);
    delay(10);
  }
   
   // Interruptor físico.
  estadoBoton1 = digitalRead(A0);

  if(estadoBoton1 == HIGH && ultimoEstado == LOW){
    estado = estado-1;
    delay(20); //rebote del boton
  }

  if(comando.equals("Led1_ON") == true){
    estado = 1;
    escribeProm(B0);
    Serial.println("El comando es Led1_ON"); 
  }else if(comando.equals("Led1_OFF") == true){
    estado = 0;
    escribeProm(B1);
    Serial.println("El comando es Led1_OFF");  
  }

  ultimoEstado = estadoBoton1;

  if(estado == 1){
    digitalWrite(pinLed1, HIGH);       
  }else{
    digitalWrite(pinLed1, LOW); 
  }

  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando="";
}

si hay veces en que todavía falla el botón aumenta el valor del delay a 25 o 30.

Surbyte · November 27, 2014, 10:12am

que nunca te ocurra gepd que por tener mal las condiciones de las variables resulte en una resta negativa.

Esto es la primera vez que lo veo: estado = estado -1
Se suele usar estado != estado o estado = !estado;

es mas mira como son las cosas... cuando comienzo esto no reparé en las condiciones de las que te hablo y que ocurre, que estan mal.
Defines a estado como

int estado = 0;

y luego el código dice

// Interruptor físico.
estadoBoton1 = digitalRead(A0);

if(estadoBoton1 == HIGH && ultimoEstado == LOW){
estado = estado-1;
delay(20); //rebote del boton
}

o sea que cuando presionen el botón,

estadoboton =1 ultimoestado = 0 y estado = 0, entonces
estado = estado -1 da como resultado -1 ERROR!!!!

Metaconta · November 27, 2014, 3:35pm

Hola:

Gracias a los dos.

Antes que nada, suelo usar este método.

estado != estado

#include <EEPROM.h>

int estadoBoton1 = 0; // Guarda el estado del botón en HIGH o LOW.
int estadoBoton2 = 0;
int estadoBoton3 = 0;
int estadoBoton4 = 0;
int estadoBoton5 = 0;
int estadoBoton6 = 0;
int estadoBoton7 = 0;
int estadoBoton8 = 0;
char caracter; // Alacenas carácteres de entrada.
String comando;
int pinLed1 =  13;   // Declaramos la variable pin del Led.
int pinLed2 =  8;
int pinLed3 =  7;
int pinLed4 =  6;
int pinLed5 =  5;
int pinLed6 =  4;
int pinLed7 =  3;
int pinLed8 =  2;
int Direccion = 0; // Dirección de memoria de la EEPROM.
byte Dato; // Dato de la EEPROM.
byte Dato2;
int ultimoEstado = 0;
int estado = 0;

void setup()
{
  pinMode(pinLed1, OUTPUT);  // Inicializa el pin del Led 1 como salida.
  pinMode(pinLed2, OUTPUT);
  pinMode(pinLed3, OUTPUT);
  pinMode(pinLed4, OUTPUT);
  pinMode(pinLed5, OUTPUT);
  pinMode(pinLed6, OUTPUT);
  pinMode(pinLed7, OUTPUT);
  pinMode(pinLed8, OUTPUT);
  pinMode(A0,INPUT); // Salida digital para el Led 1.
  pinMode(A1,INPUT);
  pinMode(A2,INPUT);
  pinMode(A3,INPUT);
  pinMode(A4,INPUT);
  pinMode(A5,INPUT);
  Serial.begin(115200); // Puerto serie 115200 baudios.
  delay(200); // Retardo 0,2 segundos.
  Serial.println(EEPROM.read(Direccion),DEC); // Imprime en pantalla la dirección en decimal.
  Dato2 = EEPROM.read(Direccion); // Lee la dirección y lo almacena en la variable Dato2.
    
    // Lee los datos almacenados en al EEPROM al iniciar el programa.
    switch (Dato2) 
    {
    case B0:
    digitalWrite(pinLed1, HIGH); // Enciende el Led 1.
    break;
    
    case B1:
    digitalWrite(pinLed1, LOW); // Apaga el Led 1.
    break;
    }
}

void escribeProm(byte = Dato){
  EEPROM.write(Direccion, Dato); 
  }

void loop()
{
  /* Leyendo carácter a carácter lo que se resive por el canal del puerto serie
  y los voy concatenando uno tras otro en una cedena. */
  while (Serial.available() > 0)
  {
    caracter= Serial.read();
    comando.concat(caracter);
    delay(10);
  }
   
   // Interruptor físico.
  estadoBoton1 = digitalRead(A0);

  if(estadoBoton1 == HIGH && ultimoEstado == LOW){
    estado != estado;
    delay(20); //rebote del boton
  }

  if(comando.equals("Led1_ON") == true){
    estado = 1;
    escribeProm(B0);
    Serial.println("El comando es Led1_ON"); 
  }else if(comando.equals("Led1_OFF") == true){
    estado = 0;
    escribeProm(B1);
    Serial.println("El comando es Led1_OFF");  
  }

  ultimoEstado = estadoBoton1;

  if(estado == 1){
    digitalWrite(pinLed1, HIGH);       
  }else{
    digitalWrite(pinLed1, LOW); 
  }

  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando="";
}

Funciona los comandos por vía serie pero no del interruptor. Nota, uso interruptor cuando hablo de botón.

Surbyte · November 27, 2014, 3:59pm

A quemar neuronas Metaconta que no es tan dificil, tienes todo servido, solo algunos ajustes.

Metaconta · November 27, 2014, 4:48pm

Estoy neureneando...

Debo poner el botón físico en el programa en paralelo con el comendo del serie. Haber si me hace caso.

Luego pongo códigos.

gepd · November 27, 2014, 7:01pm

gracias por la sugerencia surbyte, en verdad el código del botón no lo había probado porque no tenía uno a mano, acabo de testear uno ~~y a parte del problema que en el if encontré otro~~

~~la lectura del botón la haces desde un pin analógico:~~
~~estadoBoton1 = digitalRead(A0);~~
~~y debería ser digital:~~

ese código me ha funcionado sin problemas (cambia los pines correspondiente a tu configuración)

#include <EEPROM.h>

int estadoBoton1 = 0; // Guarda el estado del botón en HIGH o LOW.
int estadoBoton2 = 0;
int estadoBoton3 = 0;
int estadoBoton4 = 0;
int estadoBoton5 = 0;
int estadoBoton6 = 0;
int estadoBoton7 = 0;
int estadoBoton8 = 0;
char caracter; // Alacenas carácteres de entrada.
String comando;
int pinLed1 =  13;   // Declaramos la variable pin del Led.
int pinLed2 =  8;
int pinLed3 =  7;
int pinLed4 =  6;
int pinLed5 =  5;
int pinLed6 =  4;
int pinLed7 =  3;
int pinLed8 =  2;
int Direccion = 0; // Dirección de memoria de la EEPROM.
byte Dato; // Dato de la EEPROM.
byte Dato2;
int ultimoEstado = 0;
int estado = 0;

void setup()
{
  pinMode(pinLed1, OUTPUT);  // Inicializa el pin del Led 1 como salida.
  pinMode(pinLed2, OUTPUT);
  pinMode(pinLed3, OUTPUT);
  pinMode(pinLed4, OUTPUT);
  pinMode(pinLed5, OUTPUT);
  pinMode(pinLed6, OUTPUT);
  pinMode(pinLed7, OUTPUT);
  pinMode(pinLed8, OUTPUT);
  pinMode(A0,INPUT); // Salida digital para el Led 1.
  pinMode(A1,INPUT);
  pinMode(A2,INPUT);
  pinMode(A3,INPUT);
  pinMode(A4,INPUT);
  pinMode(A5,INPUT);
  Serial.begin(115200); // Puerto serie 115200 baudios.
  delay(200); // Retardo 0,2 segundos.
  Serial.println(EEPROM.read(Direccion),DEC); // Imprime en pantalla la dirección en decimal.
  Dato2 = EEPROM.read(Direccion); // Lee la dirección y lo almacena en la variable Dato2.
    
    // Lee los datos almacenados en al EEPROM al iniciar el programa.
    switch (Dato2) 
    {
    case B0:
    digitalWrite(pinLed1, HIGH); // Enciende el Led 1.
    break;
    
    case B1:
    digitalWrite(pinLed1, LOW); // Apaga el Led 1.
    break;
    }
}

void escribeProm(byte = Dato){
  EEPROM.write(Direccion, Dato); 
  }

void loop()
{
  /* Leyendo carácter a carácter lo que se resive por el canal del puerto serie
  y los voy concatenando uno tras otro en una cedena. */
  while (Serial.available() > 0)
  {
    caracter= Serial.read();
    comando.concat(caracter);
    delay(10);
  }
   
   // Interruptor físico.
  estadoBoton1 = digitalRead(3);

  if(estadoBoton1 == HIGH && ultimoEstado == LOW){
    estado = !estado;
    delay(20); //rebote del boton
  }
  
  if(comando.equals("Led1_ON") == true){
    estado = 1;
    escribeProm(B0);
    Serial.println("El comando es Led1_ON"); 
  }else if(comando.equals("Led1_OFF") == true){
    estado = 0;
    escribeProm(B1);
    Serial.println("El comando es Led1_OFF");  
  }

  ultimoEstado = estadoBoton1;
  
  Serial.println(estado);
  
  if(estado == 1){
    digitalWrite(pinLed1, HIGH);       
  }else{
    digitalWrite(pinLed1, LOW); 
  }

  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando="";
}

Surbyte · November 27, 2014, 7:04pm

Pero si define el pin A0 como entrada esta permitido.

Al menos para el futuro corrige esto Metanconta

 pinMode(A0,INPUT); // Salida digital para el Led 1.

por esto

 pinMode(A0,INPUT); // Entrada digital.

El led1 obviamente ahi no irá conectado

Metaconta · November 27, 2014, 10:37pm

gepd:

Voy a probar el código y te cuento los resultados. Pensé que se ponía como entra digital, quiero decir, transformar la entrada analógica en digital, como si fuera digitales puro y duro.

surbyte:

Por lo que cuentas, cambio esto:

pinMode(A0,INPUT);

por esto:

pinMode(A0,INPUT);

¿No será por esto OUTPOT por INPUT?

Saludos.

Surbyte · November 27, 2014, 11:16pm

A ver.. yo no hable de la definición del pin sino del comentario
// DICE SALIDA cuando estaba definido como entrada.
Como los tiene cableados no se porque no lei nada al respecto.
Si son salidas tienes razón, y que ponga OUTPUT pero eso pasa porque no dar bien la información.
Un esquema a mano alzada, una foto, se sube y no estamos perdiendo el tiempo hablando de lo que puede ser o no..
Solo se que esta definido una cosa y el comentario dice otra.

por lo visto entendi bien

  pinMode(pinLed1, OUTPUT);  // Inicializa el pin del Led 1 como salida.
  pinMode(pinLed2, OUTPUT);
  pinMode(pinLed3, OUTPUT);
  pinMode(pinLed4, OUTPUT);
  pinMode(pinLed5, OUTPUT);
  pinMode(pinLed6, OUTPUT);
  pinMode(pinLed7, OUTPUT);
  pinMode(pinLed8, OUTPUT);

y luego vienen los A0 a A6 como entradas

Metaconta · November 28, 2014, 12:29am

Hola:

Entonces me he equivocado desde el principio a la hora de explicar.

Con el ejemplo de arriba, me funciona los comandos en serie, pero no el pulsador físico.

Por lo que veo, debe ser algo así.

Si botón Led1 está pulsado OR comando serie es Led1_ON
{
Se activa el Led 1.
}

Si no
{
Se apaga el LEd 2.
}

No olvidar que cuando el interruptor está fijo encendido y apagado, debe cambiar su estado en los comandos del serial. Por eso cuesta programarlo, o cogerle el truco como se hace, y mejor saber, si realmente Arduino es capaz de hacerlo.

Saludos.

gepd · November 28, 2014, 2:51am

Yo creo que debes tener algo mal conectado, yo lo probé y me funciona el boton y los comando por serie.

Si presiono el botón 1 vez, se enciende el led, si lo presiono otra vez se apaga.
Si presiono el boton 1 vez, se enciende el led, si escribo Led1_OFF el led se apaga.
-Si escribo Led1_ON, el led se enciende, si presiono el botón, el led se apaga.

y así...

esto es lo que entendí que querías y así está funcionando.
no entiendo cual es el problema que estás teniendo.

Metaconta · November 28, 2014, 5:04am

El problema que creo que puede ser es, uso interruptor físico, no pulsador.

Interruptor.

Saludos.

Topic		Replies	Views
Encender y apagar led con pulsador mientras parpadea Software	5	8696	May 7, 2021
Encender y apagar led con pulso Software	8	3790	May 7, 2021
Encender y apagar un Led con el mismo pulsador y enviar comandos [SOLUCIONADO] Software	9	19066	May 7, 2021
Encender led con 2 caracteres iguales (ayuda) Software	3	981	May 7, 2021
Encender leds ingresando hora del día - Arduino Uno Hardware	13	1979	September 25, 2021

Lograr endender y apagar Led en dos formas diferentes

Related topics