Control de consumo eléctrico con Arduino (2)

IMPORTANTE: actualizado el software a la versión 1.2 … detalles.

Volvemos a ocuparnos del «control de consumo eléctrico» y proponemos un nuevo montaje – más bien un añadido de prestaciones – para Arduino. Tras nuestra primera entrada sobre el tema – donde comentábamos la forma de poner en marcha la medición con el sensor de consumo modelo SCT-013-030 – damos una vuelta de tuerca más al tema y añadimos un par de utilidades al montaje, a saber:

Un control de tiempo (fecha y hora) mediante módulo RTC
Volcado de lecturas a tarjeta SD mediante módulo microSD

Estos dos añadidos nos van a permitir medir la potencia consumida por los dispositivos de nuestra elección y, gracias al concurso del módulo RTC, crear un registro (con el correspondiente TimeStamp) y guardar los datos de consumo en SD junto a la hora exacta de los mismos.

Hemos dividido esta entrada en cinco secciones diferenciadas para intentar no obviar ninguna de las posibilidades de este interesante montaje, estas son:

Descripción general del montaje.
Captura de potencia consumida.
Captura de datos de Fecha/Hora (RTC).
Volcado de datos a tarjeta microSD.
Descripción del programa utilizado.

Pero como Jack dijo, vayamos por partes…

– Descripción general del montaje –

Ya hemos comentado que la base de este circuito tiene su origen en la entrada publicada como «Control de consumo eléctrico con Arduino (1)«,

y respecto a la forma de «medir» la potencia no ha variado gran cosa. A nivel hardware al circuito original se le han añadido dos elementos nuevos, estos son:

Placa de prototipo Arduino que incorpora lector de tarjeta microSD y circuiteria necesaria +
Kit de pines hembra (6) y Kit de pines hembra (8) Un (un par de cada uno)
Un modulo RTC que gestiona el control de Fecha/Hora mediante el chip DS1307.

Además, al esquema eléctrico se le ha añadido un diodo LED que nos sirve para indicarnos diversos «status» del montaje.

Resumiendo, los componentes precisos para todo el montaje serían:

Podemos localizar los componentes electrónicos en cualquier comercio del ramo y, referente a los módulos microSD y RTC, ambos están disponibles, por ejemplo, en la tienda BricoGeek.

El montaje de la parte microSD no tiene misterio alguno: se inserta sobre los propios pines hembra del Arduino. Eso si, hemos aprovechado la zona de prototipado de este «Shield» para implementar cómodamente el montaje sobre la misma. Además, se ha reservado espacio para insertar el pequeño modulo RTC encargado de «poner el circuito en hora». El aspecto del montaje ya implementado es este … bueno, puede variar según el gusto / habilidad de cada uno 😉

La conexión del Arduino y el módulo microSD hace uso de las patillas D8, D12 y D13.

Respecto al software a utilizar lo comentamos despues, pero os adelanto que el módulo RTC se usa sin añadir librerias extra al entorno Arduino, tan solo se utiliza la wire.h que este ya incorpora, no siendo así en el caso del módulo microSD , en cuyo caso hemos recurrido a la libreria SdFat disponible en la Web (hemos usado la última versión).

Y respecto al módulo RTC, su conexionado precisa tan solo de dos hilos (mas alimentación). Podemos ver algunos detalles añadidos en la entrada entrada sobre Arduino y DS1307 publicada anteriormente.

– Captura de potencia consumida –

La rutina interna del programa de «medida» de potencia es básicamente la misma, y el hardware – como ya comentamos – se ocupa de rectificar en onda completa la señal proveniente del sensor y adaptarla luego (mediante el segundo A.O. incluido en el LM358) al nivel de trabajo (0-5 V) del Arduino.

Como quiera que se obtienen algunas informaciones añadidas (lease RTC y estado del guardado de LOG) hemos reducido la información que se ofrece via terminal al usuario en lo que respecta a la medición, dejando tan solo la referente a potencia (en vatios esta vez) y tensión, aunque el programa contiene variables internas que pueden mostrarse con tan solo ligeras variaciones del código.

Ahora en el terminal serie podemos ver esta información acompañada de los datos de fecha/hora (TimeStamp), los datos que se guardan periodicamente en el fichero LOG y el estado (satisfactorio o no) de dicho guardado. Nos mostrará – al margen del volcado a tarjeta microSD – algo como esto …

Podemos variar el dato a guardar en nuestro LOG. En el programa ejemplo se genera por cada medida una nueva línea en el fichero «power.log» en formato csv , fácilmente tratable a posteriori por cualquier herramienta software. Vemos que se separan los campos …

fecha (YYYYMMDD) ; hora (hh:mm:ss) ; tensión (voltios) ; potencia (vatios)

– Captura de datos de Fecha/Hora (RTC) –

Para dotar a nuestro control de consumo Arduino de «fecha y hora» de una manera sencilla usamos el módulo RTC (Real Time Clock) que utiliza como núcleo de su operativa el chip DS1307, el cual incorpora unos pocos componentes periféricos y una pila tipo botón que se encargará de que guarde fecha y hora aunque desconectemos el módulo del Arduino. En la entrada «Arduino y DS1307» ya describimos este interesante módulo.

Entre los programas incluidos para descarga al final de esta entrada están

Set_RTC : que imprescindiblemente hemos de utilizar en primer lugar para «poner en hora» nuestro DS1307.
Lee_RTC : que nos servirá de control extra para verificar que el montaje «está en hora».

Nota: es ¡ IMPORTANTE ! que editemos las posiciones de fecha y hora en el programa Set_RTC – lógicamente – para que al ejecutarlo se escriban dichos datos en la memoria del chip. Una vez en hora, y gracias a la batería que incorpora el módulo, no hemos de preocuparnos más por su ajuste. Tan solo lo utilizaremos como reloj de consulta (por ejemplo, con el programa Lee_RTC). Editamos estos datos (año, mes, dia…etc.) fijándonos en el formato admitido para cada uno de ellos.

– Volcado de datos a tarjeta microSD –

Para guardar los datos de fecha/hora y consumo eléctrico urilizaremos un módulo modelo Sparkfun que incorpora ya el lector para la tarjeta microSD así como la circuitería precisa para su manejo por Arduino. Esta placa contiene además una zona específica para el montaje de prototipos, que es donde hemos implementado el circuito intefaz para «medir» a partir del sensor no invasivo SCT-013-030.

En la entrada Control de consumo electrico con Arduino(1) – tenemos algunos detalles más específicos sobre el mismo y su conexionado. Como ya hemos comentado, la tarjeta de prototipo con lector SD incorporado puede localizarse en Bricogeek.

Recordamos que para su conexionado al Arduino tendremos que adquirir también los cuatro juegos de pines hembra: dos de 6 pines y dos de 8 pines. Una vez soldados estos el aspecto de la placa – lista para montarse sobre nuestro Arduino – será parecido a este …

En lo que respecta al software uilizado para el control de la tarjeta microSD (lectura, escritura, SD) hemos hecho uso de las librerías SdFat existentes en esta página y cuyo proceso de instalación es sencillo. En caso de duda podemos consultar el tutorial incluido en su propio fichero de ayuda (QuickStart.txt) o bien obtener algo mas de información en la página guía de Arduino sobre como instalar librerías adicionales.

En el fichero descargable del final de esta entrada se incluye un programa para testear la operativa de lectura / escritura en el módulo microSD.

– Descripción del programa utilizado –

El programa «Power_LOG» que hemos desarrollado para poner en marcha el montaje está constituido por una rutina de medición de señal del sensor practicamente similar a la publicada en la entrada anterior, además de las variables y rutinas extra para el manejo de módulo RTC y de la placa con lector de tarjeta SD.

Algunos de los parámetros que debemos prefijar / verificar en la parte inicial del programa son:

– chipSelect = 8; -> debe ser 8 (para módulo SD de Sparkfun).

– int retardo = 5 ; -> retardo (s.) entre muestreos.

– vV = 230; -> tensión existente en lugar a medir.

– ff = 5; -> frecuencia de la tensión a medir. ( 50Hz -> 5 / 60Hz -> 4.15) )

A modo de resumen vamos a comentar el proceso que se genera en el bucle loop ( ) del programa, haciendo hincapié en las particularidades más interesantes de cada una de ellas. Este sería el organigrama del citado bucle …

Nota : queda claro que antes de probar el programa tendremos que haber cableado correctamente el módulo RTC y efectuado su «puesta en hora».

Lo primero que efectúa la rutina principal es la consulta de fecha/hora desde el módulo RTC – LeeRTC ( ) -, sin fijarnos en que la misma sea correcta o no, luego ya lo comprueba el programa. Inmediatamente se llama a EfetuaMedida ( ) , rutina que lee los valores registrados por el sensor de intensidad y rellena las variables programadas al efecto.

A continuación el programa realiza dos chequeos interesantes, a saber :

CheckSD ( ) -> verifica que tenemos una tarjeta microSD disponible en el lector del módulo, donde se escribirá el LOG de datos (fichero power.log). En caso de que esta verificación no sea correcta se genera un mensaje de ERROR y el programa – a pesar de que muestra la medida efectuada – obviará la escritura en tarjeta microSD (además de activar el LED en modo fijo).

CheckRTC ( ) -> verifica la existencia (conexionado correcto ) del módulo RTC. ¡ Ojo ! … no se verifica la hora/fecha correcta – eso es responsabilidad de cada usuario – sino la presencia y operativa del módulo RTC. Para ello se recurre a la estrategia de escribir un dato en la zona extra de memoria RAM que incorpora el chip DS1307 : generamos un número aleatorio y lo escribimos y leemos de dicha posición. Si el valor escrito y el leído coinciden tendremos la certeza de que el módulo RTC esta correctamente conectado y operativo. Al igual que ocurre con el chequeo de SD, en caso de que esta verificación de RTC no sea correcta se nos genera un mensaje de ERROR y el programa refleja la medida, pero no escribe el LOG en la tarjeta SD (además de activar el LED en modo fijo).

El diodo LED incorporado al circuito se encarga de informarnos del estado del programa. Dichos estados mostrados por el LED pueden ser:

* LED parpadea rápidamente => se está iniciando el programa. Sucede al energizar el circuito.

* LED emite un destello => lo hace cada vez que se efectúa un muestreo (y grabado en microSD).

* LED permanece fijo => ERROR en módulo RTC o bien en módulo microSD (tarjeta no detectada).

PROGRAMA PARA MEDIDA DE CONSUMO CON REGISTRO (LOG)

// ============================================================
// =   Arduino PowerLOG  -  DIVERTEKA  (Abril 2014)  v. 1.1   =
// =   Develop by Txus [J.C. Garcia Preciado]                 =
// ============================================================
// Parte de este codigo esta basado en:
// RTC Control ==>  <http://www.combustory.com> John Vaughters
// SD Control ===> <http://code.google.com/p/sdfatlib>
// ------------------------------------------------------------
const int chipSelect = 8; // <=== IMPORTANTE (Sparkfun cs pin) 
#include "Wire.h"
#include <SdFat.h>
#define DS1307_I2C_ADDRESS 0x68  //  direccion I2C 
// ------------------------------------------------------------
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
const int analogInPin = A0;     // pin de entrada analogica
int retardo = 5;                // (tiempo (s.) entre lecturas)
float lectura,ff,pW,iA,vV,vS,S_Ratio;
int voltios,vatios;
int SD_OK = 0 ; 
SdFat sd;
SdFile myFile;
char Volts [10];
char Vats  [10];
int StatusLED = 6; 
// ------------------------------------------------------------
void setup() {
  pinMode(StatusLED, OUTPUT);
  Blink(10);
  int n = 1;
  Wire.begin();  
  Serial.begin(9600); 
  S_Ratio = 36.5;          // Sensor/ratio (mV/mA ) : 36.5
  vV = 230;                // valor de tension a computar
  ff = 5;     // freq. factor / (50Hz -> 5 / 60Hz -> 4.15)  
  while (!Serial) { }     // solo necesario para A. Leonardo
  Serial.print("- Iniciando programa PowerLOG " ); 
  pinMode(10, OUTPUT);
  for (n;n<4;n++){
      delay(300);
      Serial.print(n);}
  Serial.println(".");
  Serial.println(" ");
  Serial.print("- Inicializando SD ...");
  if (!sd.begin(chipSelect, SPI_HALF_SPEED)) {
    Serial.println(" ERROR.");
    return;
  }
  Serial.println(" OK."); 
}
// ------------------------------------------------------------
void Blink(int n)
{
  int i;
   for (i=0;i<n;i++){
    digitalWrite(StatusLED, HIGH);  delay(50); 
    digitalWrite(StatusLED, LOW);   delay(50);
  }
}
// ------------------------------------------------------------
byte bcdToDec(byte val)
{
  return ( (val/16*10) + (val%16) );
} 
// ------------------------------------------------------------
byte decToBcd(byte val)
{
  return ( (val/10*16) + (val%10) );
}
// ------------------------------------------------------------
float smoothread(){  
  int ni = 35;   // n. iteraciones => smooth (10-50)
  float retorno = 0.0;
  for (int x = 0; x< ni; x++){
  do {                         // espero paso por cero  
      delayMicroseconds(100); 
      } while (analogRead(0) != 0) ;
      delay (ff);            // espera centro de ciclo
      delay (10);            // estabilizacion CAD
      retorno = retorno +(analogRead(0)); 
    }
  return retorno / ni; 
}
// ------------------------------------------------------------
void LeeRTC(){
  Wire.beginTransmission(DS1307_I2C_ADDRESS); 
  Wire.write((byte)0x00);                     
  Wire.endTransmission();                     
  Wire.requestFrom(DS1307_I2C_ADDRESS, 7);    
  second     = bcdToDec(Wire.read() & 0x7f);  
  minute     = bcdToDec(Wire.read());
  hour       = bcdToDec(Wire.read() & 0x3f);  
  dayOfWeek  = bcdToDec(Wire.read());
  dayOfMonth = bcdToDec(Wire.read());
  month      = bcdToDec(Wire.read());
  year       = bcdToDec(Wire.read());
}
// ------------------------------------------------------------
String fprint (int dato) // formatea dato a dos digitos
{
String retorno = String(dato);
if (retorno.length() < 2) 
  retorno = "0" + retorno;
return retorno;
}
// ------------------------------------------------------------
void EfectuaMedida() // calcula datos desde sensor SCT013
{
  Serial.println();
  Serial.println("===================================");
  Serial.println("  * PowerLOG - DIVERTEKA v. 1.0 *  " );
  Serial.println("===================================" );
  Serial.print("Midiendo: ");
  // Capturo variables float 
  lectura = smoothread () / 1.41;   // lectura (rms)   
  vS = (lectura * 0.0048);          // valor de C.A.D.
  iA = (lectura * S_Ratio)/1000;    // Intensidad (A.)
  pW = vV * iA;                     // Potencia (vat.)
  // Casting a int para escritura en fichero LOG
  voltios = (int)vV;
  vatios = (int)pW;
  Serial.print (voltios);
  Serial.print(" voltios, " );
  Serial.print(vatios); 
  Serial.println(" vatios" );
  Serial.println("-----------------------------------" );
}
// ------------------------------------------------------------
int CheckSD() // verifica tarjeta SD OK
{
  return sd.begin(chipSelect, SPI_HALF_SPEED);  
}
// ------------------------------------------------------------
void EscribeLog (String dato) // escribe datos en fichero LOG
{
  if (!myFile.open("power.log", O_RDWR | O_CREAT | O_AT_END)) {
    Serial.println(" ERROR en tarjeta SD !!");
    Serial.println("-----------------------------------" );
    return;
  }
  myFile.println(dato);
  myFile.close();
  Serial.println(" OK.");
}
// ------------------------------------------------------------
int CheckRTC() // verifica modulo DS1307 OK
{
 int retorno = 0; 
 int valorA,valorB;
 long randNumber;
 randomSeed(analogRead(0));
 randNumber = random(1,100);
 valorA = (int)randNumber;
 // escribo en RAM DS1307
 Wire.beginTransmission(DS1307_I2C_ADDRESS);  
 Wire.write((byte)0x09);   
 Wire.write(decToBcd(valorA));                      
 Wire.endTransmission();
  // leo en RAM DS1307
 Wire.beginTransmission(DS1307_I2C_ADDRESS);  
 Wire.write((byte)0x09);                   
 Wire.endTransmission();
 Wire.requestFrom(DS1307_I2C_ADDRESS, 2); 
 valorB = bcdToDec(Wire.read()) ;  
 if (valorA == valorB)
     retorno = 1;
 return retorno;
}
// ------------------------------------------------------------
void loop() // Bucle principal del programa
{   
 LeeRTC();
 EfectuaMedida();
 String DatoTS = "20"; 
 DatoTS.concat (fprint(year));
 DatoTS.concat (fprint(month));
 DatoTS.concat (fprint(dayOfMonth));
 DatoTS.concat (";");
 DatoTS.concat (fprint(hour));
 DatoTS.concat (fprint(minute));
 DatoTS.concat (fprint(second));
 DatoTS.concat (";");
 DatoTS.concat (voltios);
 DatoTS.concat (";");
 DatoTS.concat (vatios);

 if (!CheckSD()) {
   digitalWrite(StatusLED, HIGH);
   Serial.println("Datos no guardados en fichero LOG !");
   Serial.println("-----------------------------------" );   
   Serial.println("   ** ERROR de Tarjeta SD **  ");
   Serial.println("-----------------------------------" );
 } 
  digitalWrite(StatusLED, HIGH);
  if (!CheckRTC()) {
   Serial.println("Datos no guardados en fichero LOG !");
   Serial.println("-----------------------------------" );     
   Serial.println("   ** ERROR de RTC [DS1307] **");
   Serial.println("-----------------------------------" );
 } 

 if ( (CheckSD())  &&  (CheckRTC()) )
 {
    Blink(1);
    Serial.print  ("TS+Datos: ");
    Serial.println(DatoTS);
    Serial.println("-----------------------------------" );    
    Serial.print("Escribiendo en fichero LOG ...");
    EscribeLog (DatoTS);
    Serial.println("-----------------------------------" );  
 }
 Serial.println();
 delay(retardo * 1000);                     
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

// ============================================================

// = Arduino PowerLOG - DIVERTEKA (Abril 2014) v. 1.1 =

// = Develop by Txus [J.C. Garcia Preciado] =

// ============================================================

// Parte de este codigo esta basado en:

// RTC Control ==> <http://www.combustory.com> John Vaughters

// SD Control ===> <http://code.google.com/p/sdfatlib>

// ------------------------------------------------------------

const int chipSelect = 8; // <=== IMPORTANTE (Sparkfun cs pin)

#include "Wire.h"

#include <SdFat.h>

#define DS1307_I2C_ADDRESS 0x68 // direccion I2C

// ------------------------------------------------------------

byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;

const int analogInPin = A0; // pin de entrada analogica

int retardo = 5; // (tiempo (s.) entre lecturas)

float lectura,ff,pW,iA,vV,vS,S_Ratio;

int voltios,vatios;

int SD_OK = 0 ;

SdFat sd;

SdFile myFile;

char Volts [10];

char Vats [10];

int StatusLED = 6;

// ------------------------------------------------------------

void setup() {

pinMode(StatusLED, OUTPUT);

Blink(10);

int n = 1;

Wire.begin();

Serial.begin(9600);

S_Ratio = 36.5; // Sensor/ratio (mV/mA ) : 36.5

vV = 230; // valor de tension a computar

ff = 5; // freq. factor / (50Hz -> 5 / 60Hz -> 4.15)

while (!Serial) { } // solo necesario para A. Leonardo

Serial.print("- Iniciando programa PowerLOG " );

pinMode(10, OUTPUT);

for (n;n<4;n++){

delay(300);

Serial.print(n);}

Serial.println(".");

Serial.println(" ");

Serial.print("- Inicializando SD ...");

if (!sd.begin(chipSelect, SPI_HALF_SPEED)) {

Serial.println(" ERROR.");

return;

}

Serial.println(" OK.");

}

// ------------------------------------------------------------

void Blink(int n)

{

int i;

for (i=0;i<n;i++){

digitalWrite(StatusLED, HIGH); delay(50);

digitalWrite(StatusLED, LOW); delay(50);

}

// ------------------------------------------------------------

byte bcdToDec(byte val)

{

return ( (val/16*10) + (val%16) );

}

// ------------------------------------------------------------

byte decToBcd(byte val)

{

return ( (val/10*16) + (val%10) );

}

// ------------------------------------------------------------

float smoothread(){

int ni = 35; // n. iteraciones => smooth (10-50)

float retorno = 0.0;

for (int x = 0; x< ni; x++){

do { // espero paso por cero

delayMicroseconds(100);

} while (analogRead(0) != 0) ;

delay (ff); // espera centro de ciclo

delay (10); // estabilizacion CAD

retorno = retorno +(analogRead(0));

}

return retorno / ni;

}

// ------------------------------------------------------------

void LeeRTC(){

Wire.beginTransmission(DS1307_I2C_ADDRESS);

Wire.write((byte)0x00);

Wire.endTransmission();

Wire.requestFrom(DS1307_I2C_ADDRESS, 7);

second = bcdToDec(Wire.read() & 0x7f);

minute = bcdToDec(Wire.read());

hour = bcdToDec(Wire.read() & 0x3f);

dayOfWeek = bcdToDec(Wire.read());

dayOfMonth = bcdToDec(Wire.read());

month = bcdToDec(Wire.read());

year = bcdToDec(Wire.read());

}

// ------------------------------------------------------------

String fprint (int dato) // formatea dato a dos digitos

{

String retorno = String(dato);

if (retorno.length() < 2)

retorno = "0" + retorno;

return retorno;

}

// ------------------------------------------------------------

void EfectuaMedida() // calcula datos desde sensor SCT013

{

Serial.println();

Serial.println("===================================");

Serial.println(" * PowerLOG - DIVERTEKA v. 1.0 * " );

Serial.println("===================================" );

Serial.print("Midiendo: ");

// Capturo variables float

lectura = smoothread () / 1.41; // lectura (rms)

vS = (lectura * 0.0048); // valor de C.A.D.

iA = (lectura * S_Ratio)/1000; // Intensidad (A.)

pW = vV * iA; // Potencia (vat.)

// Casting a int para escritura en fichero LOG

voltios = (int)vV;

vatios = (int)pW;

Serial.print (voltios);

Serial.print(" voltios, " );

Serial.print(vatios);

Serial.println(" vatios" );

Serial.println("-----------------------------------" );

}

// ------------------------------------------------------------

int CheckSD() // verifica tarjeta SD OK

{

return sd.begin(chipSelect, SPI_HALF_SPEED);

}

// ------------------------------------------------------------

void EscribeLog (String dato) // escribe datos en fichero LOG

{

if (!myFile.open("power.log", O_RDWR | O_CREAT | O_AT_END)) {

Serial.println(" ERROR en tarjeta SD !!");

Serial.println("-----------------------------------" );

return;

}

myFile.println(dato);

myFile.close();

Serial.println(" OK.");

}

// ------------------------------------------------------------

int CheckRTC() // verifica modulo DS1307 OK

{

int retorno = 0;

int valorA,valorB;

long randNumber;

randomSeed(analogRead(0));

randNumber = random(1,100);

valorA = (int)randNumber;

// escribo en RAM DS1307

Wire.beginTransmission(DS1307_I2C_ADDRESS);

Wire.write((byte)0x09);

Wire.write(decToBcd(valorA));

Wire.endTransmission();

// leo en RAM DS1307

Wire.beginTransmission(DS1307_I2C_ADDRESS);

Wire.write((byte)0x09);

Wire.endTransmission();

Wire.requestFrom(DS1307_I2C_ADDRESS, 2);

valorB = bcdToDec(Wire.read()) ;

if (valorA == valorB)

retorno = 1;

return retorno;

}

// ------------------------------------------------------------

void loop() // Bucle principal del programa

{

LeeRTC();

EfectuaMedida();

String DatoTS = "20";

DatoTS.concat (fprint(year));

DatoTS.concat (fprint(month));

DatoTS.concat (fprint(dayOfMonth));

DatoTS.concat (";");

DatoTS.concat (fprint(hour));

DatoTS.concat (fprint(minute));

DatoTS.concat (fprint(second));

DatoTS.concat (";");

DatoTS.concat (voltios);

DatoTS.concat (";");

DatoTS.concat (vatios);

if (!CheckSD()) {

digitalWrite(StatusLED, HIGH);

Serial.println("Datos no guardados en fichero LOG !");

Serial.println("-----------------------------------" );

Serial.println(" ** ERROR de Tarjeta SD ** ");

Serial.println("-----------------------------------" );

}

digitalWrite(StatusLED, HIGH);

if (!CheckRTC()) {

Serial.println("Datos no guardados en fichero LOG !");

Serial.println("-----------------------------------" );

Serial.println(" ** ERROR de RTC [DS1307] **");

Serial.println("-----------------------------------" );

}

if ( (CheckSD()) && (CheckRTC()) )

{

Blink(1);

Serial.print ("TS+Datos: ");

Serial.println(DatoTS);

Serial.println("-----------------------------------" );

Serial.print("Escribiendo en fichero LOG ...");

EscribeLog (DatoTS);

Serial.println("-----------------------------------" );

}

Serial.println();

delay(retardo * 1000);

}

A DIVERTIRSE

Descarga de código

El fichero descargable contiene:

Software Power_LOG.ino para medida con registro LOG.
Software Test_SdFat.ino para verificar módulo microSD.
Software Set_RTC.ino para ajuste del DS1307.
Software Lee_RTC.ino para consulta del DS1307.
Librerías SdFAT para el módulo SD.
Información del chip DS1307
Información del sensor SCT-013-030
Esquema del módulo microSD
Esquema del módulo RTC

Power_2.zip

Modificaciones Software

Se ha modificado el programa principal (Power_LOG.ino) añadiéndole alguna funcionalidad adicional y revisando alguna rutina.

Se puede descargar desde este LINK:

Power_2_rev.zip

Resumen de modificaciones:

– Revisión de rutinas para operar a 60 Hz.

– Añadido control sobre conexión del Sensor.

– Añadido aviso por sensor desconectado.

– Añadido aviso por LED (fijo) para sensor.

Nota: la toma de medida se trata de efectuar en el pico de la señal rectificada. Para dar tiempo a la estabilización del CAD se utilizan factores diferenciados en el software bien se trate de señales de 50 o 60 Hz. En esta gráfica se puede ver el cálculo efectuado para la obtención de los citados tiempos, tanto para la variable ff como para ff2.

Bitcoin Currency Converter

Amount of BTC to convert

To currency:

1BTC =