Livewire y PCBWizard

Todo empieza ayer.

Estaba de visita por un blog llamado http://electronicavm.wordpress.com/ y vi un post acerca de un vibrador astable con transistores.

Leyendo acerca del post vi que había un diagrama del vibrador así que decidí probarlo en Everycircuit (simulador de circuitos) para Android, pero leyendo más acerca del vibrador, me di cuenta de que usan un programa para simular los circuitos (similar a Everycircuit pero en PC).

Entonces me propuse a buscarlo, y esperaba no tuviera que pagar por el.

Más adelante en Google me encontré con un Torrent, el cual, además de Livewire viene con PCBWizard (otro software para diseño y manufacturación de circuitos impresos).

Así que para aquellos que quieran bajar los dos programas de una sola vez les aconsejo dos cosas.

La primera busquen un cliente Torrent yo uso µTorrent.

La segunda visiten éste link: http://thepiratebay.se/torrent/7281296/Livewire__amp_amp__PCB_Wizard

Ésto es todo por hoy.

Publicado en Descargas, Fuera de Arduino | Etiquetado , , , , , , , , , , , | Deja un comentario

Prototipo de temporizador programable con Arduino

He vuelto con otro prototipo, en cuyo caso se trata de un temporizador programable en horas, minutos y segundos, el cual, a diferencia del que ya había publicado anteriormente utiliza como cerebro una Arduino UNO.

El funcionamiento es bastante simple, ya que para seleccionar tanto como horas como minutos y segundos se usan tres botones.

Por ahora la información de las horas los minutos y segundos se muestran en el monitor Serial del IDE de Arduino.

El código ya fue escrito, pero sigue en fase de prueba.

Entonces espero que sí alguien toma el código y lo ponga en funcionamiento me lo haga saber.

Entonces, he aquí el código.

/*
Escrito por: Pablo Andrade Mejía
http://www.arduinolab.wordpress.com
Temporizador programable en horas, minutos y segundos
Está en prueba, así que no puedo asegurar todavía que funcione correctamente
Los botones se usan para ajustar la cantidad de tiempo segun lo prefiera el usuario
Para eso se usan tres botones
Uno se encarga de los segundos, otro se encarga de los minutos y por último otro se encarga de las hora
*/

//Los pines a los cuales los botones están conectados
int minsPin = 2;
int hoursPin = 3;
int segsPin = 4;
//Los estados iniciales de las horas, minutos y segundos
int hourState = LOW;
int minState = LOW;
int segState = LOW;
//Las variables indicadas con 0 son las variables iniciales, lo cual significa que los segundos, minutos y horas al principio son cero.
//float lo usamos para convertir milisegundos (millis) a segundos, y sucesivamente a minutos y horas.
float hours = 0;
float mins = 0;
float segs = 0;
int led = 13; //El pin que va conectado al relevo lo marqué como led por simplicidad.
void setup()
{
  Serial.begin(9600);
  pinMode(led, OUTPUT);
  pinMode(minsPin, INPUT);
  pinMode(hoursPin, INPUT);
  pinMode(segsPin, INPUT);
}
//¡Aquí vamos! :D
void loop()
{
segs = (segs * millis());
mins = (segs * 60);
hours = (mins * 60);
{
  minState = digitalRead(minsPin);
  hourState = digitalRead(hoursPin);
  segState = digitalRead(segsPin);
  
  {
    if(segsPin =! segState);
    {
    for(segs = 0; segs < 59; segs += 1)
    Serial.println("Segundos:  ");
    Serial.print(segs);
  {
    if (segs == 59);
    segs = 0;
  }
  if(minsPin =! minState);
  }
    for(mins = 0; mins < 59; mins += 1)
    Serial.println("Minutos:  ");
    Serial.print(mins);
  if (mins == 59);
  mins = 0;
  }
  {
    if(hoursPin =! hourState);
    {
      for(hours = 0; hours < 24; hours += 1)
      Serial.println("Horas:  ");
      Serial.print(hours);
    }
    {
      if(hours == 24);
      hours = 0;
    }
  }
    {
    digitalWrite(led, HIGH);
    delay(segs);
    delay(mins);
    delay(hours);
    digitalWrite(led, LOW);
    delay(segs);
    delay(mins);
    delay(hours);
  }
  }
}
 
    
    
    
  

Publicado en Con Arduino, Ideas y prototipos | Etiquetado , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , | 4 comentarios

Y más avances en el proyecto del cronógrafo y guía para instalar la librería de Standby

Ya compré los materiales para el proyecto del cronógrafo que estoy construyendo lo cual inlcuye: una pantalla de cristal líquido, dos potenciómetros de 10k Ohm, led’s infrarrojos, detectores de infrarrojos, resistencias de 1k, 10k, 100k y 470k Ohm, mucho cable, conectores hembra y macho de 2.1mm para la fuente de poder externa, un conector de batería de 9 voltios y dos perillas para los potenciómetros.

El código ha tenido cierto número de modificaciones importantes, hace poco le añadí la función de Standby, lo que significa que mientras no haya actividad en Arduino éste entrará en modo de espera o “Standby” lo cual lo hace sumamente útil para reducir el consumo de batería. Se le añadió la función de analogWrite() para controlar el brillo de la pantalla LCD usando uno de los potenciómetros y el otro controlará directamente el contraste.

Advertencia, la librería de Standby NO viene en la Arduino, hay que instalarla y la manera de hacerlo es asi

El primer paso es ubicar donde está Arduino instalado en el computador, por lo general se encuentra en disco local(C: ) –> Archivos de Programa –> Arduino ” “

Cuando encuentren donde está instalado van a ver que hay varias carpetas una de ellas es Libraries, abran esa carpeta y creen una carpeta nueva y llamenla Standby.

luego vayan a http://www.code.google.com/p/narcoleptic/ una vez estén en la página descarguen el ZIP van a ver dos carpetas, una dice _MACOSX, y, la otra dice Narcoleptic, abran la que dice Narcoleptic. Una vez allí verán varios archivos, seleccionen desde release notes hasta examples, luego copien los archivos vayan a donde crearon la carpeta para Arduino Standby y peguen los archivos ahí.

Sí tienen el IDE de Arduino abierto, ciérrenlo, y vuélvanlo a abrir.

Después en el IDE vayan a File–> Examples –> Standby–> MerlinTheCat

MerlinTheCat es el códico escrito para poner a funcionar el Standby.

Eso es todo para la libería, una vez sepan cómo hacerlo y lo hayan hecho correctamente podrán hacerlo con cualquier otra librería que sea compatible con Arduino

*nota: Ésta guía está basada en Arduino 1.0, asegurense que las librerías a instalar son compatibles con el 1.0, de no ser así bajen una versión anterior como el 0022.

Ahora el código del cronógrafo.

/*
Tomado de http://aeroquad.com/showthread.php?845-How-do-I-make-a-tachometer-with-my-spare-arduino-board-and-IR-LED-and-RECEIVER
Modificado por Pablo Andrade Mejía http://www.arduinolab.wordpress.com

05 de Noviembre de 2012

Se le añadió la función de enviar la velocidad en metros por segundo y pies por segundo al monitor serial
lo que quita la necesidad de tener una pantalla de cristal líquido

Aquellos que tengan dudas acerca de cómo se debe conectar los sensores para que funcione correctamente
hagan click aquí http://www.instructables.com/id/Arduino-Based-Optical-Tachometer/step3/IR-Detector-Circuit/

Los fotodiodos o fototransistores son nombrados como attachInterrupt(0, front, CHANGE); Éste está relacionado
con el pin digital 2, y, el attachInterrupt(1, rear, CHANGE); Éste está relacionado con el pin digital 3

Quienes quieran probarlo pueden conectar dos botones a los pines 2 y 3

Los fotodiodos deben tener una resistencia entre 10k y 100k ohm conectados al emisor (pin, o pata corta) y ésta a los pines digitales
para asegurarnos que cuando el haz de luz sea interrumpido el voltaje llegue a '0' o tierra

El colector (pin, o pata larga) debe ir a 3.3v o 5v
*/

#include <LiquidCrystal.h>
#include <Narcoleptic.h> //Librería para poner la Arduino en Standby 
#define MPS2FPSCOEFF 3.28084
#define LENGTH 0.159              
#define MICRO2SEKCOEFF 1000000

LiquidCrystal lcd(4, 5, 6, 7, 8, 9);

volatile int stateFront = HIGH;
volatile int stateRear = HIGH;
int pot = 0;
int val = 0;
int led1 = 12;                             
int led2 = 13;                             
int startChrono;
unsigned long startTime, stopTime, elapsed; 
double fpsSpeed, mpsSpeed; //double tiene la misma función que float, así que no hay que preocuparse

void setup()
{
  Serial.begin(9600);
  pinMode(2,INPUT);
  digitalWrite(2,HIGH);
  pinMode(13,OUTPUT);
  digitalWrite(13,LOW);
  lcd.begin(16, 2);
  lcd.setCursor(0, 0);
  lcd.print("Super Chrono");
  Serial.println("Cronografo");
  lcd.setCursor(0, 1);
  lcd.print("by Honk");
  delay(700);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Initializing...");
  Serial.println("Inicializando");  
  delay(700);
  lcd.clear();

  startChrono = 0;
  elapsed = 0;
  fpsSpeed = mpsSpeed = 0;

  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  /*
  Sí los resultados no son los esperados donde dice CHANGE cambien por RISING o LOW
  tanto como en attachInterrupt(0, front, "      "); como en attachInterrup(1, rear, "     ");
  
  Sí todo resulta bien simplemente no hagan nada
  */
  attachInterrupt(0, front, CHANGE); //0 (on digital pin 2) kanske falling/rising/low
  attachInterrupt(1, rear, CHANGE);  //1 (on digital pin 3)

  lcd.setCursor(0, 0);
  lcd.print("Take a shot!");
  Serial.println("Preparado para disparar?");
} 

void loop()
{ 
  val = analogRead(pot);
  {
    val = map(val, 0, 1023, 0, 255);
    analogWrite(11, val);
  }
   {
  int a;

  // Merlin the cat is snoozing... Connect digital pin 2 to ground to wake him up.
  Narcoleptic.delay(500); // During this time power consumption is minimised

  while (digitalRead(2) == LOW) {
    // Wake up CPU. Unfortunately, Merlin does not like waking up.

  }

  // Merlin the cat goes to sleep...
}
  //Start counting when interrupted
  if(stateFront == LOW && startChrono == 0)
  {
    startTime = micros();  // Count microseconds since start
    startChrono = 1;       // Set Chrono flag
    digitalWrite(led1, HIGH);
  }

  // Stop counting and calculate speed
  if(stateRear == LOW && startChrono == 1)
  {
    stopTime = micros();  // Count microseconds since start
    startChrono = 0;      // Clear Chrono flag
    elapsed = stopTime - startTime;  // Calculate elapsed time (in us)

    digitalWrite(led2, HIGH);
    mpsSpeed = (LENGTH*(MICRO2SEKCOEFF)) / elapsed;            // s = v * t, v = s / t
    fpsSpeed = mpsSpeed * MPS2FPSCOEFF;

    lcd.clear();
    lcd.print("Fps: ");
    lcd.print(fpsSpeed);
    Serial.println("FPS(Pies por segundo) ");
    Serial.print(fpsSpeed);
    lcd.setCursor(0, 1);
    lcd.print("m/s: ");
    lcd.print(mpsSpeed);
    Serial.println("Metros por segundo ");
    Serial.print(mpsSpeed);

    startChrono = 0;

    delay(500);
    digitalWrite(led2, LOW);
    digitalWrite(led1, LOW);  
    {
        // Swipe claws left
    digitalWrite(13,HIGH);
    delay(50);

    // Swipe claws right
    digitalWrite(13,LOW);
    delay(50);
    }
  } 

}

void front()
{
  stateFront = !stateFront;
}

void rear()
{
  stateRear = !stateRear;
}
Publicado en Con Arduino, Descargas, Ideas y prototipos, Vídeos y demás | Etiquetado , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , | Deja un comentario

Continuando con el proyecto del cronógrafo para balística.

Un poco de teoría detrás de todo esto.

Un cronógrafo tiene dos partes importantes.

La primera es el cerebro, circuito integrado o microcontrolador

La segunda los sensores de luz.

La manera en que este funciona es simple, el microcontrolador está configurado como un temporizador al cual se le añaden una serie de ecuaciones matemáticas.

Todo empieza cuando el proyectil pasa por los sensores de luz, cuando uno el primero detecta una sombra que es causada por el proyectil al pasar. Ésta señal eléctrica es enviada al micro el cual empieza a contar la cantidad de tiempo, cuando el proyectil pasa por el segundo sensor causa que micro pare de contar la cantidad de tiempo, una vez esto ha ocurrido aplica la siguiente ecuación v= d/t dónde v es velocidad, d es distancia (la cual ya debe ser conocida) y t es tiempo, entonces sería como decir velocidad es igual a distancia sobre tiempo. Una vez todo esto ha ocurrido la información se muestra en una pantalla LCD.

Suena simple, pero cuando llegamos a la parte de programación todo cambia.

Ahora hablemos de los sensores de luz. Generalmente éstos sensores de luz son conocidos como fotodiodos o fototransistores, sabemos que los transistores tienen tres terminales una llamada colector, otra base y una llamada emisor, y la manera en que éstos funcionan es cuando se aplica una cantidad de corriente a la base otra cierta cantidad de corriente puede fluir a del colector al emisor.

Los fototransistores a diferencia de los transistores comunes tienen dos terminales colector la terminal más larga y emisor la terminal más corta, pero la corriente sólo puede fluir de colector a emisor si hay luz sobre el de manera que cuando un proyectil bloquea los sensores la cantidad de corriente que fluye disminuye cantidades, pero no lo suficiente para que el micro lo determine como que no hay corriente, así que se usan resistencias para hacer caer el voltaje a cero o tierra.

Básicamente ésta es toda la teoría.

Ahora les dejaré un ejemplo de cómo deben ir los sensores conectados a la Arduino y el código.

/*
Tomado de http://aeroquad.com/showthread.php?845-How-do-I-make-a-tachometer-with-my-spare-arduino-board-and-IR-LED-and-RECEIVER
Modificado por Pablo Andrade Mejía http://www.arduinolab.wordpress.com

05 de Noviembre de 2012

Se le añadió la función de enviar la velocidad en metros por segundo y pies por segundo al monitor serial
lo que quita la necesidad de tener una pantalla de cristal líquido

Aquellos que tengan dudas acerca de cómo se debe conectar los sensores para que funcione correctamente
hagan click aquí http://www.instructables.com/id/Arduino-Based-Optical-Tachometer/step3/IR-Detector-Circuit/

Los fotodiodos o fototransistores son nombrados como attachInterrupt(0, front, CHANGE); Éste está relacionado
con el pin digital 2, y, el attachInterrupt(1, rear, CHANGE); Éste está relacionado con el pin digital 3

Quienes quieran probarlo pueden conectar dos botones a los pines 2 y 3

Los fotodiodos deben tener una resistencia entre 10k y 100k ohm conectados al emisor (pin, o pata corta) y ésta a los pines digitales
para asegurarnos que cuando el haz de luz sea interrumpido el voltaje llegue a '0' o tierra

El colector (pin, o pata larga) debe ir a 3.3v o 5v
*/

#include <LiquidCrystal.h>
 
#define MPS2FPSCOEFF 3.28084
#define LENGTH 0.159              
#define MICRO2SEKCOEFF 1000000

LiquidCrystal lcd(4, 5, 6, 7, 8, 9);

volatile int stateFront = HIGH;
volatile int stateRear = HIGH;

int led1 = 12;                             
int led2 = 13;                             
int startChrono;
unsigned long startTime, stopTime, elapsed; 
double fpsSpeed, mpsSpeed; //double tiene la misma función que float, así que no hay que preocuparse
 
void setup()
{
  Serial.begin(9600);
  lcd.begin(16, 2);
  lcd.setCursor(0, 0);
  lcd.print("Super Chrono");
  Serial.print("Cronografo");
  lcd.setCursor(0, 1);
  lcd.print("by Honk");
  delay(700);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Initializing...");
  Serial.println("Inicializando");  
  delay(700);
  lcd.clear();
 
  startChrono = 0;
  elapsed = 0;
  fpsSpeed = mpsSpeed = 0;
 
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  /*
  Sí los resultados no son los esperados donde dice CHANGE cambien por RISING o LOW
  tanto como en attachInterrupt(0, front, "      "); como en attachInterrup(1, rear, "     ");
  
  Sí todo resulta bien simplemente no hagan nada
  */
  attachInterrupt(0, front, CHANGE); //0 (on digital pin 2) kanske falling/rising/low
  attachInterrupt(1, rear, CHANGE);  //1 (on digital pin 3)
 
  lcd.setCursor(0, 0);
  lcd.print("Take a shot!");
  Serial.println("Preparado para disparar?");
} 
 
void loop()
{ 
  //Start counting when interrupted
  if(stateFront == LOW && startChrono == 0)
  {
    startTime = micros();  // Count microseconds since start
    startChrono = 1;       // Set Chrono flag
    digitalWrite(led1, HIGH);
  }
 
  // Stop counting and calculate speed
  if(stateRear == LOW && startChrono == 1)
  {
    stopTime = micros();  // Count microseconds since start
    startChrono = 0;      // Clear Chrono flag
    elapsed = stopTime - startTime;  // Calculate elapsed time (in us)
  
    digitalWrite(led2, HIGH);
    mpsSpeed = (LENGTH*(MICRO2SEKCOEFF)) / elapsed;            // s = v * t, v = s / t
    fpsSpeed = mpsSpeed * MPS2FPSCOEFF;

    lcd.clear();
    lcd.print("Fps: ");
    lcd.print(fpsSpeed);
    Serial.println("PPS(Pies por segundo) ");
    Serial.print(fpsSpeed);
    lcd.setCursor(0, 1);
    lcd.print("m/s: ");
    lcd.print(mpsSpeed);
    Serial.println("Metros por segundo ");
    Serial.print(mpsSpeed);
    
    startChrono = 0;
    
    delay(500);
    digitalWrite(led2, LOW);
    digitalWrite(led1, LOW);  
    
  } 
  
}

void front()
{
  stateFront = !stateFront;
}

void rear()
{
  stateRear = !stateRear;
}

Publicado en Con Arduino, Descargas, Ideas y prototipos, Vídeos y demás | Etiquetado , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , | Deja un comentario

Cronógrafo con Arduino

Damas y caballeros.

Éste quizás sea uno de los proyectos más buscados para hacer con Arduino.

Un cronógrafo es un aparato electrónico que se encarga de medir la velocidad de proyectiles.

Lo que hace éste proyecto tan buscado, es porque los buenos cronógrafos son costosos y no muy fáciles de conseguir. El hecho de que sean construidos por uno mismo le da ese toque de personalidad y lo hace además divertido.

Entonces, después de buscar, buscar, buscar y buscar finalmente encontré el código, al cual le hice unas pequeñas modificaciones.

Por ahora lo he probado sólo con dos botones conectados a los pines digitales 2 y 3 y todo parece estar en orden.

Así que aquí les dejo el código.

/*
Tomado de http://aeroquad.com/showthread.php?845-How-do-I-make-a-tachometer-with-my-spare-arduino-board-and-IR-LED-and-RECEIVER
Modificado por Pablo Andrade Mejía http://www.arduinolab.wordpress.com

05 de Noviembre de 2012

Se le añadió la función de enviar la velocidad en metros por segundo y pies por segundo al monitor serial
lo que quita la necesidad de tener una pantalla de cristal líquido

Aquellos que tengan dudas acerca de cómo se debe conectar los sensores para que funcione correctamente
hagan click aquí http://www.instructables.com/id/Arduino-Based-Optical-Tachometer/step3/IR-Detector-Circuit/

Los fotodiodos o fototransistores son nombrados como attachInterrupt(0, front, CHANGE); Éste está relacionado
con el pin digital 2, y, el attachInterrupt(1, rear, CHANGE); Éste está relacionado con el pin digital 3

Quienes quieran probarlo pueden conectar dos botones a los pines 2 y 3

Los fotodiodos deben tener una resistencia entre 10k y 100kohm conectados al colector (pin, o pata larga) y esta al pin digital
para asegurarnos que cuando el haz de luz sea interrumpido el voltaje llegue a 0 o tierra
*/

#include <LiquidCrystal.h>
 
#define MPS2FPSCOEFF 3.28084
#define LENGTH 0.159              
#define MICRO2SEKCOEFF 1000000

LiquidCrystal lcd(4, 5, 6, 7, 8, 9);

volatile int stateFront = HIGH;
volatile int stateRear = HIGH;

int led1 = 12;                             
int led2 = 13;                             
int startChrono;
unsigned long startTime, stopTime, elapsed; 
double fpsSpeed, mpsSpeed; //double tiene la misma función que float, así que no hay que preocuparse
 
void setup()
{
  Serial.begin(9600);
  lcd.begin(16, 2);
  lcd.setCursor(0, 0);
  lcd.print("Super Chrono");
  Serial.print("Cronografo");
  lcd.setCursor(0, 1);
  lcd.print("by Honk");
  delay(700);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Initializing...");
  Serial.println("Inicializando");  
  delay(700);
  lcd.clear();
 
  startChrono = 0;
  elapsed = 0;
  fpsSpeed = mpsSpeed = 0;
 
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  /*
  Sí los resultados no son los esperados donde dice CHANGE cambien por RISING o LOW
  tanto como en attachInterrupt(0, front, "      "); como en attachInterrup(1, rear, "     ");
  
  Sí todo resulta bien simplemente no hagan nada
  */
  attachInterrupt(0, front, CHANGE); //0 (on digital pin 2) kanske falling/rising/low
  attachInterrupt(1, rear, CHANGE);  //1 (on digital pin 3)
 
  lcd.setCursor(0, 0);
  lcd.print("Take a shot!");
  Serial.println("Preparado para disparar?");
} 
 
void loop()
{ 
  //Start counting when interrupted
  if(stateFront == LOW && startChrono == 0)
  {
    startTime = micros();  // Count microseconds since start
    startChrono = 1;       // Set Chrono flag
    digitalWrite(led1, HIGH);
  }
 
  // Stop counting and calculate speed
  if(stateRear == LOW && startChrono == 1)
  {
    stopTime = micros();  // Count microseconds since start
    startChrono = 0;      // Clear Chrono flag
    elapsed = stopTime - startTime;  // Calculate elapsed time (in us)
  
    digitalWrite(led2, HIGH);
    mpsSpeed = (LENGTH*(MICRO2SEKCOEFF)) / elapsed;            // s = v * t, v = s / t
    fpsSpeed = mpsSpeed * MPS2FPSCOEFF;

    lcd.clear();
    lcd.print("Fps: ");
    lcd.print(fpsSpeed);
    Serial.println("PPS(Pies por segundo) ");
    Serial.print(fpsSpeed);
    lcd.setCursor(0, 1);
    lcd.print("m/s: ");
    lcd.print(mpsSpeed);
    Serial.println("Metros por segundo ");
    Serial.print(mpsSpeed);
    
    startChrono = 0;
    
    delay(500);
    digitalWrite(led2, LOW);
    digitalWrite(led1, LOW);  
    
  } 
  
}

void front()
{
  stateFront = !stateFront;
}

void rear()
{
  stateRear = !stateRear;
}

Publicado en Con Arduino, Descargas, Ideas y prototipos | Etiquetado , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , | Deja un comentario

Termómetro con almacenamiento en la EEPROM.

EEPROM: Electrically Erasable Progammable Read-Only Memory

La idea de éste proyecto es poder almacenar la temperatura recogida por una Arduino usando una termo resistencia LM35 conectada al puerto análogo 0.

La ventaja de usar la EEPROM de la Arduino es que no hace falta casi piezas externas que sean costosas o difíciles de conseguir.

La EEPROM es una memoria en estado sólido esto quiere decir que no tiene partes móviles y está integrada todas las Arduino sin excepción alguna.

La EEPROM a diferencia de las memorias SD o MicroSD es que no requieren de comandos complejos para su uso, no requieren partes externas para su uso, muy importante y sumamente útil, siempre están ahí para nosotros :D y ya que vienen integradas no sucederá lo típico como: “Se me olvidó la memoria” “está dañada” “se me olvidó cambiarla” “no la formatee” etc…

Su mayor desventaja es la poca capacidad que tiene :( si quisiéramos almacenar grandes cantidades de datos tendríamos que usar la función delay para hacer que cada tanto los datos sean almacenados en la EEPROM y usar algo de matemáticas.

Ahora, basta de teoría, directo al grano.

Escribí un simple código que me ayudara a almacenar la temperatura en la EEPROM para después ser leída y formateada.

Anteriormente había publicado una entrada de como usar un sensor de temperatura LM35 con una Arduino.

Enlace a la entrada: https://arduinolab.wordpress.com/2012/04/16/arduino-con-termo-resistencia-lm35-6/

Para el proyecto haran falta tres códigos.

Uno para tomar los datos del sensor y almacenarlos en la EEPROM, otro para leer los datos y por último uno para borrar la información de la EEPROM.

Mi código

/*********************************************************************************************************************************************************************************************
Termómetro con almacenamiento en EEPROM (Electrically Erasable Progammable Read-Only Memory)
La o el EEPROM es una memoria en estado sólido, lo cual significa que no tiene partes móviles, haciéndola ideal para aplicaciones que deben estar en hambientes húmedos.

Éste proyecto lo que hace simplemente es leer la temperatura de un sensor análogo conectado a una Arduino, y almacenar los datos en la EEPROM.

Debido a la poca capacidad de la EEPROM (512 bytes) no podemos almacenar mucha información en ella continuamente (a diferencia de una memoria SD), a menos que la espera sea sumamente larga.
Lo que significa que para medición de temperatura durante periodos cortos es apenas suficiente.

Para este ejemplo usé simples matemáticas, necesito almacenar la temperatura durante 8 horas 15 minutos (desde las 22:30 a las 6:45).
Para convertir de horas a segundos
8.25 * 360000 = 2970000
Para calcular cuanto tiempo debe esperar la Arduino antes de tomar una lectura nueva tome 2970000/512 (512 es la cantidad bytes que la EEPROM puede almacenar)
esto da un total de 5800.78125 segundos de espera.

Pero para hacer las cosas más fáciles lo haré con 6000 o 6 segundos.

Ejemplo de un LM 35 con Arduino: https://arduinolab.wordpress.com/2012/04/16/arduino-con-termo-resistencia-lm35-6/

Elaborado por: Pablo Andrade Mejía
http://www.arduinolab.wordpress.com
*********************************************************************************************************************************************************************************************/
//Variables a declarar
#include <EEPROM.h> //Librería para controlar la EEPROM de la Arduino
float tempC;
int tempPin = 0;
int memFull = 12;//<---- Ésta parte sigue en proceso
int addr = 0; //Cantidad de espacios (bytes) iniciales
void setup()
{
Serial.begin(9600); //Abre el puerto serial a 9600 bps
}

void loop()
{
tempC = analogRead(tempPin); //Toma los datos del sensor
tempC = (5.0 * tempC * 100.0)/1024.0;  //Convierte la señal análoga en temperatura 
Serial.println((byte)tempC); //Envía los datos al computador mediante el puerto serial
EEPROM.write(addr, tempC);
 addr = addr + 1; //Por cada dato recibido lo guarda en una de los 512 espacios disponibles en la EEPROM
  if (addr == 512) //Sí el número total de datos excede los 512 
    addr = 0; //Borrar todo y comenzar de nuevo
    digitalWrite(memFull, HIGH); //<---- Ésta parte sigue en proceso.
delay(6000); //Espera 6 segundos antes de enviar y almacenar la información en la EEPROM y enviarla al computador
}

Para leer la EEPROM

/*
 * EEPROM Read
 *
 * Reads the value of each byte of the EEPROM and prints it 
 * to the computer.
 * This example code is in the public domain.
 */

#include <EEPROM.h>

// start reading from the first byte (address 0) of the EEPROM
int address = 0;
byte value;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  // read a byte from the current address of the EEPROM
  value = EEPROM.read(address);
  
  Serial.print(address);
  Serial.print("\t");
  Serial.print(value, DEC);
  Serial.println();
  
  // advance to the next address of the EEPROM
  address = address + 1;
  
  // there are only 512 bytes of EEPROM, from 0 to 511, so if we're
  // on address 512, wrap around to address 0
  if (address == 512)
    address = 0;
    
  delay(500);
}

Formatear la EEPROM

/*
 * EEPROM Clear
 *
 * Sets all of the bytes of the EEPROM to 0.
 * This example code is in the public domain.

 */

#include <EEPROM.h>

void setup()
{
  // write a 0 to all 512 bytes of the EEPROM
  for (int i = 0; i < 512; i++)
    EEPROM.write(i, 0);
    
  // turn the LED on when we're done
  digitalWrite(13, HIGH);
}

void loop()
{
}

Publicado en Con Arduino, Descargas, Ideas y prototipos | Etiquetado , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , | 2 comentarios

Presentación de nuestro proyecto (Peachimetro Atlas Scientific y Arduino)

Como ya había mencionado antes nosotros de grado undécimo escogimos como proyecto el acceso al Hardware (Arduino) y Software libre (Processing) y después de dar muchas vueltas,  decidimos montar un peachimetro para medir el pH de las aguas lluvias.

Aquí está la presentación que hicimos.

Presentación peachimetro.

Publicado en Con Arduino, Descargas, Fuera de Arduino, Vídeos y demás | Etiquetado , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , | Deja un comentario