- Material som krävs för ESP32 Power Meter
- Arduino och ESP32-baserad effektivitetsmätare - kretsschema
- PCB-design för Arduino och ESP32-baserad effektivitetsmätare
- Arduino och ESP32-baserad effektivitetsmätare - kod
- Testar Arduino- och ESP32-baserad effektivitetsmätare
- Ytterligare förbättringar
Vi är alla medvetna om en grundläggande voltmeter, amperemeter och wattmeter, de tre grundläggande sakerna du behöver för att mäta värden på alla elektroniska projekt eller kretsar. Att mäta spänning och ström med hjälp av en multimeter kan vara ett bra sätt att börja, men ett av de största problemen jag står inför när jag testar en krets är att mäta effektivitet. Så i dag kommer vi att lösa det problemet genom att bygga en Arduino- och ESP32-baserad effektivitetsmätare som kan mäta ingångsspänning, ingångsström, utgångsspänning och utgångsström. Därför kan den mäta ingångseffekt och uteffekt samtidigt, och med dessa värden kan vi enkelt mäta effektiviteten. Tidigare har vi också gjort något mycket liknande i vårt Arduino-baserade Wattmeter-projekt, men här kommer vi att mäta både ingångseffekt och uteffekt till beräkna effektivitet.
Istället för att köpa fyra meter för jobbet kommer vi att kunna lösa detta problem genom att integrera alla fyra meters kapacitet i en. Att bygga din digitala mätare minskar inte bara kostnaden utan ger dig också ett vickrum för uppgraderingar och förbättringar. Eftersom vi använder en ESP32 för att bygga detta projekt kan vi enkelt göra denna mätares IoT-aktiverade och logga data över webben, vilket är ämnet för det framtida projektet. Med alla grunderna rensade, låt oss gå in i det.
Obs: Denna effektmätare är avsedd för likströmskretsar. Om du vill mäta växelström till beräknad växelströmseffektivitet kan du kolla in IoT-baserade elenergimätare och förbetalda energimätarprojekt.
Material som krävs för ESP32 Power Meter
Bilden nedan visar material som används för att bygga kretsen. Eftersom detta är gjort med mycket generiska komponenter, bör du kunna hitta allt listat material i din lokala hobbybutik.
Jag har också listat komponenterna nedan tillsammans med önskad mängd. Om du själv bygger kretsen rekommenderas det starkt att hämta allt material från listan nedan.
- ESP32-kort - 1
- 128X64 OLED - 1
- ACS712-20 IC - 2
- DC Barrel Jack - 1
- 100uF kondensator - 2
- 104pF - 2
- 102pF - 2
- 10K, 1% - 4
- 68K, 1% - 2
- 6,8 tusen, 1% - 2
Arduino och ESP32-baserad effektivitetsmätare - kretsschema
Schemat för Arduino och ESP32-baserad effektivitetsmätare visas nedan. Att skapa den här kretsen är mycket enkel och använder generiska komponenter.
Kretsens funktion är mycket enkel. Vi kommer att mäta spänningen och strömmen i detta projekt men på ett unikt sätt. Vi mäter spänning och ström för både ingången och utgången, därför kan vi se kretsens effektivitet. Detta är mycket användbart för vissa projekt. Ett exempel kan vara en DC till DC-omvandlare där effektivitetsmätning blir obligatorisk. Hur kretsen fungerar beskrivs nedan.
ACS712 nuvarande sensor IC:
Som du kan se i bilden ovan använder vi en ACS712 strömgivare IC för att mäta ström. Detta är en mycket intressant IC eftersom den använder Hall-effekten för att mäta ström, det finns tre varianter av denna IC som finns på marknaden f (eller 5A, 20A och 30A). Vi använder 20A-varianten av detta och den är märkt som ACS712-20.
ACS712-databladet rekommenderar ett spänningsområde på 4,5 - 5,5 för att fungera smidigt. Och när vi ska mäta strömmen med en ESP32 är den bara 3,3 V tolerant, varför jag har använt en spänningsdelare med två 10K-motstånd för att få ner utgångsspänningen på ACS712 IC. När ingen ström strömmar genom IC: n matar den ut 2,5V, och när någon mängd ström strömmar genom IC: n sänker den antingen spänningen eller så ökar den spänningen beroende på strömflödesriktningen. Vi har använt två av dessa IC för att mäta in- och utström. Kolla in våra tidigare projekt (nedan) där vi använde den här ACS712-sensorn.
- IoT-baserad elenergimätare med Arduino och ESP8266 Wi-Fi-modul
- Digital amperemätarkrets med PIC-mikrokontroller och ACS712
Där vi diskuterade hur dessa sensorer fungerar i detalj. Du kan kolla in dem om du vill veta mer om dessa sensorer.
Spänningsdelaren:
För att mäta in- och utspänningen har vi två spänningsdelare på kretsens ingångs- och utgångssida. Den maximala spänningen som kretsen kan mäta är 35V, men den kan enkelt ändras genom att ändra motståndsvärdena för spänningsdelaren.
Spänningsregulatorn:
En generisk LM7805-spänningsregulator används för att driva ESP32, OLED och ACS712 IC. Eftersom vi driver upp den med ganska ren effekt används inga frikopplingskondensatorer, men vi har använt 100uF kondensatorer vid både ingången och utgången för att stabilisera IC.
ESP32 IC och OLED-skärmen:
Vi har använt en ESP32 som huvudprocessor, som ansvarar för alla avläsningar, beräkningar, ingångar och utgångar. Vi har också använt en 128X64 OLED-skärm för att känna till värdena.
PCB-design för Arduino och ESP32-baserad effektivitetsmätare
Kretskortet för vår Arduino- och ESP32-baserade effektivitetsmätare är utformad på ett ensidigt kort. Jag har använt Eagle för att designa min PCB men du kan använda valfri designprogramvara. 2D-bilden av min brädedesign visas nedan.
Tillräckligt markspår används för att göra korrekt markförbindelser mellan alla komponenter. Vi såg också till att använda korrekta 5V- och 3.3V-spår för att minska buller och förbättra effektiviteten.
- Ladda ner PCB-design och GERBER-filer Arduino och ESP32-baserad effektivitetsmätare
Handgjord PCB:
För bekvämlighet och testning gjorde jag min handgjorda version av PCB och den visas nedan. I den första versionen gjorde jag några misstag som jag rättade till med hjälp av några bygelkablar. Men i den slutliga versionen fixade jag dem, du kan bara ladda ner filerna och använda dem.
Arduino och ESP32-baserad effektivitetsmätare - kod
Nu när vi har en bra förståelse för hårdvarusidan av saker kan vi öppna Arduino IDE och börja vår kodning. Syftet med koden är att läsa den analoga spänningen från stift 35 och 33 på ESP32-kortet. Vi läser också spänningen från 32 och 34 stift som är det aktuella värdet. När vi väl gjort det kan vi multiplicera dem för att få ineffekt och uteffekt, och genom att sätta på den till effektivitetsformeln kan vi få effektiviteten.
Slutligen visar vi den på LCD-skärmen. Det kompletta programmet för att göra detsamma ges i slutet, vilket kan användas som sådant för hårdvaran som diskuterats ovan. Vidare delas koden upp i små utdrag och förklaras.
Eftersom vi använder en 128X64 OLED-skärm behöver vi Adafruit_GFX-biblioteket och Adafruit_SSD1306-biblioteket för att kommunicera med skärmen. Du kan ladda ner båda från Arduinos standardkortterminal; om du har några problem med styrelsedelen kan du också ladda ner och inkludera biblioteken från tillhörande GitHub-arkiv, som anges nedan.
- Ladda ner Adafruit_GFX-biblioteket
- Ladda ner Adafruit_SSD1306-biblioteket
Som alltid börjar vi vår kod med att inkludera alla bibliotek som krävs. Sedan definierar vi alla nödvändiga stift och variabler som alla visas nedan.
#omfatta
De SCREEN_WIDTH & SCREEN_HEIGHT definitioner används för att definiera bildstorleken. Därefter har vi definierat alla nödvändiga stift, genom vilka vi ska mäta spänningen och strömmen. Därefter har vi definierat motståndsvärdena som används i hårdvaran som du kan se från schemat. Om du inte har dessa värden eller om du vill ändra mätarens räckvidd kan du ändra dessa värden, koden fungerar bra.
Eftersom vi använder en ACS712 för att mäta strömmen behöver vi mVperAmp- värdet för att beräkna strömmen från spänningen. När jag använder en 20A ACS712-modul är mV / A-värdet 100 som anges i databladet. Men eftersom vi använder en ESP32 och en spänningsdelare kommer vi att ha halva värdet som är 50, och det är därför vi har lagt in mV / AMP-värdet.
ACSoffset är den offset som behövs för att beräkna strömmen från spänningen. Eftersom ACS712 IC drivs från 5V är offset-spänningen 2,5V. Men när vi använder en spänningsdelare går den ner till 1,25V. Du kanske redan känner till den skitiga ADC på ESP32, så jag var tvungen att använda värdet 1136. Om du har kalibreringsproblem kan du justera värdena och kompensera för ADC.
Slutligen avslutar vi detta avsnitt med att skapa ett visningsobjekt av klassen Adafruit_SSD1306 och passera skärmens bredd, höjd, I 2 C-konfiguration, och den sista -1-parametern används för att definiera återställningsfunktionen. Om din skärm inte har en extern återställningsstift (vilket verkligen är för min skärm) måste du använda -1 för det sista argumentet.
ogiltig installation () {Serial.begin (115200); if (! display.begin (SSD1306_SWITCHCAPVCC, 0x3C)) {// Address 0x3D for 128x64 Serial.println (F ("SSD1306 allocation failed")); för (;;); } display.clearDisplay (); display.setRotation (2); display.setTextSize (1); fördröjning (100); }
Därefter har vi vår inställning () avsnitt. I det här avsnittet aktiverar vi seriell för felsökning, vi kontrollerar om en I 2 C-skärm är tillgänglig eller inte med hjälp av startmetoden för visningsobjektet. Vi ställer också in I 2 C-adressen. Därefter rensar vi skärmen med metoden clearDisplay () . Vi roterar också skärmen med setRotation- metoden, det beror på att jag har förstört min PCB-design. Därefter sätter vi en fördröjning på 100 ms för att funktionerna ska träda i kraft. När det är klart kan vi nu gå vidare till loopfunktionen. Men innan du fortsätter till slingan funktionen måste vi diskutera två andra funktioner som är return_voltage_value () , och return_current_value () .
dubbel return_voltage_value (int pin_no) {dubbel tmp = 0; dubbel ADCVoltage = 0; dubbel ingångsspänning = 0; dubbel genomsnitt = 0; för (int i = 0; i <150; i ++) {tmp = tmp + analogRead (pin_no); } genomsnitt = tmp / 150; ADCVoltage = ((avg * 3.3) / (4095)) + 0.138; inputVoltage = ADCVoltage / (R2_VOLTAGE / (R1_VOLTAGE + R2_VOLTAGE)); // formel för beräkning av spänning i dvs GND return inputVoltage; }
Den return_voltage_value () funktionen används för att mäta spänningen som kommer in i ADC, och det tar den pin_no som ett argument. I den här funktionen börjar vi med att deklarera några variabler, som är tmp, ADCVoltage, inputVoltage och avg. Tmp-variabeln används för att lagra det tillfälliga ADC-värdet som vi får från analogRead () -funktionen, sedan genomsnittar vi det 150 gånger i en for-loop och vi lagrar värdet till en variabel som heter avg. Vi beräknar sedan ADCVoltage från den givna formeln, slutligen beräknar vi ingångsspänningen och returnerar värdena. +0,138-värdet du ser är kalibreringsvärdet som jag använde för att kalibrera spänningsnivån, spela med det här värdet om du får några fel.
dubbel return_current_value (int pin_no) {dubbel tmp = 0; dubbel genomsnitt = 0; dubbel ADCVoltage = 0; dubbla förstärkare = 0; för (int z = 0; z <150; z ++) {tmp = tmp + analogRead (pin_no); } genomsnitt = tmp / 150; ADCVoltage = ((avg / 4095.0) * 3300); // Gets you mV Amps = ((ADCVoltage - ACSoffset) / mVperAmp); returförstärkare; }
Därefter har vi funktionen return_current_value () . Denna funktion tar också pin_no som argument. I denna funktion har vi också fyra variabler, nämligen. tmp, avg, ADCVoltage och Amps
Därefter läser vi stiftet med analogRead () -funktionen och genomsnittar det 150 gånger, nästa använder vi formeln för att beräkna ADCvoltage, med det beräknar vi strömmen och vi returnerar värdet. Med det kan vi gå vidare till loop-sektionen.
ogiltig slinga () {float input_voltage = abs (return_voltage_value (INPUT_VOLTAGE_SENSE_PIN)); float input_current = abs (return_current_value (INPUT_CURRENT_SENSE_PIN)); float output_voltage = abs (return_voltage_value (OUTPUT_VOLTAGE_SENSE_PIN)); float output_current = abs ((return_current_value (OUTPUT_CURRENT_SENSE_PIN))); input_current = input_current - 0,025; Serial.print ("Ingångsspänning:"); Serial.print (input_voltage); Serial.print ("- Ingångsström:"); Serial.print (input_current); Serial.print ("- Utgångsspänning:"); Serial.print (output_voltage); Serial.print ("- Utström:"); Serial.println (output_current); fördröjning (300); display.clearDisplay (); display.setCursor (0, 0); display.print ("I / PV:"); display.setCursor (37, 0); display.print (input_voltage); display.setCursor (70, 0); visa.tryck ("V"); }
Vi startar loop-avsnittet med att deklarera och definiera några float-variabler, i alla fyra variablerna. Vi kallar respektive funktioner, passerar pin_no som ett argument, eftersom ACS712-modulen kan returnera aktuella värden i negativt. Vi använder abs () -funktionen i mattebiblioteket för att göra det negativa värdet positivt. Därefter serietrycker vi alla värden för felsökning. Därefter rensar vi skärmen, ställer in markören och skriver ut värdena. Vi gör detta för alla tecken som visas på displayen. Vilket markerar slutet på loopfunktionen och programmet.
Testar Arduino- och ESP32-baserad effektivitetsmätare
Som du kan se min testinställning i bilden ovan. Jag har min 30V-transformator som ingång och jag har min mätare ansluten till testkortet. Jag använder ett LM2596-baserat buck-omvandlarkort och för lasten och jag använder tre 10 ohm motstånd, parallellt.
Som du kan se i bilden ovan har jag anslutit till multimetrar för att kontrollera ingångs- och utspänningen. Transformatorn producerar nästan 32V och utgången från buck-omvandlaren är 3,95V.
Bilden här visar utströmmen mätt av min effektivitetsmätare och multimeter. Som du kan se visar multimetern 0,97 ampere, och om du zoomar in lite visar den 1.0A, den är lite av på grund av icke-linjäritet som finns i ACS712-modulen men detta tjänar vårt syfte. För en detaljerad förklaring och testning kan du kolla in videon i vår videoavsnitt.
Ytterligare förbättringar
För denna demonstration är kretsen gjord på ett handgjort kretskort men kretsen kan enkelt byggas i en kretskort av god kvalitet. I mitt experiment är storleken på PCB väldigt stor på grund av komponentstorleken, men i en produktionsmiljö kan den minskas genom att använda billiga SMD-komponenter. Kretsen har inte heller någon inbyggd skyddsfunktion, så att inkludera en skyddskrets kommer att förbättra kretsens övergripande säkerhetsaspekt. Även när jag skrev koden märkte jag att ADC för ESP32 inte är så bra. Att inkludera en extern ADC som ADS1115-modulen ökar den övergripande stabiliteten och noggrannheten.
Jag hoppas att du gillade den här artikeln och lärde dig något nytt av den. Om du är osäker kan du fråga i kommentarerna nedan eller använda våra forum för detaljerad diskussion.