Introduction: Rechargeable Battery Capacity Tester

Picture of Rechargeable Battery Capacity Tester

Do you have a pile of AA rechargeable batteries in your drawer? Some are old, some are new, but which sets would you bring with your camera on your next trip, and which ones are past their useful life? I like using rechargeable batteries, but I’m certain that some of them are not living up to the stated capacity on the label.

So how good are those batteries? Simple battery testers measure the voltage, but that’s not what we need – we want to find the overall capacity of the battery. How long will a battery last from the time it’s fully charged to the time that the “low battery” indicator comes on your device?

You can see this in action in a video in the last step of this instructable.

Step 1: This Is a Job for a Microcontroller

Picture of This Is a Job for a Microcontroller

A simple way to test a battery would be to attach a load resistance to a fully charged battery and monitor the voltage until it drops below its useful value. The amount of time the battery lasts indicates its capacity.
That is a quick solution to the problem, but it involves watching a voltmeter for a few hours. That’s no fun at all. With a microcontroller, like the good old AVR chip, we can make a rechargeable battery tester that does the work for us. My tester puts AA batteries through a discharge test and reports the capacity in milliamp-hours (mAh) so you can compare battery capacity.

Design features
The tester can test multiple cells individually, and display the results on an LCD.
The tester discharges the battery while monitoring the voltage of the batteries. When the low threshold is reached, that cell is done it disconnects the load from the battery. When all tests are complete a series of beeps alerts the user. The tester identifies the type of battery by its initial voltage allowing both NiCd and NiMh batteries to be tested.

The design is based on the ATMega168 (or 328) microcontroller, which has 6 A/D converters on the chip, so these will be used to read the battery voltages and determine the load current. Since each battery will require two A/D converters per cell, the maximum number of cells is three.

I built two of the testers, first using an Arduino board as a development system, and then a standalone device that will be more compact, and free up the Arduino for other projects.

Step 2: Main Parts

Picture of Main Parts

Here's what you need:

  • An Arduino board
  • or a ATMega168 or 328p chip and associated parts for the standalone version - see the schematic for details.
  • A Nokia 5110 graphic LCD.
  • Three MOSFETs -- used to switch the resistive load on and off.
  • Resistors to discharge the battery
  • Resistors to interface to the LCD
  • A small speaker typically found in PCs.
  • Circuit Board or breadboard.
  • A holder for AA batteries. This has to be modified so that each cell is wired individually.
  • A case to house the project

Step 3: Circuit Design

Picture of Circuit Design

The discharging circuit is relatively simple, each battery has a corresponding load resistor that discharges the battery when the FET is switched ON. The switching is controlled by the microcontroller. The microcontroller’s A/D converter is used to monitor the battery’s voltage. A second A/D converter is connected to the FET to determine the current going through the load resistor. The current is calculated by subtracting the FET voltage from the battery’s voltage, which results in the voltage across the resistor. Dividing by the resistance gives the discharge current. Multiply this by the time and you get the milliamp-hour value.

If you look at the code, you’ll notice that the math is not quite this straightforward. The microcontroller reads the battery status every second, calculates the amount of charge drawn during the past second and adds it to the total. In that short amount of time there is only a fraction of a milliamp-hour that has been used, so it would be rounded off to zero if we’re not careful with our integer math. So instead of tallying the number of milliamp-hours, I tally the number of microamp-hours. That will be 1000 times larger so no worries of rounding down to zero. When milliamp-hours are displayed, the charge is divided by 1000.
The code is well commented, so the details can be seen there.

Load resistor
The resistor needs to dissipate a bit of power, so size does matter in this case. Testing NiCd and NiMH batteries (1.2 volts) the power dissipation is under 1 watt, so choose a sufficiently large resistor, or several resistors in parallel. With the relatively large current, be sure to use thick wire for the discharge path.

I considered allowing testing of type 14500 Li-Ion batteries since they are AA size too, but the load resistor would need to be changed to a larger value to accommodate the higher voltage. When the battery is inserted, the program checks the battery voltage, and does not perform the test if detects a Li-Ion battery. If I didn’t do this, the load resistor would draw over 1400 milliamps, which is way over the maximum recommended discharge current of 450 milliamps. The resistor would (in theory) dissipate about 6 watts, and the aroma of smoke would fill the room. This emphasizes the need for your code to test and handle unexpected conditions! I could have designed a circuit to allow testing of Li-Ion batteries by adding an additional FET and load resistor, but I didn’t need this feature.

This component is like a switch. The output from the microcontroller controls the switch. When the output is high to the gate of the FET, it allows current to pass from the positive terminal of the battery, through the resistor, and the FET then completes the path back to the negative terminal. This discharges the battery over a period of time. I used a FET I salvaged from an old PC (partnumber IRL3103S). Any similar device should work as long as the Drain-to-Source On-Resistance is low. The 2M ohm resistor ensures the voltage read from an empty battery holder is zero volts. Without it, the A/D input will produce unpredictable results.

I used a LCD from a old Nokia 5110 cell phone which was a pain to wire up, but the good news is that the display is available in an easy to use board from Sparkfun - along with the other materials. The Arduino is running at 5 volts, but the display and the control lines need no more than 3.3 volts. There are several ways to accomplish this – I chose using resistors to form a voltage divider. The 1800 ohm and 3300 ohm resistors form a pair that divide the 5 volt outputs from the Arduino to the desired 3.3 volts. In the standalone version I kept the design the same. I could have lowered the microcontroller’s voltage - the AVR chip will run at a lower voltage - but that would cause other design changes, so I kept the same design. The display has a back light, so I wired it up through a current limiting resistor. The Nokia display is a bit mapped display, so I took advantage of that and made animated battery icons to show the status of the three cells. The PCD8544 library makes controlling the display a snap

The above diagram is a simplified schematic showing one of the discharge circuits controlled by the Arduino.

Step 4: Full Schematics

Picture of Full Schematics

These schematics show the complete design - one design with the Arduino board, and one as a more compact and inexpensive standalone design.

Disclaimers and other notes

♦The accuracy of the tester won't be perfect, but it does give reasonable results that can be used and compared with other batteries so you can determine whether you want to keep a battery or get rid of it. Please dispose batteries properly.
♦The voltage drop across the FET should be negligible.
♦After the battery test is complete, the tester continues to display the voltage of the batteries – since the load is removed, the voltage will return to what will seem to be an acceptable voltage, but it the battery is really discharged.

♦ The pin numbering for the LCD has confused some readers - note that the LCD I used was pulled from an old cell phone, but if you buy an LCD from sparkfun it will have different numbers. Even comments in the PCD8544 library indicate another different numbering scheme - so just match the signal names and ignore the pin numbering.

Step 5: Source Code

Picture of Source Code

I've uploaded the source code (.PDE file) for you to view and use.
(Update - the .PDE extension is what early Arduino development used. You can rename this to .INO for compatibility with the more recent development environment)
I have placed comments in the code for readability.

Step 6: Design of the Case

Picture of Design of the Case

A case makes the project complete, and you can find many acceptable metal or plastic boxes. I chose to make one out of wood for a unique custom look. See the video at the end of this instructable for more info.

This part of the project took quite a long time, but I like how it turned out.

Step 7: Feature Upgrade - Because a Home Project Is Never Quite Done!

Picture of Feature Upgrade - Because a Home Project Is Never Quite Done!

It was only a few days after completing the project that I realized I needed the ability to handle physically larger cells - in particular, the sub-C cells that I used in one of my other instructables. So I added a connector to the bottom of the device that simply gives access to the wires on two of the battery holders. So now I can test batteries that won't fit in the AA battery holder. When not in use, the alligator clips simply pull out from the recessed connector

Step 8: Video

Picture of Video

Step 9: Other Sources for Battery Testing

This project was designed for electronics/microcontroller enthusiasts who wanted to make something that is also practical. However, not everyone has the time, interest and/or ability to build something like this, but do want the ability to test batteries.

The good news is that you can buy something similar like this for about $40. I have seen two such devices advertised on Amazon.
They both do battery discharge testing - and also serve as a charger.

AccuPower IQ-328 Battery Charger Analyzer Tester (AA AAA NiMH NiCd)
La Crosse Technology BC-700 (NiCd & NiMH AA/AAA)

I have no experience on either of these devices - so I won't personally recommend either them, but the Amazon reviews are generally positive.


mwasky (author)2017-11-28

Thanks guys for the helpful info. I wanted to ask if anyone has tried the project with a different type of LCD and which one they used

KDMcMullan (author)2017-10-23

I suspect the method is flawed. You're sampling the voltage at each end of the load resistor: FET drain end and also battery end. I think you use the difference to calculate the V drop across the load. I accept that this is correctly going to give you the V drop across the load, but I don't think that's the information you need. I suspect you really need the total V drop across the load and the FET all the way down to ground. The ground is, of course, 0V. So the Vdrop need only be measured at the cell itself. I don't see the need for the voltage measurement at the FET drain. I think we can get better results with only a single ADC per cell.

KDMcMullan (author)KDMcMullan2017-10-23

Ahhh. Unless your FET's not grounding the resistor?

Wilczur (author)2017-05-03

hi, this is great project

does author or anybody have modification this code for 16x2 lcd or 20x4? or can modify it and share? it could be only for one battery for me
i am beginner and try do this but no results

squelch41 (author)2017-03-22

Wondering if anyone could offer me advice - wired as diagram - 2.2ohm load resistor, 1.25V NiMH AAA battery (voltage measured by multimeter), F12N1OL FET.

Arduino reads around 0.9V and calculated current to be around 380mAh - measured current is 125ma with multimeter and battery voltage around 1.25V.

Load resistor confirmed at 2.2Ohm on multimeter.

Total resistance battery --> load resistor -->fet --> ground (when fet held at 5v manually) is 6Ohms

Tried adjusting ardunio programme to 6Ohm load but didnt make any more accurate with voltage.

What am I doing wrong?

many thanks

BrianH (author)squelch412017-04-08

What is the Battery Tester telling you? Is it reporting "Test complete" too soon? What does it report as mAh capacity.

You mentioned that you were testing AAA battery - that may require a different load resistor.

I couldn't find any specs on the FET you are using - what is the "Drain-to-Source On-Resistance" rating? It should be very low (the part I used has a 16 milli-ohm rating).

squelch41 (author)BrianH2017-04-09

It is reporting 'test complete' too soon as the voltage drops below the threshold very early on.

It varies as to what it reports as mAh capacity - it will sometimes say 'test complete' after only a very short time and say capacity of a few mAh only.

This is the FET I am using

I did also try with

BrianH (author)squelch412017-04-09

I see that the F12N10L spec says 200 milli-ohms and the FQP30N06L says 35 milli-ohms. I would think this is probably OK.

You said "Total resistance battery --> load resistor -->fet --> ground (when fet held at 5v manually) is 6Ohms"

How did you get this number?

Since you are testing lower capacity AAA batteries instead of AA batteries, I would try reducing the load by changing the resistor to 7 ohms (the 2.5 ohms is drawing too much power) This will reduce the drain to about 171 mA which is more appropriate for the smaller cell. Be sure to change the code to match the resistor's actual value (not the sum of resistor plus FET).

This would explain the lower than expected voltage displayed, and why the tester is stopping early (this is protection from over-discharging which is bad for batteries). I would expect about 300mAh for Ni-Cads and 600 to 800 for NiMh AAA calls (depending on manufacturer and age). Also: Be sure to use thick wire for the discharge path.

squelch41 (author)BrianH2017-04-11

Thanks for your advice.

I changed the resistor to a 10ohm one and updated the LOAD_RESITANCE to 10 accordingly. (I am using a 1M ohm resistor rather than 2M as a pull down)

At rest, the multimeter reads the AAA battery as 1.26v (NiMH 550mAh)

Using F12N10L:

The arduino program reads 0.78V after the 'detecting' phase (multimeter reads 1.25v) which pretty much instantly ends with the screen saying 0 mAh and then jumps to 1.33-1.34 at the 'test complete' phase (multimeter back to 1.26v).

If I apply 5v manually to the gate and measure current flow from the battery, draw is about 60mA

If I run 5v through the gate while the arduino is in the 'test complete' phase, the arduino calculated voltage is displayed at 0.3-0.6v whilst the multimeter reads a steady 1.25v on the battery.

Using the FQP30N06L, the same thing happens though it reads a voltage of 0.439v at the test phase before rapdily stopping and reading 1.36v

I really can't figure out what I'm doing wrong.

TrAx Palicaru made it! (author)2016-10-09

I make it for li-ion

code on

BrianH (author)TrAx Palicaru2017-04-08

Nice job - I like the layout with the attention to high-wattage resistors and thick wire.

haselot (author)2017-01-09

Actually we can recondition batteries in simple way

Thank you Gregory ! :)

niq_ro made it! (author)2016-07-19

I'm in test the schematic just with for 2 battery, phically I put just one :))

matthiasl2 (author)2016-03-16

Nice project!

But there is a little indistinctness:

It is assumed that the VREF Voltage is permanently 5V, but this would never happend! (Depends on the power supply....)

Remedy: Use the internal VREF 1.1V and use the variable:

Code getting the real internal voltage (sorry, original author is unknown to me):

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);


ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);


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


So with this function you get back a int value like 4988 (4,98V), so you have to exchange in the code the lines like:

[482] return map(analogRead(battery[batteryNum].batteryVoltagePin), 0,1023,0,5000);


return map(analogRead(battery[batteryNum].batteryVoltagePin), 0,1023,0,readVCC());

Uggy (author)matthiasl22016-05-01

Hi matthiasl2,

Great modification, much more accurate and easier than changing 5000 in code !

I modified like this

long readVcc() {
ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
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


return map(analogRead(battery[batteryNum].batteryVoltagePin), 0,1023,0,readVcc());


return map(analogRead(battery[batteryNum].fetVoltagePin), 0,1023,0,readVcc());

Thx !!!! :)

MarcinK46 (author)Uggy2016-06-11

Would it be possible for You to post the entire code with the changes?

frabo made it! (author)2015-10-10

@BrianH. Thanks for this instructable. After dabling myself with a similar project using the Arduino IDE monitor and relais to switch the load I came across your project. As has been commented before I must commend you for writing such clear code. It enabled me to adapt the code to make use of all four battery bays that are in the box of the commercial battery charger that I used to hold the batteries. I've used an arduino pro mini controller which has 8 analog inputs so I made the most of it.

MaudaM (author)frabo2016-03-03

2frabo: Can you share your code for four battery bays, please? I can rebuild the same old-charger :) Thank you in advance.

MaudaM (author)2016-03-02

This looks like a similar product:

YerzhanM (author)2015-11-03

Want to ask if this circuit (project) charges and then discharges the battery? And if yes, can I make multiple desired amount of cycles of charging discharging process?

Uggy (author)YerzhanM2016-02-13

It does not charge the battery. It discharge it.

By discharging, it can measure the battery capacity.

carloszoom3000 (author)2015-10-29


I was able build it, however when not using 1 battery (1 transistor) it shows the other 2 are not connected, but it shows nore than 1V and the mAh start to increment even if there's no battery in the compartment.

Any help will be appreciated.


This is how the project looks like

Uggy made it! (author)2015-10-23

Hi Brian,

Great idea, great job!

Just finished to build it on breadboard and it looks like it's working \o/.

My main goal was to test 18650 batteries (Li-Ion / 3.7V) . So I modified as folow:

- 10 Ohms Load resistor. (10W)

So around 370mA discharge current, wich should give around 6 hours in theory to discharge a 2500mA cell. 3.7V x 0.37A = 1.4W Power (so 10W is fine and is around 45 degrees celcius during discharge)

- I used a MTP50N06V Mosfet and Arduino Nano clone

- I modified variables in code to match Nano pins and LOAD_RESISTANCE -> 10 MAX_VOLTAGE -> 4300 and NIMH_MIN_VOLTAGE -> 3600 (NIMH could be renamed later)

So need further testing, and moving all to the stripboard...

Great work Brian.

Thank you

PsychoDrake (author)2013-02-09

hi, im doing this project too and have a arduino uno. I have download the pde but when i try upload to arduino apear this:
can help?

Mattef (author)PsychoDrake2015-10-23

Have you installed the PCD8544 library?

If not, put the directory PCD8544 downloaded from into your Arduino library folder.

RafaelN13 (author)2015-10-02

Is it possible to use a coil relay instead of MOSFET?

xtreamx2 (author)2015-07-12

My circuit is slightly different because instead I used Rload 2.5Ω 2.2Ω (code changed). 2MΩ has been changed to 2.2MΩ (only one was available). The transistor is STP80NF55-06 (0.0065Ω).

I question what I'm doing wrong that the circuit detects battery and works only 3 seconds and then shows you a "test complite". Unfortunately, Arduino I am still too weak to deal with it. My English is not better :(

4r1y4n (author)2015-02-25


I created the circuit with a bit change in schematic & code and added a push button to trigger test; so before pushing the button it only displays the battery voltage & after that it begins the test; the strange thing is before test (before turning on the FET) battery voltage that arduino reads is the same value I measure with a multimeter but after turning on the FET battery voltage drops about 0.2V ( e.g. 3.97 becomes 3.80)

the more strange thing is after the test finishes that 0.2 comes back again!! and 2.7v becomes 2.9v !!

Why this happens? am I doing something wrong?

BrianH (author)4r1y4n2015-05-28

Your results are normal. A battery with a load on it will have a drop in voltage due to the battery's 'internal resistance'. An ideal battery would have zero internal resistance, but real-world batteries are imperfect, and act as if there is a small (fractions of an ohm) resistor in series inside the cell. This is the cause of the voltage drop that you see. This is why you should test a battery with a typical load on it rather than just a voltmeter for a better idea of the battery's true state.

dk_bis made it! (author)2014-11-10

It works! Thank you! Only minor changes - correct LCD connecting pins and comment out the strings about third battery. But I'm a little confused - it shows the reduced voltages (about -0.03V) when compared with measurements of battery with multimeter. Is my multimeter wrong or LOAD_RESISTANCE is measured with error?

BrianH (author)dk_bis2015-05-28

The 0.03 V difference is an acceptable tolerance - it should not affect your testing. It could be due to an resistor that is not exactly the correct value - or the Arduino A/D converter may be a little bit off.

Caudex (author)2014-03-02

Is it possible to modify this so that it can be used to test Lithium Ion batteries for cell phones?

sadeghjun (author)2014-01-18

Hi brayanH.

Thanks a lot for your good and useful project.

I'm bigginer. Is it possible for you to give me this project with 2x16 lcd and in a circut without Arduino board?



professorred (author)2013-03-09

Hi. I am having a couple problems here. I have built this but used 22 ohm load resistors and changed the code to match. the thing is that on 2500 mAh NiMH batteries that I am testing, I am getting over 1.3V and over 9999 mAh (then the capacity reading goes to ****). I am thinking that there is something wrong here.

Please help. Thank you.

BrianH (author)professorred2013-03-16

The 22 ohm resistor that you are using is almost 9 times larger than the value that I chose - this of course reduces the discharge rate and will cause the battery to take about 9 times longer to discharge - probably not an ideal way to test the battery, but since you changed the code (#define LOAD_RESISTANCE 22) the algorithm should work. Have you check the 22 ohm resistor to make sure it really reads 22 ohms? Is your MOSFET ok? As for the 1.3V - That is reasonable for fully charged NiCads/NiMh batteries.

professorred (author)BrianH2013-03-16

Thank you for the response. As far as time goes, I do not mind it taking a long time. I used the measured value of the resistor in the code. I am not sure on the mosfet but it should be ok. I am getting the same result on all three batteries. I was curious about the voltage as that was after the circuit removed about 10,000 mAh on a 2,500 mAh battery. I am just confused.

BrianH (author)professorred2013-03-18

It sounds like the battery is not getting discharged at all if it still reads 1.3V. I'm thinking that the MOSFET might not be turning ON to start the discharge. What is the part number of MOSFET are you using? Are you sure you are have the Drain, Source and Gate wired correctly?

professorred (author)BrianH2013-03-18

I could be wrong (I do not have it in front of me) but I believe that it is a MTP50N06V bought at RP Electronics. I used the blink sketch to control it and measured drain to source resistance. It went very low then very high.

wasteoinc (author)2012-11-24

you are definitely right, thanks

one more small question if the resistances in parallel are different in value between them (but have the same total value) will the power be distributed equally between them or not. my hunch says no, but your answer would be more credible

BrianH (author)wasteoinc2013-03-16

Your hunch is correct - you'll have to do the math on each resistor. Power dissipation in each resistor = Voltage squared divided by the resistance. The voltage will be the same for all parallel resistors, but the different resistance values will affect the individual resistor's power dissipation.

HarleyDK (author)2013-01-26

What about higher voltage, like Li-Po or Li-Ion, would that be possible?
Otherwise nice circuit, I also have some Ni-Mh to test

BrianH (author)HarleyDK2013-03-16

I designed the circuit with NiMh and NiCd in mind (1.2v). A minor redesign would be necessary to test higher voltage batteries - the discharge resistor would need to be properly sized for discharge rate, and power dissipation. Small changes needed to the code too.

staryhad (author)2013-02-22

Hi, I am getting different results with the same battery in 1st and 2nd battery bay (3rd bay is not connected, just grounded via the 2MOhm resistor). in bay1 it reads voltage above 1V and will start testing, however in bay2 it reads voltage just above 0,8V and will not test. in general it seems the voltage is always detected lower in bay2 (e.g. when I test 2 batteries and swap them, the 2nd bay always reads lower than the 1st). any idea what could it be?

BrianH (author)staryhad2013-03-16

Double check your wiring, and make sure that you use heavy gauge wire for the wires in the discharge path - especially the ground wire - otherwise the resistance in the wire will affect the readings. Does the battery in bay#2 read low voltage when it is the only battery under test - or just when it is tested in pairs?

staryhad1 (author)2013-03-13

@ PsychoDrake

you need to have the PCD8544 library in your Arduino\libraries directory. download it from and extract to the abovementioned directory.
posting as a new topic, as it doesn't let me to post as a reply for an unknown reason...

wasteoinc (author)2012-09-02

very nice project, one small correction and one small question

if you dont have a high power resistor, then you should connect 2 or 3 smaller of them in series not in parallel. 2x 1W resistors in series will withstand 2W of power :)

and the question is . while I have many power resistors around I dont have 2,5 ones. what would be the safe values to pursue ??

thanks again for the nice project :)

BrianH (author)wasteoinc2012-11-23

There are two ways to get the desired resistance. Using several series resistors of smaller value as you suggested is one way, but you may have trouble finding the values you desired. Since I had higher valued resistors available to me, I chose to use a parallel circuit to achieve the 2.5 ohms. The correct value can be achieved with four 10 ohm resistors in parallel yielding 2.5 ohms, and the power is dissipated (as heat) equally in the four resistors. This can be calculated by the formula Power = Voltage squared divided by the resistance (see If the FET was a perfect switch (zero ohms) then the single 2.5 ohm resistor would have 1.2 volts across it, and the power dissipated would be 0.576 watts. If we use four 10 ohm resistors in parallel, then using the above formula, each resistor dissipates only 0.144 watts. (Since the FET does have a small voltage drop across it, the actual voltage across the resistor is a bit lower - and therefore the power dissipated is lower).

If you choose to use a different value for the resistor, the code must be modified appropriately.
Ideally the load resistor should be chosen to draw the amount of current that you expect from the device you want to use the batteries in.

visuallabs (author)2011-07-22

Hey, Cool TUT
But The Code Isn't Opening In
Arduino IDE
Please Can You Send It To: OR

BrianH (author)visuallabs2011-08-24

You should be able to download the code from page 5 of the instructable.
Click on Rechargeable_Battery_Capacity_Tester.pde

If you are using Windows, It downloads with a weird filename (ending in .tmp)
you will need to rename it to "Rechargeable_Battery_Capacity_Tester.pde"

You will also need to get the file PCD8544.h it's a library from
(google search for this file)

About This Instructable




More by BrianH:Car Podcast downloader and playerThe Household InformerRechargeable Battery Capacity Tester
Add instructable to: