Hallo, Habr! Vandaag wil ik doorgaan met het onderwerp "het kruisen" van Arduino en Android. IN vorige publicatie Ik had het over de Bluetooth-machine en vandaag zullen we het hebben over doe-het-zelf Bluetooth-voltmeter. Een ander dergelijk apparaat kan een slimme voltmeter, een "slimme" voltmeter of gewoon een slimme voltmeter worden genoemd, zonder aanhalingstekens. De achternaam is onjuist vanuit het oogpunt van de Russische grammatica, maar wordt vaak in de media aangetroffen. Aan het einde van het artikel zal er over dit onderwerp worden gestemd, maar ik stel voor om te beginnen met een demonstratie van de werking van het apparaat om te begrijpen waar het artikel over zal gaan.
Disclaimer: het artikel is bedoeld voor de gemiddelde Arduino-liefhebber die doorgaans niet bekend is met programmeren voor Android, daarom zullen we, net als in het vorige artikel, een applicatie voor een smartphone maken met behulp van een visuele ontwikkelomgeving Android-applicaties App Uitvinder 2.
Om een doe-het-zelf Bluetooth-voltmeter te maken, moeten we twee relatief onafhankelijke programma's schrijven: een schets voor Arduino en een applicatie voor Android. Laten we beginnen met een schets.
Ten eerste moet u weten dat er drie hoofdopties zijn voor het meten van spanning met Arduino, ongeacht waar u de informatie moet uitvoeren: naar de com-poort, naar een scherm dat is verbonden met de Arduino, of naar een smartphone.
Eerste geval: spanningsmetingen tot 5 volt. Hier zijn één of twee regels code voldoende en wordt de spanning rechtstreeks aan pin A0 geleverd:
int waarde = analogRead(0); // lees metingen van A0
spanning = (waarde / 1023,0) * 5; // alleen waar als Vcc = 5,0 volt
Tweede geval: om spanningen groter dan 5 volt te meten, wordt een spanningsdeler gebruikt. Het circuit is heel eenvoudig, en dat geldt ook voor de code.
Schetsen
int analogeIngang = A0;
vlotterwaarde = 0,0;
vlotterspanning = 0,0;
vlotter R1 = 100.000,0; //Batterij Vin-> 100K -> A0
vlotter R2 = 10.000,0; //Batterij Gnd -> Arduino Gnd en Arduino Gnd -> 10K -> A0
int-waarde = 0;
Installatie ongeldig maken() (
Serieel.begin(9600);
pinMode(analoge invoer, INPUT);
}
Ongeldige lus() (
waarde = analogRead(analogInvoer);
val = (waarde * 4,7) / 1024,0;
spanning = waarde / (R2/(R1+R2));
Serieel.println(spanning);
vertraging(500);
}
Arduino Uno
Bluetooth-module
Derde geval. Als u nauwkeurigere informatie over de spanning nodig heeft, moet u als referentiespanning niet de voedingsspanning gebruiken, die bijvoorbeeld enigszins kan variëren als deze wordt gevoed door een batterij, maar de spanning van de interne Arduino-stabilisator van 1,1 volt circuit is hier hetzelfde, maar de code is iets langer. Ik zal deze optie niet in detail analyseren, omdat deze al goed wordt beschreven in thematische artikelen, maar de tweede methode is voor mij voldoende, aangezien mijn stroomvoorziening stabiel is vanaf de USB-poort van de laptop.
Dus we hebben de spanningsmeting geregeld, laten we nu verder gaan met de tweede helft van het project: het maken van een Android-applicatie. We zullen de applicatie rechtstreeks vanuit de browser maken in de visuele ontwikkelomgeving voor Android-applicaties App Inventor 2. Ga naar de website appinventor.mit.edu/explore, log in met uw Google-account, klik op de knop Maken, nieuw project en door eenvoudig slepen en neerzetten elementen creëren we zoiets als dit ontwerp:
Ik heb de afbeeldingen heel eenvoudig gemaakt. Als iemand interessantere afbeeldingen wil, wil ik je eraan herinneren dat je hiervoor .png-bestanden met een transparante achtergrond moet gebruiken in plaats van .jpeg-bestanden.
Ga nu naar het tabblad Blokken en maak daar de applicatielogica, ongeveer als volgt:
Als alles lukt, kunt u op de knop Build klikken en .apk op mijn computer opslaan en vervolgens de applicatie downloaden en installeren op uw smartphone, hoewel er andere manieren zijn om de applicatie te uploaden. hier is het voor iedereen handiger. Als gevolg hiervan kwam ik bij deze toepassing terecht:
Ik begrijp dat maar weinig mensen de visuele ontwikkelomgeving App Inventor 2 voor Android-applicaties in hun projecten gebruiken, dus er kunnen veel vragen rijzen over het werken daarin. Om enkele van deze vragen te verwijderen, heb ik dat gedaan gedetailleerde video, over hoe je zo'n applicatie “vanaf nul” kunt maken (om deze te bekijken moet je naar YouTube gaan):
P.S. Een verzameling van meer dan 100 educatief materiaal over Arduino voor beginners en professionals
Beschreven hoe je een zelfgemaakte dubbele voltmeter monteert op basis van het platform Arduino UNO met behulp van het 1602A LCD-scherm. In sommige gevallen is het nodig om twee constante spanningen tegelijkertijd te meten en te vergelijken. Dit kan bijvoorbeeld nodig zijn bij het repareren of afstellen van de stabilisator Gelijkstroomspanning om de spanning aan de ingang en uitgang te meten, of in andere gevallen.
Schematisch diagram
Met behulp van de universele microcontrollermodule ARDUINO UNO en een tweeregelig LCD-display type 1602A (gebaseerd op de HD44780-controller) kunt u eenvoudig zo'n apparaat maken. Op de ene regel wordt de spanning U1 weergegeven, op de andere regel de spanning U2.
Rijst. 1. Schematisch diagram dubbele voltmeter met 1602A-display op Arduino UNO.
Maar allereerst wil ik u eraan herinneren dat ARDUINO UNO een relatief goedkope kant-en-klare module is - een kleine printplaat, waarop de ATMEGA328-microcontroller zich bevindt, evenals al het “harnas” dat nodig is voor de werking ervan, inclusief een USB-programmeur en voeding.
Voor degenen die niet bekend zijn met ARDUINO UNO, raad ik u aan eerst de artikelen L.1 en L.2 te lezen. Het circuit van een dubbele voltmeter wordt getoond in Fig. 1. Het is ontworpen om twee spanningen te meten van 0 tot 100V (praktisch tot 90V).
Zoals uit het diagram blijkt, naar digitale poorten D2-D7 ARDUINO-borden UNO is aangesloten op de liquid crystal displaymodule H1 type 1602A. De LCD-indicator wordt gevoed door een 5V-spanningsstabilisator die zich op de 5V-spanningsstabilisatorkaart bevindt.
De gemeten spanningen worden geleverd aan twee analoge ingangen A1 en A2. Er zijn in totaal zes analoge ingangen, A0-A5, u kunt er twee selecteren. IN in dit geval, A1 en A2 zijn geselecteerd. De spanning op analoge poorten kan alleen positief zijn en alleen in het bereik van nul tot de voedingsspanning van de microcontroller, dat wil zeggen nominaal tot 5V.
De uitvoer van de analoge poort wordt door de ADC van de microcontroller omgezet in digitale vorm. Om het resultaat in volteenheden te krijgen, moet je het met 5 vermenigvuldigen (met de referentiespanning, dat wil zeggen met de voedingsspanning van de microcontroller) en delen door 1024.
Om spanningen te kunnen meten die groter zijn dan 5V, of beter gezegd, groter dan de voedingsspanning van de microcontroller, omdat de werkelijke spanning aan de uitgang van de 5 volt stabilisator op het ARDUINO UNO-bord kan afwijken van 5V, en meestal een iets lager, moet u conventionele resistieve verdelers aan de ingang gebruiken. Hier zijn dit spanningsdelers over weerstanden R1, R3 en R2, R4.
In dit geval moet u, om de apparaatmetingen op de werkelijke waarde van de ingangsspanning te brengen, in het programma de verdeling van het meetresultaat door de deelcoëfficiënt van de resistieve deler instellen. En de deelcoëfficiënt, laten we het “K” noemen, kan worden berekend met behulp van de volgende formule:
K = R3 / (R1+R3) of K = R4 / (R2+R4),
respectievelijk voor verschillende ingangen dubbele voltmeter.
Het is heel interessant dat de weerstanden in de verdelers niet noodzakelijkerwijs zeer nauwkeurig hoeven te zijn. U kunt gewone weerstanden nemen, vervolgens hun werkelijke weerstand meten met een nauwkeurige ohmmeter en deze gemeten waarden in de formule vervangen. U krijgt de waarde “K” voor een specifieke deler, die in de formule moet worden vervangen.
Voltmeter programma
Het C++-programma wordt getoond in Figuur 2.
Rijst. 2. Bron programma's.
Om de LCD-indicator te besturen, werd besloten om de poorten D2 tot en met D7 van het ARDUINO UNO-bord te gebruiken. In principe zijn andere poorten mogelijk, maar zo heb ik besloten deze te gebruiken.
Om de indicator te laten communiceren met ARDUINO UNO, moet je een subroutine in het programma laden om deze te besturen. Dergelijke routines worden "bibliotheken" genoemd, en er zijn veel verschillende "bibliotheken" in het ARDUINO UNO-softwarepakket. Om met een LCD-indicator op basis van de HD44780 te werken, heb je de LiquidCrystal-bibliotheek nodig. Daarom begint het programma (Tabel 1) met het laden van deze bibliotheek:
Deze regel geeft de opdracht om in ARDUINO UNO te laden deze bibliotheek. Vervolgens moet u ARDUINO UNO-poorten toewijzen die werken met de LCD-indicator. Ik heb de poorten D2 tot en met D7 gekozen. Je kunt anderen kiezen. Deze poorten worden toegewezen door de regel:
LiquidCrystal-led(2, 3, 4, 5, 6, 7);
Daarna gaat het programma verder met de daadwerkelijke bediening van de voltmeter. Om de spanning te meten is er voor gekozen om de analoge ingangen A1 en A2 te gebruiken. Deze ingangen worden gespecificeerd in de regels:
int analogeInvoer=1;
int analogeInvoer1=2;
Gebruik de analogRead-functie om gegevens van analoge poorten te lezen. Het lezen van gegevens van analoge poorten vindt plaats in de lijnen:
vout=analogRead(analogInvoer);
voutl=analogRead(analoglnput1);
Vervolgens wordt de werkelijke spanning berekend, rekening houdend met de deelverhouding van de ingangsspanningsdeler:
volt=vuit*5,0/1024,0/0,048;
volt1=vuit1*5,0/1024,0/0,048;
In deze regels is het getal 5.0 de spanning aan de uitgang van de stabilisator van het ARDUINO UNO-bord. Idealiter zou deze 5V moeten zijn, maar om de voltmeter nauwkeurig te laten werken, moet deze spanning eerst worden gemeten. Sluit de stroombron aan en meet de +5V-spanning op de POWER-connector van het bord met een redelijk nauwkeurige voltmeter. Wat er gebeurt, voer dan deze regels in in plaats van 5.0. Als er bijvoorbeeld 4,85V is, zien de regels er als volgt uit:
volt=vuit*4,85/1024,0/0,048;
volt1=vuit1*4,85/1024,0/0,048;
In de volgende fase moet u de werkelijke weerstanden van de weerstanden R1-R4 meten en de K-coëfficiënten (aangegeven als 0,048) voor deze lijnen bepalen met behulp van de formules:
K1 = R3 / (R1+R3) en K2 = R4 / (R2+R4)
Laten we zeggen K1 = 0,046 en K2 = 0,051, dus we schrijven:
volt=vuit*4,85/1024,0/0,046;
volt1=vout1*4,85/1024,0/0,051;
Er moeten dus wijzigingen in de programmatekst worden aangebracht op basis van de werkelijke spanning aan de uitgang van de 5-volt-stabilisator van het ARDUINO UNO-bord en op basis van de werkelijke deelcoëfficiënten van de resistieve verdelers. Hierna werkt het apparaat nauwkeurig en is er geen aanpassing of kalibratie nodig.
Door de deelcoëfficiënten van de resistieve verdelers (en dienovereenkomstig de “K”-coëfficiënten) te wijzigen, kunt u andere meetlimieten maken, die niet noodzakelijkerwijs hetzelfde zijn voor beide ingangen.
Karavkin V.RK-2017-01.
Literatuur:
- Karavkin V. - Kerstboomflitser op ARDUINO als remedie tegen de angst voor microcontrollers. RK-11-2016.
- Karavkin V. - Frequentiemeter op ARDUINO. RK-12-2016.
Idee
Idee apparaten voor het meten van spanning, stroom, capaciteit, ontlading en misschien lading zijn lang geleden ontstaan, en niet alleen voor mij. Je kunt veel speelgoed vinden dat USB Tester (Doctor) wordt genoemd om te testen verschillende apparaten vanaf USB. Ik ben iets meer geïnteresseerd universeel apparaat, onafhankelijk van de interface, maar eenvoudigweg ontworpen voor bepaalde spanningen en stromen. Bijvoorbeeld 0 - 20,00 V, 0 - 5,00 A, 0 - 99,99 Ah. Wat de functies betreft, ik zie het zo
- Geeft de huidige spanning en stroom weer, dat wil zeggen een volt-ampèremeter. In principe kun je de kracht meteen weerspiegelen.
- Geaccumuleerde capaciteit tellen en weergeven. In ampère-uren en hoogstwaarschijnlijk in wattuur.
- Procestijdweergave
- En hoogstwaarschijnlijk instelbare onder- en bovengrens voor spanningsafsluiting (ontladings- en laadlimieten)
Ontwikkeling
Om berekeningen en metingen uit te voeren hebben we een controller nodig. Ik herinnerde me dit idee als onderdeel van mijn kennismaking met Arduino, dus de controller zal een eenvoudige populaire Atmega328 zijn en deze zal in de omgeving worden geprogrammeerd Arduino. Vanuit technisch oogpunt is de keuze waarschijnlijk niet de beste - de controller is een beetje dik voor de taak en de ADC kan niet meten worden genoemd, maar... we zullen het proberen.
- We zullen niet veel solderen in dit project. Als basis nemen we een kant-en-klaar exemplaar Arduino-module Pro Mini Gelukkig zijn de Chinezen bereid ze te leveren voor een prijs van $ 1,5 in de detailhandel.
- Het weergaveapparaat zal een 1602-scherm zijn – nog eens $ 1,5. Ik heb een optie met een I2C-interfacemodule, maar in dit project is dat niet echt nodig ($0,7).
- Voor ontwikkeling hebben we nodig broodplank. In mijn geval is dit een klein BreadBoard voor $ 1.
- Natuurlijk heb je draden en een aantal weerstanden met verschillende waarden nodig. Voor een 1602-display zonder I2C moet je ook het contrast selecteren - dit gebeurt met een variabele weerstand van 2 - 20 kOhm.
- Om een ampèremeter te implementeren heeft u een shunt nodig. In eerste benadering zou het een weerstand van 0,1 Ohm en 5 W kunnen zijn.
- Om automatische uitschakeling te implementeren, hebt u een relais nodig met contacten die daarvoor zijn ontworpen maximale stroom apparaat en spanning gelijk aan de voedingsspanning. Om het relais te besturen heb je een NPN-transistor en een beveiligingsdiode nodig.
- Het apparaat wordt gevoed door een externe voedingsbron, uiteraard minimaal 5 V. Als de voeding sterk varieert, is ook een geïntegreerde stabilisator van het type 7805 vereist - deze bepaalt de relaisspanning.
- Wanneer Arduino Pro Mini vereist een USB-TTL-converter om de firmware te uploaden.
- Voor het instellen heeft u een multimeter nodig.
Voltmeter
Ik implementeer een eenvoudige voltmeter met een bereik van ongeveer 0 - 20V. Deze opmerking is belangrijk omdat de ADC van onze controller een capaciteit van 10 bits heeft (1024 discrete waarden), dus de fout zal minimaal 0,02 V (20 / 1024) zijn. Om de hardware te implementeren hebben we een analoge ingang van de controller nodig, een verdeler gemaakt van een paar weerstanden en een soort uitgang (een display in de voltooide versie, een seriële poort kan worden gebruikt voor foutopsporing).
Het principe van ADC-meting is het vergelijken van de spanning aan de analoge ingang met de referentie VRef. De ADC-uitgang is altijd geheel getal - 0 komt overeen met 0V, 1023 komt overeen met spanning VRef. De meting wordt geïmplementeerd door een reeks opeenvolgende spanningsmetingen en het middelen van de periode tussen updates van de waarde op het scherm. De keuze van de referentiespanning is belangrijk omdat deze standaard wordt ingesteld op de voedingsspanning, die mogelijk niet stabiel is. Dit past helemaal niet bij ons - we zullen als basis een stabiele interne referentiebron nemen met een spanning van 1,1 V, en deze initialiseren door analogReference (INTERNAL) aan te roepen. Vervolgens kalibreren we de waarde met behulp van de multimeterwaarden.
Het diagram links toont een variant met directe bediening van het display (deze wordt eenvoudigweg bestuurd - zie de standaard LiquidCrystal\HelloWorld-schets). Aan de rechterkant staat de I2C-optie, die ik verder zal gebruiken. Met I2C kunt u besparen op draden (waarvan er 10 zijn in de gebruikelijke versie, de achtergrondverlichting niet meegerekend). Maar dit vereist een extra module en een complexere initialisatie. In ieder geval moet eerst de weergave van tekens op de module worden gecontroleerd en het contrast worden aangepast - hiervoor hoeft u na de initialisatie eenvoudigweg de eventuele tekst weer te geven. Het contrast wordt aangepast door weerstand R1, of een soortgelijke weerstand van de I2C-module.
De invoer is een deler van 1:19, waarmee we kunnen krijgen maximale spanning ongeveer 20V (meestal wordt ter bescherming een condensator + zenerdiode parallel aan de ingang geplaatst, maar dit is voor ons voorlopig niet belangrijk). Weerstanden hebben een spreiding, en dat geldt ook voor de referentie Vref van de controller, dus na montage moeten we de spanning (tenminste de voeding) parallel meten met ons apparaat en een referentiemultimeter en Vref in de code selecteren totdat de meetwaarden overeenkomen. Het is ook vermeldenswaard dat elke ADC een nul-offsetspanning heeft (wat de metingen aan het begin van het bereik bederft), maar daar gaan we nu niet op in.
Belangrijk zal ook de scheiding van de aanvoer- en meetgrond zijn. Onze ADC heeft een resolutie die iets slechter is dan 1 mV, wat problemen kan veroorzaken als de bedrading niet correct is, vooral op een breadboard. Omdat de lay-out van het modulebord al is gedaan en we alleen de pinnen hoeven te selecteren. De module heeft verschillende 'aarde'-pinnen, dus we moeten ervoor zorgen dat de stroom via de ene 'aarde' de module binnenkomt en via de andere. Om wijzigingen aan te brengen, gebruik ik altijd de aardingspin die zich het dichtst bij de analoge ingangen bevindt.
Om I2C te besturen wordt een versie van de LiquidCrystal_I2C-bibliotheek gebruikt - in mijn geval wordt de specifieke pinout van de I2C-module aangegeven (de Chinezen produceren modules met verschillende bedieningselementen). Ik merk ook op dat I2C in Arduino het gebruik van pinnen A4, A5 - aan inhoudt Pro-bord Mini, ze bevinden zich niet aan de rand, wat lastig is voor het maken van prototypen op de BreadBoard.
Bron
#erbij betrekkenMet enkele toevoegingen.
Een weinig bekend kenmerk van Arduino en vele andere AVR-chips is de mogelijkheid om de interne referentiespanning van 1,1 V te meten. Deze functie kan wordt gebruikt voor toenemende nauwkeurigheid Arduino-functies - analoogRead gebruik makend van standaard referentiespanning van 5 V (op platforms met een voedingsspanning van 5 V) of 3,3 V (op platforms met een voedingsspanning van 3,3 V).Dat kan zij ook zijn gebruikt om te meten Vcc toegepast op de chip, waardoor middel van controle batterij voltage zonder gebruik kostbare analoge pinnen.
Motivatie
Tenminste, dat is zo minstens twee redenen voor meten voedingsspanning onze Arduino (Vcc). Eén daarvan is ons project op batterijen, als we het batterijspanningsniveau in de gaten willen houden. Bovendien, als het batterijvermogen (Vcc) niet 5,0 volt kan zijn (het vermogen van 3 cellen is bijvoorbeeld 1,5 V), en we willen dit doen analoge metingen preciezer - we moeten de interne 1,1 V-referentie gebruiken of externe bron referentiespanning. Waarom?
Het is gebruikelijk om bij gebruik van analogRead() aan te nemen dat de analoge voedingsspanning van de controller 5,0 volt is, terwijl dit in werkelijkheid helemaal niet het geval kan zijn (een voeding van 3 elementen is bijvoorbeeld 1,5 V). De officiële Arduino-documentatie kan ons zelfs tot deze onjuiste veronderstelling leiden. Het punt is dat de stroom niet noodzakelijkerwijs 5,0 volt is, hoe dan ook huidig niveau dit vermogen wordt toegepast op de Vcc van de chip. Als onze stroomvoorziening niet gestabiliseerd is of als we op batterijvoeding werken, kan deze spanning nogal variëren. Hier is een codevoorbeeld dat dit probleem illustreert:
Dubbele Vcc = 5,0; // niet noodzakelijk waar int-waarde = analogRead(0); / lees de meetwaarden van A0 dubbele volt = (waarde / 1023,0) * Vcc; // alleen waar als Vcc = 5,0 volt Om de spanning nauwkeurig te meten, is een nauwkeurige referentiespanning nodig. De meeste AVR-chips bieden drie spanningsreferenties:
- 1,1 inch vanaf interne bron, in de documentatie wordt het doorgegeven als een bandgap-referentie (sommige zijn 2,56 V, bijvoorbeeld ATMega 2560). De selectie wordt gemaakt door de functie analogReference() met de parameter INTERNAL: analogReference(INTERNAL) ;
- externe bron van referentiespanning, met het label AREF op de Arduino. Selecteer: analogReference(EXTERN);
- Vcc is de voeding van de controller zelf. Selecteer: analogReference(DEFAULT).
In Arduino kun je Vcc niet zomaar rechtstreeks op de analoge pin aansluiten - standaard is AREF verbonden met Vcc en krijg je altijd een maximale waarde van 1023, ongeacht de spanning waarop je wordt aangesloten. Het aansluiten op AREF van een spanningsbron met een eerder bekende, stabiele spanning helpt, maar dit is het geval extra onderdeel in het diagram.
U kunt Vcc ook verbinden met AREF via diode: De spanningsval over de diode is van tevoren bekend, dus het berekenen van Vcc is niet moeilijk. Echter, met een dergelijke schakeling via een diode stroom vloeit voortdurend, waardoor de levensduur van de batterij wordt verkort, wat ook niet erg goed is.
Een externe spanningsreferentie is het meest nauwkeurig, maar vereist aanvullende hardware. Interne ION is stabiel maar niet nauwkeurig +/- 10% afwijking. Vcc is in de meeste gevallen volkomen onbetrouwbaar. Het selecteren van een interne spanningsreferentie is goedkoop en stabiel, maar meestal willen we meer spanning dan 1,1 V meten, dus het gebruik van Vcc is het meest praktisch, maar potentieel het minst nauwkeurig. In sommige gevallen kan het zeer onbetrouwbaar zijn!
Hoe je dat doet
Veel AVR-chips, waaronder de ATmega- en ATtiny-series, bieden een manier om de interne referentiespanning te meten. Waarom is dit nodig? De reden is simpel: door de interne spanning te meten, kunnen we de waarde van Vcc bepalen. Hier is hoe:
- Stel de standaard spanningsreferentie in: analogReference(DEFAULT); . Wij gebruiken Vcc als bron.
- Voer ADC-metingen uit voor de interne 1,1 V-bron.
- Bereken de Vcc-waarde op basis van de 1,1 V-meting met behulp van de formule:
Vcc * (ADC-waarde) / 1023 = 1,1 V
Wat volgt:
Vcc = 1,1 V * 1023 / (ADC-meting)
Als we alles samenvoegen, krijgen we de code:
long readVcc() ( // Lees 1,1V-referentie tegen AVcc // stel de referentie in op Vcc en de meting op de interne 1,1V-referentie #if gedefinieerd(__AVR_ATmega32U4__) || gedefinieerd(__AVR_ATmega1280__) || gedefinieerd(__AVR_ATmega2560__) ADMUX = _BV (REFS0) |. _BV(MUX3) |.BV(MUX1); #elif gedefinieerd(__AVR_ATtiny44__) ||. else ADMUX = _BV(MUX3) |. _BV(MUX1); #endif delay(75); // Wacht tot Vref ADCSRA heeft afgehandeld |= _BV(ADSC) // Start de conversie terwijl (bit_is_set(ADCSRA,ADSC) ); ADCL; // moet eerst ADCL lezen - het vergrendelt vervolgens ADCH uint8_t high = ADCH; // ontgrendelt beide lange resultaten = (high<<8) | low; result = 1125300L / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000 return result; // Vcc in millivolts }Gebruik
Vcc of batterijspanning controleren
U kunt deze functie readVcc() aanroepen als u Vcc wilt monitoren. Een voorbeeld hiervan is het controleren van het laadniveau van de batterij. Ook kunt u hiermee bepalen of u op een stroombron bent aangesloten of op batterijstroom werkt.
Vcc-meting voor referentiespanning
U kunt het ook gebruiken om de juiste Vcc-waarde te verkrijgen voor gebruik met analogRead() wanneer u de referentiespanning (Vcc) gebruikt. Tenzij u een gereguleerde voeding gebruikt, kunt u er niet zeker van zijn dat Vcc = 5,0 volt. Met deze functie kunt u de juiste waarde verkrijgen. Er is echter één kanttekening...
In een van de artikelen heb ik verklaard dat deze functie gebruikt zou kunnen worden om de nauwkeurigheid van analoge metingen te verbeteren in gevallen waarin Vcc niet helemaal 5,0 volt was. Helaas zal deze procedure geen nauwkeurig resultaat opleveren. Waarom? Dit hangt af van de nauwkeurigheid van de interne spanningsreferentie. De specificatie geeft een nominale spanning van 1,1 volt aan, maar zegt dat deze tot 10% kan variëren. Dergelijke metingen zijn mogelijk minder nauwkeurig dan onze Arduino-voeding!
Toenemende nauwkeurigheid
Hoewel de grote toleranties van de interne 1,1V-voeding de meetnauwkeurigheid aanzienlijk beperken bij gebruik in massaproductie, kunnen we een grotere nauwkeurigheid bereiken voor projecten op maat. Dit is eenvoudig te doen door eenvoudigweg Vcc te meten met behulp van een voltmeter en onze readVcc()-functie. Vervang vervolgens de constante 1125300L door een nieuwe variabele:
schaal_constant = intern1.1Ref * 1023 * 1000
internal1.1Ref = 1,1 * Vcc1 (voltmeter_aflezingen) / Vcc2 (readVcc_function_readings)
Deze gekalibreerde waarde is een goede indicator voor AVR-chipmetingen, maar kan worden beïnvloed door temperatuurveranderingen. Experimenteer gerust met uw eigen metingen.
Conclusie
Je kunt veel doen met deze kleine functie. U kunt een stabiele referentiespanning van bijna 5,0 V gebruiken zonder daadwerkelijk 5,0 V op Vcc te hebben. U kunt uw accuspanning meten of zelfs zien of u op accuvoeding of stationair werkt.
Ten slotte ondersteunt de code alle Arduino's, inclusief de nieuwe Leonardo, evenals de chips uit de ATtinyX4- en ATtinyX5-serie.
Er wordt een handig diagram gepresenteerd voor degenen die graag met Arduino experimenteren. Dit is een eenvoudige digitale voltmeter die op betrouwbare wijze gelijkspanning in het bereik van 0 - 30V kan meten. Het Arduino-bord kan, zoals gewoonlijk, worden gevoed door een 9V-batterij.
Zoals u waarschijnlijk weet, kunnen de analoge ingangen van Arduino worden gebruikt om gelijkspanning te meten in het bereik van 0 - 5V en dit bereik kan worden vergroot.
gebruik twee weerstanden als spanningsdeler. De verdeler reduceert de gemeten spanning tot het niveau van de analoge ingangen van de Arduino. En dan berekent het programma de werkelijke spanningswaarde.
De analoge sensor op het Arduino-bord detecteert de aanwezigheid van spanning op de analoge ingang en zet deze om in digitale vorm voor verdere verwerking door de microcontroller. In de figuur wordt spanning geleverd aan de analoge ingang (A0) via een eenvoudige spanningsdeler bestaande uit weerstanden R1 (100 kOhm) en R2 (10 kOhm).
Met deze delerwaarden kan het Arduino-bord worden voorzien van een spanning van 0 tot
55V. Op ingang A0 hebben we de gemeten spanning gedeeld door 11, dus 55V / 11=5V. Met andere woorden: bij het meten van 55V aan de Arduino-ingang hebben we een maximaal toegestane waarde van 5V. In de praktijk is het beter om op deze voltmeter het bereik “0 - 30V” te schrijven, zodat dit blijft
Veiligheidsmarge!
Opmerkingen
Als de displaywaarden niet samenvallen met de waarden van een industriële (laboratorium) voltmeter, dan is het noodzakelijk om de waarde van weerstanden R1 en R2 te meten met een nauwkeurig instrument en deze waarden in te voeren in plaats van R1=100000.0 en R2=10000.0 in de programmacode. Vervolgens moet u de werkelijke spanning tussen de 5V- en “Ground”-pinnen van het Arduino-bord meten met een laboratoriumvoltmeter. Het resultaat zal een waarde zijn die kleiner is dan 5 V, bijvoorbeeld 4,95 V. Deze echte waarde moet in de coderegel worden ingevoegd
vout = (waarde * 5,0) / 1024,0 in plaats van 5,0.
Probeer ook precisieweerstanden te gebruiken met een tolerantie van 1%.
Weerstanden R1 en R2 bieden enige bescherming tegen verhoogde ingangsspanningen. Houd er echter rekening mee dat spanningen boven de 55V het Arduino-bord kunnen beschadigen. Bovendien biedt dit ontwerp geen andere soorten bescherming (tegen spanningspieken, ompoling of overspanning).
Digitaal voltmeterprogramma
/*
DC-voltmeter
Een Arduino DVM gebaseerd op een spanningsdelerconcept
TK Hareendran
*/
#erbij betrekken
LiquidCrystal-lcd-scherm (7, 8, 9, 10, 11, 12);
int analogeInvoer = 0;
vlotter vout = 0,0;
vlotter vin = 0,0;
vlotter R1 = 100.000,0; // weerstand van R1 (100K) -zie tekst!
vlotter R2 = 10.000,0; // weerstand van R2 (10K) – zie tekst!
int-waarde = 0;
ongeldige instellingen())(
pinMode(analoge invoer, INPUT);
lcd.begin(16, 2);
lcd.print(“DC-VOLTMETER”);
}
lege lus()
// lees de waarde op analoge ingang
waarde = analogRead(analogInvoer);
vout = (waarde * 5,0) / 1024,0; // zie tekst
vin = vuit / (R2/(R1+R2));
als (vin<0.09) {
vin=0.0;//statement om ongewenst lezen te vernietigen!
}
lcd.setCursor(0, 1);
lcd.print(“INVOER V= “);
lcd.print(vin);
vertraging(500);
}
Schematisch diagram van Arduino-voltmeter
Lijst met componenten
Arduino Uno-bord
100 kOhm weerstand
10 kOhm-weerstand
100 ohm weerstand
Trimmerweerstand van 10 kOhm
LCD-scherm 16?2 (Hitachi HD44780)
