Cómo construir un monitor de energía Arduino y un registrador de datos

Acerca de este proyecto

(Esta publicación se basa en una publicación que se publicó por primera vez el 19 de septiembre de 2017 en Medium, y se ha actualizado y es más actual aquí, incluidos los detalles de la publicación de la biblioteca y ejemplos en GitHub).

En esta publicación, les mostraré cómo construí un monitor de energía Arduino y un registrador de datos que me ayudarían a recopilar datos de corriente y energía para diferentes cargas fácilmente y trazar esa información usando un programa como Excel.

Algunos de ustedes pueden saber que he creado una nueva placa de control de energía que llamo Dr. Wattson (que se basa en el #Microchip # MCP39F521, un IC de monitoreo de energía) junto con una biblioteca #Arduino y una biblioteca #Python ( para tableros como #RaspberryPi y #BeagleBoneBlack) para una fácil integración de datos energéticos de calidad en su próximo proyecto. Si no ha oído hablar de él y desea obtener más información, consulte https://upbeatlabs-wattson.launchrock.com/ para obtener más información. También está disponible en Tindie.

Para ayudarme a estudiar las características energéticas de diferentes cargas, seguí adelante y creé un monitor de energía y registrador de datos Arduino, ¡que es el tema de esta publicación!

Consiste en un Arduino (¡por supuesto!) Hablando con la placa Dr. Wattson para obtener datos de energía, junto con una tarjeta SD para escribir los datos. También agregué un botón para alternar el registro de datos, junto con un indicador LED para mostrar cuándo se están registrando datos. El botón junto con el LED hizo que fuera realmente fácil iniciar el registro de datos cuando tenía la carga adecuada enchufada.

Para facilitar el registro y el análisis posterior, también implementé un esquema de rotación de registros, por lo que cada ejecución se registrará en un archivo diferente. La salida está en formato CSV, lo que significa que se puede importar fácilmente a Excel (o Numbers en Mac u otro equivalente) y trazar los datos.

Configuración

Coloqué la placa Dr. Wattson en un gabinete de acrílico para que los cables de CA estén encerrados, ¡y usted puede usarlo de manera segura! Así:

Más tarde actualicé un poco el gabinete y ahora está disponible en Tindie. Así es como luce ahora. Un poco más limpio con un enchufe IEC adicional y conectores de horquilla para conexiones fáciles.

He preparado un manual de usuario que muestra cómo se debe realizar el cableado, que ahora está disponible en GitHub.

La salida digital que viene del Dr. Wattson está completamente aislada de la red, ya que la medición de energía se realiza de forma aislada utilizando transformadores de corriente y voltaje, por lo que la salida digital es perfectamente segura de manejar.

Una vez en el gabinete, todo lo que necesita hacer es conectar el cable a un tomacorriente existente y enchufar cualquier dispositivo en el tomacorriente del gabinete; el PCB está diseñado para corrientes de hasta 12A, por lo que está bastante bien construido. Está calibrado para medir corrientes de hasta 4 A (por lo que podría medir corrientes realmente pequeñas para medir la potencia de reserva; el chip MCP39F521 en el que se basa tiene una relación dinámica de 4000:1, lo que significa que puede medir desde 4 A hasta 1 mA)

Circuito

Aquí está el circuito que utilicé:

Usé una tarjeta SD similar a la de Adafruit (así que la usé en Fritzing, ya que era la parte más cercana). La conexión es bastante estándar:CLK (pin 13 de Arduino Uno), MISO (pin 12 de Arduino Uno), MOSI (pin 11 de Arduino Uno) y CS (selección de chip). CS es configurable, aunque por defecto es el pin 10 para hardware CS; solo lo uso.

Para el botón, utilizo la biblioteca de botones de Jack Christensen, que proporciona eliminación de rebotes y una variedad de cosas útiles en un paquete fácil de usar. (https://github.com/JChristensen/Button). El botón está usando el pullup interno de Arduino, por lo que no tiene pullups externos y también usa lógica invertida (alto es APAGADO, bajo está ENCENDIDO) - ¡todos estos son configurables como parámetros para el constructor del Botón! Conecté el botón al pin 4, pero puedes usar cualquier pin disponible que quieras.

Realmente no tuve el tiempo y la paciencia para modelar al Dr. Wattson como un nuevo papel en Fritzing, así que hice trampa y usé el consejo de Z-HUT para preparar fácilmente una pieza personalizada sin mucho preámbulo. ¡Recomiendo verlo! https://www.youtube.com/watch?v=dfxx8wF3Uhs - gracias Z-HUT ! :-)

El único inconveniente es que tengo que contentarme con usar la imagen de la placa de pruebas de la parte del "CI genérico" que modifiqué para representar al Dr. Wattson. ¡C'est la vie!

Aquí hay un vistazo a los pines del Dr. Wattson (de izquierda a derecha):

• SCL:para la comunicación I2C, va a Arduino Uno A5
• SDA:para la comunicación I2C, va a Arduino Uno A4
• ZCD:detección de cruce por cero:no utilizamos esta función en este ejemplo
• Evento:indicador de evento:no utilizamos esta función en este ejemplo
• GND - Conéctese a Arduino GND
• VIN - Conéctese a Arduino 5V
• 3.3v - Conéctese a Arduino 3.3v
• GND:conéctese a Arduino GND (solo necesita conectar uno de los pines GND)

Bosquejo

¡Bien, ahora pasemos a la programación real!

Permítanme comenzar explicando el boceto. En setup (), primero configuro las comunicaciones de la tarjeta SD y las comunicaciones de Dr.Wattson llamando a sus respectivos métodos begin ().

  // ver si la tarjeta está presente y se puede inicializar:if (! SD.begin (CHIP_SELECT)) {Serial.println (F ("Tarjeta fallida o no presente")); // no hagas nada más:} wattson.begin (); // Pasar la dirección apropiada. El valor predeterminado es 0x74  

También inicializo el pin LED como SALIDA.

  // inicializa el pin digital como salida. pinMode (LED, SALIDA);  

El botón se declara globalmente, por lo que no tengo que hacer nada en la configuración del botón.

  #define BUTTON_PIN 4 // Conecte un interruptor de botón táctil (o algo similar) // desde el pin 4 de Arduino a tierra. #define PULLUP true // Para simplificar las cosas, usamos la resistencia pullup interna de Arduino. # define INVERT true // Dado que la resistencia pullup mantendrá el pin alto a menos que el // interruptor esté cerrado, esto es lógica negativa, es decir, un alto state // significa que el botón NO está presionado. (Suponiendo un interruptor normalmente abierto.) # Define DEBOUNCE_MS 20 // Un tiempo de supresión de rebotes de 20 milisegundos generalmente funciona bien para interruptores de botón táctil. Botón myBtn (BUTTON_PIN, PULLUP, INVERT, DEBOUNCE_MS); // Declara el botón  

Mi registro de datos se realiza en archivos con un nombre como DATAXX.CSV, donde XX es un número (de 00 a 99, es decir, 100 archivos). Verifico la tarjeta SD en busca de nombres de archivo existentes y selecciono el último nombre de archivo sin usar, por ejemplo, DATA15.CSV

  char filename [] ="DATA00.CSV"; setup () {... // crea un nuevo archivo para (uint8_t i =0; i <100; i ++) {filename [4] =i / 10 + '0'; nombre de archivo [5] =i% 10 + '0'; if (! SD.exists (filename)) {Serial.print (F ("El archivo de datos es")); Serial.println (nombre de archivo); // solo abre un archivo nuevo si no existe break; // ¡deja el bucle! el nombre del archivo ahora será el que deseamos}} ...}  

En la función loop (), una vez que se presiona el botón, alterna la variable readData, que controla si leo los datos de energía.

  void loop () {... myBtn.read (); // Leer el botón if (myBtn.wasReleased ()) {// Si se soltó el botón, cambie el estado del LED readData =! ReadData; digitalWrite (LED, readData); } if (readData) {... // leer datos y guardarlos en la tarjeta SD, etc .......}  

Una vez que se activa readData, leo los datos de energía del Dr. Wattson y también registro la hora:

  UpbeatLabs_MCP39F521_FormattedData fData; int readMCPretval =wattson.readMCP39F521 (&datos, NULL); unsigned long currentMillis =millis ();  

y escríbalo en la tarjeta SD:

  // si el archivo está disponible, escríbalo:File dataFile =SD.open (filename, FILE_WRITE); if (dataFile) {dataFile.print (currentMillis); dataFile.print (","); dataFile.print (fData.currentRMS); dataFile.print (","); dataFile.print (fData.activePower); dataFile.print (","); dataFile.print (fData.reactivePower); dataFile.print (","); dataFile.println (fData.apparentPower); // imprime también en el puerto serie:dataFile.close (); } // si el archivo no está abierto, aparece un error:else {Serial.print (F ("error al abrir")); Serial.println (nombre de archivo); }  

Si se vuelve a activar el botón, detengo la lectura / grabación de datos.

¡Acción!

Una vez que compilé y cargué el boceto en mi Arduino, obtener datos de energía fue bastante fácil.

Enchufé la carga de mi elección:una lámpara CFL. Quería ver el consumo actual y de energía desde una perspectiva de arranque en frío, así como desde un arranque en caliente. Enchufé la lámpara, pero no la encendí.

Presioné el botón en mi circuito para iniciar las mediciones de energía; cuando estaba registrando, ¡el LED ROJO me lo dijo! Luego encendí la lámpara CFL y esperé hasta que pensé que había obtenido suficientes datos; ya ve, la CFL, al comenzar, consume más energía de la anunciada (en mi caso, una bombilla CFL de 14 W) y luego se calma. eventualmente a aproximadamente 14W. Esperé hasta que las lecturas se estabilizaron. Luego presioné el botón para apagar la lectura.

¡Ahora podría expulsar mi tarjeta SD y comenzar a mirar los datos!

PD:para registrar datos de dispositivos adicionales, todo lo que tiene que hacer es restablecer el Arduino; elegirá el siguiente DATAXX.CSV disponible para registrar los datos, de modo que pueda mantener los datos separados fácilmente.

Nota: En lugar de usar Arduino Serial Monitor, uso el comando "screen" integrado en mi terminal Mac como terminal serial. En mi Sketch, imprimo los datos de energía en Serial y también emito un comando de "borrar pantalla", para que la salida no se mueva

  Serial.write ("\ x1B" "c"); // Limpia la pantalla en un terminal normal wattson.printMCP39F521Data (&data);  

Esto solo funciona en un terminal normal que puede aceptar comandos de terminal como el anterior, y desafortunadamente no funciona en el monitor serial Arduino. Sin embargo, una vez que lo intente pantalla , ¡es posible que nunca vuelva a Arduino Serial Monitor!

El comando será algo como esto:

  $ screen /dev/tty.usbmodem1411 9600  

donde el primer parámetro es el "puerto serie", y el segundo es la velocidad que ha configurado para su conexión serie en su boceto de Arduino.

Trazar los datos en Excel

Debido a que el archivo está en formato CSV, cargarlo y trazarlo en Excel fue bastante fácil. No entraré en detalles aquí, ya que hay muchos tutoriales para crear un gráfico en Excel. Inserté una fila que contiene los encabezados de las columnas

  marca de tiempo, currentRMS, activePower, reactivePower, aparente  

(nota para mí mismo:esta será una mejora futura de mi Sketch:agregar los encabezados de columna en el CSV directamente)

Elegí los puntos de datos anteriores para registrar y trazar. El consumo actual a lo largo del tiempo es obviamente interesante. ¿Por qué activePower, reactivePower y aparentePower? Según las características eléctricas del dispositivo, puede ser una carga resistiva, una carga reactiva o en algún punto intermedio, y los tres parámetros de potencia nos indican sus características generales y también si cambian con el tiempo. O eso creo ...

Echemos un vistazo a mis resultados para una lámpara CFL desde un arranque en frío:

La corriente alcanza un máximo de alrededor de 0,21 amperios antes de finalmente estabilizarse en aproximadamente 0,18 amperios.

La potencia activa alcanza un máximo de aproximadamente 17 vatios antes de finalmente establecerse en aproximadamente 14,2 vatios.

Una vez que se hubo asentado, apagué la CFL y esperé un poco antes de volver a encenderla (de ahí la caída de la corriente en el gráfico anterior). Puede ver que una vez que una CFL se ha "calentado", se adapta rápidamente a su consumo de estado estable.

Conclusión

Hay una gran cantidad de datos y experimentos interesantes que puede hacer con los datos de energía de sus electrodomésticos y dispositivos. ¡Estaba emocionado de comenzar a tener en mis manos algunos datos y compartirlos con ustedes!

Mi objetivo con Dr. Wattson es habilitar datos de energía de calidad para el Creador y hacerlos más accesibles, para que pueda usarlos como un bloque de construcción para sus ideas locas y locas.

Dr. Wattson está diseñado para ser seguro de usar (especialmente con el gabinete), viene calibrado (para que pueda obtener datos de energía de calidad de inmediato), pero también expone una funcionalidad más compleja para el usuario serio

• rutinas de calibración
• ZCD (detector de cruce por cero)
• Notificación de eventos (sobrecorriente, sobretensión, caídas de voltaje / eventos de sobretensión)
• la capacidad de personalizar el rango de lecturas (modificando las resistencias de carga yo CT y recalibrando usando las rutinas de calibración mencionadas anteriormente),
• usando varios Dr. Wattsons junto con una sola MCU (cambiando el direccionamiento I2C configurable).

Si está interesado en el monitoreo de energía y le gusta el Dr. Wattson, regístrese en (https://upbeatlabs-wattson.launchrock.com/) para mantenerse al tanto de las noticias y actualizaciones.

Saludos,

Sridhar

¡Aquí está el boceto completo, para su referencia! También puede encontrarlo y la biblioteca de Dr. Wattson, junto con una serie de otros ejemplos en el repositorio drwattson GitHub de Upbeat Labs.

  / **************************************** *********************************** Este es un boceto de ejemplo para Upbeat Labs Dr. Wattson Energy Monitoring Breakout -> https://www.tindie.com/products/UpbeatLabs/dr-wattson-energy-monitoring-board-2/ Este ejemplo demuestra cómo obtener datos de energía del Dr. Wattson y escribirlos en una tarjeta SD separados por comas (CSV) formato. Se utiliza un botón para alternar la recopilación de datos, de modo que pueda registrar los datos cuando esté listo. Cuando el botón alterna la medición, el boceto comienza a sondear el módulo en busca de datos de energía y los imprime. Para facilitar la visualización de los valores, utilice una pantalla similar a un programa para mostrar la salida en serie. El serial escribe los caracteres necesarios para borrar la pantalla en un terminal regular, lo que significa que la salida serial permanecerá en su lugar y simplemente se actualizará con el tiempo. Encienda la energía de entrada para ver el voltaje RMS, los valores de frecuencia de línea cambian a los valores apropiados. Encienda la carga adjunta a su salida para ver el RMS actual, el factor de potencia, los valores de potencia activa, reactiva y aparente cambian. Todos estos valores se escriben en la tarjeta SD en formato CSV, que luego se puede usar con un programa como Excel para ver / trazar los datos. El nombre del archivo tiene el formato DATAnn.CSV. En el momento de la configuración, se elige un nuevo nombre de archivo que aún no existe, por lo que los archivos serán DATA00.CSV, DATA01.CSV, DATA02.CSV y así sucesivamente. El registro rota a nuevos archivos hasta DATA99.CSV. La comunicación ocurre a través de I2C. Se requieren 2 pines para la interfaz. Hay 4 posibilidades de direcciones I2C seleccionables por placa (seleccionables mediante dos puentes de soldadura (que seleccionan cada pin para que sea alto o bajo). En base a esto, hay 4 direcciones posibles:dirección I2C SJ1 SJ2 0x74 LOW LOW 0x75 LOW HIGH 0x76 HIGH LOW 0x77 HIGH HIGH Dr. Wattson tiene dos salidas, ZCD o Event, que se utilizan para notificaciones y, por lo tanto, normalmente se conectarán a un pin interrumpible externamente (como pin2 o pin3 en Arduino Uno). En este ejemplo, ZCD y Event no son El botón está conectado al pin 4. * Tarjeta SD conectada al bus SPI de la siguiente manera:** MOSI - pin 11 ** MISO - pin 12 ** CLK - pin 13 ** CS - pin 10 LED está conectado al pin 9 Escrito por Sridhar Rajagopal para Upbeat Labs LLC. Licencia BSD. Todo el texto anterior debe incluirse en cualquier redistribución * / # include  #include "UpbeatLabs_MCP39F521.h" #include  #include  //https://github.com/JChristensen/Button#define BUTTON_PIN 4 // Conecta un interruptor de botón táctil (o algo similar) // desde el pin 4 de Arduino # define PULLUP true // Para simplificar las cosas, usamos la resistencia pullup interna de Arduino. # define INVERT true // Dado que la resistencia pullup mantendrá el pin alto a menos que el // interruptor esté cerrado, esto es lógica negativa, es decir, un estado alto // significa que el botón NO está presionado. (Suponiendo un interruptor normalmente abierto.) # Define DEBOUNCE_MS 20 // Un tiempo de supresión de rebotes de 20 milisegundos generalmente funciona bien para interruptores de botón táctil. Botón myBtn (BUTTON_PIN, PULLUP, INVERT, DEBOUNCE_MS); // Declare el botón # define LED 9 // Conecte un LED (a través de una resistencia de 220ohm) desde el pin 9 (ánodo) a GND (cátodo). #define CHIP_SELECT 10UpbeatLabs_MCP39F521 wattson =UpbeatLabs_MCP39F521 (); bool readData =false; char filename [] ="DATA00.CSV"; void setup () {Serial.begin (9600); // activa la comunicación en serie Serial.println (F ("** Bosquejo de ejemplo del Dr. Wattson de Upbeat Labs **")); Serial.println (F ("Bosquejo de ejemplo de registro de tarjeta SD de datos de energía de Upbeat Labs Dr. Wattson")); Serial.println (F ("**************************************** *********************** ")); // inicializa el pin digital como salida. pinMode (LED, SALIDA); pinMode (CHIP_SELECT, SALIDA); // ver si la tarjeta está presente y se puede inicializar:if (! SD.begin (CHIP_SELECT)) {Serial.println (F ("*** Tarjeta SD fallida, o no está presente ***")); // no hagas nada más:} wattson.begin (); // Pasar la dirección apropiada. Por defecto es 0x74 // crea un nuevo archivo para (uint8_t i =0; i <100; i ++) {nombre de archivo [4] =i / 10 + '0'; nombre de archivo [5] =i% 10 + '0'; if (! SD.exists (filename)) {Serial.print (F ("El archivo de datos es")); Serial.println (nombre de archivo); // solo abre un archivo nuevo si no existe break; // ¡deja el bucle! el nombre del archivo ahora será el que deseamos}} Serial.println (F ("** inicialización completa. **"));} void loop () {myBtn.read (); // Leer el botón if (myBtn.wasReleased ()) {// Si se soltó el botón, cambie el estado del LED readData =! ReadData; digitalWrite (LED, readData); } if (readData) {UpbeatLabs_MCP39F521_Data datos; UpbeatLabs_MCP39F521_FormattedData fData; int readMCPretval =wattson.read (&datos, NULL); currentMillis largo sin firmar =millis (); if (readMCPretval ==UpbeatLabs_MCP39F521 ::SUCCESS) {// Imprime cosas Serial.write ("\ x1B" "c"); // Limpia la pantalla en un terminal normal wattson.convertRawData (&data, &fData); printMCP39F521Data (&fData); // si el archivo está disponible, escríbalo:Archivo dataFile =SD.open (nombre de archivo, FILE_WRITE); if (dataFile) {dataFile.print (currentMillis); dataFile.print (","); dataFile.print (fData.currentRMS); dataFile.print (","); dataFile.print (fData.activePower); dataFile.print (","); dataFile.print (fData.reactivePower); dataFile.print (","); dataFile.println (fData.apparentPower); // imprime también en el puerto serie:dataFile.close (); } // si el archivo no está abierto, aparece un error:else {Serial.print (F ("error al abrir")); Serial.println (nombre de archivo); }} else {Serial.print (F ("¡Error!")); Serial.println (readMCPretval); }}} void printMCP39F521Data (UpbeatLabs_MCP39F521_FormattedData * datos) {Serial.print (F ("Voltaje =")); Serial.println (datos-> voltageRMS, 4); Serial.print (F ("Actual =")); Serial.println (datos-> currentRMS, 4); Serial.print (F ("Frecuencia de línea =")); Serial.println (datos-> frecuencia de línea, 4); Serial.print ("Voltaje de entrada analógica ="); Serial.println (datos-> analogInputVoltage, 4); Serial.print (F ("Factor de potencia =")); Serial.println (datos-> powerFactor, 4); Serial.print (F ("Energía activa =")); Serial.println (datos-> activePower, 4); Serial.print (F ("Potencia reactiva =")); Serial.println (datos-> reactivePower, 4); Serial.print (F ("Potencia aparente =")); Serial.println (datos-> potencia aparente, 4);}  

 // ver si la tarjeta está presente y se puede inicializar:if (! SD.begin (CHIP_SELECT)) {Serial.println (F ("Tarjeta fallida o no presente")); // no hagas nada más:} wattson.begin (); // Pasar la dirección apropiada. El valor predeterminado es 0x74 

 #define BUTTON_PIN 4 // Conecta un interruptor de botón táctil (o algo similar) // desde el pin 4 de Arduino a tierra. #define PULLUP true // Para simplificar las cosas, usamos la resistencia pullup interna de Arduino. # define INVERT true // Dado que la resistencia pullup mantendrá el pin alto a menos que el // interruptor esté cerrado, esto es lógica negativa, es decir, un alto state // significa que el botón NO está presionado. (Suponiendo un interruptor normalmente abierto.) # Define DEBOUNCE_MS 20 // Un tiempo de supresión de rebotes de 20 milisegundos generalmente funciona bien para interruptores de botón táctil. Botón myBtn (BUTTON_PIN, PULLUP, INVERT, DEBOUNCE_MS); // Declarar el botón 

 char filename [] ="DATA00.CSV"; setup () {... // crea un nuevo archivo para (uint8_t i =0; i <100; i ++) {filename [4] =i / 10 + '0'; nombre de archivo [5] =i% 10 + '0'; if (! SD.exists (filename)) {Serial.print (F ("El archivo de datos es")); Serial.println (nombre de archivo); // solo abre un archivo nuevo si no existe break; // ¡deja el bucle! el nombre del archivo ahora será el que deseamos}} ...} 

 myBtn.read (); // Leer el botón if (myBtn.wasReleased ()) {// Si se soltó el botón, cambie el estado del LED readData =! ReadData; digitalWrite (LED, readData); } if (readData) {... // leer datos y guardarlos en la tarjeta SD, etc .... 

 // si el archivo está disponible, escríbalo:File dataFile =SD.open (filename, FILE_WRITE); if (dataFile) {dataFile.print (currentMillis); dataFile.print (","); dataFile.print (data.currentRMS); dataFile.print (","); dataFile.print (data.activePower); dataFile.print (","); dataFile.print (data.reactivePower); dataFile.print (","); dataFile.println (data.apparentPower); // imprime también en el puerto serie:dataFile.close (); } // si el archivo no está abierto, aparece un error:else {Serial.print (F ("error al abrir")); Serial.println (nombre de archivo); } 

 / ******************************************** ***** Este es un boceto de ejemplo para Upbeat Labs Dr. Wattson Energy Monitoring Breakout La comunicación se realiza a través de I2C. Se requieren 2 pines para la interfaz. Hay 4 posibilidades de direcciones I2C seleccionables por placa (seleccionables mediante dos puentes de soldadura (que seleccionan cada pin para que sea alto o bajo). En base a esto, hay 4 direcciones posibles:dirección I2C SJ1 SJ2 0x74 LOW LOW 0x75 LOW HIGH 0x76 HIGH LOW 0x77 HIGH HIGH Dr. Wattson tiene dos salidas, ZCD o Event, que se utilizan para notificaciones y, por lo tanto, normalmente se conectarán a un pin interrumpible externamente (como pin2 o pin3 en Arduino Uno). En este ejemplo, ZCD y Event no se utilizan .El botón está conectado al pin 4. * Tarjeta SD conectada al bus SPI de la siguiente manera:** MOSI - pin 11 ** MISO - pin 12 ** CLK - pin 13 ** CS - pin 10 LED está conectado al pin 9 Escrito por Sridhar Rajagopal para Upbeat Labs LLC. Licencia BSD. Todo el texto anterior debe incluirse en cualquier redistribución * / #include  #include "MCP39F521.h" #include  #include  / /https://github.com/JChristensen/Button#define BUTTON_PIN 4 // Conecta un interruptor de botón táctil (o algo similar) // desde el pin 4 de Arduino a tierra . #define PULLUP true // Para simplificar las cosas, usamos la resistencia pullup interna de Arduino. # define INVERT true // Dado que la resistencia pullup mantendrá el pin alto a menos que el // interruptor esté cerrado, esto es lógica negativa, es decir, un alto state // significa que el botón NO está presionado. (Suponiendo un interruptor normalmente abierto.) # Define DEBOUNCE_MS 20 // Un tiempo de supresión de rebotes de 20 milisegundos generalmente funciona bien para interruptores de botón táctil. Botón myBtn (BUTTON_PIN, PULLUP, INVERT, DEBOUNCE_MS); // Declare el botón # define LED 9 // Conecte un LED (a través de una resistencia de 220ohm) desde el pin 9 (ánodo) a GND (cátodo). # Define CHIP_SELECT 10MCP39F521 wattson =MCP39F521 (); bool readData =false; char filename [ ] ="DATA00.CSV"; configuración vacía () {Serial.begin (9600); // activa la comunicación en serie Serial.println (F ("** Bosquejo de ejemplo del Dr. Wattson de Upbeat Labs **")); // inicializa el pin digital como salida. pinMode (LED, SALIDA); pinMode (10, SALIDA); // ver si la tarjeta está presente y se puede inicializar:if (! SD.begin (CHIP_SELECT)) {Serial.println (F ("Tarjeta fallida o no presente")); // no hagas nada más:} wattson.begin (); // Pasar la dirección apropiada. Por defecto es 0x74 // crea un nuevo archivo para (uint8_t i =0; i <100; i ++) {nombre de archivo [4] =i / 10 + '0'; nombre de archivo [5] =i% 10 + '0'; if (! SD.exists (filename)) {Serial.print (F ("El archivo de datos es")); Serial.println (nombre de archivo); // solo abre un archivo nuevo si no existe break; // ¡deja el bucle! el nombre del archivo ahora será el que deseamos}} Serial.println (F ("** inicialización completa. **")); } // ¡Así es como se ve MCP39F521Data, como referencia! // typedef struct MCP39F521Data {// uint16_t systemStatus; // uint16_t systemVersion; // uint16_t voltageRMS; // uint16_t lineFrequency; // uint16_t analogInputVoltage; // int16_t powerFactor / uint32_t currentRMS; // uint32_t activePower; // uint32_t reactivePower; // uint32_t aparentePower; //} MCP39F521Data; bucle vacío () {myBtn.read (); // Leer el botón if (myBtn.wasReleased ()) {// Si se soltó el botón, cambie el estado del LED readData =! ReadData; digitalWrite (LED, readData); } if (readData) {MCP39F521Data datos; int readMCPretval =wattson.readMCP39F521 (&datos, NULL); currentMillis largo sin firmar =millis (); if (readMCPretval) {// Imprime cosas Serial.write ("\ x1B" "c"); // Limpia la pantalla en un terminal normal wattson.printMCP39F521Data (&data); // si el archivo está disponible, escríbalo:Archivo dataFile =SD.open (nombre de archivo, FILE_WRITE); if (dataFile) {dataFile.print (currentMillis); dataFile.print (","); dataFile.print (data.currentRMS); dataFile.print (","); dataFile.print (data.activePower); dataFile.print (","); dataFile.print (data.reactivePower); dataFile.print (","); dataFile.println (data.apparentPower); // imprime también en el puerto serie:dataFile.close (); } // si el archivo no está abierto, aparece un error:else {Serial.print (F ("error al abrir")); Serial.println (nombre de archivo); }} else {Serial.println (F ("¡Error!")); }}} 

Esquemas