A little known feature of Arduinos and many other AVR chips is the ability to measure the internal 1.1 volt reference. This feature can be exploited to improve the accuracy of the Arduino function – analogRead() when using the default analog reference. It can also be used to measure the Vcc supplied to the AVR chip, which provides a means of monitoring battery voltage without using a precious analog pin to do so.
I first learned of this technique from these articles – Making accurate ADC readings on the Arduino, and Secret Voltmeter. In this article, I have incorporated some additional improvements.
Motivation
There are at least two reasons to measure the voltage supplied to our Arduino (Vcc). One is if our project is battery powered, we may want to monitor that voltage to measure battery levels. Also, when battery powered, Vcc is not going to be 5.0 volts, so if we wish to make analog measurements we need to either use the internal voltage reference of 1.1 volts, or an external voltage reference. Why?
A common assumption when using analogRead() is that the analog reference voltage is 5.0 volts, when in reality it may be quite different. The official Arduino documentation even leads us to this wrong assumption. The fact is the default analog reference is not 5.0 volts, but whatever the current level of Vcc is being supplied to the chip. If our power supply is not perfectly regulated or if we are running on battery power, this voltage can vary quite a bit. Here is example code illustrating the problem:
double Vcc = 5.0; // not necessarily true int value = analogRead(0); double volt = (value / 1023.0) * Vcc; // only correct if Vcc = 5.0 volts
double Vcc = 5.0; // not necessarily true int value = analogRead(0); double volt = (value / 1023.0) * Vcc; // only correct if Vcc = 5.0 volts
In order to measure analog voltage accurately, we need an accurate voltage reference. Most AVR chips provide three possible sources – an internal 1.1 volt source (some have a 2.56 internal voltage source), an external reference source or Vcc. An external voltage reference is the most accurate, but requires extra hardware. The internal reference is stable, but has about a +/- 10% error. Vcc is completely untrustworthy in most cases. The choice of the internal reference is inexpensive and stable, but most of the time, we would like to measure a broader range, so the Vcc reference is the most practical, but potentially the least accurate. In some cases it can be completely unreliable!
How-To
Many AVR chips including the ATmega series and many ATtiny series provide a means to measure the internal voltage reference. Why would anyone want to do so? The reason is simple – by measuring the internal reference, we can determine the value of Vcc. Here’s how:
- First set the voltage reference to Vcc.
- Measure the value of the internal reference.
- Calculate the value of Vcc.
Our measured voltage is:
Vcc * (ADC-measurement) / 1023
which as we know is 1.1 volts. Solving for Vcc, we get:
Vcc = 1.1 * 1023 / ADC-measurement
Putting it altogether, here’s the code:
long readVcc() { // Read 1.1V reference against AVcc // set the reference to Vcc and the measurement to the internal 1.1V reference #if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1); #elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__) ADMUX = _BV(MUX5) | _BV(MUX0); #elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__) ADMUX = _BV(MUX3) | _BV(MUX2); #else ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1); #endif delay(2); // Wait for Vref to settle ADCSRA |= _BV(ADSC); // Start conversion while (bit_is_set(ADCSRA,ADSC)); // measuring uint8_t low = ADCL; // must read ADCL first - it then locks ADCH uint8_t high = ADCH; // unlocks both long result = (high<<8) | low; result = 1125300L / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000 return result; // Vcc in millivolts }
long readVcc() {
// Read 1.1V reference against AVcc
// set the reference to Vcc and the measurement to the internal 1.1V reference
#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
ADMUX = _BV(MUX5) | _BV(MUX0);
#elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
ADMUX = _BV(MUX3) | _BV(MUX2);
#else
ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#endif
delay(2); // Wait for Vref to settle
ADCSRA |= _BV(ADSC); // Start conversion
while (bit_is_set(ADCSRA,ADSC)); // measuring
uint8_t low = ADCL; // must read ADCL first - it then locks ADCH
uint8_t high = ADCH; // unlocks both
long result = (high<<8) | low;
result = 1125300L / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000
return result; // Vcc in millivolts
}Usage
Checking Vcc or Battery Voltage
You can call this function – readVcc(), if you want to monitor your Vcc. One example would be for checking your battery charge level. You could also use it to determine if you are connected to a power source or running from batteries.
Measuring Vcc for Analog Reference
You can also use it to get a correct value for Vcc to use withanalogRead() when using the default (Vcc) voltage reference. Unless you are using a regulated supply, you can’t be sure Vcc is 5.0 volts or not. This function will provide the correct value to use. There is one caveat though…
One of the articles I cited earlier made the claim that this function could be used to improve the accuracy of the analog measurement in cases where Vcc wasn’t exactly 5.0 volts. Unfortunately, this procedure will not provide that result. Why? It is dependent on the accuracy of the internal voltage reference. The spec sheet gives a nominal value of 1.1 volts, but states that it can vary from 1.0 to 1.2 volts. That means that any measurement of Vcc could be off by as much as 10%. Such a measurement could be less accurate than our power supply for the Arduino!
Improving Accuracy
While the large tolerance of the internal 1.1 volt reference greatly limits the accuracy of this measurement, for individual projects we can compensate for greater accuracy. To do so, simply measure your Vcc with a voltmeter and with our readVcc() function. Then, replace the constant 1125300L with a new constant:
scale_constant = internal1.1Ref * 1023 * 1000
where
internal1.1Ref = 1.1 * Vcc1 (per voltmeter) / Vcc2 (per readVcc() function)
This calibrated value will be good for the AVR chip measured only, and may be subject to temperature variation. Feel free to experiment with your own measurements.
Conclusion
You can do a lot with this little function. You can use a stable voltage reference close to 5.0 volts without having to rely on your Vcc actually being 5.0 volts. You can measure your battery voltage or even see if you are running on battery or A/C power.
Lastly, the code provided will support all the Arduino variants, including the new Leonardo, as well as the ATtinyX4 and ATtinyX5 series chips.
Please share any corrections in the comments below.
54 Comments
hey Scott, this is incredibly helpful. I’ve been struggling with measuring voltage with the Arduino for a while, and I note that different boards and different batteries lead to really different results on all my analog readings. I have a few questions:
– is one of the lines of code essentially doing a analogReference() call? If so, is there any risk of doing that call out of sequence with the reads, or another call to that function?
– As you can tell from the previous question, I don’t follow the code you’ve posted, though I figure the variables IN CAPS are internal Arduino vars. Is there a list of those vars you point me to?
– Can you give me a bit more detail on how this would be used to correct analog references?
thanks! — wylbur.
Yes – the first line of actual code (3 variants) does two things. 1) It sets the analog ref to Vcc. 2) It sets the measurement to not a pin, but the internal 1.1v reference. The rest of the code simply makes the analog measurement (ADC conversion). The first line must come before the rest. It can of course be changed for subsequent measurements.
As for the constants, those are standard AVR constants (not Arduino, but more low level). You can peruse the documentation for the AVR LibC here, or review the Atmel spec sheets.
The whole trick of this code (readVcc) is to figure out the supply voltage (Vcc) by reading the internal 1.1 volt reference using Vcc as the reference. With simple math, the real Vcc can then be calculated.
Those Arduino boards I have measured give about 4.85 V or thereabouts .Put a multimeter on the regulator output or stick it across the 5V out pinand ground pin and use the voltage read in your adc conversion formula directly -accuracy will be improved. Look at the chips datasheet and most of them have a tollerance of +/-1 degree when measuring temperature so atm your temp measurements can be up to 2 degrees out!
Hihi,
Would it be possible to read the internal temperature sensor of the Arduino Leonardo ( 32U4)
in a similar way ?
Yes. I haven’t written an article here yet that shows how, but I recently posted an Instructable with the code to do exactly that, including support for the 32U4 chip.
No, reading the chip internal temperature will not be a help in ‘calibrating’ the A/D reference voltage. The chip’s internal temperature is more a reflection of how fast it is being clocked and how much current is being sunk or sourced via it’s output pins, as well as external ambient temperature.
Nice trick, too bad the ATtinyx5 series can’t handle this, I love these small chips
You can – thanks to Doug (below) for pointing that out. I have amended the code in the article to support the ATtinyx5 series chips as well.
One question. On a arduino board, when plugged on USB, arduino uses a 5V Vcc, but what is the regulation when I feed it with 9V?
Vcc ought to still be 5v
Tolerance depends on the Voltage regulator chip used. Typically 4.9 to 5.1V
When powered via USB then Vcc is whatever the PC’s USB voltage is and can vary from I think 4.5 to 5.5vdc and still be in specification? If powered via external power then the board’s Vcc will be whatever the on-board 5 volt regulator voltage is with a similar specification tolerance. So there is no true 5.00000 board voltage, rather it’s whatever actual value within normal tolerance specs of whatever voltage source is being used.
Maybe I’m missing something, but I don’t see why you can’t use this on an ATTiny25/45/85.
Can’t you just set ADMUX to
#elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
ADMUX = _BV(MUX3) | _BV(MUX2) ;
and readthe bandgap reference (i.e. Vref) ?
If I’m mistaken, please educate me as to my error. I’m always interested in learning more.
You are absolutely right. I overlooked that entry in the Atmel spec sheet for that series AVR chip. I will amend the code in the article.
You should edit your conclusion paragraph as well, just to avoid confusion.
Fixed – thanks for catching that.
I used the 1.1V internal reference on an Arduino a few months ago. But I found out (the hard way) that the tolerance on the 1.1V reference is really poor. It’s specified to be between 1.0V and 1.2V, or roughly +/- 10%. In my case, this made the reference useless. I added an external TL431 2.5V reference, with a tolerance closer to 1%.
As I mentioned in the article, the accuracy of the 1.1v reference is poor. It still has value however – 1) in battery operated projects, it is better than using Vcc (it is at least constant) and you can use it to monitor battery voltage, and 2) you can calibrate for the error. You can even automatically calibrate for each chip automatically as part of the programming process. If you really want an accurate voltage reference however, a separate chip is the way to go – just like you said.
This is very cool. After I call your function, should I set the reference back to default with
analogReference(DEFAULT);
Just so I’m clear, this does not use any of the analog I/O pins, right?
As noted already, the 1.1 voltage reference is not very accurate. Is there a way to measure that with a voltmeter so I can see what it is for a specific Arduino device?
The internal 1.1 volt reference voltage does have a pretty wide specification, however it is pretty stable for any specific chip within the tolerance range, so the trick is to somehow calculate or measure the actual 1.1 vdc reference for your chip. If you select the internal 1.1 reference voltage in a sketch, you can actually measure it on the Aref pin of the chip. Also I have just tweeked the reference voltage in my calculation until the results of a analog read using a known external test voltage value agreed with the calculated/corrected value.
You can measure actual 1,1V reference voltage from Aref pin, after you have muxed internal 1,1V there. You can connect a small capacitor there, to make it more stable.
Hi,
Could you please describe how to “mux the 1.1 ref to pin AREF” ?
And do i need to switch it back after that ?
thks
1) No need to change analog reference. This function sets it to the default = Vcc.
2) It uses none of the I/O pins.
3) To measure the internal ref voltage, you can use the excellent suggestions already made, or else calculate it from the value of Vcc given by the ReadVcc() function based on actual Vcc measured with a volt meter.
Very interesting function. I tried it out and found a very interesting result with my setup. I fed the sketch to my Arduino uno rev3 which I use to provide 5 Vcc to a couple of prototype boards. I’d forgotten I had a ATmega328 plugged into the proto board running a sketch which lights all the pins 0 -13 as well as A0 thru A5. After lighting them one by one the sketch lights all 19 at once. When I was running the Vcc function on the factory built arduino the 5Vcc line would vary by as much as 110 millivolts when all leds were on with the bare minimum ATmega328. I thought that was a fairly large drop but I have no idea what resistance is between the USB port and the arduino.
I did measure the DC current to the proto board with all leds lit and it was 85ma.
Just goes to show that even though the Arduino is supposed to supply 500ma when connected to USB, that may not be without consequences even at much lower loads. When I plugged a 12 volt power pack into the line in jack the voltage was rock solid.
Occasionally, but not always, the statement “long result = (high<<8) | low;" returns a zero. Why would this be and what can I do about it? This is a very cool routine but this behaviour is driving me a little mad!
Thanks, Will
Clarification on the above. This never happens on the first read following a restart of the controller….so I just make sure I restart the controller before I get my reading! In any case I have taken what I think I learned from this post and applied it to my project. I then documented what I did here. It should be noted that I am a software guy and this hardware stuff confuses me! I get the answer that I want (e.g. a voltage reading that matches my meter) but I am not sure I have done so in the ‘right’ manner.
I am not sure why that is happening. I took the analog read code straight from the Arduino library. Are both high & low zero as well (should be obvious, but you never know)? Try adding a short delay before reading the register values for high & low.
Seeing that it works the first time and then not afterward, check to make sure the ADLAR bit is not being set somehow in the ADMUX register – that could cause the data to be left shifted and possible read as zero.
A last thing to try is to check to make sure the ADIF bit is set in register ADCSRA before reading the data registers. You may want to study up the Analog to Digital Conversion in the datasheet if all this fails.
If you find the problem, please post the result. Good luck!
Scott:
Thanks. I have not been able to reproduce this problem on a regular basis but will try to do so. The first thing I will try is the one thing that I understand how to do…put in a delay!
Cheers,
Will
Thanks for posting the code with explanation! It was exactly what I was looking for. I would like to be able to monitor how much life the battery has left. I’m a total newbie when it comes to electronics and the Arduino so please excuse if my question is a little naive: After uploading the sketch to my Uno Rev 3 which was connected to my computer via USB and running from a 9V battery (I connected the battery via VIN and GND) I checked the Serial output and it reads a consistent 4855. I was assuming that it would read somewhere between 8000 and 9000 since I was connected via a new 9V battery. Since the Arduino uses 5V will it always read around 4855 until the battery is drained and dips below that value?
Thanks in advance for your help.
That is pretty close. What the function does is measure the voltage supplied to the ATmega chip itself. The Uno has a 5 volt regulator which provides the 4.855 volts your are reading (the actual voltage is probably closer to 5 volts, but that is a limitation on the internal ref’s accuracy). The regulator probably has around 1.2 to 2 volts of dropout, so the voltage you read will stay the same until your power source drops to less than 6 to 7 volts.
If you want to monitor your battery voltage before the regulator, you will have to use an analog pin to do so. For monitoring battery voltage, this function will only work when powering the IC directly and not using a voltage regulator. Make sense?
Hi Scott,
Thanks so much! Makes absolute sense.
Best regards,
Martin.
Martin:
I think you also need to have a voltage divider to take the 9v to under 5v for the arduino to be able to read it. In my post right above yours there is a link to what I have done that may help. I am a complete hardware novice as well……..
Cheers, Will
Thanks for the info. I’ll check it out the link!
Hi excellent article thanks. I have a question if I may. I’m intending to run an atmega328p from a single 3.6v lion cell and I’m confused as to how I can take accurate ADC readings on my A0-A5 pins with VCC slowly dropping down. I figured I would just use readVcc then keep the battery between 4200(4.2v) and 3000(3v) but what is the reference for ADC readings the current vcc? If so how can I maintain accuracy with a constantly changing ratio? I’m reading 0-24v through a resistive divide using a ratio of 70Mohm 10Mohm giving me 0-3v out. But at 4.2v 3v is 730 ish and at 3v 3v is 1023. So how can I adjust the value to track vcc?
Kind Thanks
You have two options: either use a voltage reference (internal or external) or use the standard Vcc reference (as you are doing) and scale it using the readVcc function. Here’s how to do the latter.
long millivolts = readVcc();
long measured = analogRead(A0);
long voltage = millivolts * measured / 1023; // answer is in millivolts
You don’t have to call readVcc everytime – just often enough to track the battery voltage.
is this code useful for atmega168? thanks
Yes – most of not all ATmega chips support this feature.
I don’t quite understand all the info presented here but perhaps I could have some feedback. Part of the project I have just started on is to measure sensor input to my vehicle’s computer(PCM). Power to the sensor is +5Vn. If I were to use the same +5Vn to power the arduino, would that automatically act as a reference for a fairly accurate reading of the sensor output? or should it also be input into the AREF to obtain an accuracy of +/- .01V?(is this accuracy even possible?) I would assume that as long as I read the same value that would appear in the PCM, it wouldn’t matter that power to the sensor is not exactly 5V.
Thanx
That is a tough question to answer without knowing more details. Is the 5V source accurate? (I doubt it is +/- 0.01 volts). Is the PCM relying on the +5v source?
As indicated by this article, the default analogRead uses the AVR’s Vcc for a voltage reference. The technique given to measure Vcc is somewhat crude (about 10% accuracy). If you need an absolute accurate voltage reading (such as the 0.01 volts cited), then you will need to use a precision voltage reference chip and feed it to AREF. Even then, that kind of accuracy might be iffy at best. If you meant +/- 0.1 volts, then the precision ref will work.
The 5V source would be from the PCM(powertrain control module, aka ECU) and it probably isn’t an accurate value, I’ve measured it before but don’t remember what it was ~4.8 to 4.9 maybe.
The PCM supplies 5V to most all of the sensors which are predominately variable resistive loads that return a voltage less 5V. I’m not sure what resolution the PCM reads.
I want to begin only measuring the post cat O2 sensor which returns oscillating signals from around .3V to .7V up to 3 times a second where each high and low value may possibly vary +/-.2V. Eventually, I would like to interrupt the signal from the O2 to PCM with the arduino, in real time, feeding the PCM a predetermined, or augmented through calculation, signal for every O2 pulse. Essentially fooling the PCM that the engine is running normally as I make changes to the system that would otherwise be automatically defeated by the PCM’s readjustments.
Do you think that if I use the sensor input voltage for AREF, I will still have only 10% accuracy?
Would you have suggestions for a particular reference chip to use if I need to use one? I didn’t figure it would be a difficult measurement seeing as how my $5 voltmeter reads to .01V, but I’m a novice and the arduino experience is very new to me.
I appreciate the input.
Since your sensor input voltage appears to be only 5% accurate, the same will be true of any measurement made with it for a reference. On a related note, who knows what effect the sensor input voltage has on the sensor accuracy? I wonder if you really need absolute accuracy or relative accuracy. If the sensor reading vary with their input voltage, absolute accuracy may not do you any good.
Therefore, I suggest just using the sensor input voltage for AREF and do some testing. I would also monitor this voltage itself as well. Does it change with temperature for example? If you find you need a precision voltage reference, the SC431 (available from Digikey) will serve you well. It works just like a 2.5 volt Zener diode, except it is 1% accurate. Just hook a 1 to 10K resistor to Vcc and then your volt ref and input that to your AREF pin.
If the Arduino supply Voltage is made to track the PCM 5V all measurements will be ratiometric and the errors drop out.
Hi,
This is all very helpful, but what if I want to measure the voltage across another power line? I am working on a project in which I need to continuously measure the voltage of the line powering the project. I am using regulators to regulate, but I need a way to read and store that reading for data analysis after the project. What is the best way I can do that? I’ve been looking around but I can’t find anything.
Thanks,
You’ll just need to use an analog pin to make the measurement. Use two resistors to make a voltage divider that drops your maximum line voltage just under 5 volts (or 1.1 volts if using the internal reference) and measure your voltage at that point.
I would like to change the reference on the Arduino DUO board. The analogReference(INTERNAL1V1); code returns an error.
Do you think that reference could be changed with lower level code?
I haven’t played with the DUO yet. Look in the spec sheet for the appropriate analog reference bit to use.
Hi,
Thank you for this article.
I have a large number of 2VDC 1200Ah Lead Acid Batteries that I use for off-grid power.
I need to be able to monitor the voltage, amperage and temperature of each battery. The “device” should be self powering, so I have settled on the ATTINY43U as this operates from 0.8 to 5.5 VDC and is well within the operable battery voltage range of 1.57 to 2.85 etc.
Your routine should I believe, give me the first part of the problem, namely the battery voltage.
Is that correct?
Can the ATTINY43U also provide the amperage?
I also read that it can return the temperature of the chip for reference value.
I intend to use a copper lug with an LM35 inside sealed with hot glue and feed that output back to the ATTINY43U but that requires 5VDC? So somehow I need to increase the voltage from the battery to deliver that??
Could you or any of your stalwarts advise me as to whether this is feasible and help me with a little bit of code / hardware advice to get me going, please?
Thanks and kind regards,
jB
Yes, you can measure the voltage using this technique. You can also measure the ambient temperature with a similar technique. The latter is not real precise, but is probably sufficient with your application (you will have to calibrate the chip however). Alternatively, you can use a temperature chip as you mentioned, but will need a boost converter to get 5 volts.
For current, that is not a property of each cell, but the entire battery of cells. You will want to use another circuit for that. You will need to measure it using an analog pin and a current sense resistor.
Hi scott
I am using atmega2560 (arduino)
I had added your code for reading chip Vcc using the internal 1.1 vref and its working great
The problem is that I need to read some value from other analog pin in my program also
And iam doing it like this:
#define VPowerLeg 8
Serial1.print(“Voltage:”);
Serial1.println(analogRead(VPowerLeg));
When I add this to my code your function returns -1
If I use “analog read” function or readVcc() separately they work fine, but not together
Please advice
the solution for this issue is to add:
ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
ADCSRB &= ~_BV(MUX5); // Without this the function always returns -1 on the ATmega2560
The correct value is 1024 not 1023.
it took me a while to figure-out the problem, but on MEGA 2560, immediately after analogRead(A8), ADCL started returning zero. So every attempt to read from A8-A16 on Arduino MEGA will damage the functionality of readVcc().
I’ve resolved the problem by adding:
ADCSRB = 0;
just before
delay(2);
yet, I cannot explain why this has such an impact.
Frequently gulping down elephant-size portions of food will only
make your dream of attaining a slimmer figure only a pipe-dream.
Effects Of Slimming Pills – If pills originated to reduce appetite are consumed,
they can have risky effects such as causing the heart to beat
faster and palpitations could occur and a fine
tremor to develop. You will not only lose weight but will also
be able to keep fat from coming back; this is great news as it simply means losing weight
on permanent basis.
I hope this article has given you some useful information about roofs.
Have you played any gigs out and about, any house parties, any
school dances. Just when your swelling falls a bit responding on the
diuretic does not necessarily mean you are receiving better.
8 Trackbacks
[...] http://provideyourown.com/2012/secret-arduino-voltmeter-measure-battery-voltage/ [...]
[...] We think it’s a great learning experience to tear back the veil of abstraction and learn a bit more about the hardware found on an Arduino board. This project is a great example. [Scott Daniels] takes a look at the other voltage measurement options available to AVR chips used by Arduino. [...]
[...] We think it’s a great learning experience to tear back the veil of abstraction and learn a bit more about the hardware found on an Arduino board. This project is a great example. [Scott Daniels] takes a look at the other voltage measurement options available to AVR chips used by Arduino. [...]
[...] Find the code and explanation on his website. [...]
[...] this Secret Arduino Voltmeter – Mete Group Voltage A petty famous element of Arduinos and numerous further AVR chisels is the talent to criterion the within 1.1 volt recommendation. This facet can be exploited to better the correctness of the Arduino use – analogRead() during using the failure analog credentials. It can and be worn to law the Vcc supplied to the AVR hew, which gives a intends of monitoring group voltage minus using a precious analog peg to do so. Secret Arduino Voltmeter – Fathom Artillery Voltage – read more about this project detail [...]
[...] more information, visit Scott’s tutorial pages. And we’re on twitter and Google+, so follow us for news and [...]
[...] Read more in the source. [...]
[...] Secret Arduino Voltmeter – Measure Battery Voltage [...]