{"id":499,"date":"2024-03-31T14:29:35","date_gmt":"2024-03-31T14:29:35","guid":{"rendered":"https:\/\/www.zonetronik.com\/en\/?p=499"},"modified":"2024-03-31T15:25:49","modified_gmt":"2024-03-31T15:25:49","slug":"arduino-battery-capacity-tester","status":"publish","type":"post","link":"https:\/\/www.zonetronik.com\/en\/arduino-battery-capacity-tester\/","title":{"rendered":"Battery capacity tester for Lithium, NiMH, and NiCd batteries with Arduino"},"content":{"rendered":"

The growing global interest in IoT and electric vehicles is driving a surge in the utilization of Lithium-Ion\/Lithium-Polymer\/NiCd\/NiMH batteries. These batteries are being increasingly employed across various devices and applications due to their high energy storage capacity relative to size. However, this heightened demand is also giving rise to an influx of batteries with misleading ampere-hour ratings in the market. Such false ratings pose a significant risk, potentially resulting in project failures, particularly in IoT endeavors where developers rely on battery ratings for on-time calculations.<\/p>\n

To address the risks associated with this issue, today’s tutorial focuses on constructing a battery capacity tester. This tester is designed to accurately determine the energy storage capacity of Lithium-Ion\/Lithium-Polymer\/NiCd\/NiMH batteries with voltages below 5 volts, thereby mitigating the potential failures caused by inaccurate battery specifications.<\/p>\n

There are numerous battery testing projects available on the internet, each with its own unique approach. However, for today’s tutorial, we will focus on the work of Instructables user Sam Moshiri. His project stands out for its high-quality build and its compact, standalone design. Moshiri aimed to create a device that could easily measure the capacity of nearly any type of battery (< 5V) using an adjustable constant load setup with an LCD for displaying battery capacity.<\/p>\n

The concept behind the constant load current setup is straightforward. By drawing a consistent current from a battery over a specific duration, it becomes possible to calculate the true ampere-hour capacity of the battery based on the voltage drop observed during that time. To achieve this constant load current, Moshiri utilized a resistor network featuring an LM358 operational amplifier and a MOSFET. The setup includes two push buttons (for adjusting load current) and a third push-button to reset the board for testing another battery. The battery’s voltage is fed into one of the analog pins on an Arduino Nano, which monitors the voltage drop corresponding to the preset current draw, calculates the battery capacity, and displays the result on a 16\u00d72 LCD display.<\/p>\n

By the end of this tutorial, you will not only understand how to determine battery capacity but also how to design for constant load\/current draw and incorporate a 16\u00d72 LCD display with an Arduino.<\/p>\n

Required components<\/h2>\n

The necessary components for this project include an Arduino Nano, a 16×2 LCD display, an LM358N operational amplifier, various resistors (4.7k\u03a9 (2), 47\u03a9 (2), 1M\u03a9, 10k\u03a9, 3R), capacitors (100nF (6), 100uF-16V, 1000uF-16V), three tactile switches, an IRF3710 MOSFET, jumper wires, a battery holder, and a variable power supply. While the project was implemented on a PCB for compactness, all components used are of the DIP type to facilitate soldering for individuals of varying soldering proficiency levels. The Arduino Nano was chosen for its ease of soldering onto a PCB, though alternative boards could have been utilized for similar purposes.<\/p>\n

Schematics<\/h2>\n

\"schematic-BATTERY-CAPACITY-TESTER-USING-ARDUINO\"<\/p>\n

Below is a comprehensive Bill of Materials (BOM) illustrating how each component corresponds to the schematics provided above:<\/p>\n

\"\"<\/p>\n

For PCB creation, Sam utilized the SamacSys component libraries due to their adherence to industrial IPC standards and their availability as free resources. These libraries were installed using the Altium Library plugin. The developed PCB is depicted in the image below, alongside the assembled version of the board.<\/p>\n

\"\"<\/p>\n

Code<\/h2>\n

The code for this project is relatively simple. Essentially, we’ll monitor the time it takes for a battery to reach a predefined “low” value, then calculate the battery’s capacity using the depletion rate and the preset constant load current it experienced. This entire process will be displayed interactively on an LCD.<\/p>\n

To streamline the code, we’ll utilize the Arduino LiquidCrystal library along with the JCButton library. The LiquidCrystal library, which comes pre-installed on Arduino, will handle interactions with the 16×2 LCD. Meanwhile, the JCButton library<\/a>, downloadable from the provided link, will manage the state of the tactile buttons, detecting presses, long presses, etc., and also handling debounce.<\/p>\n

As customary, I’ll provide a brief explanation of how the code operates, focusing on sections that may be challenging to grasp.<\/p>\n

The code begins by importing the two libraries that will be utilized.<\/p>\n

#include <LiquidCrystal.h>
\n#include <JC_Button.h><\/p><\/blockquote>\n

Afterward, we establish a variable to store the minimum allowable battery level and several other variables to hold various values. The “Current” array comprises a sequence of values corresponding to the rotation of the R7 potentiometer, which dictates the load current.<\/p>\n

const float Low_BAT_level = 3.2;
\n\/\/Current steps with a 3R load (R7)
\nconst int Current[] = {0, 37, 70, 103, 136, 169, 202, 235, 268, 301, 334, 367, 400, 440, 470, 500, 540};<\/p>\n

const byte RS = 2, EN = 3, D4 = 4, D5 = 5, D6 = 6, D7 = 7;
\nconst byte PWM_Pin = 10;
\nconst byte Speaker = 12;
\nconst int BAT_Pin = A0;
\nint PWM_Value = 0;
\nunsigned long Capacity = 0;
\nint ADC_Value = 0;
\nfloat BAT_Voltage = 0;
\nbyte Hour = 0, Minute = 0, Second = 0;
\nbool calc = false, Done = false;<\/p><\/blockquote>\n

Following that, we instantiate the Liquid Crystal library by specifying the Arduino pins to which the LCD is connected, including EN (Enable), RS (Register Select), and other necessary pins, as arguments.<\/p>\n

LiquidCrystal lcd(RS, EN, D4, D5, D6, D7);<\/p><\/blockquote>\n

We also create instances of the button library for the two major buttons (up and down).<\/p>\n

Button UP_Button(16, 25, false, true);
\nButton Down_Button(15, 25, false, true);<\/p><\/blockquote>\n

With this done, we move to the void setup() function. We start the function by setting the pinMode of the buzzer and PWM pin as output.<\/p>\n

void setup() {<\/p>\n

pinMode(PWM_Pin, OUTPUT);
\npinMode(Speaker, OUTPUT);<\/p><\/blockquote>\n

After this, we initialize the two buttons we created along with the LCD.<\/p>\n

UP_Button.begin();
\nDown_Button.begin();
\nlcd.setCursor(0, 0);
\nlcd.begin(16, 2);<\/p><\/blockquote>\n

Upon initializing the LCD, display a splash screen featuring the project name and version. After a 3-second delay, clear the display and prompt the user with the “Load Adj: up\/Down” button, indicating it is ready for the user to adjust the load current setting.<\/p>\n

lcd.print(“Battery Capacity”);
\nlcd.setCursor(0, 1);
\nlcd.print(“Measurement v1.0”);
\ndelay(3000);
\nlcd.clear();
\nlcd.print(“Load Adj:UP\/Down”);
\nlcd.setCursor(0, 1);
\nlcd.print(“0”);<\/p>\n

}<\/p><\/blockquote>\n

Next is the void loop() function. We start the function by reading the tact buttons<\/p>\n

void loop() {
\nUP_Button.read();
\nDown_Button.read();<\/p><\/blockquote>\n

Each time the Up button is pressed, it adds 5 to the Pwm_Value variable which is used as the load current indicator. The inverse is true for the Down button. For each of the button pressed, the user is provided with visual feedback of the increase or decrease in the PWM_value, on the Display.<\/p>\n

if (UP_Button.wasReleased() && PWM_Value < 80 && calc == false) { PWM_Value = PWM_Value + 5; analogWrite(PWM_Pin, PWM_Value); lcd.setCursor(0, 1); lcd.print(” “); lcd.setCursor(0, 1); lcd.print(String(Current[PWM_Value \/ 5]) + “mA”); } if (Down_Button.wasReleased() && PWM_Value > 1 && calc == false)
\n{
\nPWM_Value = PWM_Value – 5;
\nanalogWrite(PWM_Pin, PWM_Value);
\nlcd.setCursor(0, 1);
\nlcd.print(” “);
\nlcd.setCursor(0, 1);
\nlcd.print(String(Current[PWM_Value \/ 5]) + “mA”);
\n}<\/p><\/blockquote>\n

If the Up button is long pressed (indicated by 1000ms), the system switches mode as it assumes the user has selected a load current that satisfies them. The mode switch involves invoking the timer interrupt() function which handles all the calculations involved with determining the capacity of the battery. This cycle is repeated as the loop continues.<\/p>\n

if (UP_Button.pressedFor(1000) && calc == false)
\n{
\ndigitalWrite(Speaker, HIGH);
\ndelay(100);
\ndigitalWrite(Speaker, LOW);
\nlcd.clear();
\ntimerInterrupt();
\n}<\/p><\/blockquote>\n

The timerInterrupt() function handles most of the project\u2019s heavy lifting. It continuously monitors the battery voltage and as long as it\u2019s not yet at the preset Low_BAT_Level, it increments the time. As soon as the measured battery voltage becomes less than the Low_BAT_Level, it stops the time increment and uses it to estimate the capacity of the battery. At this point, the buzzer is turned on and off in a pattern to indicate the completion of the process.<\/p>\n

void timerInterrupt() {
\ncalc = true;
\nwhile (Done == false) {
\nSecond ++;
\nif (Second == 60) {
\nSecond = 0;
\nMinute ++;
\nlcd.clear();
\n}
\nif (Minute == 60) {
\nMinute = 0;
\nHour ++;
\n}
\nlcd.setCursor(0, 0);
\nlcd.print(String(Hour) + “:” + String(Minute) + “:” + String(Second));
\nlcd.setCursor(9, 0);
\nADC_Value = analogRead(BAT_Pin);
\nBAT_Voltage = ADC_Value * (5.0 \/ 1024);
\nlcd.print(“V:” + String(BAT_Voltage));
\nlcd.setCursor(0, 1);
\nlcd.print(“BAT-C: Wait!…”);<\/p>\n

if (BAT_Voltage < Low_BAT_level)
\n{
\nlcd.setCursor(0, 1);
\nlcd.print(” “);
\nlcd.setCursor(0, 1);
\nCapacity = (Hour * 3600) + (Minute * 60) + Second;
\nCapacity = (Capacity * Current[PWM_Value \/ 5]) \/ 3600;
\nlcd.print(“BAT-C:” + String(Capacity) + “mAh”);
\nDone = true;
\nPWM_Value = 0;
\nanalogWrite(PWM_Pin, PWM_Value);
\ndigitalWrite(Speaker, HIGH);
\ndelay(100);
\ndigitalWrite(Speaker, LOW);
\ndelay(100);
\ndigitalWrite(Speaker, HIGH);
\ndelay(100);
\ndigitalWrite(Speaker, LOW);
\n}<\/p>\n

delay(1000);
\n}
\n}<\/p><\/blockquote>\n

The complete code for the project is available below and also attached under the download section.<\/p>\n

#include #include<\/p>\n

const float Low_BAT_level = 3.2;<\/p>\n

\/\/Current steps with a 3R load (R7)
\nconst int Current[] = {0, 37, 70, 103, 136, 169, 202, 235, 268, 301, 334, 367, 400, 440, 470, 500, 540};<\/p>\n

const byte RS = 2, EN = 3, D4 = 4, D5 = 5, D6 = 6, D7 = 7;
\nconst byte PWM_Pin = 10;
\nconst byte Speaker = 12;
\nconst int BAT_Pin = A0;
\nint PWM_Value = 0;
\nunsigned long Capacity = 0;
\nint ADC_Value = 0;
\nfloat BAT_Voltage = 0;
\nbyte Hour = 0, Minute = 0, Second = 0;
\nbool calc = false, Done = false;<\/p>\n

LiquidCrystal lcd(RS, EN, D4, D5, D6, D7);<\/p>\n

Button UP_Button(16, 25, false, true);
\nButton Down_Button(15, 25, false, true);<\/p>\n

void setup() {<\/p>\n

pinMode(PWM_Pin, OUTPUT);
\npinMode(Speaker, OUTPUT);<\/p>\n

analogWrite(PWM_Pin, PWM_Value);<\/p>\n

UP_Button.begin();
\nDown_Button.begin();<\/p>\n

lcd.setCursor(0, 0);
\nlcd.begin(16, 2);
\nlcd.print(“Battery Capacity”);
\nlcd.setCursor(0, 1);
\nlcd.print(“Measurement v1.0”);
\ndelay(3000);
\nlcd.clear();
\nlcd.print(“Load Adj:UP\/Down”);
\nlcd.setCursor(0, 1);
\nlcd.print(“0″);<\/p>\n

}<\/p>\n

void loop() {
\nUP_Button.read();
\nDown_Button.read();<\/p>\n

if (UP_Button.wasReleased() && PWM_Value < 80 && calc == false) { PWM_Value = PWM_Value + 5; analogWrite(PWM_Pin, PWM_Value); lcd.setCursor(0, 1); lcd.print(” “); lcd.setCursor(0, 1); lcd.print(String(Current[PWM_Value \/ 5]) + “mA”); } if (Down_Button.wasReleased() && PWM_Value > 1 && calc == false)
\n{
\nPWM_Value = PWM_Value – 5;
\nanalogWrite(PWM_Pin, PWM_Value);
\nlcd.setCursor(0, 1);
\nlcd.print(” “);
\nlcd.setCursor(0, 1);
\nlcd.print(String(Current[PWM_Value \/ 5]) + “mA”);
\n}
\nif (UP_Button.pressedFor(1000) && calc == false)
\n{
\ndigitalWrite(Speaker, HIGH);
\ndelay(100);
\ndigitalWrite(Speaker, LOW);
\nlcd.clear();
\ntimerInterrupt();
\n}<\/p>\n

}<\/p>\n

void timerInterrupt() {
\ncalc = true;
\nwhile (Done == false) {
\nSecond ++;
\nif (Second == 60) {
\nSecond = 0;
\nMinute ++;
\nlcd.clear();
\n}
\nif (Minute == 60) {
\nMinute = 0;
\nHour ++;
\n}
\nlcd.setCursor(0, 0);
\nlcd.print(String(Hour) + “:” + String(Minute) + “:” + String(Second));
\nlcd.setCursor(9, 0);
\nADC_Value = analogRead(BAT_Pin);
\nBAT_Voltage = ADC_Value * (5.0 \/ 1024);
\nlcd.print(“V:” + String(BAT_Voltage));
\nlcd.setCursor(0, 1);
\nlcd.print(“BAT-C: Wait!…”);<\/p>\n

if (BAT_Voltage < Low_BAT_level)
\n{
\nlcd.setCursor(0, 1);
\nlcd.print(” “);
\nlcd.setCursor(0, 1);
\nCapacity = (Hour * 3600) + (Minute * 60) + Second;
\nCapacity = (Capacity * Current[PWM_Value \/ 5]) \/ 3600;
\nlcd.print(“BAT-C:” + String(Capacity) + “mAh”);
\nDone = true;
\nPWM_Value = 0;
\nanalogWrite(PWM_Pin, PWM_Value);
\ndigitalWrite(Speaker, HIGH);
\ndelay(100);
\ndigitalWrite(Speaker, LOW);
\ndelay(100);
\ndigitalWrite(Speaker, HIGH);
\ndelay(100);
\ndigitalWrite(Speaker, LOW);
\n}<\/p>\n

delay(1000);
\n}
\n}<\/p><\/blockquote>\n

Demo<\/h2>\n

Once the code is finalized and your PCB is prepared, connect the Arduino Nano to your computer and upload the code. Upon successful upload, the LCD should display the splash screen as depicted in the image below.<\/p>\n

\"\"<\/p>\n

After uploading the code, the next step is to power the board using an external power supply and connect a battery to it, as demonstrated in the image below. It’s important to note that, according to the current design, the board should only be powered with a maximum of 9V.<\/p>\n

\"\"<\/p>\n

With the power supply and battery connected, set your desired load Current using the up and down buttons then press and hold the up button till you hear the buzzer beeps, to kick start the process.<\/p>\n

\"\"<\/p>\n

As the process proceeds, an update will be provided on the screen, showing the time that has elapsed and the voltage of the battery.<\/p>\n

\"\"<\/p>\n

At the end of the process, the battery\u2019s true capacity is displayed as shown in the image below.<\/p>\n

\"\"<\/p>\n

That\u2019s it. For the demo, a battery rated 8800mAh was used but at the end of the test, the battery was discovered to only have an energy capacity of 1190mAh.<\/p>\n

That\u2019s it for this tutorial guy\u2019s thanks for reading. As usual, you can reach out to me via the comment section if you have any questions or difficulties replicating the project.<\/p>\n

Source :\u00a0electronics-lab.com (CC BY-SA 4.0)<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"

The growing global interest in IoT and electric vehicles is driving a surge in the utilization of Lithium-Ion\/Lithium-Polymer\/NiCd\/NiMH batteries. These batteries are being increasingly employed across various devices and applications due to their high energy storage capacity relative to size. However, this heightened demand is also giving rise to an influx of batteries with misleading… Battery capacity tester for Lithium, NiMH, and NiCd batteries with Arduino<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":500,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"neve_meta_sidebar":"","neve_meta_container":"","neve_meta_enable_content_width":"off","neve_meta_content_width":70,"neve_meta_title_alignment":"","neve_meta_author_avatar":"","neve_post_elements_order":"","neve_meta_disable_header":"","neve_meta_disable_footer":"","neve_meta_disable_title":"","iawp_total_views":84,"footnotes":""},"categories":[2],"tags":[],"class_list":["post-499","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-projects"],"_links":{"self":[{"href":"https:\/\/www.zonetronik.com\/en\/wp-json\/wp\/v2\/posts\/499","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.zonetronik.com\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.zonetronik.com\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.zonetronik.com\/en\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.zonetronik.com\/en\/wp-json\/wp\/v2\/comments?post=499"}],"version-history":[{"count":3,"href":"https:\/\/www.zonetronik.com\/en\/wp-json\/wp\/v2\/posts\/499\/revisions"}],"predecessor-version":[{"id":511,"href":"https:\/\/www.zonetronik.com\/en\/wp-json\/wp\/v2\/posts\/499\/revisions\/511"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.zonetronik.com\/en\/wp-json\/wp\/v2\/media\/500"}],"wp:attachment":[{"href":"https:\/\/www.zonetronik.com\/en\/wp-json\/wp\/v2\/media?parent=499"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.zonetronik.com\/en\/wp-json\/wp\/v2\/categories?post=499"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.zonetronik.com\/en\/wp-json\/wp\/v2\/tags?post=499"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}