Arduino meet wisselspanning 220v. Analoge metingen met Arduino

Gebruikte elementen:

• zelfstudie

Invoering

• Meting van elektriciteit.
• Kracht, kwaliteit.
• Apparaten voor het meten van de parameters van elektriciteit.

• Aansluiting van stroom- en spanningssensoren in gelijkstroomapparaten, evenals enkelfasige en driefasige wisselstroomcircuits;
• Meting van effectieve waarden van stroom en spanning;
• Meting van de arbeidsfactor;
• Volledig, actief en reactief vermogen;
• Elektriciteitsverbruik;

1. Sensoren aansluiten

DC-sensoren aansluiten

1.2 Sensoren aansluiten op eenfasige wisselstroomcircuits

1.3 Sensoren aansluiten op meerfasencircuits van wisselstroomnetwerken

2 RMS-waarde van stroom en spanning

Arduino-schets voor één kanaal

void setup () (autoadcsetup (); DDRD | = (1<

Het programma is geschreven in de Arduino IDE voor de ATmega1280-microcontroller. Op mijn debug-bord worden de eerste 8 kanalen gerouteerd voor de interne behoeften van het bord, dus het ADC8-kanaal wordt gebruikt. Het is mogelijk om deze schets te gebruiken voor een bord met een ATmega168, maar je moet wel het juiste kanaal selecteren.
Binnen de interrupts jongleren we met een paar servicepinnen om duidelijk de werkende digitaliseringsfrequentie te zien.
Een paar woorden over waar de factor 102 vandaan kwam. Bij de eerste start werd een signaal met verschillende amplitudes geleverd door de generator, werd de werkelijke spanningswaarde afgelezen van de oscilloscoop en werd de berekende waarde in absolute ADC-eenheden van de console gehaald .

We zullen op dit punt onderbreken. In het volgende deel gaan we in op de andere drie vragen van deze serie en gaan we soepel verder met het maken van het apparaat zelf.

De gepresenteerde firmware, evenals andere firmware voor deze serie (aangezien ik video's sneller maak dan het voorbereiden van artikelen), is te vinden in de repository op GitHub.

Als je je erg zorgen maakt over het verbruik van elektrische energie en je wilt echt de boosdoener achterhalen, dan is dit jouw dag. We zullen een stroomsensor samenstellen en een eenvoudige logica schrijven om de invoerwaarden te verwerken om de waarden om te zetten in kilowatt / h.

Voor de montage heb ik een Arduino nano-bord gebruikt (niemand stoort je om dezelfde code te gebruiken voor ESP- of STM-kaarten), LCD-schermafscherming, 56 Ohm-weerstand, 100 kOhm-weerstanden, 10 mKf-condensator, CT-stroomsensor - Talema AC103 (met nominale meting 30A en maximaal 75A).

Wat is een stroomsensor?

De stroomsensor is een magnetisch circuit met een opening en een compensatiewikkeling, evenals een ingebouwde Hall-sensor en een besturingskaart. De Hall-sensor bevindt zich in de opening van het magnetische circuit en reageert op het magnetische veld dat door de spoel wordt gegenereerd. Hoe sterker het magnetische veld, hoe sterker de Hall-effectsensor een signaal genereert, dat door de besturingskaart wordt versterkt.
Stroomsensoren worden gebruikt om wisselstroom en gelijkstroom te meten. De onze - CT-Talema AC103 - voor AC.

Laten we ons apparaat volgens het diagram samenstellen:

Het LCD-scherm heeft al pinnen voor het aansluiten van onze analoge poorten om het signaal te meten - en dat is handig.
Er moet een enkelfasige invoerkabel door de stroomsensor worden gevoerd. vaak komt niet alle spanning naar de nuldraad - sommige kunnen door de grond gaan.

Vergeet niet dat we de belastingsweerstand R3 moeten kalibreren. De formule voor het berekenen van R = V / I - R = 2,5 / 0,042 = 59,5 Ohm waarbij 2,5 de referentiespanning op het bord is en 42 mA het verbruik van het bord. Daarom nemen we de dichtstbijzijnde weerstand bij nominale waarde - 56 ohm.
Om de hoofdvoedingsspanning te verdelen over de referentie 5/2, moet u twee identieke weerstanden R1 en R2 leveren.

Het enige dat overblijft is om de voorbeeldcode naar de Arduino te uploaden:

// Michael Klements // The DIY Life // 27 oktober 2014 #include int huidigePin = 1; // Wijs CT-invoer toe aan pin 1 dubbele kilo = 0; int piekvermogen = 0; LiquidCrystal-lcd (8, 9, 4, 5, 6, 7); // Wijs LCD-schermpinnen toe, volgens de vereisten van het LCD-schild void setup () (lcd.begin (16,2); // kolommen, rijen.use 16,2 voor een 16x2 LCD, enz. lcd.clear (); lcd .setCursor (0,0); // zet cursor op kolom 0, rij 0 (de eerste rij) lcd.print ("Running");) void loop () (int current = 0; int maxCurrent = 0; int minCurrent = 1000; voor (int i = 0; i<=200 ; i++) //Monitors and logs the current input for 200 cycles to determine max and min current { current = analogRead(currentPin); //Reads current input and records maximum and minimum current if(current >= maxCurrent) maxCurrent = stroom; anders als (huidige<= minCurrent) minCurrent = current; } if (maxCurrent <= 517) { maxCurrent = 516; } double RMSCurrent = ((maxCurrent - 516)*0.707)/11.8337; //Calculates RMS current based on maximum value int RMSPower = 220*RMSCurrent; //Calculates RMS Power Assuming Voltage 220VAC, change to 110VAC accordingly if (RMSPower >peakPower) (peakPower = RMSPower;) kilo = kilo + (RMSPower * (2.05 / 60/60/1000)); // Bereken gebruikte kilowattuur vertraging (2000); lcd.wissen (); lcd.setCursor (0,0); // Toont alle huidige gegevens lcd.print (RMSCurrent); lcd.print ("A"); lcd.setCursor (10,0); lcd.print (RMSPower); lcd.print ("W"); lcd.setCursor (0,1); lcd.print (kilo); lcd.print ("kWh"); lcd.setCursor (10,1); lcd.print (piekvermogen); lcd.print ("W"); )

De laatste hand aan onze setup is kalibratie. Dit kan het beste worden gedaan met een bekende vermogensreferentiebelasting ingeschakeld. Krachtige gloeilampen zijn hier zeer geschikt voor. Laten we een lamp van 100 watt nemen. We zetten het tarief aan en berekenen de correctiefactor:
Dubbele RMSCurrent = ((maxCurrent - 516) * 0.707) / 11.8337 waarbij 11.8337 de aangepaste coëfficiënt is om afwijkingen in metingen te compenseren.

Analoge ingangen van het Arduino-bord.

Het Arduino UNO-bord bevat 6 analoge ingangen voor het meten van de signaalspanning. Het zou juister zijn om te zeggen dat 6 pinnen van het bord kunnen werken in de modus van zowel discrete pinnen als analoge ingangen.

Deze pinnen zijn genummerd van 14 tot en met 19. Ze zijn aanvankelijk geconfigureerd als analoge ingangen en zijn toegankelijk met de namen A0-A5. Ze kunnen op elk moment worden geconfigureerd voor discrete output-modus.

pinMode (A3, UITGANG); // discrete uitvoermodus instellen voor A3
digitalWrite (A3, LAAG); // lage status instellen op uitgang A3

Om terug te keren naar de analoge ingangsmodus:

pinMode (A3, INGANG); // de analoge ingangsmodus instellen voor A3

Analoge ingangen en pull-up weerstanden.

Optrekweerstanden zijn aangesloten op de pinnen van de analoge ingangen, evenals op de discrete pinnen. Het opnemen van deze weerstanden wordt uitgevoerd door het commando

digitalWrite (A3, HOOG); // activeer pull-up weerstand naar A3

De opdracht moet worden toegepast op de uitgang die is geconfigureerd in de invoermodus.

Houd er rekening mee dat de weerstand het niveau van het analoge ingangssignaal kan beïnvloeden. De stroom van de 5V-voeding door de pull-up-weerstand veroorzaakt een spanningsval over de interne weerstand van de signaalbron. Het is dus beter om de weerstand los te koppelen.

Analoog-naar-digitaal omzetter van het Arduino-bord.

De daadwerkelijke meting van de spanning op de ingangen wordt uitgevoerd door een analoog-naar-digitaal omzetter (ADC) met een 6-kanaals schakelaar. De ADC heeft een resolutie van 10 bits, wat overeenkomt met de code op de converteruitgang 0 ... 1023. Meetfout is niet meer dan 2 eenheden van het minst significante cijfer.

Om maximale nauwkeurigheid (10 cijfers) te behouden, is het noodzakelijk dat de interne weerstand van de signaalbron niet groter is dan 10 kΩ. Deze vereiste is vooral belangrijk bij het gebruik van weerstandsverdelers die zijn aangesloten op de analoge ingangen van het bord. De weerstand van de delerweerstanden mag niet te hoog zijn.

Analoge input software functies.

int analoog lezen (poort)

Leest de spanningswaarde op de gespecificeerde analoge ingang. Een ingangsspanning variërend van 0 tot het referentiespanningsniveau (vaak 5 V) wordt omgezet in een code van 0 tot 1023.

Bij een 5 V referentie is de resolutie 5 V / 1024 = 4,88 mV.

De conversietijd is ongeveer 100 µs.

int invoercode; // ingangsspanningscode:
vlotter ingangsspanning; // ingangsspanning in V

inputCod = analoog lezen (A3); // uitleesspanning op ingang A3
inputVoltage = ((float) inputCod * 5. / 1024.); // herberekening van de code in spanning (V)

ongeldig analoogReferentie (type)

Stelt de referentiespanning in voor de ADC. Het definieert de maximale waarde van de analoge ingangsspanning die de ADC correct kan omzetten. De waarde van de referentiespanning bepaalt ook de conversiefactor van de code in spanning:

Ingangsspanning = ADC-code * referentiespanning / 1024.

Het argument type kan de volgende waarden aannemen:

• STANDAARD - de referentiespanning is gelijk aan de voedingsspanning van de controller (5 V of 3,3 V). Voor Arduino UNO R3 - 5 V.
• INTERN is een interne 1,1 V-referentie voor kaarten met ATmega168- en ATmega328-controllers, voor ATmega8 - 2,56 V.
• INTERNAL1V1 is de interne 1.1V-referentie voor de Arduino Mega-controllers.
• INTERNAL2V56 - Interne 2,56V referentie voor Arduino Mega controllers.
• EXTERN - externe spanningsreferentie, aangesloten op de AREF-ingang.

analogeReferentie (INTERN); // de referentiespanning is 1,1 V

Tweekanaals voltmeter op Arduino.

Laten we als voorbeeld van het gebruik van de analoge ingangsfuncties een project maken voor een eenvoudige digitale voltmeter op Arduino. Het apparaat moet spanningen meten op twee analoge ingangen van het bord, en de gemeten waarden via een seriële poort naar een computer sturen. Aan de hand van dit project als voorbeeld zal ik de principes laten zien van het creëren van eenvoudige systemen voor het meten en verzamelen van informatie.

Laten we besluiten dat de voltmeter de spanning in het bereik van minimaal 0 ... 20 V moet meten en een circuit ontwikkelen om de voltmeter-ingangen aan te sluiten op het Arduino UNO-bord.

Als we de referentiespanning gelijk stellen aan 5 V, dan meten de analoge ingangen van het bord de spanning in het bereik van 0 ... 5 V. En we hebben minimaal 0 ... 20 V nodig. Dus we moeten gebruiken een spanningsdeler.

De spanning aan de ingang en uitgang van de verdeler is gerelateerd aan de verhouding:

Uout = (Uinput / (R1 + R2)) * R2

Overdrachtsverhouding:

K = Uuit / Uinput = R2 / (R1 + R2)

We hebben een versterking nodig van 1/4 (20V * 1/4 = 5V).

Om maximale nauwkeurigheid (10 cijfers) te behouden, is het noodzakelijk dat de interne weerstand van de signaalbron niet hoger is dan 10 kΩ. Daarom kiezen we de weerstand R2 gelijk aan 4,22 kOhm. We berekenen de weerstand van de weerstand R1.

0,25 = 4,22 / (R1 + 4,22)
R1 = 4,22 / 0,25 - 4,22 = 12,66 kΩ

Ik vond weerstanden van 15 kOhm met de dichtstbijzijnde waarde. Met weerstanden R1 = 15 kΩ en R2 = 4,22:

5 / (4,22 / (15 + 4,22)) = 22,77 V.

Het voltmetercircuit op basis van Arduino ziet er als volgt uit.

Op de analoge ingangen A0 en A1 zijn twee spanningsdelers aangesloten. Condensatoren C1 en C2 vormen samen met de delerweerstanden laagdoorlaatfilters die hoogfrequente ruis uit de signalen verwijderen.

Ik heb dit circuit op een breadboard gemonteerd.

Ik heb de eerste ingang van de voltmeter aangesloten op een gereguleerde voeding en de tweede op de 3,3 V-voeding van het Arduino-bord. Om de spanning te regelen, heb ik een voltmeter aangesloten op de eerste ingang. Het blijft om het programma te schrijven.

Een programma voor het meten van spanning met behulp van een Arduino-bord.

Het algoritme is eenvoudig. Vereist:

• lees de ADC-code twee keer per seconde;
• zet het om in spanning;
• meetwaarden via een seriële poort naar een computer sturen;
• het Arduino IDE-poortmonitorprogramma om de verkregen spanningswaarden op het computerscherm weer te geven.

Ik zal in één keer een volledige schets van het programma geven.

// spanning meetprogramma
// op analoge ingangen A0 en A1

#erbij betrekken

meetperiode tijd:
#definieer R1 15. // de weerstand van de weerstand R1
#definieer R2 4.22 // weerstand van weerstand R2

zweven u1, u2; // gemeten spanningen

ongeldige setup () (
Serieel.begin (9600); //

MsTimer2 :: start (); // onderbreking inschakelen
}

lege lus () (

// periode 500 ms
if (timeCount> = MEASURE_PERIOD) (
tijdtelling = 0;

//

// kanaal 2-code lezen en converteren naar spanning
u2 = ((float) analogRead (A1)) * 5. / 1024. / R2 * (R1 + R2);

// seriële gegevensoverdracht
Serieafdruk ("U1 ="); Serieafdruk (u1, 2);
Serieafdruk ("U2 ="); Serieel.println (u2, 2);
}
}

// interruptafhandeling 1ms
ongeldige timerInterupt () (
timeCount ++;
}

Laat me de regel uitleggen waarin de ADC-code wordt omgezet in spanning:

// kanaal 1-code lezen en converteren naar spanning
u1 = ((float) analogRead (A0)) * 5. / 1024. / R2 * (R1 + R2);

• De ADC-code wordt gelezen: analogRead (A0).
• Expliciet geconverteerd naar floating point formaat: (float).
• Omgerekend naar spanning op de analoge ingang: * 5. / 1024. De punt aan het einde van de cijfers geeft aan dat dit een getal met drijvende komma is.
• Er wordt rekening gehouden met de overdrachtsverhouding van de deler: / R2 * (R1 + R2).

Laten we het programma in het bord laden, de seriële poortmonitor starten.

De twee lopende staven geven de gemeten spanningen weer. Alles werkt.

Meting van de gemiddelde waarde van een signaal.

Laten we het eerste kanaal van onze voltmeter aansluiten op een spanningsbron met een hoge rimpel. We zullen zo'n beeld op de monitor zien.

De spanningswaarden van het eerste kanaal op het beeldscherm schokken en springen de hele tijd. En de aflezingen van de controle voltmeter zijn vrij stabiel. Dit komt omdat de referentie-voltmeter het gemiddelde van het signaal meet, terwijl het Arduino-bord elke 500 ms individuele samples leest. Uiteraard valt het moment van uitlezen van de ADC in verschillende punten van het signaal. En met een hoog niveau van rimpeling is de amplitude op deze punten anders.

Bovendien, als het signaal in afzonderlijke zeldzame monsters wordt gelezen, kan elke impulsruis een significante fout in de meting introduceren.

De oplossing is om een ​​paar frequente monsters te nemen en de gemeten waarde te middelen. Voor deze:

• in de interrupt-handler lezen we de ADC-code en voegen deze toe aan de vorige voorbeelden;
• het tellen van de middelingstijd (het aantal middelingsmonsters);
• bij het bereiken van het gespecificeerde aantal monsters - sla de totale waarde van de ADC-codes op;
• om de gemiddelde waarde te verkrijgen, wordt de som van de ADC-codes gedeeld door het aantal middelingsmonsters.

Probleem uit het wiskundeboek van groep 8. Hier is een schets van het programma, een tweekanaals gemiddelde voltmeter.

// gemiddelde spanning meetprogramma
// op analoge ingangen A0 en A1

#erbij betrekken

#define MEASURE_PERIOD 500 // meetperiode tijd:
#definieer R1 15. // de weerstand van de weerstand R1
#definieer R2 4.22 // weerstand van weerstand R2

int timeCount; // tijdteller
lange sumU1, sumU2; // variabelen voor het optellen van ADC-codes
lange gemiddeldeU1, gemiddeldeU2; // som van ADC-codes (gemiddelde waarde * 500)
booleaanse vlagGereed; // gereedheidsindicator meetgegevens

ongeldige setup () (
Serieel.begin (9600); // initialiseer de poort, snelheid 9600
MsTimer2 :: set (1, timerInterupt); // timer onderbreekt, periode 1 ms
MsTimer2 :: start (); // onderbreking inschakelen
}

lege lus () (

if (flagReady == waar) (
flagReady = onwaar;
// conversie naar spanning en overdracht naar computer
Serieafdruk ("U1 =");
Serial.print ((float) avarageU1 / 500. * 5. / 1024. / R2 * (R1 + R2), 2);
Serieafdruk ("U2 =");
Serial.println ((float) avarageU2 / 500. * 5. / 1024. / R2 * (R1 + R2), 2);
}
}

// interruptafhandeling 1ms
ongeldige timerInterupt () (

timeCount ++; // +1 gemiddelde steekproefteller
sumU1 + = analoog lezen (A0); // optelling van ADC-codes
sumU2 + = analoog lezen (A1); // optelling van ADC-codes

// controleer het aantal middelingsmonsters
if (timeCount> = MEASURE_PERIOD) (
tijdtelling = 0;
gemiddeldeU1 = somU1; // gemiddelde overbelasting
gemiddeldeU2 = somU2; // gemiddelde overbelasting
somU1 = 0;
somU2 = 0;
flagReady = waar; // teken dat het meetresultaat klaar is
}
}

In de formule voor het herberekenen van de ADC-code in de spanning, werd / 500 toegevoegd - het aantal monsters. Laden, start de poortmonitor (Cntr + Shift + M).

Nu, zelfs met een aanzienlijk niveau van rimpeling, veranderen de metingen met honderdsten. Dit komt alleen omdat de spanning niet gestabiliseerd is.

Het aantal monsters moet worden gekozen rekening houdend met:

• het aantal monsters bepaalt de meettijd;
• hoe groter het aantal samples, hoe minder het effect van ruis zal zijn.

De belangrijkste storingsbron in analoge signalen is het 50 Hz-netwerk. Daarom is het raadzaam om de middelingstijd te selecteren die een veelvoud is van 10 ms - de halve cyclustijd van het netwerk met een frequentie van 50 Hz.

Optimalisatie van berekeningen.

Computing met drijvende komma verslindt gewoon de bronnen van een 8-bits microcontroller. Elke drijvende-kommabewerking vereist mantisse-denormalisatie, vaste-puntbewerking, mantisse-normalisatie, ordercorrectie ... En alle bewerkingen met 32-bits getallen. Daarom is het noodzakelijk om het gebruik van drijvende-kommaberekeningen tot een minimum te beperken. Hoe je dit doet, vertel ik je in de volgende lessen, maar laten we in ieder geval onze berekeningen optimaliseren. Het effect zal aanzienlijk zijn.

In ons programma wordt de conversie van de ADC-code naar spanning als volgt geschreven:

(float) gemiddeldeU1 / 500. * 5. / 1024. / R2 * (R1 + R2)

Hoeveel berekeningen zijn er, en alles is een drijvende komma. Maar de meeste berekeningen zijn bewerkingen met constanten. Een deel van de lijn:

/ 500. * 5. / 1024. / R2 * (R1 + R2)

(float) gemiddeldeU1 * 0.00004447756

Slimme compilers herkennen zelf berekeningen met constanten en berekenen deze tijdens het compileren. Ik vroeg me af hoe slim de Andruino-compiler is. Ik besloot het te controleren.

Ik heb een kort programma geschreven. Het voert een lus van 10.000 lussen uit en stuurt vervolgens de tijd naar de computer voor die 10.000 lussen. Die. hiermee kunt u de uitvoeringstijd zien van de bewerkingen die zich in de hoofdtekst van de lus bevinden.

// berekening optimalisatie check

intx = 876;
zweven y;
niet-ondertekende int telling;
niet-ondertekend lange tijdCurrent, timePrev;

ongeldige setup () (
Serieel.begin (9600);
}

lege lus () (
tel ++;
// y = (zwevend) x / 500. * 5. / 1024. / 4.22 * (15. + 4.22);
// y = (zwevend) x * 0.00004447756;

als (telling> = 10000) (
aantal = 0;
timeCurrent = millis ();
Serial.println (timeCurrent - timePrev);
timePrev = tijdCurrent;
}
}

In de eerste variant, wanneer de drijvende-kommabewerkingen in de lus worden uitgecommentarieerd en niet uitgevoerd, retourneerde het programma het resultaat van 34 ms.

Die. 10.000 inactieve cycli worden voltooid in 34 ms.

Toen opende ik de regel:

y = (zwevend) x / 500. * 5. / 1024. / 4.22 * (15. + 4.22);

herhaalt onze berekeningen. Resultaat van 10.000 passages in 922 ms of

(922 - 34) / 10.000 = 88,8 s.

Die. deze lijn van drijvende-kommaberekening duurt 89 µs. Ik dacht dat er meer zou zijn.

Nu sloot ik deze regel met een opmerking en opende de volgende, vermenigvuldigd met een vooraf berekende constante:

y = (zwevend) x * 0.00004447756;

Resultaat van 10.000 passages in 166 ms of

(166 - 34) / 10.000 = 13,2 µs.

Verbazingwekkend resultaat. We hebben 75,6 microseconden per regel bespaard. We voltooiden het bijna 7 keer sneller. We hebben 2 van dergelijke lijnen, maar er kunnen er veel meer in het programma staan.

Conclusie - berekeningen met constanten moeten zelf op de rekenmachine worden gedaan en in programma's worden toegepast als kant-en-klare coëfficiënten. De Arduino-compiler berekent ze niet in de compilatiefase. In ons geval moet u dit doen:

#define ADC_U_COEFF 0.00004447756 // ADC-code naar spanning conversiefactor

Serial.print ((float) avarageU1 * ADC_U_COEFF, 2);

De optimale optie in termen van snelheid is om de ADC-code naar de computer over te dragen, en daarmee alle berekeningen met drijvende komma. In dit geval moet een gespecialiseerd programma gegevens op de computer ontvangen. De poortmonitor van de Arduino IDE zal niet werken.

Ik zal het hebben over andere manieren om Arduino-programma's te optimaliseren in toekomstige lessen, indien nodig. Maar zonder dit probleem op te lossen, is het onmogelijk om complexe programma's op een 8-bits microcontroller te ontwikkelen.

Er is weer een les op de site verschenen (