Usar memoria EEPROM y leer información.

Hola:

Teniendo este código hecho en Visual C# 2013 (Los que quieran lo paso a Visual Basic 2013 también).

Tengo el código hecho, o que hace es encender y apagar el Led 13 del Arduino UNO r3 con la interfaz hecha bajo C# como indiqué ariba.

[u]Código Visual C# 2013[/u]:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

using System.IO.Ports; // No olvidar.

namespace Encender_Led_Arduino
{
    public partial class Form1 : Form
    {
        string Recibidos;
        public Form1()
        {
            InitializeComponent();

            // Abrir puerto mientras se ejecute la aplicación.
            if (!serialPort1.IsOpen)
            {
                try
                {
                    serialPort1.Open();
                }
                catch (System.Exception ex)
                {
                    MessageBox.Show(ex.ToString());
                }
            }

            serialPort1.DataReceived += new SerialDataReceivedEventHandler(Recepcion);
        }

        private void Recepcion(object sender, SerialDataReceivedEventArgs e)
        {
            Recibidos += serialPort1.ReadExisting();
            Invoke(new EventHandler(Actualizar));
        }

        private void Actualizar(object sender, EventArgs e)
        {
            richTextBox1.Text = Recibidos;
        }

        private void button_Encender_Led_1_Click(object sender, EventArgs e)
        {
            byte[] mBuffer = Encoding.ASCII.GetBytes("Led13_ON");
            serialPort1.Write(mBuffer, 0, mBuffer.Length);
        }

        private void button_Apagar_Led_1_Click(object sender, EventArgs e)
        {
            byte[] mBuffer = Encoding.ASCII.GetBytes("Led13_OFF");
            serialPort1.Write(mBuffer, 0, mBuffer.Length);
        }
    }
}

[u]Código de Arduino UNO r3[/u]:

char caracter;
String comando;
int pinLed =  13;   // Declaramos la variable pin del Led.

void setup(){
  // Inicializa el pin del LED como salida:
  pinMode(pinLed, OUTPUT);
  Serial.begin(9600);
}

void loop(){
  while (Serial.available()>0){
    caracter= Serial.read();
    comando.concat(caracter);
    delay(10);
  }
  if (comando.equals("Led13_ON") == true){
    digitalWrite(pinLed, HIGH);
        Serial.println("El comando es Led13_ON");
  }      
  if (comando.equals("Led13_OFF")== true){
    digitalWrite(pinLed, LOW);
        Serial.println("El comando es Led13_OFF");
  }  
  comando="";
}

La pregunta es: ¿Cómo puedo hacer, que el Led 13 de Arduino se grave en la EEPROM? Me refiero cuando está apagado o encendido.

Un cordial saludo.

Metaconta: La pregunta es: ¿Cómo puedo hacer, que el Led 13 de Arduino se grave en la EEPROM? Me refiero cuando está apagado o encendido.

Un cordial saludo.

Puedes almacenar el estado del led 13, como un byte, utilizando la funcion EEPROMWrite . Saludos

Puedes almacenar el estado del led 13, como un byte, utilizando la funcion EEPROMWrite . Saludos

Obviamente aunque esta implícito te comento que cuando arranque el arduino luego de un powerdown, usa EPROMRead para leer el estado mencionado.

Buenas:

Me cuesta interpretarlo pero voy a intentarlo.

Un Byte no creo, mas bien un int porque la dirección puede llegar hasta 1024. El dato almacenado si.

Bueno, les entrego el código que todavía no resuelvo el problema.

#include <EEPROM.h>

char caracter;
String comando;
int pinLed =  13;   // Declaramos la variable pin del Led.
int Direccion = 0;
byte Dato;

void setup()
{
  // Inicializa el pin del LED como salida:
  pinMode(pinLed, OUTPUT);
  Serial.begin(115200);
  Dato = EEPROM.read(Direccion);
}

void loop()
{
  while (Serial.available()>0)
  {
    caracter= Serial.read();
    comando.concat(caracter);
    delay(10);
  }
  
  if (comando.equals("Led13_ON") == true)
  {
    digitalWrite(pinLed, HIGH);
        Serial.println("El comando es Led13_ON");
        Dato = 1;
        EEPROM.write(Direccion, Dato);
  }   
  
  if (comando.equals("Led13_OFF")== true)
  {
    digitalWrite(pinLed, LOW);
        Serial.println("El comando es Led13_OFF");
        Dato = 0;
        EEPROM.write(Direccion, Dato);
  }  
  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando="";
}

PD: ¿Alguien de ustedes, les llega por e-mail las constestaciones del foro? Desde que se modernizó, no lo hace aunque toque la configuración.

El estado del led es Prendido o Apagado, 1 o 0, la direccón 0 a 512. Esta bien haber definido dato como byte.

Hola:

En las estadísticas pone del 0 a 1024 que es el que tiene el ATmega328.

Voy a poner int a todo por si acaso, luego optimizaré, por ahora debo hacer funcionar este código que no lo he logrado.

#include <EEPROM.h>


char caracter;
String comando;
int pinLed =  13;   // Declaramos la variable pin del Led.
int Direccion = 0;
int Dato;
int Dato2;

void setup()
{
  // Inicializa el pin del LED como salida:
  pinMode(pinLed, OUTPUT);
  Serial.begin(115200);
  delay(200);
  Serial.println(EEPROM.read(Direccion));
    Dato2 = EEPROM.read(Direccion);
    
    switch (Dato2) 
    {
    case 1:
    digitalWrite(pinLed, HIGH);
    break;
    
    case 2:
    digitalWrite(pinLed, LOW);
    break;
    }
}

void loop()
{
  while (Serial.available()>0)
  {
    caracter= Serial.read();
    comando.concat(caracter);
    delay(10);
  }
  
  if (comando.equals("Led13_ON") == true)
  {
    digitalWrite(pinLed, HIGH);
    Serial.println("El comando es Led13_ON");
    Dato = 1;
    EEPROM.write(Direccion, Dato);
  }   
  
  if (comando.equals("Led13_OFF")== true)
  {
    digitalWrite(pinLed, LOW);
    Serial.println("El comando es Led13_OFF");
    Dato = 0;
    EEPROM.write(Direccion, Dato);
  }  
  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando="";
}

Creo que graba los datos en una dirección y lo lee en otra. Tiene que ser en la misma dirección de memoria.

¿Alguna ayudita?

Saludo.

Deberías declarar Dato y Dato2 como Byte y comparar los valores binarios B0 B1

#include <EEPROM.h>


char caracter;
String comando;
int pinLed =  13;   // Declaramos la variable pin del Led.
int Direccion = 0;
byte Dato;
byte Dato2;

void setup()
{
  // Inicializa el pin del LED como salida:
  pinMode(pinLed, OUTPUT);
  Serial.begin(115200);
  delay(200);
  Serial.println(EEPROM.read(Direccion),DEC);
    Dato2 = EEPROM.read(Direccion);
    
    switch (Dato2) 
    {
    case B0:
    digitalWrite(pinLed, HIGH);
    break;
    
    case B1:
    digitalWrite(pinLed, LOW);
    break;
    }
}

void loop()
{
  while (Serial.available()>0)
  {
    caracter= Serial.read();
    comando.concat(caracter);
    delay(10);
  }
  
  if (comando.equals("Led13_ON") == true)
  {
    digitalWrite(pinLed, HIGH);
    Serial.println("El comando es Led13_ON");
    Dato = B0;
    EEPROM.write(Direccion, Dato);
  }   
  
  if (comando.equals("Led13_OFF")== true)
  {
    digitalWrite(pinLed, LOW);
    Serial.println("El comando es Led13_OFF");
    Dato = B1;    
    EEPROM.write(Direccion, Dato);
  }  
  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando="";
}

Para saber si es la primera vez que se guarda en el eeprom comparas con 255.

void setup()
{

  Dato2 = EEPROM.read(0); //direccion cero
  if (Dato2 = 255) //posicion sin usar
  {
    Dato2=0; //inicializas la variable
    EEPROM.Write(0,Dato2); guardo la inicializacion
  }

Y recuerta que tiene vida util limitada la grabacion de cada celda de memoria. Lo que sugiero es que guardes solo cuando sea necesario o antes de apagarse el circuito.

Y con respecto al foro: No notifica las respuestas. yo cambie por todos lados las configuraciones y no pasa nada.

Gracias.

Funciona muy bien. Este es el mismo código pero documentado un poco para que los nuevos visitantes lo entiendan bien.

#include <EEPROM.h>

char caracter;
String comando;
int pinLed =  13;   // Declaramos la variable pin del Led.
int Direccion = 0;
byte Dato;
byte Dato2;

void setup()
{
  pinMode(pinLed, OUTPUT);  // Inicializa el pin del LED como salida:
  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(pinLed, HIGH); // Enciende el Led.
    break;
    
    case B1:
    digitalWrite(pinLed, LOW); // Apaga el Led.
    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("Led13_ON") == true)
  {
    digitalWrite(pinLed, HIGH); // Enciende el Led.
    Serial.println("El comando es Led13_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("Led13_OFF")== true)
  {
    digitalWrite(pinLed, LOW); // Apaga el Led.
    Serial.println("El comando es Led13_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="";
}

Vamos a suponer que tenemos un pulsador físico en Arduino. Este pulsador lo que hace es apagar y encender un Led, el mismo, el del pin 13 que viene con Arduino UNO r3.

He ampliado el código que debe funcionar tanto como entrada de datos por el puerto USB o serie y un pulsador. Apager y encender el Led 13 como indiqué arriba. Lo que no se, el motivo de que ya no me funcione elcódigo por serie.

#include <EEPROM.h>

char caracter;
String comando;
int pinLed =  13;   // Declaramos la variable pin del Led.
int Direccion = 0;
byte Dato;
byte Dato2;

// Variables pra el pulsador.
int estadoActual1=0; 
int estadoActual2=0; 
int estadoUltimo=0; 
int contador=0; 

void setup()
{
  pinMode(pinLed, OUTPUT);  // Inicializa el pin del LED como salida:
  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(pinLed, HIGH); // Enciende el Led.
      break;
    
      case B1:
      digitalWrite(pinLed, LOW); // Apaga el Led.
      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("Led13_ON") == true)
  {
    digitalWrite(pinLed, HIGH); // Enciende el Led.
    Serial.println("El comando es Led13_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("Led13_OFF")== true)
  {
    digitalWrite(pinLed, LOW); // Apaga el Led.
    Serial.println("El comando es Led13_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="";
  
  // Pulsador.
  estadoActual1=digitalRead(8); 
  delay(10);
  estadoActual2=digitalRead(8);
  if (estadoActual1 == estadoActual2)
  {
    if (estadoActual1 != estadoUltimo)
    { 
      if (estadoActual1 == HIGH)
      {
        contador = contador + 1;
        Serial.print ("Ésta es la pulsación nº ");
        Serial.println(contador); 
      }        
    }
  }
  
  estadoUltimo= estadoActual1;
      if (contador % 2 == 0 ) {
          digitalWrite(pinLed, LOW);       
      } else {
          digitalWrite(pinLed, HIGH);     
      }  
}

Saludo.

Edito:
Hola maxid:

No te había visto.
Gracias por el código y las sugerencias. Se que está limitada, por eso me gusta más usar la EEPROM externa como 24LC256 por poner un ejemplo. Esto ya lo haré más adelante.

Antes con los PIC y en asm, usabamos la memoria RAM antes de apagar la placa. Tiene un buen condensador que dura 2 segundos, tiempo más que suficiente para que se apague todos los componentes menos el propio PIC ya que se queda encendido dos segundos para que le de tiempo de leer los datos almacenados en la RAM y se pase a la EEPROM interna, eso si, cada estado recorre un punto de posición de memoria y guarda los datos para que dure más. La vida es más larga pero aún así, prefiero la EEPROM externa que solo lo cambias y ya está.

En cuanto a las notificaciones. Gracias por confirmarlo, solo falta que lo corrijan los administradores, si antes ya lo sabe, claro.

Les dejo la versión en Inglés por si alguien le interesa. http://forum.arduino.cc/index.php?topic=279958.0

Saludo.

Hola a todos!!! he estado leyendo el forum para encontrar una solución a mi problema, quisiera implementar la eeprom en mi sistema de alarma pero no he tenido exito pues bien le hago un general de como funciona mi alarma que va conectado a un teléfono móvil. La alarma esta controlada por un control RF 433Mhz que permite activar, desactivar y un aviso de pánico. En el momento que esta desactivada la alarma esta diseñada a que solo funcionen los botones de activado y pánico, una vez activada la alarma lo único que funciona es la entrada del sensor que esta permanentemente censando hasta que aparezca una intrusión o un valor bajo en la entrada del sensor luego esta diseñada para que el botón de desactivado lo vuelva al estado en donde funcione solo el botón de activado y pánico y bueno lo que yo estoy buscando ahora es grabar el estado de la alarma en la eeprom por lo que he creado una variable “int Direccion = 0;” donde se almacene el estado de la alarma después en void setup puse a leer la EEPROM y actualizar después pase a guardar el estado donde creí que debería escribir el EEPROM.write(Direccion,1); - de activado para luego escribir EEPROM.write(Direccion,0); del desactivado pero no he tenido éxito.

mi pregunta!! en que estoy haciendo mal o cual es mi error? por favor si me pueden aconsejar o dar alguna ayudita estaré muy agradecido
att
Javier

#include <EEPROM.h>
#include <RCSwitch.h>
RCSwitch mySwitch = RCSwitch();

const int call1 = 11; //activado de la alarma con el boton activador del control
const int call2 = 10; //desactivado de la alarma con el boton desactivador del control
const int call3 = 9; //Salida del sensor
const int call4 = 8; // tecla de colgado del telefono
const int alarm_active_led = 7; //Indicador que se activo la alarma
const int power_led = 6; //Fuente conectada o alamientacion del circuito
const int trigger_input = 5; //ingreso a arduino del sensor
const int panico = 4; // boton panico del control

int trigger_state = 0;
long int value = mySwitch.getReceivedValue();//en la libreria biene int

int Direccion = 0;

void setup()
{
pinMode(call1, OUTPUT);
pinMode(call2, OUTPUT);
pinMode(call3, OUTPUT);
pinMode(call4, OUTPUT);
pinMode(alarm_active_led, OUTPUT);
pinMode(power_led, OUTPUT);
pinMode(trigger_input, INPUT);
pinMode(panico, OUTPUT);

EEPROM.read(Direccion);

mySwitch.enableReceive(0); // pin #2 de arduino como RX
long int value = mySwitch.getReceivedValue();

}

void loop()
{
salir:
long int value = mySwitch.getReceivedValue();
if (value == 4539740)// codigo del boton del control para activar la alarma
{
EEPROM.write(Direccion,1);
{
digitalWrite(call4, HIGH);
delay(500);
digitalWrite(call4, LOW);
delay(500);
digitalWrite(call4, HIGH);
delay(500);
digitalWrite(call4, LOW);
delay(500);
digitalWrite(call1, HIGH);
delay(3000);
digitalWrite(call1, LOW);
delay(1000);
digitalWrite(power_led, HIGH);// LED indicador de salida
delay(1200); //tiempo de salida
digitalWrite(power_led, LOW);
delay(500);

}

while(true)
{

trigger_state = digitalRead(trigger_input); //sensor de la alarma
if(trigger_state == LOW)

{

digitalWrite(alarm_active_led, HIGH);
digitalWrite(call4, HIGH);
delay(500);
digitalWrite(call4, LOW);
delay(500);
digitalWrite(call4, HIGH);
delay(500);
digitalWrite(call4, LOW);
delay(500);
digitalWrite(call3, HIGH);
delay(3000);
digitalWrite(call3, LOW);
delay(1000);
while(trigger_state == LOW){
trigger_state = digitalRead(trigger_input);
digitalWrite(alarm_active_led, HIGH); //Flash Alarma LED
delay(5); //Flash Alarma LED
digitalWrite(alarm_active_led, LOW); //Flash Alarma LED
delay(5); //Flash Alarma LED
long int value = mySwitch.getReceivedValue();
if (value == 4539731)// codigo de desactivado de la alarma del control
{
digitalWrite(alarm_active_led, LOW);
digitalWrite(call4, HIGH);
delay(500);
digitalWrite(call4, LOW);
delay(500);
digitalWrite(call4, HIGH);
delay(500);
digitalWrite(call4, LOW);
delay(500);
digitalWrite(call2, HIGH);
delay(3000);
digitalWrite(call2, LOW);
delay(1000);

}
if(trigger_state == LOW && value == 4539731)
{
EEPROM.write(Direccion,0);
goto salir;
}
}

}

}

}
if(value == 5584640)//codigo del boton de panico del control
{
digitalWrite(call4, HIGH);
delay(500);
digitalWrite(call4, LOW);
delay(500);
digitalWrite(call4, HIGH);
delay(500);
digitalWrite(call4, LOW);
delay(500);
digitalWrite(panico, HIGH);
delay(3000);
digitalWrite(panico, LOW);
delay(1000);
digitalWrite(alarm_active_led, HIGH);
delay(4000);
digitalWrite(alarm_active_led, LOW);
delay(500);

}

}

Erprom.read() devuelve un valor ,por lo que tendrias que recoger su valor en una variable (o usarlo directamente ) en el setup:

byte valor = Eeprom.read(Direccion);