DATA LOGGING SD
http://www.prometec.net/importar-csv-excel/
0.- TEORÍA: DATA LOGGING SD
1.- SD Y DHT11
2.- SD Y LDR
0.- TEORÍA: DATA LOGGING SD.
Características del Data Logger Shield:
- Interface para de tarjetas SD: FAT 16 y FAT32.
- Real Time Clock incluido basado en el RTC integrado 1307.
- Porta pilas incluido para mantener la fecha durante años.
- Regulador propio de 3.3V para alimentar la tarjeta SD.
- Zona de prototipos para incluir tus sensores.
- Unas librerías ad hoc, para arrancar rápido con la toma de datos.
USO DE UN RELOJ EXTERNO
Como configurar el reloj de esta shield: http://www.prometec.net/data-logger-shield/
Arduino inorpora un reloj intereno para su funcionamiento básico pero en esta ocasión si queremos una medición más profesional deberemos utilizar el Reloj de tiempo real o RTC basado en el chip 1307 que incorpora nuestro módulo datalogger.
¿Por qué usar un reloj externo cunado Arduino tiene su propio reloj con millis ()?
En primer lugar porque el reloj interno cuenta mili segundos desde que Arduino arrancó y no tiene una referencia real con el tiempo universal (O sea la hora de tu reloj)
Podríamos a pesar de todo, ponerle en hora ese reloj y funcionaria correctamente… durante un tiempo, hasta que se reinicie a 0 al cabo de unos pocos días, porque tiene capacidad limitada, y además si por cualquier razón nuestro equipo se apagase volvería a contar el tiempo desde 0, lo que falsearía nuestros datos irrevocablemente.
El reloj interno de Arduino es muy útil para proyectos que requieren medir tiempos cortos, pero no toma de datos a largo plazo (más allá de unos días) y por eso surge este tipo de relojes con respaldo de batería. Para que puedan funcionar con una fecha y hora precisas durante años (Al menos 5, según el fabricante).
En el mismo shield incluye el porta baterías con lo que nos resuelve dos problemas al tiempo.
Aseguraros de que tenéis la batería colocada antes de empezar a trabajar con él (Y con las letras de la batería en la cara visible) porque pueden pasar cosas raras si manejáis el shield sin la batería en su sitio.
Si es la primera vez que usas el shield, la hora no estará fijada y se verá sin la hora configurada. Para ello figura la línea de código:
//RTC.adjust(DateTime(__DATE__, __TIME__));
que en la primera compilación deberás quitar las barras del comentario y luego ponerlas y volver a compilar y subir para que no se quede con esta instrucción siempre puesto que cada vez que se reinicie volvería a cargar la misma hora de base.
Como el RTC DS1307 es un reloj I2C, el shield se reserva los pines A4 y A5 para su manejo, y para programarlo vamos a usar la librería RTClib-master.
CÓDIGO DEL RELOJ
#include <Wire.h>
#include "RTClib.h" //librería del reloj de la shield RTClib_master
RTC_DS1307 RTC;
void setup () {
Serial.begin(9600);
Wire.begin();
RTC.begin();
if (! RTC.isrunning()) {
Serial.println("RTC is NOT running!");
//RTC.adjust(DateTime(__DATE__, __TIME__)); //quitar comentario y luego volver a ponerlos
}
}
void loop () {
DateTime now = RTC.now();
Serial.print(now.year(), DEC);
Serial.print('/');
Serial.print(now.month(), DEC);
Serial.print('/');
Serial.print(now.day(), DEC);
Serial.print(' ');
Serial.print(now.hour(), DEC);
Serial.print(':');
Serial.print(now.minute(), DEC);
Serial.print(':');
Serial.print(now.second(), DEC);
Serial.println();
Serial.print(" since 1970 = ");
Serial.print(now.unixtime());
Serial.print("s = ");
Serial.print(now.unixtime() / 86400L);
Serial.println("d");
//esta librería permite determinar fecha futura con sumas de días seg.
DateTime future (now.unixtime() + 7 * 86400L + 30);
Serial.print(" now + 7d + 30s: ");
Serial.print(future.year(), DEC);
Serial.print('/');
Serial.print(future.month(), DEC);
Serial.print('/');
Serial.print(future.day(), DEC);
Serial.print(' ');
Serial.print(future.hour(), DEC);
Serial.print(':');
Serial.print(future.minute(), DEC);
Serial.print(':');
Serial.print(future.second(), DEC);
Serial.println();
Serial.println();
delay(5000);
}
TARJETA SD
Imagínate que queremos guardar la temperatura y la humedad de un secadero de chorizos (Por poner un ejemplo) con su fecha y hora Unix para su estudio posterior.
Usaríamos un long 32 bits para la fecha, más dos byte para temperatura y humedad. En total 6 bytes. Pongamos 10 para poder registrar otro par de valores de integers.
Si tomamos una muestra cada minuto, son 60 por hora y 1.440 muestras diarias. A 364 días por año suponen 524.160 muestras al año de 10 bytes. Es decir necesitamos 5 GBytes largos por año.
Hoy no es difícil conseguir tarjetas SD de 32 GB por 15€ con lo que podríamos almacenar sobre 6 años de datos sin pasar a leer la tarjeta. No está mal ¿No? Por eso las SDs se utilizan profusamente en Arduinos, Raspberrys y demás fauna de bajo coste. Son pequeñas, baratas y eficaces. No se puede pedir más.
En primer lugar aseguraros de vuestra tarjeta SD esta formateada en FAT16 o FAT32, porque la librería no reconoce otras cosas.
Necesitáis descargar e instalar la librería correspondiente sdfatlib, y ya estamos listos para probar. Una vez cargada la librería, abrir el ejemplo que lleva incorporada y que encontrareis en: \\Ejemplos\SD-Master\CardInfo
Es un programita que simplemente comprobara que tu tarjeta está correctamente insertada y formateada de modo reconocible.Básicamente os informa de que ve la SD, que esta formateada en FAT32 en mi caso, su tamaño y cosas así. Además como yo tenía algo más escrito en ella devuelve un listado de ficheros.
En realidad lo importante es que no te dé un mensaje como este:
1.-DHT11
Vamos a usar un simple DHT11 como sensor de temperatura y humedad para tomar un par de valores típicos y guardarlos en la SD, y para ello vamos a usar un circuito atípico, así ahorramos cableado.
El circuito consiste simplemente en montar el DHT11 con sus pines directamente encajados en los pines hembras de nuestro shield de data Logging, mas o menos así. En ocasiones no funciona, por lo que tendrás que recurrir a alimentar el VCC y GND como siempre.
Como no consume casi nada, establecemos estas conexiones:
- VCC 5V (o pin5)
- pin7: será nuestra entrada de lectura del módulo DHT11
- GND
CÓDIGO DHT11 (sin SD):
#include <DHT11.h> //cargar la libreria DHT11.ZIP
int pin=7;
DHT11 dht11(pin);
void setup() {
Serial.begin(9600);
}
void loop() {
int err;
float temp, hum;
if((err = dht11.read(hum, temp)) == 0) { // Si devuelve 0 es que ha leido bien
Serial.print("Temperatura: ");
Serial.print(temp);
Serial.print(" Humedad: ");
Serial.print(hum);
Serial.println();
}
else {
Serial.print("Error Num :");
Serial.print(err);
Serial.println();
}
delay(1000);
}
CON OTRA LIBRERÍA
#include <SimpleDHT.h> //SampleDHT sacada de gestión zip IDE
int pinDHT11 = 7;
SimpleDHT11 dht11;
void setup() {
Serial.begin(9600);
pinMode(5,OUTPUT);
pinMode(7,OUTPUT);
digitalWrite(5,HIGH);
digitalWrite(7,LOW);
}
void loop() {
byte T = 0;
byte H = 0;
if (dht11.read(pinDHT11, &T, &H, NULL)) {
Serial.print("Fallo en la lectura del SampleDHT11");
return;
}
Serial.print("Lecturas OK: ");
Serial.print((int)T); Serial.print(" *C, ");
Serial.print((int)H); Serial.println(" %");
delay(1500);
}
Para hacer variar os valores, de humedad y temperatura y comprobar que todo funciona correctamente, podeis, sencillamente, enviar vuestro aliento al sensor, y salvo que estéis en el trópico haréis subir tanto la temperatura como la humedad relativa.
1.- DHT CON LA SD
http://www.prometec.net/data-logger-shield/
Así que ya tenemos listo el sensor para leer temperatura y humedad, además del reloj de tiempo real. Solo nos queda ver como utilizamos la tarjeta SD, y el tema no da para mucho.
Básicamente hay que incluir una llamada a SD_lib como siempre, e incluir un par de librerías para usarla. Aquí os dejo el programa completo Prog_141_3
La librería usa SPI para comunicarse con el lector de SD, y el shield usa el pin digital 10 como chip Select
http://www.prometec.net/data-logger-shield/
CÓDIGO COMPLETO CON SD:
#include <DHT11.h>
#include <SD.h>
#include <Wire.h>
#include <SPI.h> // Necesario para la SD card
#include "RTClib.h"
DHT11 dht11(6); // Definimos el sensor de temperatura
RTC_DS1307 RTC; // Definimos el reloj
File logfile; // Fichero a escribir en la SD
const int chipSelect = 10; // SD card pin select
const bool eco = true ;
int count = 0 ; // para contar el volcado a la SD
int countMAX=5; //decidimos cada cuanto tiempo vuelca los datos a SD
void setup(){
Serial.begin(9600);
pinMode(5, OUTPUT) ; // DHT11 GMD
pinMode(7, OUTPUT) ; // DHT11 Vcc
pinMode(6, INPUT_PULLUP) ; // DHT11 pin de lectura
pinMode(chipSelect, OUTPUT); // SD card pin select
digitalWrite(7, HIGH) ; // Damos tension al DHT11
digitalWrite(5, LOW) ;
if (!SD.begin(chipSelect))
error("No hay tarjeta SD.");
else
Serial.println("Tarjeta SD inicializada.");
// Creamos el fichero de registro
char filename[] = "LOGGER00.CSV";
for (uint8_t i = 0; i < 100; i++) {
filename[6] = i/10 + '0';
filename[7] = i%10 + '0';
if (! SD.exists(filename)) { // Si no existe el fichero, lo creamos
logfile = SD.open(filename, FILE_WRITE);
break; // leave the loop!
}
}
if (! logfile)
error("No s epudo crear el fichero de registro");
Serial.print("Registrando en: "); Serial.println(filename);
// connect to RTC
Wire.begin();
if (!RTC.begin())
logfile.println("No hay RTC.");
else
Serial.println("RTC correcto. Iniciando captura de datos");
logfile.print("Fecha/Hora") ;
logfile.print(", ");
//logfile.print(" ID ") ;
//logfile.print(", ");
logfile.print("Temp") ;
logfile.println("Humedad") ;
}
void loop(){
DateTime now;
int err ;
float temp, hum;
if((err = dht11.read(hum, temp)) == 0) { // Si devuelve 0 es que ha leido bien
now = RTC.now();
logfile.print(now.unixtime()); // seconds since 1/1/1970
logfile.print(", ");
//logfile.print(count);
//logfile.print(", ");
logfile.print(temp);
logfile.print(", ");
logfile.println(hum);
if ( count++ > countMAX ) {
logfile.flush(); // Para forzar la escritura en la SD
count = 0 ; // Cada countMAX lecturas
}
if (eco) {
Serial.print(now.unixtime()); // seconds since 1/1/1970
Serial.print(", ");
Serial.print(count);
Serial.print(", ");
Serial.print(temp);
Serial.print(", ");
Serial.println(hum);
}
}
else {
Serial.println();
Serial.print("Error Num :");
Serial.print(err);
Serial.println();
}
delay(1000); //Recordad que solo lee una vez por segundo
}
void error(char *str){
Serial.print("error: ");
Serial.println(str);
while(1);
}
1.- DATALOGGING SD Y LDR
Así pues, realizaremos un tutorial sencillo dónde almacenaremos datos de Luz en nuestra SD mediante un sensor LDR
Una vez ensamblada, conectaremos nuestros 3.3V de la Shield a nuestra línea de la protoboard para facilitarnos el montaje (cuidado en la foto han puesto a 3.3v la línea azul de "-" por lo que no te fíes del dibujo).
CONEXIONES:
3.3 V >>>REF de la shield
3.3V >> LDR
LDR en su divisor de tensión>> A0
GND >> Resistencia 1k
La siguiente conexión será AREF con 3.3V. Realmente para nuestro tutorial este paso no haría falta pero si decidimos que en vez de medir luz, queremos medir temperatura esta conexión nos facilitará poder definir la tensión constante para realizar nuestros cálculos para el cambio de unidades.
Seguidamente, conectaremos nuestro LDR y nuestra resistencia como muestra nuestro esquema eléctrico del principio. Sabemos, que nuestro LDR necesita estar conectado con la tensión, para ello el cable rojo lo conectaremos con la pata izquierda de nuestro sensor de luz. De nuestro sensor también deberá salir un cable para poder leer los datos. El cable naranja conectará con nuestro puerto A0. Por último conectaremos después de la resistencia el cable negro que irá conectado a GND.
debemos proceder a abrir el Monitor de Serie. Una vez abierto veremos como se produce la inicialización de la SD y veremos un muestreo de nuestro sensor de Luz.
Cuando haya transcurrido el tiempo necesario para nuestro experimento, desconectamos nuestro Arduino y extraemos nuestra SD de la Shield. Ahora la montamos en el ordenador y aparecerá un fichero con extensión .txt como el siguiente:
Ahora, para que estos datos me puedan resultar útiles los trasladaremos a una hoja de excel. Procederemos a abrir Excel y seguiremos la secuencia Archivo>Importar.
Tras seguir el
asistente de importación de archivos podremos trabajar con nuestros
datos creando gráficas, operando con ellos buscando máximos o
mínimos...etc.
CÓDIGO:
// Incluimos las librerias necesarias para trabajar con SD
#include <SPI.h>
#include <SD.h>
int photocellPin = A0; // El sensor lleva una resistencia de 1K
int photocellReading; // Lectura analogica del sensor
#define redLEDpin 2
#define greenLEDpin 3
// En nuestra shield el pin SD es el 10.
const int chipSelect = 10;
void setup()
{
// Abrimos el Puerto de Serie para monitorizar el movimiento de nuestro sensor
Serial.begin(9600);
while (!Serial) {
;
}
pinMode(redLEDpin, OUTPUT);
pinMode(greenLEDpin, OUTPUT);
#if WAIT_TO_START
Serial.println("Type any character to start");
while (!Serial.available());
#endif //WAIT_TO_START
Serial.print("Initializing SD card...");
// Comprobamos que la SD esta preparada para realizar la copia de datos:
pinMode(10, OUTPUT);
// visualiza si existe SD y si esta bien inicializada:
if (!SD.begin(chipSelect)) {
Serial.println("Card failed, or not present");
// Si responde con fallo el programa no haria nada mas:
return;
}
Serial.println("card initialized.");
}
void loop() {
photocellReading = analogRead(photocellPin);
Serial.print("Lectura de Luz = ");
Serial.print(photocellReading); // Leemos datos en el pin
// Categorias
if (photocellReading < 10) {
Serial.println(" - Oscuro");
} else if (photocellReading < 200) {
Serial.println(" - Poco Luminoso");
} else if (photocellReading < 500) {
Serial.println(" - Luminoso");
} else if (photocellReading < 800) {
Serial.println(" - Muy Luminoso");
} else {
Serial.println(" - Demasiado Luminoso");
}
delay(1000);
// Abrimos el fichero. Nota: solo se puede abrir un fichero a la vez. Para abrir un segundo fichero hay que cerrar el anterior.
File dataFile = SD.open("datalog.txt", FILE_WRITE);
// si el fichero esta disponible escribir en el:
if (dataFile) {
dataFile.println(photocellReading);
dataFile.close();
// escribe tambien en el Serial:
Serial.println(photocellReading);
}
// Si el fichero no se ha abierto, lanzar un mensaje de error:
else {
Serial.println("error opening datalog.txt");
}
digitalWrite(redLEDpin, HIGH);
dataFile.flush();
digitalWrite(redLEDpin, LOW);
}
http://hetpro-store.com/TUTORIALES/modulo-lector-microsd-datalogger/
