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

Más avances en medición de pH.

Para este último código que he modificado he tenido que usar un total de tres códigos diferentes y adaptarlos de manera que puedo ver el pH y la temperatura del agua en tiempo real en una pantalla de cristal líquido o LCD.

Los códigos que usé son:

-Custom character (para pantallas LCD).

-El de Atlas Scientific.

- Sensor de temperatura.

Primero y el mas complejo Atlas Scientific.

/*
This software was made to demonstrate how to quickly get your Atlas Scientific product running
on the Arduino platform.
An Arduino Duemilanove board was used to test this code.
This code was written in the Arudino 1.0 IDE
Modify the code to fit your system.
Code efficacy was NOT considered, this is a demo only.
The soft serial port TX line goes to the RX pin.
The soft serial port RX line goes to the TX pin.
Make sure you also connect to power and GND pins to power and a common ground.
Data is received and re-sent through the Arduinos hardware UART TX line.
Open TOOLS > serial monitor, set the serial monitor to the correct serial port and set the baud
rate to 38400.
Remember, select carriage return from the drop down menu next to the baud rate selection; not
"both NL & CR".
The data from the Atlas Scientific product will come out on the serial monitor.
Type in a command in the serial monitor and the Atlas Scientific product will respond.
*/
#include <SoftwareSerial.h>                                           
#define rxpin 2                                                               
#define txpin 3                                                                
SoftwareSerial myserial(rxpin, txpin);
String inputstring = "";
String sensorstring = "";
boolean input_stringcomplete = false;
boolean sensor_stringcomplete = false;
//enable the soft serial port
//a string to hold incoming data from the PC
//a string to hold the data from the Atlas Scientific product
//have we received all the data from the PC
//have we received all the data from the Atlas Scientific
//product

//add the soft serial library
//set the RX pin to pin 2
//set the TX pin to pin 3
void setup(){
     Serial.begin(38400);
     myserial.begin(38400);
     inputstring.reserve(5);                                                   
     sensorstring.reserve(30);                                                 
     }
//set up the hardware
//set baud rate for the hardware serial port to 38400
//set baud rate for software serial port to 38400
//set aside some bytes for receiving data from the PC
//set aside some bytes for receiving data from Atlas Scientific
//product
//if the hardware serial port receives a char
//get the char we just received
//add it to the inputString
//if the incoming character is a <CR>, 
//set the flag
void serialEvent() {
               char inchar = (char)Serial.read();
               inputstring += inchar;                                           
               if(inchar == '\r') {input_stringcomplete = true;}
              }  
void loop(){
     
  if (input_stringcomplete){
      myserial.print(inputstring);
      inputstring = "";
      input_stringcomplete = false;
      }
//here we go...
//if a string from the PC has been received in its entierty
//send that string to the Atlas Scientific product
//clear the string:
//reset the flag used to tell if we have received
//a completed string from the PC
while (myserial.available()) {
         char inchar = (char)myserial.read();
         sensorstring += inchar;                                               
         if (inchar == '\r') {sensor_stringcomplete = true;}
         }
//while a char is holding in the serial buffer
//get the new char
//add it to the sensorString
//if the incoming character is a <CR>,
//set the flag
if (sensor_stringcomplete){
       Serial.print(sensorstring);
       sensorstring = "";
       sensor_stringcomplete = false;
      }
}
//if a string from the Atlas Scientific product has been
//received in its entirety
//use the hardware serial port to send that data to the PC
//clear the string:
//reset the flag used to tell if we have received a completed
//string from the Atlas Scientific product

Segundo, Custom character.

/*
  LiquidCrystal Library - Custom Characters
 
 Demonstrates how to add custom characters on an LCD  display.  
 The LiquidCrystal library works with all LCD displays that are 
 compatible with the  Hitachi HD44780 driver. There are many of 
 them out there, and you can usually tell them by the 16-pin interface.
 
 This sketch prints "I <heart> Arduino!" and a little dancing man
 to the LCD.
 
  The circuit:
 * LCD RS pin to digital pin 12
 * LCD Enable pin to digital pin 11
 * LCD D4 pin to digital pin 5
 * LCD D5 pin to digital pin 4
 * LCD D6 pin to digital pin 3
 * LCD D7 pin to digital pin 2
 * LCD R/W pin to ground
 * 10K potentiometer:
 * ends to +5V and ground
 * wiper to LCD VO pin (pin 3)
 * 10K poterntiometer on pin A0
 
 created21 Mar 2011
 by Tom Igoe
 Based on Adafruit's example at
 https://github.com/adafruit/SPI_VFD/blob/master/examples/createChar/createChar.pde
 
 This example code is in the public domain.
 http://www.arduino.cc/en/Tutorial/LiquidCrystal
 
 Also useful:
 http://icontexto.com/charactercreator/
 
 */

// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// make some custom characters:
byte heart[8] = {
  0b00000,
  0b01010,
  0b11111,
  0b11111,
  0b11111,
  0b01110,
  0b00100,
  0b00000
};

byte smiley[8] = {
  0b00000,
  0b00000,
  0b01010,
  0b00000,
  0b00000,
  0b10001,
  0b01110,
  0b00000
};

byte frownie[8] = {
  0b00000,
  0b00000,
  0b01010,
  0b00000,
  0b00000,
  0b00000,
  0b01110,
  0b10001
};

byte armsDown[8] = {
  0b00100,
  0b01010,
  0b00100,
  0b00100,
  0b01110,
  0b10101,
  0b00100,
  0b01010
};

byte armsUp[8] = {
  0b00100,
  0b01010,
  0b00100,
  0b10101,
  0b01110,
  0b00100,
  0b00100,
  0b01010
};
void setup() {
  // create a new character
  lcd.createChar(0, heart);
  // create a new character
  lcd.createChar(1, smiley);
  // create a new character
  lcd.createChar(2, frownie);
  // create a new character
  lcd.createChar(3, armsDown);
  // create a new character
  lcd.createChar(4, armsUp);

  // set up the lcd's number of columns and rows: 
  lcd.begin(16, 2);
  // Print a message to the lcd.
  lcd.print("I ");
  lcd.write(0);
  lcd.print(" Arduino! ");
  lcd.write(1);

}

void loop() {
  // read the potentiometer on A0:
  int sensorReading = analogRead(A0);
  // map the result to 200 - 1000:
  int delayTime = map(sensorReading, 0, 1023, 200, 1000);
  // set the cursor to the bottom row, 5th position:
  lcd.setCursor(4, 1);
  // draw the little man, arms down:
  lcd.write(3);
  delay(delayTime);
  lcd.setCursor(4, 1);
  // draw him arms up:
  lcd.write(4);
  delay(delayTime);
}

Sensor de temperatura.

//declare variables
float tempC;
int tempPin = 0;

void setup()
{
Serial.begin(9600); //opens serial port, sets data rate to 9600 bps
}

void loop()
{
tempC = analogRead(tempPin); //read the value from the sensor
tempC = (5.0 * tempC * 100.0)/1024.0;  //convert the analog data to temperature
Serial.print((byte)tempC); //send the data to the computer
delay(1000); //wait one second before sending new data
}

Para después obtener esto.

/*
This software was made to demonstrate how to quickly get your Atlas Scientific product running
on the Arduino platform.
An Arduino Duemilanove board was used to test this code.
This code was written in the Arudino 1.0 IDE
Modify the code to fit your system.
Code efficacy was NOT considered, this is a demo only.
The soft serial port TX line goes to the RX pin.
The soft serial port RX line goes to the TX pin.
Make sure you also connect to power and GND pins to power and a common ground.
Data is received and re-sent through the Arduinos hardware UART TX line.
Open TOOLS > serial monitor, set the serial monitor to the correct serial port and set the baud
rate to 38400.
Remember, select carriage return from the drop down menu next to the baud rate selection; not
"both NL & CR".
The data from the Atlas Scientific product will come out on the serial monitor.
Type in a command in the serial monitor and the Atlas Scientific product will respond.
*/
#include <SoftwareSerial.h>//add the soft serial library
#include <LiquidCrystal.h>
/*Atlas Scientific in the code source defined the RX pin as digital pin 2 and TX pin as digital pin 3
and since I'll be using a LCD display in order to print the current water pH, I adapted the code to
use the already defined TX and RX pins on the Arduino UNO.

I might attach a temperature sensor; such as the LM35 and variants in order to see if the temperature
affects the water pH as well.

* LCD RS pin to digital pin 12
 * LCD Enable pin to digital pin 11
 * LCD D4 pin to digital pin 5
 * LCD D5 pin to digital pin 4
 * LCD D6 pin to digital pin 3
 * LCD D7 pin to digital pin 2
 * LCD R/W pin to ground
 * 10K potentiometer:
 * ends to +5V and ground
 * wiper to LCD VO pin (pin 3)
 * 10K poterntiometer on pin A0

*/

#define rxpin 0//set the RX pin to pin 0                                                             
#define txpin 1                                                               
SoftwareSerial myserial(rxpin, txpin);//enable the soft serial port
String inputstring = "";//a string to hold incoming data from the PC
String sensorstring = "";//a string to hold the data from the Atlas Scientific product
boolean input_stringcomplete = false;//have we received all the data from the PC
boolean sensor_stringcomplete = false;//have we received all the data from the Atlas Scientific product
float tempC;
int tempPin = 1;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup(){ //set up the hardware                                                           
     Serial.begin(38400); //set baud rate for software serial port to 38400                                                
     myserial.begin(38400); //set baud rate for software serial port to 38400                                                  
     inputstring.reserve(5); //set aside some bytes for receiving data from the PC                                                
     sensorstring.reserve(30); //set aside some bytes for receiving data from Atlas Scientific product                                              
     }

void serialEvent() { //if the hardware serial port receives a char                                                        
               char inchar = (char)Serial.read(); //get the char we just received                             
               inputstring += inchar; //add it to the inputString                                         
               if(inchar == '\r') {input_stringcomplete = true;} //if the incoming character is a <CR>, set the flag           
              }  
void loop(){ //here we go...                                                            
     
  if (input_stringcomplete){ //if a string from the PC has been received in its entierty                                                
      myserial.print(inputstring); //send that string to the Atlas Scientific product                                        
      inputstring = ""; //clear the string:                                                     
      input_stringcomplete = false; //reset the flag used to tell if we have received a completed string from the PC                                     
      }
      
while (myserial.available()) { //while a char is holding in the serial buffer                                             
         char inchar = (char)myserial.read(); //get the new char                                 
         sensorstring += inchar; //add it to the sensorString                                            
         if (inchar == '\r') {sensor_stringcomplete = true;} //add it to the sensorString if the incoming character is a <CR>, set the flag      
         }

if (sensor_stringcomplete){                                                 
       Serial.println(sensorstring); //if a string from the Atlas Scientific product has been received in its entirety                                        
       lcd.print(sensorstring); //use the hardware serial port to send that data to the PC clear the string:
       sensorstring = "";                                             
       delay(10000); //Hold the pH for ten seconds
       sensor_stringcomplete = false; //reset the flag used to tell if we have received a completed                                          
      }
{
  lcd.print("                ");//Command to clear the lcd display after the pH data is received string from the Atlas Scientific product
  tempC = analogRead(tempPin);//Read the value from the sensor
  tempC = (5.0 * tempC * 100.0)/1024.0;//Convert the analog data to temperature
  Serial.print((byte)tempC);//Send the data to the computer
  lcd.print((byte)tempC);//Print temperature.
  delay(10000);//Hold temperature for ten seconds
}
}

Disfruten el dolor de cabeza :P

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