Introduction: DIY Arduino Battery Capacity Tester - V2.0
Nowadays fake Lithium and NiMH batteries are everywhere and are sold by advertising with higher capacities than their true capacity. So it is really difficult to distinguish between a real and a fake battery. Similarly, it is difficult to know the capacity retained in the salvaged 18650 laptop batteries. So, a device is required to measure the true capacity of the batteries.
In the year 2016, I have written an Instructable on " Arduino Capacity Tester - V1.0 " which was a very straightforward and simple device. The earlier version was based on Ohms Law. The battery to be tested is discharged through a fixed resistor, current and time duration is measured by Arduino, and capacity is calculated by multiplying both the readings ( Discharge current and time ).
The drawback of the earlier version was that during the testing, the battery voltage decreased, and the current also decreases which make the calculations complex and inaccurate. To overcome this, I have made the V2.0 which is designed in such a way that the current will remain constant throughout the discharging process. I made this device by inspiring the original design by MyVanitar
The main features of Capacity Tester V2.0 are :
1. Capable of measuring the capacity of AA / AAA NiMh / NiCd, 18650 Li-ion, Li-Polymer, and Li FePO4 battery. It is suitable for almost any kind of battery rated below 5V.
2. Users can set the discharge current by using pushbuttons.
3. OLED user Interface
4. The device can be used as an Electronic Load
Update on 10.08.2022
You can order the fully assembled board ( V2.1 ) from my Tindie Store.
Support me On Patreon:
If you enjoy my work here on Instructables, consider joining my Patreon, it will be a great help for me to make more interesting projects in the future.
Patreon Link: https://www.patreon.com/opengreenenergy
Update on 02.12.2019
Now you can order the PCB and components together in a kit from PCBWay
Disclaimer:Please note that you are working with Li-Ion battery which is highly explosive and dangerous. I cannot be held responsible for any loss of property, damage, or loss of life if it comes to that. This tutorial was written for those who have knowledge of rechargeable lithium-ion technology. Please do not attempt this if you are a novice. Stay Safe.
Supplies
Components Used
Now Order PCB and all the components to build this project in a kit from PCBWay
1. PCB: PCBWay
2. Arduino Nano: Amazon / Banggood
3. Opamp LM358: Amazon / Banggood
4. Voltage Reference (LM385BZ-1.2): ( Amazon )
5. 0.96" OLED display : Amazon / Banggood
6. Ceramic Resistor: Amazon / Banggood
7. Capacitor 100nF : Amazon / Banggood
8. Capacitor 220uF: Amazon / Banggood
9. Resistors 4.7K & 1M : Amazon / Banggood
10. Push Button: Amazon / Banggood
11. Push-Buttons Cap: Aliexpress
12. Screw Terminal: Amazon / Banggood
13. Prototype Board: Amazon / Banggood
14. PCB Stand-off: Amazon / Banggood
15. Heatshrink Tubing: Amazon/ Banggood
16. Heatsink: Aliexpress
Tools Used
1. Soldering Iron: Amazon / Banggood
2. Clamp Meter: Amazon / Banggood
3. Multimeter: Amazon / Banggood
4. Hot Air Blower: Amazon / Banggood
Step 1: Schematic Diagram
The whole schematic is divided into to followings sections:
1. Power Supply Circuit
2. Constant Current Load Circuit
3. Battery Voltage Measurement Circuit
4. User Interface Circuit
5. Buzzer Circuit
1. Power Supply Circuit
The power supply circuit consists of a DC Jack ( 7-9V) and two filter capacitors C1 and C2. The power output (Vin) is connected to the Arduino pin Vin. Here I am using the Arduino on-board voltage regulator to step down the voltage to 5V.
2. Constant Current Load Circuit
The main component of this project is LM358 dual amplifier. LM358 is a dual amplifier in a single package. However, in this project, only one op-amp is required. The PWM output from Arduino Pin D10 is connected to the first operational amplifier’s non-inverted pin. The PWM is filtered through a low pass filter ( R1 and C3 ) to get an equivalent analog voltage. Whereas, the Inverting input is acting as feedback for the operational amplifier which is connected between the IRLZ44N MOSFETsource pin and the 1R shunt resistor (R3).
This op-amp, R3, and the MOSFET build a constant current load circuit. When we set the voltage on the non-inverting input pin, the op-amp turns on the MOSFET and tries to get the same voltage across the R3. The Voltage appears due to the ohms law, as current flows through the resistor a voltage drop must appear. So now we can control the current through the load resistor (R4) by changing the PWM signal pulse width.
3. Battery Voltage Measurement Circuit
The battery voltage is measured by the Arduino analog input pin A0. Two capacitors C1 and C2 are used to filter out the noises coming from the constant current load circuit which can degrade the ADC conversion performance.
4. User Interface Circuit
The user interface circuit consists of two push buttons and a 0.96" I2C OLED display. The Up and Down push-button is to increase or decrease the PWM pulse width. R3 and R4 are pull-up resistors for the Up and Down push-buttons. C7 and C8 are used to debounce the push buttons. The third push-button (RST) is used for resetting the Arduino.
5. Buzzer Circuit
The buzzer circuit is used to alert the starting and end of the test. A 5V buzzer is hooked to Arduino digital pin D9.
Step 2: How Does It Work?
The theory is based on the voltage comparison of the inverting (pin-2) and the non-inverting (pin-3) inputs of the OpAmp, configured as a unity amplifier. When you set the voltage applied to the non-inverting input by adjusting the PWM signal, the output of the opamp opens the gate of MOSFET. As the MOSFET turn-on, the current runs through R1, it creates a voltage drop, which provides negative feedback to OpAmp. It controls the MOSFET in such a way that the voltages at its inverting and non-inverting inputs are equal. So, the current through the load resistor is proportional to the voltage at the non-inverting input of the OpAmp.
The PWM signal from the Arduino is filtered by using a low pass filter circuit ( R2 and C1). To test the PWM signal and filter circuit performance, I hooked up my DSO ch-1 at the input and ch-2 at the output of the filter circuit. The output waveform is shown above.
Step 3: Capacity Measurement
Here Battery is discharged to its low-level threshold voltage ( 3.2V).
Battery Capacity (mAh) = Current ( I ) in mA x Time (T ) in Hours
From the above equation it is clear that to calculate battery capacity (mAh), we have to know the current in mA and time in Hour. The designed circuit is a constant current load circuit, so the discharge current remains constant throughout the testing period.
The discharge current can be adjusted by pressing the Up and Down Button. The time duration is measured by using a timer in the Arduino code.
Step 4: Making the Circuit
In the previous steps, I have explained the function of each of the components in the circuit. Before jump to make the final board, test the circuit on a breadboard first. If the circuit works perfectly on the breadboard, then move to solder the components on the prototype board.
I used the 7cm X 5cm prototype board.
Mounting the Nano: First cut two rows of female header pin with 15 pins in each. I used a diagonal nipper to cut the headers. Then solder the header pins. Be sure the distance between the two rails fits the Arduino nano.
Mounting OLED Display: Cut a female header with 4pins. Then solder it as shown in the picture.
Mounting the terminals and components: Solder the remaining components as shown in pictures.
Wiring: Make the wiring as per the schematic. I used colored wires to make the wiring so that I can identify them easily.
Step 5: OLED Display
To display the Battery Voltage, discharge current and capacity, I used a 0.96" OLED display. It has 128x64 resolution and uses an I2C bus to communicate with the Arduino. Two pins SCL (A5), SDA (A4) in Arduino Uno are used for communication.
I am using the Adafruit_SSD1306 library to display the parameters.
First, you have to download the Adafruit_SSD1306. Then installed it.
The connections should be as follows
Arduino --> OLED
5V --->VCC
GND -->GND
A4----> SDA
A5----> SCL
Step 6: Buzzer for Warning
To provide alerts during the start and competition of the test, a piezo buzzer is used. The buzzer has two terminals, the longer one is positive and the shorter leg is negative. The sticker on the new buzzer has also " + " marked to indicate the positive terminal.
As the prototype board doesn't have enough room to place the buzzer, I have connected the buzzer to the main circuit board by using two wires. To insulate the bare connection, I have used heat shrink tubing.
The connections should be as follows
Arduino --> Buzzer
D9--> Positive terminal
GND--> Negative terminal
Step 7: Mounting the Standoffs
After soldering and wiring, mount the standoffs at 4 corners. It will provide sufficient clearance to the soldering joints and wires from the ground.
Step 8: PCB Design
I have drawn the schematic by using EasyEDA online software after that switched to the PCB layout.
All of the components you added in the schematic should be there, stacked on top of each other, ready to be placed and routed. Drag the components by grabbing on its pads. Then place it inside the rectangular borderline.
Arrange all the components in such a way that the board occupies minimum space. Smaller the board size, the cheaper will be the PCB manufacturing cost. It will be useful if this board has some mounting holes on it so that it can be mounted in an enclosure.
Now you have to route. Routing is the most fun part of this entire process. It’s like solving a puzzle! Using the tracking tool we need to connect all the components. You can use both the top and the bottom layer for avoiding overlap between two different tracks and making the tracks shorter.
You can use the Silk layer to add text to the board. Also, we are able to insert an image file, so I add an image of my website logo to be printed on the board. In the end, using the copper area tool, we need to create the ground area of the PCB.
You can order it from PCBWay.
Sign up PCBWay now to get a US $5 coupon. That means your first order is free of cost only you have to pay the shipping charges.
When you place an order, I will get 10% donation from PCBWay for a contribution to my work. Your little help may encourage me to do more awesome work in the future. Thank you for your cooperation.
Step 9: Assemble the PCB
For Soldering, you will need a decent Soldering Iron, Solder, Nipper and a multimeter.It is good practice to solder the components according to their height. Solder the lesser height components first.
You can follow the following steps to solder the components :
1. Push the component legs through their holes, and turn the PCB on its back.
2. Hold the tip of the soldering iron to the junction of the pad and the leg of the component.
3. Feed solder into the joint so that it flows all around the lead and covers the pad. Once it has flowed all around, move the tip away.
Step 10: Software & Libraries
First, download the attached Arduino Code. Then download the following libraries and install them.
Libraries:
Download and install the following libraries:
1. JC_Button: https://github.com/JChristensen/JC_Button
2. Adafruit_SSD1306: https://github.com/JChristensen/JC_Button
In the code, you have to change the following two things.
1. Current Arrays values: This can be done by connecting a multimeter in series with the battery. Press the up button and measure the current, the current values are the elements of the array.
2. Vcc: You use a multimeter to measure the voltage at the Arduino 5V pin. In my case it is 4.96V.
Updated on 20.11.2019
You can change the Low_BAT_Level value in the code as per the battery chemistry. It is better to take a little margin over the cut-off voltage stated below.
Here is the discharge rates and cutoff voltages for various Lithium-Ion Battery chemistries:
1. Lithium Cobalt Oxide: Cut-off Voltage = 2.5V at 1C discharge rate
2. Lithium Manganese Oxide: Cut-off Voltage = 2.5V at 1C discharge rate
3. Lithium Iron Phosphate: Cut-off Voltage = 2.5V at 1C discharge rate
4. Lithium Titanate: Cut-off Voltage = 1.8V at 1C discharge rate
5. Lithium Nickel Manganese Cobalt Oxide: Cut-off Voltage = 2.5V at 1C discharge rate
6. Lithium Nickel Cobalt Aluminum Oxide: Cut-off Voltage = 3.0V at 1C discharge rate
Updated on 01.04.2020
jcgrabo, suggested some changes to the original design to improve the precision. The changes are listed below:
1. Add a precision reference (LM385BLP-1.2) and connected it to A1. During setup, read its value which is known to be 1.215 volts, and then calculate Vcc thereby eliminating the need to measure Vcc.
2.Replace the 1 ohm 5% resistor with a 1 ohm 1% power resistor thereby reducing errors that depend on the value of the resistance.
3. Rather than using a fixed set of PWM values for each current step (in increments of 5) create an array of desired current values that used to compute the necessary PWM values to achieve those current values as close as possible. He followed that by calculating the actual current values that will be achieved with the computed PWM values.
By considering the above changes, he revised the code and shared it in the comment section. The revised code is attached below.
Thank you so much jcgrabo for your valuable contribution to my project. I hope this improvement will be helpful for many more users.
Step 11: Conclusion
To test the circuit, first I charged a good Samsung 18650 battery using my ISDT C4 Charger. Then connect the battery to the battery terminal. Now set the current to according to your requirement and long-pressed the “UP” button. Then you should hear a beep and the test procedure starts. During the test, you will monitor all the parameters on the OLED display. The battery will discharge until its voltage reaches its low-level threshold (3.2V). The test process will be finished by two long beeps.
Note: The project is still under development stage. You can join me for any improvements. Raise comments if any mistakes or errors. I am designing a PCB for this project. Stay connected for more updates to the project.
Hope my tutorial is helpful. If you like it, don't forget to share :) Subscribe for more DIY projects. Thank You.
103 Comments
Tip 8 months ago
Built a circuit based on this & the referenced original - perfect Nano project.
I used LM358's 2nd op-amp as a buffer/amp, added some smoothing caps & series resistors to the analog inputs, all of which improve voltage measurments - that's what these projects are for, experiment, scratch head, learn, repeat... for fun ;-)
Still, I found voltage measurements varying from expectation, particularly as current increased. Drove me a bit crazy. Finally traced it down to the resistance in the battery holder & its thin wires. With 1R shunt resistance & the mosfets minimal vDrop, 0.35R is significant; I ended up noting 0.4v drop in the battery holder & it's wires, which is a third of the 18650's voltage drain (4.2v -> 3.0v)! Gen'ed up a solid holder, with 18ga. wire, and reduced drop to about 25mV... now getting much more consistent results.
Reply 2 months ago
Hi
At higher current draw I am having the same issue where the battery voltage is showing an incorrect lower value. I used thicker wires to the battery but it still did not solve the problem. My project is still on a breadboard. Could the other wires (dupont wires) being used on the breadboard be a problem because they are too thin?
Question 1 year ago
Hello and thank you for this project.
I tried to do this but I ran into a problem that I couldn't solve.
when I ask I = 100 mA the program tells me 3.2v in battery voltage and locks in safety
which
is logical because the more I increase the intensity, the more the
voltage drop in RLOAD becomes important and distorts the measurement in
A0
tests showed me:
I = 0 mA V Bat = 4.10 V
I= 23mA Vbat= 3.99V
I= 100mA VBat = 3.65v
We can therefore see that the more I increases, the closer it gets to 3.2V
How to measure that VBattery please?
Answer 2 months ago
Hi
Have you been able to solve this problem? I am having the same issue.
4 months ago
Hey guys did anyone made this circuit using an adafruit ST7735 1.8" display??
Question 7 months ago
Hi, I build the circuit on a breadboard according to rev. 2.1 but it does not work properly. I have rebuild it several times now but no succes. The nano will start and the display will light up as soon as I connect a battery to test. Next the display shows a higher voltage, up to 5,1 V so it seems the tester tries to discharge the power input. I have tried different input sources, i.e. a 9 V battery to VIN and an USB connection. None did work propery. What am I doing wrong? Please help.
Question 11 months ago
Can we use a IRFZ44 instead of a IRLZ44 due to unavailability?
Answer 9 months ago
No, any logic level MOSFET will work.
Question 10 months ago
When I use the PWM 50 with about 1a discharge and controll the output ampere with a clamp amperemeter this only show about 225mA
Question 11 months ago on Step 11
Why did you use the Nano? Just for the programming plug? A pro-mini would do the job with a much lower footprint, as 12v power, 3.3v reference of the Nano were not used.
3 years ago
After assembling V2.0 I decided to make some changes to improve its precision.
1. I added a precision reference (LM385BLP-1.2) and connected it to A1. During setup I read its value which I know to be 1.215 volts and then calculate Vcc thereby eliminating the need to measure Vcc.
2. I replaced the 1 ohm 5% resistor with a 1 ohm 1% power resistor thereby reducing errors that depend on the value of the resistance.
3. Rather than using a fixed set of PWM values for each current step (in increments of 5) I created an array of desired current values that I used to compute the necessary PWM values to achieve those current values as close as possible. I followed that by calculating the actual current values that will be achieved with the computed PWM values.
The above steps resulted in measured current values within a couple of milliamps of the ones the program is using to measure capacity.
Reply 11 months ago
For vcc there's an easier route.
I'm using a Ref02 Precision 5V connected as external reference.
Use 2x 1K 0,1% as divider network, connect the middle to a analog pin, mesure it multiply by 2 and you have you're vcc. However, one might take regular samples and average them, in case vcc fluctuates. I'm using a lgt8f328p (nano style) instead of the original arduino nano. It's cheaper, has 12bit adc and can run 32Mhz (not that speed is critical here). Do keep in mind that the Ref02 does at least need 8V input. I'm running on a 12V psu.
@opengreenenergy:
Add the folowing var to setup:
int Discharge_Pwm = 0;
and change the loop to this:
void loop() {
UP_Button.read();
Down_Button.read();
if (UP_Button.wasReleased() && PWM_Index < (Array_Size-1) && calc == false)
{
PWM_Value = PWM[++PWM_Index];
//analogWrite(PWM_Pin,PWM_Value);
Discharge_Pwm = PWM_Value;
Display_UP_DOWN();
}
if (Down_Button.wasReleased() && PWM_Index > 0 && calc == false)
{
PWM_Value = PWM[--PWM_Index];
//analogWrite(PWM_Pin,PWM_Value);
Discharge_Pwm = PWM_Value;
Display_UP_DOWN();
}
if (UP_Button.pressedFor (1000) && calc == false)
{
digitalWrite(Buzzer, HIGH);
delay(100);
digitalWrite(Buzzer, LOW);
display.clearDisplay();
analogWrite(PWM_Pin,Discharge_Pwm);
timerInterrupt();
}
}
That way, you start discharging at the selected current after you long press the button instead of when selecting the current allready.
And one other thing I forgot. Never connect a power source directly to an analog input. It may damage whatever ucontroller you are using. If you unplug vcc, you get back-powering. The current is flowing into the input pin and then flowing up through the ESD protection diode inside the chip to VCC. It's bad, because the ESD protection diode can't take much current and is easy to damage. unpowered you may have only -0,5 - +0,5V in reference to ground.
You could add a mosfet to detach the battery from the input of the arduino and power the gate from a digital out. However connect a resistor from the gate to the ground as well to not get in a floating state. 100K should be fine. It will remove the 30-40mA that some people are seeing without discharging.
Reply 1 year ago
I can't find LM385BLP around here, any suggest for substitute component ?
Reply 3 years ago
Congratulations on your build.
I would like to see some pictures.
Please share the schematic and codes that you have done. I would like to include it in this instructable.
Reply 3 years ago
My notes along with images of the bottom of the board with the Band Gap Reference attached in a dead bug fashion. The top of the board shows the replacement of the 1 ohm 5% power resistor with a Dale 1 ohm 1% 7.5 watt power resistor. I am not familiar how to upload the modified sketch.
My sketch follows:
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
// ARDUINO BATTERY CAPACITY TESTER
//Version-2.0
//by deba168,INDIA // The code is taken from Hesam Moshiri ( https://www.pcbway.com/blog/technology/Battery_capacity_measurement_using_Arduino.html )
//Dated : 20/10/2019
//
//Dated : 29/02/2020
//Added code to read a band gap reference connected to analog pin A1,
// thus allowing measurement of Vcc and avoiding the need to measure it using a multimeter
//Replaced 1 ohm 5% resistor with 1 ohm 1% power resistor
//Modified code to compute actual current draw based on desired values. Measurements
// using ammeter show computed values within 2 milliamps of measured
//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#include<JC_Button.h>
#include <Adafruit_SSD1306.h>
#define DEBUG 0 // Binary Treatment 0=Nothing, 1=Early, 2=Running Voltages, 4=Finish
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET 4 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
void timerInterrupt();
void Display_UP_DOWN();//Debugging support
void Print_DEBUG_4();//Debugging support
const float Low_BAT_level = 2.80;// Threshold for stopping test
//Desired Current steps with a 3R load (R7)
int Current [] = {0,50,100,200,300,400,500,600,700,800,900,1000};
int PWM [] = {0, 2, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50};
int Array_Size;// calculated during setup
const byte PWM_Pin = 10;
const byte Buzzer = 9;
const int BAT_Pin = A0;
const int Vref_Pin = A1;//Pin to which Band Gap Reference is attached
int Current_Value = 0; // Selected Current value for test
int PWM_Value = 0;// Value of PWM during test
int PWM_Index = 0;// Index into PWM array during test
unsigned long Capacity;
float Capacity_f;
int ADC_Value = 0;
float Vref_Voltage = 1.215; // LM385BLP-1.2 Band Gap Reference voltage
float Vcc = 5.32; // Voltage of Arduino 5V pin ( Measured during setup using Band Gap Reference )
float BAT_Voltage = 0;
float Resistance = 1.0; // Value of R3 Power Resistor
float sample = 0;
byte Hour = 0, Minute = 0, Second = 0;
bool calc = false, Done = false, Report_Info = true;
Button UP_Button(2, 25, false, true);
Button Down_Button(3, 25, false, true);
// string values for reporting intermediate information
const int VAL_MAX = 10;
char val_0[VAL_MAX]={""};
char val_2[VAL_MAX]={""};
void setup () {//Setup
Serial.begin(38400);
pinMode(PWM_Pin, OUTPUT);
pinMode(Buzzer, OUTPUT);
analogWrite(PWM_Pin, PWM_Value);
UP_Button.begin();
Down_Button.begin();
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
display.clearDisplay();
display.setTextColor(WHITE);
display.setTextSize(1);
display.setCursor(12,25);
display.print("Open Green Energy");
display.display();
delay(3000);
display.clearDisplay();
display.setTextSize(2);
display.setCursor(2,15);
display.print("Adj Curr:");
display.setCursor(2,40);
display.print("UP/Down:");
display.print("0");
display.setCursor(2,55);
display.setTextSize(1);
#if (DEBUG == 1 || DEBUG == 5)
Serial.println("\nStart of calculations");
#endif
Array_Size = sizeof(Current)/2;
//Read voltages of Band Gap Reference and use it to calculate actual Vcc
float fTemp=0.0;
for(int i=0;i< 100;i++)
{
fTemp=fTemp+analogRead(Vref_Pin); //read the Band Gap Reference voltage
delay (2);
}
fTemp=fTemp/100.0;
Vcc = Vref_Voltage * 1024.0 / fTemp;
// Convert desired current levels to PWM using actual Vcc
// Convert PWM values back to actual current levels
// While measuring actual current I discovered that the actual draw is
// (PWM + 1)/256 rather than PWM/255 as indicated in Arduino documentation
int iTemp;
for (int i=0;i<Array_Size;i++)
{
iTemp = int( Resistance * Current[i] * 256.0 / Vcc / 1000.0 - 1.0 + 0.5 ); // desired current to nearest PWM
iTemp = min(iTemp,255);
iTemp = max(iTemp,0);
Current[i] = int( (iTemp+1) * Vcc / 256.0 / Resistance * 1000.0); // actual current for PWM
PWM[i] = iTemp;//Save PWM in array
}
//Include Threshold and Vcc in startup display
dtostrf(Low_BAT_level, 5, 3, val_0);
dtostrf(Vcc, 5, 3, val_2);
display.print("Thr=");
display.print(val_0);
display.print("v, Vcc=");
display.print(val_2);
display.display();
display.setTextSize(2);
}//Setup
//************************* End of Setup function *******************************
void loop() {
if (Report_Info)
{//Report_Info
Serial.flush();
#if (DEBUG == 1 || DEBUG == 5)
// Serial.println("Measured Vcc Voltage: " + String(Vcc) + " volts");
Serial.print("Threshold: ");
Serial.print(Low_BAT_level,3);
Serial.println(" volts");
Serial.print("R3 Resistance: ");
Serial.print(Resistance,3);
Serial.println(" ohms");
Serial.print("Measured Vcc Voltage: ");
Serial.print(Vcc,4);
Serial.println(" volts");
sample = 0.0;
Serial.println("Index Actual(mA) PWM");
for (int i=0;i<Array_Size;i++)
{
// Serial.println( "["+String(i)+"]="+String(Current[i])+" mA PWM["+String(i)+"]="+String(PWM[i]) );
Serial.print("[");
Serial.print(i);
Serial.print("]");
Serial.print(" ");
Serial.print(Current[i],DEC);
Serial.print(" ");
Serial.print(PWM[i],DEC);
Serial.println(" ");
}
#endif
Report_Info = false;
}//Report_Info
UP_Button.read();
Down_Button.read();
if (UP_Button.wasReleased() && PWM_Index < (Array_Size-1) && calc == false)
{
PWM_Value = PWM[++PWM_Index];
analogWrite(PWM_Pin,PWM_Value);
Display_UP_DOWN();
}
if (Down_Button.wasReleased() && PWM_Index > 0 && calc == false)
{
PWM_Value = PWM[--PWM_Index];
analogWrite(PWM_Pin,PWM_Value);
Display_UP_DOWN();
}
if (UP_Button.pressedFor (1000) && calc == false)
{
digitalWrite(Buzzer, HIGH);
delay(100);
digitalWrite(Buzzer, LOW);
display.clearDisplay();
timerInterrupt();
}
}
//************************* End of Loop function *******************************
void timerInterrupt(){
calc = true;
while (Done == false) {//(Done == false)
Second ++;
if (Second == 60) {
Second = 0;
Minute ++;
}
if (Minute == 60) {
Minute = 0;
Hour ++;
}
//************ Measuring Battery Voltage ***********
for(int i=0;i< 100;i++)
{
sample=sample+analogRead(BAT_Pin); //read the Battery voltage
delay (2);
}
sample=sample/100;
BAT_Voltage = sample * Vcc / 1024.0;
//*********************************************
display.clearDisplay();
display.setTextSize(2);
display.setCursor(20,5);
// display.print(String(Hour) + ":" + String(Minute) + ":" + String(Second));
display.print(Hour);
display.print(":");
display.print(Minute);
display.print(":");
display.print(Second);
display.setTextSize(1);
display.setCursor(0,25);
display.print("Disch Curr: ");
// display.print(String(Current[PWM_Index])+"mA");
display.print(Current_Value);
display.print("mA");
display.setCursor(2,40);
// display.print("Bat Volt:" + String(BAT_Voltage)+"V" );
display.print("Bat Volt:");
display.print(BAT_Voltage,3);
display.print("V");
// When total seconds is greater than 32767 the statement below did not work until the byte values
// Hour, Minute and Second were cast to an unsigned long. Apparently the compiler cast the byte
// values to an "int" first which cannot represent 32768 correctly
Capacity = ((unsigned long)Hour * 3600) + ((unsigned long)Minute * 60) + (unsigned long)Second;
Capacity_f = ((float)Capacity * Current_Value) / 3600.0;
display.setCursor(2, 55);
// display.print("Capacity:" + String(Capacity) + "mAh");
display.print("Capacity:");
display.print(Capacity_f,1);
display.print("mAh");
display.display();
#if (DEBUG == 4 || DEBUG == 2)
Print_DEBUG_4();
#endif
if (BAT_Voltage < Low_BAT_level)
{//BAT_Voltage < Low_BAT_level
#if (DEBUG == 4 || DEBUG == 5)
Serial.println("\nCurrent_Value PWM_Value");
Serial.print(Current_Value);
Serial.print(" ");
Serial.println(PWM_Value);
Serial.println("\nHour Minute Second PWM_Index");
Serial.print(Hour);
Serial.print(" ");
Serial.print(Minute);
Serial.print(" ");
Serial.print(Second);
Serial.print(" ");
Serial.println(PWM_Index);
#endif
// When total seconds is greater than 32767 the statement below did not work until the byte values
// Hour, Minute and Second were cast to an unsigned long. Apparently the compiler cast the byte
// values to an "int" first which cannot represent 32768 correctly
Capacity = ((unsigned long)Hour * 3600) + ((unsigned long)Minute * 60) + (unsigned long)Second;
#if (DEBUG == 4 || DEBUG == 5)
Serial.println("Capacity HMS");
Serial.println(Capacity);
#endif
Capacity_f = ((float)Capacity * Current_Value) / 3600.0;
#if (DEBUG == 4 || DEBUG == 5)
Serial.println("Capacity HMS*PWM");
Serial.println(Capacity_f,1);
#endif
display.clearDisplay();
display.setTextSize(2);
display.setCursor(2,15);
display.print("Capacity:");
display.setCursor(2,40);
// display.print(String(Capacity) + "mAh");
display.print(Capacity_f,1);
display.print("mAh");
display.display();
Done = true;
PWM_Value = 0;
analogWrite(PWM_Pin, PWM_Value);
digitalWrite(Buzzer, HIGH);
delay(100);
digitalWrite(Buzzer, LOW);
delay(100);
digitalWrite(Buzzer, HIGH);
delay(100);
digitalWrite(Buzzer, LOW);
delay(100);
}//BAT_Voltage < Low_BAT_level
delay(1000);
}//(Done == false)
}// timerInterrupt
void Display_UP_DOWN()
{//Display_UP_DOWN()
Current_Value = Current[PWM_Index];
display.clearDisplay();
display.setCursor(2,25);
display.print("Curr:");
display.print(Current_Value);
display.print("mA ");
display.setCursor(2,40);
display.print("PWM=");
display.print(PWM_Value);
display.display();
}//Display_UP_DOWN()
void Print_DEBUG_4()
{//Print_DEBUG_4()
Serial.print(Hour);
Serial.print(":");
Serial.print(Minute);
Serial.print(":");
Serial.print(Second);
Serial.print(" ");
Serial.print(BAT_Voltage,3);
Serial.print("v ");
Serial.print(Capacity_f,1);
Serial.println("mAh");
}//Print_DEBUG_4()
Reply 2 years ago
Hi,
Thank you so much for your valuable contribution to this project. I have added this update to my Instructables today. You can see it on Step-10.
Reply 2 years ago
Great add-on, thanks for sharing. For those who would prefer to save on a cheaper 5% resistor or already have some (and they have a multimeter) they could measure the resistance of what they have and make adjustments in the Arduino code to compensate for the variation in resistance.
Reply 2 years ago
does it work with lm385z-1.2?
Reply 2 years ago
Yes. What is important is to have a known reliable reference to eliminate the need to measure the actual DC power being used to power the board. The actual current depends on the resistance being used and the DC voltage. USB ports are allowed to provide power over a wide DC range from 5.25 to 4.40 volts although the nominal is 5.0.
Reply 2 years ago
Very nice additions. Nicely done. Thank you very much for sharing.
I haven't created it yet, but planning to build one. I will definitely try these additions.
One doubt though. How did you find the value as 1.215 as reference in the calculation? Should it be typical voltage mentioned in the datasheet specs like 1.235 here as you mentioned in your hand written sheet?
If there are any calculations to find the value could you please share it.. That will be very helpful in understanding it.