Wat is de minimale inganspanning op een analoge ingang van een Arduino

Ik wil een Arduino uno gaan kopen, het is de bedoeling dat dit uiteindelijk een spanningsmeter meetinstrument wordt.
Ik stel als maximale spanning op de ingang 4,419 Volt gelijkspanning.
Dat wordt vermenigvuldigd met 0,707 om de effectieve spanning terug te kennen rekenen, vervolgens wordt die waarde vermenigvuldigd met 80 en uitgelezen op het lcd scherm in 'Volts eff,'
Om even op mijn vraag terug te komen wordt de gemeten ingang spanning door de Arduino gedeeld wordt met 1024? Of is het 5Volt/1024?
Ook ben ik benieuwd naar de maximale spanning op die ingangen.

Kan ik vanuit een eerdere rekenkundige bewerking ook meerdere berekeningen maken en deze laten tonen door het lcd display?
Hetzelfde wilde ik namelijk doen om de verbruiksstroom te berekenen en het vermogen wat wordt verbruikt(U^2/Rl).
Ik meet dus uit één analoge waarde 3 andere waardes uit welke worden aangegeven op het lcd display. (16x2)

Kan ik een digitale temperatuur sensor aansluiten op een digitale ingang en vervolgens die waarde gebruiken om de pulspauze verhouding van een koel ventilator te regelen.

Al deze vragen stel ik omdat ik onervaren bent met de Arduino-uno.

"tijd is relatief"

Een "digitale" sensor , is alleen maar hoog of laag.Digitale signalen zijn niet in waarde regelbaar.
Het is OF 0, OF 1.
Analoge ingangen kan je wel gebruiken.
Ik dacht dat de Arduino van 0 tot 3,3 volt vol bereik heeft, maar dat weet waarschijnlijk iemand anders beter.
Je kan er wel 5 volt op zetten, maar dan is hij buiten het meetbereik.Dus dat heeft weinig zin.
Meetsensors zijn eigenlijk ALTIJD analoog, of je moet een speciale techniek toepassen.
Een digitale ingang is voor het detecteren van schakelaars, en zo.

[Bericht gewijzigd door mel op 2 maart 2018 03:38:38 (17%)]

u=ir betekent niet :U bent ingenieur..

Uit je berekening maak ik op dat je wisselspanning om gaat zetten naar gelijkspanning (factor 0.707). Vervolgens met een spanningsdeler (factor 80) de spanning terug brengen naar een acceptabele waarde.

Op zich klopt het wat je zegt, maar :

1) Je Arduino werkt misschien op 5V en dat is waarschijnlijk ook de referentiespanning voor de AD-conversie (of 3V3, zoals Mel aangeeft).

2) Een 10-bit conversie bestaat inderdaad uit 1024 stapjes. Maar wat doet het met de waarde 0 ? Eigenlijk tel je van 0 tot 1023 en dat bestaat uit 1024 stapjes. Ik strompel zelf ook altijd over dit probleem / geneuzel, zodra ik een ADC gebruik.

3) Ik weet niet of 0.707 de juiste factor is. Mij staat bij dat dit zo voor stroom geldt bij gelijkrichten. Voor spanning krijg je -dacht ik- juist een hogere waarde. Ik meen 1 / 0.707, zodat het totale vermogen weer klopt.

4) Verder vergeet je -denk ik- de spanningsval over de gelijkrichter. De gelijkrichter "snoept" namelijk ook nog wat af van de gelijkgerichte spanning. Als je dat hebt gedaan met die waarde van 4.419V dan kan het correct zijn, indien je pad als volgt is : wisselspanning - spanningsdeler - gelijkrichter - beschermingsweerstandje - meetpin Arduino. (Maar dan klopt de spanningsdeler misschien niet meer helemaal).

Misschien kun je eens tekenen hoe je het electronische gedeelte hebt ontworpen. Ik denk dat er dan nog wel meer reacties gaan komen. Dit omdat je het (licht)net rechtstreeks op de Arduino hebt aangesloten. En dat heeft te maken met mogelijke druktoetsjes waar iemand op kan drukken en nog een aantal zaken.

-=[ EDIT ]=-
> Ook ben ik benieuwd naar de maximale spanning op die ingangen.
Die is "relatief" hoog. Een Atmega kan namelijk ook met 12V geprogrammeerd worden (High-Voltage programming). Die chip moet daar dus mee om kunnen gaan. Echter, het beste is er van uit te gaan dat de max. spanning 5V is (dat hogere moet je zien als bescherming en je niet aan wagen).

[Bericht gewijzigd door oxurane op 2 maart 2018 03:55:33 (11%)]

Van elk bezoek aan CO leer ik weer meer...

ik weet niet hoe de uno's werken, maar een nano werkt op 5V.
ik gebruik er zo ene in de auto om vanalles te meten (temperatuur, accuspanning, brandstof niveau).
de accu loopt van 12 tot 15V en dat is teveel. ik heb er een 4deler op gezet met weerstanden.
12V is dan 3V, en met zijn maximum van 5V kan ik eigenlijk tot 20V meten.

de 1024 code is op de meetspanning.
mijn temperatuur en brandstofniveau zijn van 0-10V signalen. daar gebruik ik een 2deler en deze ga ik gebruiken in het voorbeeld nu.

stel, de motortemperatuur is 50°C en dit komt overeen met 5V. door de 2deler ziet mijn arduino nu 2,5V.
hij zal hier dan een code 512 aan geven (5V = 1024, 2,5V= 512).

dan moet je nog in je programma schrijven dat 512 overeenkomt met 50°C en dat weergeven op het scherm.

nu ook opletten, de referentie is ook niet stabiel. bij een arduino is de 5V referentie eigenlijk de USB voedingsspanning. als je dus 4,9V usb spanning hebt, of 5,1V, zal je telkens andere meetwaarden hebben.
ook de internal referentie van 1,1V is niet altijd gelijk. de ene arduino heeft 1,11 en de andere 1,09. ook pr arduino moet je dan opnieuw calibreren.
je kan beter ergens een externe exacte referentiespanning toevoegen, en met deze altijd rekenen.

een tipje nog, ga niet onnozel staan omrekenen tussen je binaire meetgegeven en de effectieve gemeten spanning buiten je schakeling.
er is een map functie en als jij 2 referenties opgeeft, berekent die alles zelf.

bv 512 = 50°C
845 = 80°C
dan maak je map(512,50,845,80).
de arduino zal nu elke tussenliggende waarde ook uitrekenen en weergeven op het scherm. hoef jij geen ingewikkelde formule te maken. die map fnctie kan ook meerdere punten pakken, zou het niet al te lineair verlopen

ik hou van werken ..., ik kan er uren naar kijken

Een Uno draait op 5V, en dat is ook de default Uref van de ADC. Maar je kunt een andere Uref aansluiten.
https://www.arduino.cc/reference/en/language/functions/analo...reference/

Ik zou het gewoon calibreren; dus de spannningsdeler zo instellen (1:20 oid) dat je ruim onder de Uref blijft, met een multimeter de gewenste meting doen en dan de benodigde factor uitrekenen.
Via een gelijkrichter en met de voeding als Uref dat niet zo nauwkeurig worden, maar voor veel dingen goed genoeg.
Let op dat je zo "asynchroon" wel voor gelijkspanning een vermogen kunt berekenen, maar niet voor wisselspanning omdat daar fase en harmonischen belangrijk kunnen zijn. Die informatie raak je kwijt bij het gelijkrichten.
Voor een Arduino Wattmeter project zie alhier: https://meettechniek.info/diy-instrumenten/arduino-wattmeter.html

AC direct meten kan op zich ook prima, RMS bijvoorbeeld met de Filters library, in dat geval moet je zorgen dat 0V op de halve Uref komt te liggen, dat gaat het eenvoudigste door de te meten spanning na deling AC te koppelen naar een hoogohmige 1:1 spanningsdeler op Uref via een condensator.
Deze lib gebuik ik in combinatie met de ACS710 stroomsensoren en dat werkt erg goed.

De bedoeling is om de spanning te meten over een bekende belasting waarde. De generator leverd een maximale spanning van 250V eff. over die belasting. De generator is een HF generator met frequenties tussen 100kHz en 30MHz.

Onderstaande schema toont ongeveer de meetopstelling; via een spanningstransformator wordt de hoge spanning over de belasting getransformeerd met een factor van 20 maal kleinere amplitude.
De gelijkrichter dioden zijn van een bias voorspanning voorzien zodat er geen spanningsval over de dioden valt.
De gelijkrichting is dubbelfasig en word door een spanningsdeler gehalveerd.
Hierachter volgt nog een opamp welke aan een laag impedante uitgang is te belasten.

De gemeten spanning naar de Arduino is nu Ugemeten x 0,707 x 40 en dat is de spanning over de belasting.
Die waarde wil ik uitleesbaar maken op het LCD scherm als 'Veff'.
Deze spanning in kwadraat en gedeeld door de weerstand is het vermogen in Watts.
Dat vermogen wil ik ook afleesbaar maken op het lcd scherm als 'P output'.

Dit is ongeveer wat de bedoeling is en dat zou ik graag met een Arduino willen doen.

"tijd is relatief"

Kun je niet beter actief gelijkrichten? Nu heb je altijd spanningsval over de diodes.

En als je de Arduino op 5,120V (rekent makkelijk) laat draaien dan is je bereik 4,419/5,120*1024 stapjes. Een stapje blijft 5,120/1024 Volt.

EDIT: Bij 30MHz wordt actief gelijkrichten misschien wel meer een uitdaging. En als je generator toch niet onder 80*0,7V uit komt dan boeit het minder. Nauwkeurig wordt het iig niet, met verschil onderling in diodes, temperatuur (-2.5mV/K), niet stroomconstante load, Arduino ruis/afwijking etc.

Kom eens langs bij RevSpace of één van de andere spaces! WORKSHOP!

Inderdaad niet erg precies is deze manier van meten, maar dat hoeft ook niet het ontwerp wil ik zo éénvoudig als mogelijk is houden.
Of zou ik niet beter een logaritmische detector kunnen nemen waarbij iedere 25mV op de uitgang overeenkomt met 1dB.
Wel moet ik dan van decibels weer terugrekenen naar Volts en Watts.

Het maximale vermogen wat hier gemeten kan worden is 1250 Watt over een belasting van 50 ohm.
Dat is 250Veff en op de Arduino kan ik dit aanbieden als bijvoorbeeld 5,024 Volt gelijkspanning.
Dat is dan 5,024 x 0,707 en dat vermenigvuldigd met 70,372888 is 250 Volt.
Ook kan ik die factor x 0,707 door een opamp als gelijkspanning versterker laten doen, maar dat is wellicht veel makkelijker om dit in de software te kunnen schrijven.

[Bericht gewijzigd door Martin V op 2 maart 2018 11:23:50 (13%)]

"tijd is relatief"

Misschien kun je met een compensatie tabel/formule of een current sink de drop over de diodes wat constanter krijgen. Of dat zo eenvoudig gaat werken weet ik niet.

Temperatuur meten bij de diodes kan met een andere analoge ingang. Daarmee komt het nog iets mooier uit. Maar als je met zo'n 2V afwijking kunt leven (bij 10 graden verschil) dan zou ik dat zelfs laten.

Kom eens langs bij RevSpace of één van de andere spaces! WORKSHOP!

Ah, dat is wat anders dan 50 Hz :) Je zult wel een referentiemeting moeten doen.

Als je voor temperatuur compenseerd kan dat allicht flink schelen. Je moet dan wel zorgen dat de diodes en sensor steeds behoorlijk dezelfde temperatuur hebben, bijvoorbeeld door de boel op een printje te zetten en dat thermisch geïsoleerd in te pakken. Je kunt inderdaad ook naar een AD8318 grijpen oid. Bij Ali niet duur. Excuses, die werkt vanaf 1 MHz zie ik nu. Ik heb dan ook weinig verstand van HF.

Als temperatuursensor vind ik een DS18B20 of soortgelijke oneWire sensor tegenwoordig praktisch, maar dat is allicht een kwestie van smaak en wat je hebt liggen.

Alles wat in software kan zou ik in software doen. Persoonlijk ben ik in dit soort gevallen eigenwijs en gebruik ik ook op een 8 bit microcontroller gewoon een float (kommagetal) als dat praktisch is en geen problemen geeft. In het algemeen is de CPU / geheugen load in zo een toepassing toch heel laag.

Voor die frequenties kun je beter een log-detector gebruiken zoals de AD8307.

1250 W in 50 ohm bij 100 kHz tot 30MHz is wel erg veel?

Een logaritmische detector meet vermoedelijk nauwkeuriger.
Maar deze bewerking gaat heel anders, als dat de ingang spanning op de analoge ingang gedeeld wordt met 1024.
De gemeten spanning uit de AD8307 moet gedeeld worden door 0,025 dan kom ik op een getal uit tussen 0 en 100.
Dit getal vermenigvuldigd met 2,5 geeft de effectieve spanning over de belasting.
En dat moet zichtbaar gemaakt worden op het lcd scherm.
Mijn vraag is nu kan ik die berekening in de software doen op de analoge ingang, of werkt dit anders?

Wat ik vermoed is de gemeten maximale spanning 2,5Volt dat is 1024,
en 1,25Volt is dan 512.
Deze 1024 deel ik door 4,096 en dat is 250Volt effectief.
Hetzelfde bij 512 delen door 4,096 is 125Volt en dat klopt precies.

[Bericht gewijzigd door Martin V op 2 maart 2018 14:33:36 (18%)]

"tijd is relatief"

/*
Analog Input

Demonstrates analog input by reading an analog sensor on analog pin 0 and
turning on and off a light emitting diode(LED) connected to digital pin 13.
The amount of time the LED will be on and off depends on the value obtained
by analogRead().

The circuit:
- potentiometer
center pin of the potentiometer to the analog input 0
one side pin (either one) to ground
the other side pin to +5V
- LED
anode (long leg) attached to digital output 13
cathode (short leg) attached to ground

- Note: because most Arduinos have a built-in LED attached to pin 13 on the
board, the LED is optional.

created by David Cuartielles
modified 30 Aug 2011
By Tom Igoe

This example code is in the public domain.

http://www.arduino.cc/en/Tutorial/AnalogInput
*/

int sensorPin = A0; // select the input pin for the potentiometer
int ledPin = 13; // select the pin for the LED
int sensorValue = 0; // variable to store the value coming from the sensor

void setup() {
// declare the ledPin as an OUTPUT:
pinMode(ledPin, OUTPUT);
}

void loop() {
// read the value from the sensor:
sensorValue = analogRead(sensorPin);
// turn the ledPin on
digitalWrite(ledPin, HIGH);
// stop the program for <sensorValue> milliseconds:
delay(sensorValue);
// turn the ledPin off:
digitalWrite(ledPin, LOW);
// stop the program for for <sensorValue> milliseconds:
delay(sensorValue);
}

Een AD8307 is een log-detector en deze meet geen effectieve spanningen.
Is zolang we over sinussen praten geen probleem. Maar als je een blokgolf op 30MHz wil meten dan is het wat lastiger. Het kan wel.

Een ding kan ik je alvast mee geven : 30 MHz sampling-rate zal niet lukken.
Een Atmega werkt op max. 16 MHz, en een kleine uitzondering op een hogere kloksnelheid. Een Arduino zal geen 16 MHz Xtal onboard hebben.
Misschien dat je met wat overklokken hoger kan gaan dan de 16MHz, maar dan nog blijft het samplen een probleem.

De onboard ADC gaat max. tot iets van 10.000 samples / seconde. En dat is -meen ik- 8-bits. 10-bits zal op een lagere snelheid gaan.
Ikzelf heb een USB-stick ontworpen en voer daar 10-bit ADC-sampling mee uit. Met een beetje goede wil kom ik op 1000 samples / seconde uit. Dat heeft enerzijds te maken met de beperkingen van de Atmega, anderzijds is het de output over RS232 / USB naar een computer. Met moeite lukt het me om 5x een string met 200 meetwaarden te versturen op 115K2 bps. Sneller lukt niet.
Dat komt doordat een USB-poort meerdere dingen tegelijk uitvoert.

Op een USB-poort kun je max. 127 USB-devices aansturen. Je computer kijkt om de zoveel tijd of een device is aangesloten of juist weer is los gekoppeld. Evenzo wordt er gekeken of er data naar een device moet worden verzonden of wordt ontvangen. Dit gaat als het ware via time-slicing. Dit gaat allemaal ten koste van het verzenden van data.

Het maximale wat ik ooit voor elkaar heb gekregen is 1800 meetwaarden per seconde versturen. Wat me opviel was dat het versturen van decimale waarden langzamer verliep, dan wanneer ik hex-waarden verzond (1000 meetsamples versus 1800 meetsamples). Verder is het erg verstandig om je kloksnelheid van je kristal af te stemmen op je serieele communicatie-snelheid (bps).
Dit heeft te maken met de error-rate, die kan ontstaan.

Al met al, kan ik je op een briefje geven dat je gewenste 30MHz zeker niet gaat lukken, ook niet met een externe ADC-chip of overklokken. Je Arduino loopt immers al op een lagere snelheid. Om de data te verwerken zijn al extra stappen nodig, wat het meetproces verder zal vertragen.

Wil je de meetgegevens op een schermpje weergeven, kom je al snel terecht bij het middelen van de meetgegevens. Een scherm zal een update naar het scherm van 30 MHz niet aankunnen, laat staan of het mogelijk is om het te kunnen lezen.
Maar goed, bovenstaande zijn mijn persoonlijke ervaringen. Misschien dat iemand anders je andere info kan verstrekken.

Van elk bezoek aan CO leer ik weer meer...

Dat is zo. TS is echter nooit van plan geweest op 30 MHz te sampelen, hij heeft altijd gesproken over een gelijkrichter of log detector.

De suggestie direct te sampelen en de rest in software te doen kwam van mij, maar ging uit van een meting op 50 Hz en is hier van geen belang.

[joke-mode]
Volgens mij dwalen we wat af... ;-)
Het antwoord op de originele vraag in de topic header is.... [drumroll] NUL Volt.
[/joke-mode]

Serieus weer: leuk onderwerp by the way, over de beperkingen van de Arduino...

.

Ain't no place like 127.0.0.1

Dat is een complex en uitgebreid onderwerp omdat "Arduino" een ecosysteem beschrijft, niet een van de vele specifieke implementaties van hard- en software.

Om het te beperken tot de huidige Uno met de gewone bootloader, IDE (b.v. 1.8.5) en libraries; ik heb bij experimenten met de ADC niet het gevoel gehad dat de pcb layout te slecht is om de specificaties van de Atmega328 waar te maken.
Voor wat de software / compiler betreft zijn er helemaal geen beperkingen. De meegeleverde library functies zoals analogRead() doen geen gekke dingen maar zijn allicht niet zo snel als dat onder specifieke omstandigheden met een eigen stukje code mogelijk is.

Op 3 maart 2018 04:31:49 schreef oxurane:
Een ding kan ik je alvast mee geven : 30 MHz sampling-rate zal niet lukken.

Dat was ik ook niet van plan @oxurane, wat ik ga doen is gewoon de gelijkspanning op een analoge ingang zetten en deze meten en op het lcd scherm uitleesbaar maken.
Die gelijkspanning komt uit een wisselspanning meetopstelling die er gelijkspanning van maakt. De wisselspanning meet spanningen tot aan frequenties van 30MHz.

Wat ik dus in feite nodig heb voor de software is een analoge spanningsmeter. Hiervan heb ik een sketch gevonden en heb deze een klein beetje aangepast en ik wil jullie vragen of ik dit op de juiste manier heb gedaan.

Sketch:

/*
ReadAnalogVoltage

Reads an analog input on pin 0, converts it to voltage, and prints the result to the Serial Monitor.
Graphical representation is available using Serial Plotter (Tools > Serial Plotter menu).
Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground.

This example code is in the public domain.

http://www.arduino.cc/en/Tutorial/ReadAnalogVoltage
*/

// the setup routine runs once when you press reset:
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
}

// the loop routine runs over and over again forever:
void loop() {
// read the input on analog pin 0:
int sensorValue = analogRead(A0);
// Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
float voltage = sensorValue * (5.0 / 1023.0);
// print out the value you read:
Serial.println(voltage);
}

Waarbij ik de laatste regel verander in:

Serial.println(voltage*1,766*0,707106*40);

Een spanning van 5Volt op de analoge ingang laat nu een spanning zien van 250Veff op het lcd display.
Graag had ik dat dan ook uit willen lezen als 'Veff', geen idee hoe ik dat moet doen.

Maar nu komt het: Hoe kan ik die laatst berekende waarde opslaan in de Arduino en deze waarde opnieuw te gebruiken in de software om er de stroom en het vermogen te kunnen berekenen?

Heb ik dat aanpassen van die sketch juist gedaan, ik hoor graag van jullie.

[Bericht gewijzigd door Martin V op 3 maart 2018 15:01:38 (26%)]

"tijd is relatief"

Je zou dit eens kunnen proberen:

// the loop routine runs over and over again forever:
void loop() {
// read the input on analog pin 0:
int sensorValue = analogRead(A0);
// Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
float voltage = sensorValue * (5.0 / 1023.0);
float veff = voltage * 1,766 * 0,707106 * 40;
// print out the value you read:
Serial.print("voltage = ");
Serial.print(voltage);
Serial.print(", Veff = ");
Serial.print(veff);
Serial.println(" ");
}

Het bewaren van de laatst gelezen waarde doe je door deze in een global variabele op te slaan. Hoe stel je je voor om de stroom te berekenen? Gaat dat nog over die weerstand van 50 Ohm?

Ain't no place like 127.0.0.1

Bijvoorbeeld:

// the loop routine runs over and over again forever:
void loop() {
// read the input on analog pin 0:
int sensorValue = analogRead(A0);
// Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
float voltage = sensorValue * (5.0 / 1023.0);
float veff = voltage * 1,766 * 0,707106 * 40;

// print out the value you read:
Serial.print("voltage = ");
Serial.print(voltage);
Serial.print(", Veff = ");
Serial.print(veff);
Serial.println(" ");

float current = veff / 50; // calculate current
float power = veff * current; // calculate power

Serial.print("current = ");
Serial.print(current);
Serial.print(", power = ");
Serial.print(power);
Serial.println(" ");

}

Ain't no place like 127.0.0.1
blackdog

Golden Member

Hi,

De AD conversie van de standaard Arduino Uno, Nano is een zwabber conversie...
Is dat toegestaan in jouw meetopstelling?
Bij het 5V bereik wat standdaard is, is de referentie gekoppeld aan de voeding van de Arduino, wat nu niet direct een mooie stabiele conversie geeft.
Iets beter is een externe 1,25V referentie gebruiken (LT1004-1.2 of een LM385-1.2) en dit dan samen met een spanningsdeler aan de ingang.
En dan een aantal metingen middelen voor een stabielere weergave.

Nog beter en echt niet moeilijk is een i2c dac gebruiken, zoals de ADS1115 printjes van ebay.
Dan heb je 15 bits resolutie met een goede storings onderdrukking.

Hoe je de waarde wilt weergeven in b.v. effectief, vermogen of wat anders, bepaal je in de software.

Groet,
Blackdog

Waarheden zijn "Illusies waarvan men vergeten is dat het illusies zijn"

Op 3 maart 2018 18:16:47 schreef blackdog:
...
En dan een aantal metingen middelen voor een stabielere weergave.
...

Groet,
Blackdog

Zoals Blackdog al zegt, het is goed om een aantal metingen te doen en de resultaten te middelen. Zie hieronder voor een functie die precies dat doet:

// ------------------------------------------------------------------------
// read an Analog Pin and calculate the resulting value in mV
// ------------------------------------------------------------------------
float readAnalogPin(int pin, int rep = 1) {
long sum = 0; // holds sum of results
float millivolts = 0; // resulting millivolts
int count = rep; // repetition (defaults to 1)
for (int i = 0; i < count; i++) { // counting # of times
sum += analogRead(pin); // add [count] values
}
long result = sum / count; // Calculate average
millivolts = result * VCC / 1023.0; // calculate to millivolts
return(millivolts);
}

Ain't no place like 127.0.0.1

Geweldig! Dit is precies wat ik wilde bereiken en nu kan ik hiermee verder. Bovendien leer ik er hier ook een hoop van.
Mijn hartelijke dank hiervoor, nu zie ik zelf hoe makkelijk programmeren is.

De berekening:
float veff = voltage * 1,766 * 0,707106 * 40;

Kan ik vereenvoudigen; door te stellen dat 5,00V op de analoge ingang, overeenkomt met 250Veff op de meting.
Dat is precies een factor 50 en dat scheelt een hoop onnodig rekenwerk.

En Blackdog je hebt helemaal gelijk dat deze meting niet erg nauwkeurig is, bij het maximale vermogen is Uin/1023, één stapje terug naar 1022, scheelt al zo 2,5 Watt in de meting.
Dat is voorlopig nog niet zo erg, omdat dat maar een tijdelijke oplossing is en ik wat programmeer kennis kan opdoen.
Heel goed dat jullie wijzen op de interne referentie spanning en dat ik daarvoor een goede oplossing voor moet gebruiken, dat ik zal ik zeker gaan doen.

Een betere manier van meten is met een 16bit A/D convertor en deze vond ik: https://www.adafruit.com/product/1085
Met de ADS1115, met een I2C shield is dat mogelijk.
Dat is leuk voor later, eerst maar eens zo proberen.

"tijd is relatief"

Op 3 maart 2018 20:07:54 schreef Martin V:

Dat is precies een factor 50 en dat scheelt een hoop onnodig rekenwerk..

nee. De compiler is tegenwoordig zo slim dat ie ziet dat x*1.76666*.707*40 gelijk is aan x* (1.7666*.707*40) en dat ie het stuk tussen de haakjes maar 1x hoeft uit te rekenen, en dat ie dit op je PC kan doen ipv op de arduino.

En Blackdog je hebt helemaal gelijk dat deze meting niet erg nauwkeurig is, bij het maximale vermogen is Uin/1023, één stapje terug naar 1022, scheelt al zo 2,5 Watt in de meting.

Maar.... een paar stapjes aan "ruis" kan je zomaar hebben. En dat gaat uit van een "goed ontworpen analoog circuit". Als het analoge deel wat minder goed ontworpen is, zoals op een arduino, dan kan je zomaar nog meer afwijking zien. (bijvoorbeeld variaties bij een stabiele ingangsspanning).

[Bericht gewijzigd door rew op 4 maart 2018 08:19:33 (38%)]

four NANDS do make a NOR . Kijk ook eens in onze shop: http://www.bitwizard.nl/shop/

De interne voltage referentie van de 328P is gespecificeerd op 1.1V met een minimum van 1.0 en een max van 1.2 Volt dus die kan er 10% naast zitten. Ik weet niet hoe accuraat je meting moet zijn maar ik zou toch een externe referentie kiezen bv de TL431

10 bits of hoger maakt niet zoveel uit bij een vref afwijking van 1% zit je er al 0.05 volt naast bij 5 volt.

Let ook een beetje op je input protectie.

Have you debounced your buttons today?