Een Arduino-energiemonitor en datalogger bouwen

Over dit project

(Dit bericht is gebaseerd op een bericht dat voor het eerst werd gepubliceerd op 19 september 2017 op Medium en dat hier is bijgewerkt en actueler is, inclusief details over de publicatie van de bibliotheek en voorbeeld(en) op GitHub).

In dit bericht laat ik je zien hoe ik een Arduino-energiemonitor en datalogger heb gebouwd waarmee ik gemakkelijk stroom- en energiegegevens voor verschillende belastingen kan verzamelen en die informatie kan plotten met een programma zoals Excel.

Sommigen van jullie zijn zich er misschien van bewust dat ik een nieuw breakout-bord voor energiebewaking heb gemaakt dat ik Dr. Wattson noem (dat is gebaseerd op de #Microchip #MCP39F521, een stroombewakings-IC) samen met een #Arduino-bibliotheek en #Python-bibliotheek ( voor boards zoals #RaspberryPi en #BeagleBoneBlack) voor eenvoudige integratie van hoogwaardige energiegegevens in uw volgende project! Als je er nog nooit van hebt gehoord en meer informatie wilt, ga dan naar https://upbeatlabs-wattson.launchrock.com/ voor meer informatie. Het is ook beschikbaar op Tindie.

Om me te helpen de energiekenmerken van verschillende belastingen te bestuderen, ging ik verder en maakte ik een Arduino-energiemonitor en datalogger, waarover dit bericht gaat!

Het bestaat uit een Arduino (natuurlijk!) die praat met het Dr. Wattson-bord om energiegegevens te krijgen, samen met een SD-kaart om de gegevens naar te schrijven. Ik heb ook een knop toegevoegd om de gegevensregistratie in te schakelen, samen met een LED-indicator om aan te geven wanneer gegevens worden geregistreerd. De knop en de LED maakten het heel gemakkelijk om gegevensregistratie te starten wanneer ik de juiste belasting had aangesloten.

Om het loggen en de daaropvolgende analyse te vergemakkelijken, heb ik ook een logrotatieschema geïmplementeerd, zodat elke run in een ander bestand wordt vastgelegd. De uitvoer is in CSV-indeling, wat betekent dat het gemakkelijk kan worden geïmporteerd in Excel (of Numbers op Mac of een ander equivalent), en de gegevens kunnen worden geplot.

Instellen

Ik heb het Dr. Wattson-bord in een acrylbehuizing geplaatst, zodat de AC-draden zijn ingesloten en je het op een veilige manier kunt gebruiken! Vind ik leuk:

Ik heb later de behuizing een beetje bijgewerkt en deze is nu beschikbaar op Tindie. Dit is hoe het er nu uitziet. Een beetje meer opgeruimd met een extra IEC-aansluiting en spade-connectoren voor eenvoudige verbindingen.

Ik heb een gebruikershandleiding opgesteld die laat zien hoe de bedrading moet worden gedaan, die nu beschikbaar is op GitHub.

De digitale uitgang die van Dr. Wattson komt, is volledig geïsoleerd van het lichtnet, aangezien de energiemeting op een geïsoleerde manier wordt gedaan met behulp van stroom- en spanningstransformatoren, dus de digitale uitgang is volkomen veilig te hanteren.

Eenmaal in de behuizing hoeft u alleen maar de kabel in een bestaand stopcontact te steken en een willekeurig apparaat in het stopcontact op de behuizing aan te sluiten - de PCB is ontworpen voor stromen tot 12 A, dus hij is behoorlijk goed gebouwd! Het is gekalibreerd om stromen tot 4A te meten (dus ik zou heel kleine stromen kunnen meten voor het meten van stand-byvermogen - de MCP39F521-chip waarop het is gebaseerd, heeft een dynamische verhouding van 4000:1, wat betekent dat het kan meten van 4A tot 1mA)

Circuit

Hier is het circuit dat ik heb gebruikt:

Ik gebruikte een SD-kaartuitbraak vergelijkbaar met die van Adafruit (dus ik gebruikte die in Fritzing, omdat dat het dichtstbijzijnde deel was). De verbinding is vrij standaard — CLK (Arduino Uno pin 13), MISO (Arduino Uno pin 12), MOSI (Arduino Uno pin 11) en CS (Chip select). CS is configureerbaar, hoewel het standaard pin 10 is voor hardware CS — Ik gebruik dat gewoon.

Voor de knop gebruik ik de Button-bibliotheek van Jack Christensen, die debouncing en een verscheidenheid aan nuttige dingen biedt in een gebruiksvriendelijk pakket. (https://github.com/JChristensen/Button). De knop gebruikt de interne pull-up van de Arduino, dus hij heeft geen externe pull-ups en gebruikt ook omgekeerde logica (hoog is UIT, laag is AAN) — al deze zijn configureerbaar als parameters voor de knopconstructor! Ik heb de knop aangesloten op pin 4, maar je kunt elke beschikbare pin gebruiken die je wilt.

Ik had echt niet de tijd en het geduld om Dr. Wattson te modelleren als een nieuwe rol in Fritzing, dus ik speelde vals en gebruikte het advies van Z-HUT om gemakkelijk een aangepast onderdeel op te zwepen zonder veel ophef. Ik raad het ten zeerste aan om het te bekijken! https://www.youtube.com/watch?v=dfxx8wF3Uhs — bedankt Z-HUT ! :-)

Het enige nadeel is dat ik tevreden moet zijn met het gebruik van de breadboard-afbeelding van het 'generieke IC'-gedeelte dat ik heb aangepast om Dr. Wattson te vertegenwoordigen. C'est la vie!

Hier is een blik op de pinnen van Dr. Wattson (van links naar rechts):

• SCL — voor I2C-communicatie, gaat naar Arduino Uno A5
• SDA — voor I2C-communicatie, gaat naar Arduino Uno A4
• ZCD — Zero Cross Detection — we gebruiken deze functie niet in dit voorbeeld
• Event — Event indicator — we gebruiken deze functie niet in dit voorbeeld
• GND — Verbinden met Arduino GND
• VIN — Verbind met Arduino 5V
• 3.3v — Verbinden met Arduino 3.3v
• GND — Verbind met Arduino GND (u hoeft maar één van de GND-pinnen aan te sluiten)

Schets

Ok, nu om verder te gaan met de eigenlijke programmering!

Laat ik eerst beginnen met het uitleggen van de schets. In setup() heb ik eerst de communicatie met de SD-kaart en de communicatie van Dr.Wattson ingesteld door hun respectievelijke begin()-methoden aan te roepen.

// kijk of de kaart aanwezig is en kan worden geïnitialiseerd:if (!SD.begin(CHIP_SELECT)) { Serial.println(F("Kaart mislukt, of niet aanwezig")); // doe niets meer:​​} wattson.begin(); // Geef het juiste adres door. Standaard ingesteld op 0x74 

Ik initialiseer ook de LED-pin als OUTPUT.

// initialiseer de digitale pin als een uitgang. pinMode(LED, UITGANG); 

De knop wordt wereldwijd gedeclareerd, dus ik hoef niets te doen in de configuratie voor de knop.

#define BUTTON_PIN 4 // Sluit een tactiele knopschakelaar (of iets dergelijks) aan // van Arduino pin 4 naar aarde. #define PULLUP true //Om het simpel te houden, gebruiken we de interne pullup-weerstand van de Arduino.#define INVERT true //Aangezien de pullup-weerstand de pin hoog houdt tenzij de //-schakelaar gesloten is, is dit negatieve logica, dwz een hoge state // betekent dat de knop NIET is ingedrukt. (Uitgaande van een normaal open schakelaar.) #define DEBOUNCE_MS 20 // Een debounce-tijd van 20 milliseconden werkt meestal goed voor schakelaars met tactiele knoppen. Button myBtn(BUTTON_PIN, PULLUP, INVERT, DEBOUNCE_MS); //Declareer de knop 

Mijn datalogging gebeurt in bestanden met een naam als DATAXX.CSV, waarbij XX een getal is (van 00 tot 99, dus 100 bestanden). Ik controleer de SD-kaart op bestaande bestandsnamen en kies de laatste ongebruikte bestandsnaam — bijvoorbeeld DATA15.CSV

char bestandsnaam[] ="DATA00.CSV";setup() { ... // maak een nieuw bestand voor (uint8_t i =0; i <100; i++) { bestandsnaam [4] =i /10 + '0'; bestandsnaam [5] =i%10 + '0'; if (! SD.exists(bestandsnaam)) { Serial.print(F("Databestand is ")); Serial.println(bestandsnaam); // open alleen een nieuw bestand als het niet bestaat break; // verlaat de lus! bestandsnaam zal nu degene zijn die we wensen } }...} 

In de loop()-functie schakelt het, zodra de knop is ingedrukt, de readData-variabele om, die bepaalt of ik de energiegegevens lees.

void loop() { ... myBtn.read(); //Lees de knop if (myBtn.wasReleased()) { //Als de knop is losgelaten, verander dan de LED-status readData =!readData; digitalWrite (LED, leesgegevens); } if (readData) { ... // gegevens lezen en opslaan op SD-kaart, enz .......} 

Zodra readData is ingeschakeld, lees ik de energiegegevens van Dr. Wattson en noteer ik ook de tijd:

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

en schrijf het naar de SD-kaart:

 // als het bestand beschikbaar is, schrijf er dan naar: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); // print ook naar de seriële poort:dataFile.close(); } // als het bestand niet geopend is, verschijnt er een foutmelding:else { Serial.print(F("error opening ")); Serial.println(bestandsnaam); }  

Als de knop opnieuw wordt geschakeld, stop ik het lezen/opnemen van gegevens.

Actie!

Nadat ik de schets had gecompileerd en geüpload naar mijn Arduino, was het verkrijgen van energiegegevens vrij eenvoudig.

Ik heb de lading naar keuze aangesloten:een CFL-lamp. Ik wilde de stroom en het energieverbruik zien vanuit het perspectief van een koude start, maar ook van een warme start. Ik heb de lamp aangesloten, maar niet aangezet.

Ik drukte op de knop op mijn circuit om de energiemetingen te starten — toen het aan het loggen was, vertelde de RODE LED me dat! Ik deed toen de CFL-lamp aan en wachtte tot ik dacht dat ik genoeg gegevens had gekregen - zie je, de CFL verbruikt bij het starten meer energie dan geadverteerd (in mijn geval een 14 W CFL-lamp) en gaat dan tot rust uiteindelijk tot ongeveer 14W. Ik wachtte tot de metingen tot rust waren gekomen. Ik heb toen op de knop gedrukt om het lezen uit te schakelen.

Ik kon nu mijn SD-kaart uitwerpen en naar de gegevens gaan kijken!

PS — Om gegevens van extra apparaten te loggen, hoeft u alleen maar de Arduino te resetten — deze kiest de volgende beschikbare DATAXX.CSV om de gegevens op in te loggen, zodat u de gegevens gemakkelijk gescheiden kunt houden.

Opmerking: In plaats van de Arduino Serial Monitor te gebruiken, gebruik ik de ingebouwde "screen"-opdracht op mijn Mac-terminal als een seriële terminal. In mijn Sketch print ik de energiegegevens naar Serial en geef ik ook een "clearscreen" -opdracht, zodat de uitvoer niet beweegt

Serial.write("\x1B" "c"); // Wis het scherm op een gewone terminal wattson.printMCP39F521Data(&data); 

Dit werkt alleen op een gewone terminal die terminalcommando's zoals hierboven kan accepteren, en werkt helaas niet op de Arduino Serial Monitor. Als u echter . probeert scherm , je mag nooit meer terug naar Arduino Serial Monitor!

Het commando ziet er ongeveer zo uit:

$ scherm /dev/tty.usbmodem1411 9600 

waarbij de eerste parameter de "seriële poort" is en de tweede de snelheid is die je hebt geconfigureerd voor je seriële verbinding in je Arduino-schets.

De gegevens plotten in Excel

Omdat het bestand in CSV-formaat was, was het vrij eenvoudig om het te laden en te plotten in Excel. Ik zal hier niet in detail treden, omdat er veel tutorials zijn voor het maken van een grafiek in Excel. Ik heb een rij ingevoegd die de kolomkoppen bevat

tijdstempel, huidigeRMS, activePower, reactievePower, schijnbaarPower 

(Opmerking voor mezelf — dit wordt een toekomstige verbetering van mijn Sketch — om de kolomkoppen rechtstreeks in de CSV toe te voegen!)

Ik koos de bovenstaande datapunten om te loggen en plotten. Het huidige verbruik in de tijd is uiteraard interessant. Waarom activePower, reactievePower en schijnbaarPower? Op basis van de elektrische kenmerken van het apparaat kan het een resistieve belasting, een reactieve belasting of ergens daartussenin zijn, en de drie vermogensparameters vertellen ons dus de algemene kenmerken ervan, en ook of ze in de loop van de tijd veranderen. Althans, dat denk ik...

Laten we eens kijken naar mijn resultaten voor een CFL-lamp met een koude start:

De stroom piekt rond de 0,21 ampère en zakt uiteindelijk naar ongeveer 0,18 ampère.

Het actieve vermogen bereikt een piek van ongeveer 17 watt en zakt uiteindelijk naar ongeveer 14,2 watt.

Nadat hij tot rust was gekomen, schakelde ik de CFL uit en wachtte een tijdje, voordat ik hem weer aanzette (vandaar de daling van de stroom in de bovenstaande grafiek). Je kunt zien dat als een spaarlamp eenmaal "opgewarmd" is, hij snel tot een constant verbruik overgaat.

Conclusie

Er zijn veel interessante gegevens en experimenten die u kunt doen met energiegegevens van uw apparaten en apparaten. Ik was opgewonden om wat gegevens in handen te krijgen en deze met jullie te delen!

Mijn doel met Dr. Wattson is om hoogwaardige energiegegevens voor de Maker mogelijk te maken en toegankelijker te maken, zodat je het kunt gebruiken als een bouwsteen voor je wilde en gekke ideeën.

Dr. Wattson is ontworpen om veilig te gebruiken (vooral met de behuizing), wordt gekalibreerd geleverd (zodat u meteen hoogwaardige energiegegevens kunt krijgen), maar biedt ook meer complexe functionaliteit voor de serieuze gebruiker

• kalibratieroutines
• ZCD (Zero Crossing Detector)
• Gebeurtenismelding (overstroom, oververmogen, spanningsverzakking/-piek)
• de mogelijkheid om het meetbereik aan te passen (door de belastingsweerstanden en/of CT aan te passen en opnieuw te kalibreren met behulp van bovengenoemde kalibratieroutines),
• het gebruik van meerdere Dr. Wattsons samen met een enkele MCU (door de configureerbare I2C-adressering te wijzigen).

Als je geïnteresseerd bent in energiemonitoring en zoals Dr. Wattson, meld je dan aan op (https://upbeatlabs-wattson.launchrock.com/) om op de hoogte te blijven van nieuws en updates!

Groetjes,

Sridhar

Hier is de hele schets, ter referentie! Je kunt het en de Dr. Wattson-bibliotheek ook vinden, samen met een groot aantal andere voorbeelden in de Drwattson GitHub-repository van Upbeat Labs.

/******************************************* *********************************** Dit is een voorbeeldschets voor Upbeat Labs Dr. Wattson Energy Monitoring Breakout --> https://www.tindie.com/products/UpbeatLabs/dr-wattson-energy-monitoring-board-2/ Dit voorbeeld demonstreert het verkrijgen van energiegegevens van Dr. Wattson en het schrijven naar een SD-kaart in een komma gescheiden (CSV) formaat. Er wordt een knop gebruikt om de gegevensverzameling te schakelen, zodat u de gegevens kunt loggen wanneer u klaar bent. Wanneer de knop de meting schakelt, begint de schets de module te pollen voor energiegegevens en drukt deze af. Gebruik voor het gemak van het zien van de waarden een programma-achtig scherm om de seriële uitvoer weer te geven. De seriële schrijft de tekens die nodig zijn om het scherm op een gewone terminal te wissen, wat betekent dat de seriële uitvoer op zijn plaats blijft en na verloop van tijd wordt bijgewerkt. Schakel het ingangsvermogen in om de spanning RMS te zien, de lijnfrequentiewaarden veranderen in de juiste waarden. Schakel de belasting in die op uw uitgang is aangesloten om de huidige RMS, arbeidsfactor, actief, reactief en schijnbaar vermogen te zien veranderen. Al deze waarden worden in CSV-indeling naar de SD-kaart geschreven, die vervolgens met een programma als Excel kan worden gebruikt om de gegevens te bekijken/plotsen. De bestandsnaam heeft de vorm DATAnn.CSV. Bij het instellen wordt een nieuwe bestandsnaam gekozen die nog niet bestaat, dus de bestanden zijn DATA00.CSV, DATA01.CSV, DATA02.CSV enzovoort. De logging roteert naar nieuwe bestanden tot DATA99.CSV. De communicatie gebeurt via I2C. Voor de interface zijn 2 pinnen nodig. Er zijn 4 selecteerbare I2C-adresmogelijkheden per bord (selecteerbaar via twee soldeerjumpers (die elke pin hoog of laag selecteren). Op basis hiervan zijn er 4 mogelijke adressen:I2C-adres SJ1 SJ2 0x74 LAAG LAAG 0x75 LAAG HOOG 0x76 HOOG LAAG 0x77 HOOG HOOG Dr. Wattson heeft twee uitgangen, ZCD of Event, die worden gebruikt voor notificaties en daarom meestal worden aangesloten op een extern onderbreekbare pin (zoals pin2 of pin3 op Arduino Uno).In dit voorbeeld zijn ZCD en Event niet Knop is aangesloten op pin 4. * SD-kaart is als volgt aangesloten op SPI-bus:** MOSI - pin 11 ** MISO - pin 12 ** CLK - pin 13 ** CS - pin 10 LED is aangesloten op pin 9 Geschreven door Sridhar Rajagopal voor Upbeat Labs LLC. BSD-licentie. Alle bovenstaande tekst moet worden opgenomen in elke herdistributie*/#include #include "UpbeatLabs_MCP39F521.h"#include #include  //https://github.com/JChristensen/Button#define BUTTON_PIN 4 //Sluit een tactiele knopschakelaar (of iets dergelijks) aan //van Arduino pin 4 naar aarde.#define PULLUP true //Om het simpel te houden, gebruiken we de interne pullup-weerstand van de Arduino.#define INVERT true //Aangezien de pullup-weerstand de pin hoog houdt tenzij de // schakelaar gesloten is, is dit negatieve logica, dwz een hoge status // betekent dat de knop NIET is ingedrukt. (Uitgaande van een normaal open schakelaar.) #define DEBOUNCE_MS 20 // Een debounce-tijd van 20 milliseconden werkt meestal goed voor schakelaars met tactiele knoppen. Button myBtn(BUTTON_PIN, PULLUP, INVERT, DEBOUNCE_MS); //Declare the button#define LED 9 // Verbind een LED (via een 220ohm weerstand) van pin 9 (anode) naar GND (kathode). #define CHIP_SELECT 10UpbeatLabs_MCP39F521 wattson =UpbeatLabs_MCP39F521();bool readData =false;char bestandsnaam[] ="DATA00.CSV";void setup() { Serial.begin(9600); //zet seriële communicatie Serial.println(F("**Upbeat Labs Dr. Wattson Voorbeeldschets**")); Serial.println(F("Upbeat Labs Dr. Wattson Energy Data SD Card Logging Voorbeeldschets")); Serial.println(F("******************************************* *********************")); // initialiseer de digitale pin als uitvoer. pinMode (LED, UITGANG); pinMode (CHIP_SELECT, UITGANG); // kijk of de kaart aanwezig is en kan worden geïnitialiseerd:if (!SD.begin(CHIP_SELECT)) { Serial.println(F ("*** SD-kaart is mislukt, of niet aanwezig ***")); // doe niets meer:​​} wattson.begin(); // Geef het juiste adres door. Standaard ingesteld op 0x74 // maak een nieuw bestand voor (uint8_t i =0; i <100; i++) { bestandsnaam [4] =i/10 + '0'; bestandsnaam [5] =i%10 + '0'; if (! SD.exists(bestandsnaam)) { Serial.print(F("Databestand is ")); Serial.println(bestandsnaam); // open alleen een nieuw bestand als het niet bestaat break; // verlaat de lus! bestandsnaam zal nu degene zijn die we wensen } } Serial.println(F("**initialisatie voltooid.**"));}void loop() { myBtn.read(); //Lees de knop if (myBtn.wasReleased()) { //Als de knop is losgelaten, verander dan de LED-status readData =!readData; digitalWrite (LED, leesgegevens); } if (readData) { UpbeatLabs_MCP39F521_Data-gegevens; UpbeatLabs_MCP39F521_FormattedData fData; int readMCPretval =wattson.read(&data, NULL); unsigned long currentMillis =millis(); if (readMCPretval ==UpbeatLabs_MCP39F521::SUCCESS) { // Print dingen uit Serial.write ("\x1B" "c"); // Wis het scherm op een gewone terminal wattson.convertRawData(&data, &fData); printMCP39F521Data(&fData); // als het bestand beschikbaar is, schrijf er dan naar: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); // print ook naar de seriële poort:dataFile.close(); } // als het bestand niet geopend is, verschijnt er een foutmelding:else { Serial.print(F("error opening ")); Serial.println(bestandsnaam); } } else { Serial.print(F("Fout!")); Serial.println(leesMCPretval); } }} ongeldig printMCP39F521Data(UpbeatLabs_MCP39F521_FormattedData *data){ Serial.print(F("Voltage =")); Serial.println(data->voltageRMS, 4); Serial.print(F("Huidige =")); Serial.println(data->currentRMS, 4); Serial.print(F("Lijnfrequentie =")); Serial.println(data->lineFrequency, 4); Serial.print ("Analoge ingangsspanning ="); Serial.println(data->analoge ingangsspanning, 4); Serial.print(F("Power Factor =")); Serial.println(data->powerFactor, 4); Serial.print(F("Actief vermogen =")); Serial.println(data->activePower, 4); Serial.print(F("Reactief vermogen =")); Serial.println(data->reactivePower, 4); Serial.print(F("Schijnbare kracht =")); Serial.println(data->apparentPower, 4);} 

// kijk of de kaart aanwezig is en kan worden geïnitialiseerd:if (!SD.begin(CHIP_SELECT)) { Serial.println(F("Kaart mislukt, of niet aanwezig")); // doe niets meer:​​} wattson.begin(); // Geef het juiste adres door. Standaard ingesteld op 0x74

#define BUTTON_PIN 4 // Sluit een tactiele knopschakelaar (of iets dergelijks) aan // van Arduino pin 4 naar aarde. #define PULLUP true //Om het simpel te houden, gebruiken we de interne pullup-weerstand van de Arduino.#define INVERT true //Aangezien de pullup-weerstand de pin hoog houdt tenzij de //-schakelaar gesloten is, is dit negatieve logica, dwz een hoge state // betekent dat de knop NIET is ingedrukt. (Uitgaande van een normaal open schakelaar.) #define DEBOUNCE_MS 20 // Een debounce-tijd van 20 milliseconden werkt meestal goed voor schakelaars met tactiele knoppen. Button myBtn(BUTTON_PIN, PULLUP, INVERT, DEBOUNCE_MS); //Declareer de knop

char bestandsnaam[] ="DATA00.CSV";setup() { ... // maak een nieuw bestand voor (uint8_t i =0; i <100; i++) { bestandsnaam[4] =i/10 + '0'; bestandsnaam [5] =i%10 + '0'; if (! SD.exists(bestandsnaam)) { Serial.print(F("Databestand is ")); Serial.println(bestandsnaam); // open alleen een nieuw bestand als het niet bestaat break; // verlaat de lus! bestandsnaam zal nu degene zijn die we wensen } }...}

 mijnBtn.read(); //Lees de knop if (myBtn.wasReleased()) { //Als de knop is losgelaten, verander dan de LED-status readData =!readData; digitalWrite (LED, leesgegevens); } if (readData) { ... // gegevens lezen en opslaan op SD-kaart, enz ....

 // als het bestand beschikbaar is, schrijf er dan naar: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); // print ook naar de seriële poort:dataFile.close(); } // als het bestand niet geopend is, verschijnt er een foutmelding:else { Serial.print(F("error opening ")); Serial.println(bestandsnaam); } 

/************************************************** ***** Dit is een voorbeeldschets voor Upbeat Labs Dr. Wattson Energy Monitoring Breakout De communicatie gebeurt via I2C. Voor de interface zijn 2 pinnen nodig. Er zijn 4 selecteerbare I2C-adresmogelijkheden per bord (selecteerbaar via twee soldeerjumpers (die elke pin hoog of laag selecteren). Op basis hiervan zijn er 4 mogelijke adressen:I2C-adres SJ1 SJ2 0x74 LAAG LAAG 0x75 LAAG HOOG 0x76 HOOG LAAG 0x77 HOOG HOOGDr. Wattson heeft twee uitgangen, ZCD of Event, die worden gebruikt voor meldingen en daarom meestal worden aangesloten op een extern onderbreekbare pin (zoals pin2 of pin3 op Arduino Uno). In dit voorbeeld worden ZCD en Event niet gebruikt .Knop is aangesloten op pin 4. * SD-kaart is als volgt aangesloten op SPI-bus:** MOSI - pin 11 ** MISO - pin 12 ** CLK - pin 13 ** CS - pin 10 LED is aangesloten op pin 9 Geschreven door Sridhar Rajagopal voor Upbeat Labs LLC. BSD-licentie. Alle bovenstaande tekst moet worden opgenomen in elke herdistributie */ #include #include "MCP39F521.h"#include #include  / /https://github.com/JChristensen/Button#define BUTTON_PIN 4 //Sluit een tactiele knopschakelaar (of iets dergelijks) aan //van Arduino pin 4 naar aarde . #define PULLUP true //Om het simpel te houden, gebruiken we de interne pullup-weerstand van de Arduino.#define INVERT true //Aangezien de pullup-weerstand de pin hoog houdt tenzij de //-schakelaar gesloten is, is dit negatieve logica, dwz een hoge state // betekent dat de knop NIET is ingedrukt. (Uitgaande van een normaal open schakelaar.) #define DEBOUNCE_MS 20 // Een debounce-tijd van 20 milliseconden werkt meestal goed voor schakelaars met tactiele knoppen. Button myBtn(BUTTON_PIN, PULLUP, INVERT, DEBOUNCE_MS); //Declare the button#define LED 9 // Verbind een LED (via een 220ohm weerstand) van pin 9 (anode) naar GND (kathode).#define CHIP_SELECT 10MCP39F521 wattson =MCP39F521();bool readData =false;char bestandsnaam[ ] ="DATA00.CSV"; ongeldige setup() { Serial.begin(9600); //zet seriële communicatie Serial.println(F("**Upbeat Labs Dr. Wattson Voorbeeldschets**")); // initialiseer de digitale pin als uitvoer. pinMode (LED, UITGANG); pinMode (10, UITGANG); // kijk of de kaart aanwezig is en kan worden geïnitialiseerd:if (!SD.begin(CHIP_SELECT)) { Serial.println(F("Kaart mislukt, of niet aanwezig")); // doe niets meer:​​} wattson.begin(); // Geef het juiste adres door. Standaard ingesteld op 0x74// maak een nieuw bestand aan voor (uint8_t i =0; i <100; i++) { bestandsnaam [4] =i/10 + '0'; bestandsnaam [5] =i%10 + '0'; if (! SD.exists(bestandsnaam)) { Serial.print(F("Databestand is ")); Serial.println(bestandsnaam); // open alleen een nieuw bestand als het niet bestaat break; // verlaat de lus! bestandsnaam zal nu degene zijn die we wensen } } Serial.println(F("**initialisatie voltooid.**")); }// Zo ziet MCP39F521Data eruit, ter referentie!//typedef struct MCP39F521Data {// uint16_t systemStatus;// uint16_t systemVersion;// uint16_t voltageRMS;// uint16_t lineFrequency;// uint16_t analogIntVoltage; / uint32_t currentRMS;// uint32_t activePower;// uint32_t reactivePower;// uint32_t schijnbaarPower;//} MCP39F521Data; void loop() { myBtn.read(); //Lees de knop if (myBtn.wasReleased()) { //Als de knop is losgelaten, verander dan de LED-status readData =!readData; digitalWrite (LED, leesgegevens); } if (readData) { MCP39F521Data-gegevens; int readMCPretval =wattson.readMCP39F521(&data, NULL); unsigned long currentMillis =millis(); if (readMCPretval) { // Print dingen uit Serial.write ("\x1B" "c"); // Wis het scherm op een gewone terminal wattson.printMCP39F521Data(&data); // als het bestand beschikbaar is, schrijf er dan naar: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); // print ook naar de seriële poort:dataFile.close(); } // als het bestand niet geopend is, verschijnt er een foutmelding:else { Serial.print(F("error opening ")); Serial.println(bestandsnaam); } } else { Serial.println(F("Fout!")); } }}

Schema's