Lithium-Ion Battery Charger

Following is the tutorial of a DIY Lithium-Ion battery charger implemented on Arduino with several advanced features like state-of-charge estimation, EEPROM logging and command-line interface. It uses the Constant Current Constant Voltage (CC-CV) charging method with end-of-charge detection based on multiple criteria. The same design can be used for charging Lithium-Polymer (LiPo) batteries.

The rationale behind this project was to upgrade the depleted battery pack and charger of an old cordless drill from Nickel-Cadmium (NiCd) to Lithium-Ion (Li-Ion) technology.

Please note that the documentation provided on this page always refers to the latest firmware release found on GitHub. Older firmware versions may or may not work as described within this article.

Warning: Lithium-Ion batteries are hazardous devices. Overcharging, short-circuiting or otherwise abusing Lithium-Ion batteries may result in a fire and/or a violent explosion. The author of this page neither takes any responsibility nor can be held liable for any damage caused to human beings and things due to the improper handling of Lithium-Ion batteries. Please be aware that the current design has not been certified for safety, consequently it is not suitable for commercial applications and must be implemented at your own risk. Last but not least, it is imperative to equip each Lithium-Ion battery pack with its dedicated battery protection board (or Battery Management System aka BMS).

Theory of Operation

The following sub-sections cover the theoretical and mathematical aspects of Lithium-Ion (Li-Ion) battery charging. The exact same principles apply to Lithium-Polymer (LiPo) batteries.

CC-CV Charging

Li-Ion batteries must be charged using the Constant Current Constant Voltage (CC-CV) charging method. This method consists of charging the battery at a constant current I_{chrg} until a certain voltage threshold V_{max} = \SI{4.2}{\volt/cell} is reached, then gradually reducing the charging such that the constant cell voltage V_{max} is not exceeded. Charging is terminated once the current reaches a certain minimum threshold I_{full} of typically 50..150 mA.

Additional end-of-charge (EoC) criteria have been implemented for safety reasons. These include the time-based and capacity-based EoC detection. When a battery is connected, the charger measures the voltage at its terminals and roughly estimates its state of charge SoC in %. The SoC value is used for calculating the remaining capacity C_{max} and charge duration T_{max}. Charging is terminated if either of these values has been reached. The SoC calculation details are described in the following sections.

Control Loop

The battery “+” terminal is connected to the positive power supply through a power MOSFET (field-effect transistor). The battery “-” terminal is connected to the power supply ground through a low-value shunt resistor R_{shunt}.

The charging current is regulated by means of Pulse Width Modulation (PWM), where the MOSFET cyclically turned on and off by the Arduino at a frequency of 31.250 kHz. The charging current is controlled by gradually adjusting the PWM duty cycle which is the ratio between the MOSFET on and off duration.

V_1 is the voltage measured at the battery “+” terminal and V_2 is the voltage measured at the battery “-” terminal. Both voltages are measured relative to the power supply ground and are used for calculating the voltage V across the battery pack and the charging current I as follows:

V (V) = V_1 - V_2

I (A) = \frac{V_2}{R_{shunt}}

Two separate ADC channels on the Arduino are used for measuring the above voltages. The Arduino continuously monitors V and I and adjusts the PWM duty cycle in order to achieve the desired constant current or constant voltage regulation.

State-of-Charge Estimation

The state of charge SoC is estimated by reading the battery voltage V and comparing it to a series of values stored in a lookup table L = [l_0,l_1,l_2,l_3,l_4,l_5,l_6,l_7,l_8]. The threshold voltages are derived from the particular discharge curve shown below for the LG 18650 HE4 cells used in this project (source: https://lygte-info.dk/review/batteries2012/LG%2018650%20HE4%202500mAh%20%28Yellow%29%20UK.html).

The red discharge curve corresponding to 0.2 A discharge current has been used, whereas the values of L were assigned such that:

  • l_0 = V@\SI{2.25}{Ah}
  • l_1 = V@\SI{2.00}{Ah}
  • l_2 = V@\SI{1.75}{Ah}
  • l_8 = V@\SI{0.25}{Ah}

SoC is calculated as follows:

  • V < l_0: SoC = \SI{0}{\percent}
  • l_0 < V < l_1: SoC = \SI{10}{\percent}
  • l_1 < V < l_2: SoC =\SI{20}{\percent}
  • l_8 < V: SoC = \SI{90}{\percent}

The remaining capacity C_{max} and charge duration T_{max} are derived as follows:

C_{max}(mAh) = C_{full} \cdot (100 - SoC) \cdot 1.3

T_{max}(s) = 3600 \cdot \frac{C_{full}}{I_{chrg}} \cdot (90 - SoC) + 45 \cdot 60

Where C_{full} is the battery design capacity and I_{chrg} is the nominal charging current. Note that C_{max} is increased by 30 % and T_{max} is increased by 45 minutes in order to to account for resistive losses and SoC estimation inaccuracy.

Safety

The charger implements several safety features. These include undervoltage, overvoltage, short circuit and open circuit detection.

The typical voltage range where a Li-Ion battery can safely operate is between V_{min} = \SI{2.5}{V/cell} and V_{max} = \SI{4.2}{V/cell}. Operating outside this range is likely to cause permanent damage to the Li-Ion cells and may even result in a catastrophic failure such as an explosion or fire.

The battery pack is additionally protected by a battery protection board (or Battery Management System aka BMS). The BMS measures the voltages of the individual battery cells as well as the charge/discharge current flowing through the battery. The BMS uses a solid-state switch to disconnect the battery as soon as the voltage or current values become outside of the specified limits.

For the most part, the BMS is completely transparent and does not interfere with the charging process, except for the case where the BMS disconnects the depleted battery in order to prevent over-discharge. In this case, the voltage of the depleted battery is still present across the BMS terminals through a high value resistor placed in series with the battery. This high value resistor causes a much lower voltage value to be measured at the charger terminals. Consequently, the charger must ignore the V_{min} lower limit and start charging at a much lower value of as low as V_{start} = \SI{0.5}{V/cell}.

When presented with a depleted battery, the charger would start charging at a reduced safety current I_{safe} = I_{chrg} / 10 until the battery voltage reaches V_{safe} = \SI{2.8}{V/cell}, afterwards it would apply the full charging current I_{chrg}. Once the voltage reaches this threshold, it is no longer allowed to drop below the V_{min}. A voltage below V_{min} would raise an “undervolt error” which is may caused by either a short circuit or a battery open circuit.

Open circuit is also detected if the charging current stays equal to zero while the PWM duty cycle increases beyond a specific threshold. This condition would raise an “open circuit error”.

Overvoltage is detected whenever the battery pack voltage momentarily exceeds V_{surge} = \SI{2.25}{V/cell}. Exceeding this value would raise an “overvolt error”.

Trickle Charging

Once the end-of-charge (EoC) criteria has been met, the charger would cut-off the charging current and switch to an idle mode where it will continuously monitor the battery voltage. Once the voltage drops below a specific threshold of V_{trickle\_start} = \SI{4.10}{V/cell}, a new charging cycle will be initiated using the following parameters:

V_{max} (V/cell) = V_{trickle\_max} = \SI{4.15}{V/cell}

C_{max} (mAh) = C_{full} \cdot 0.3 + C

T_{max} (s) = 20 \cdot 60 + T

Where C_{full} is the battery design capacity. C and T are the accumulated charge capacity and charge time since the battery has been connected, including the initial charge and all of the subsequent trickle charge cycles.

Given the above formulas, the trickle charge cycle uses a reduced V_{max} and allows for charging up to a maximum of 3 % of the battery design capacity during a maximum duration of 20 minutes.

Hardware

The following sub-sections describe the hardware design aspects of the Li-Ion charger.

Mechanical Design

The following image gallery shows the mechanical design of both battery pack and charger.

The original 12 NiCd cells have been removed from the battery pack and replaced by 4 LG 18650 HE4 Li-Ion cells and a battery protection board (or Battery Management System aka BMS). Despite the increased capacity, the modern Lithium-Ion cells use significantly less space which leaves plenty of room for the BMS and and the required wiring.

The original battery charger has been retrofitted with the custom PCB containing the Arduino and required circuitry. A 19.5 V / 3.33 A notebook power supply has been used for powering the whole system.

Battery Protection Board

Despite the safety features described above, it is imperative to use a dedicated battery protection board for each of the battery packs. This provides an additional layer of protection to prevent an overcharge or over-discharge condition due to a software or hardware malfunction.

The following figures show the particular 4 S / 30 A (4 S means 4 cells in series) battery protection board (or BMS) that has been used in this project. It has been acquired for less than 10€ on Ebay.

In the above figure one can see the wiring diagram for connection the 4 Li-Ion cells with the BMS.

This particular BMS includes the cell balancer feature. If the voltage of one or more cells becomes higher than the rest of the pack, the BMS would actively discharge those cells to ensure that all the cells of the battery pack share the exact same voltage.

Circuit Diagram

The the following figure shows the Li-Ion charger circuit diagram.

Lithium-Ion battery charger circuit diagram (click to enlarge)

The above schematic, the 19.5 V of the power supply are stepped-down to 5 V by the 7805 voltage regulator U1. The 5 V is used for powering the Arduino board.

The Arduino Pro Mini compatible board U2 hosts an ATmega 328P microcontroller running at 16 MHz clock frequency and is used as the main processing unit for the device.

The Lithium-Ion battery is connected across the B+ and B- terminals. The battery charging current is regulated by switching P-Channel MOSFET (field-effect transistor) Q1 via pulse-width modulation (PWM).

The PWM-enabled digital output pin 9 on the Arduino generates a PWM signal which drives the gate of the MOSFET Q1 through the NPN transistor Q2. The voltage divider formed by R1 and R2 ensures that the gate-source voltage of the MOSFET stays within the specified limits.

A current-sensing shunt resistor connects the B- terminal with ground. It consists of two 1 Ω / 3 W resistors R8 and R9 connected in parallel. This results in a total resistance of 0.5 Ω. At a charging current of I = \SI{2}{\ampere}, the voltage across the shunt will be exactly 1 V; which is slightly below the 1.1 V internal voltage reference of the Arduino thus corresponds to the full range of the Arduino’s analog-to-digital converter (ADC).

The analog pin A0 on the Arduino is used for measuring the voltage V_1 between B+ and 0 V. Analog pin A1 is used for measuring V_2 between B- and 0V.

B+ is connected to pin A0 through a voltage divider consisting of R4 and R7, the ratio has been chosen such that the maximum battery pack voltage of 16.8 V would result in slightly less than the Arduino’s internal reference voltage of 1.1 V at A0. Please note that the value of R4 needs to be adapted to the number of cells in use. For example, using a 1 cell setup would require reducing the value of R4 to 39 KΩ.

B- is connected to A1 through a current-limiting resistor R5; a voltage divider is not required for measuring V_2 as its value stays below the Arduino’s ADC internal reference voltage.

Two 100 nF capacitors C4 and C5 are used for blocking the high-frequency noise caused by the PWM from reaching the analog inputs, an essential measure for smooth ADC readings.

The Diode D1 protects the 7805 regulator from a reverse power supply polarity. The diode D2 protects the battery from a reverse polarity; it also prevents the battery from feeding power back into the Arduino in case the main power supply has been disconnected.

A LED indicator D3 and its dropper resistor R6 are connected to Arduino’s digital pin 13.

Different Number of Cells

The following values for R2, R4 and the power supply voltage need to be chosen in order to charge different numbers of Cells:

N_{cells} Power SupplyR2R4
1 *5 V-6 V220 Ω *39 KΩ
210 V – 15 V100 Ω82 KΩ
314 V – 20 V220 Ω120 KΩ
418.5 V – 20 V220 Ω180 KΩ

* When charging 1 cell, the following circuit modifications must be performed:

  • Remove the voltage regulator U1 and capacitor C3 and power the Arduino directly from the output of D1
  • Replace Q1 with a IRLML2244 MOSFET
  • Increase R1 to 10 KΩ
  • Remove Q2 and R3
  • Connect R2 directly to Arduino digital pin 9
  • Modify the code in li-charger.ino to invert the PWM signal by subtracting the PWM duty cycle from 255 within all instances of analogWrite() using one of the following statements:
analogWrite (MOSFET_PIN, 255 - G.dutyCycle);  // Replaces analogWrite (MOSFET_PIN, G.dutyCycle)
analogWrite (MOSFET_PIN, 255);                // Replaces analogWrite (MOSFET_PIN, 0)

PCB Layout

All of the components are of through-hole type and are mounted on a stripboard PCB. The following figures show the PCB layout of the Li-Ion charger (click to enlarge).

The MOSFET Q1 (TO-220 device in the top right corner) and large green-colored shunt resistors will get pretty hot so adequate ventilation needs to be assured. The following measures has been taken to avoid overheating:

  • The shunt resistors R8 and R9 are raised by around 5mm from the PCB in order to assure adequate cooling.
  • A series of holes has been drilled in the bottom of the enclosure in order to allow for a better air flow.
  • The charging current I_{chrg} has been limited to 1.5 A.

The electrolytic capacitor C1 towards the top center of the board is in a sub-optimal position due to its location between two hot components – the 7805 regulator and the MOSFET. High temperatures reduce the lifespan of electrolytic capacitors thus the must be kept away from heat sources.

The pin header located at the top right corner is used for connecting all the external wires. Following is the pinout assuming that pin 1 is at the top right corner and pin 10 is towards the middle of the board.

PinPurpose
1 *LED +
2 *LED –
3, 4 † Power supply +
5, 6 † Battery +
7, 8 † Power supply –
9, 10 † Battery –

* The LED dropper resistor is located on a separate PCB together with the LED itself.

† Two pins are connected in parallel in order to increase their current capacity.

User Interface

The following sections describe the user interface of the Lithium-Ion charger. It consists of a LED indicator and a Command-Line Interface (CLI).

LED Indicator

The charger status is displayed by means turning on or blinking a single LED as shown in the following table.

Blinking PatternMeaning
On for half a second every 2 secondsReady, waiting for the battery to be connected
Solid onBattery charging
On for 0.1 second every 2 seconds Battery fully charged
Blinking fast (0.4 s period) Error
Blinking very fast (0.2 s period)Calibration mode

Command-Line Interface

This Lithium-Ion battery charger features a Command-Line Interface (CLI) that can be accessed via the Arduino’s RS232 serial port. The easiest way to connect to the CLI is to open the serial monitor of the Arduino IDE while connected to the charger using a FTDI USB to Serial converter. Please ensure that the Baud rate is set to 115200.

Once up and running, the charger will display a welcome message on the serial monitor, show the current firmware version and present with the list of available commands shown in the following list.

Some of these CLI commands need to be provided with arguments. Thus, one needs to enter a the command followed by one or two arguments separated by a white space.

CommandDescription
hHelp – show the list of available commands
.Display the real-time parameters, including the charge duration T, charge capacity C, battery voltage V, charging current I, maximum charge duration T_{max}, maximum charge capacity C_{max}, maximum charging voltage V_{max}, maximum charging current I_{max}, PWM duty cycle, voltages V_1, V_2 and their raw ADC values V_{1,raw} and V_{2,raw}
rShow the list of calibration constants that are stored within EEPROM
tShow the contents of the trace circular buffer
ncells <integer>Set the total number of cells within the battery pack N_{cells}, the value provided as an argument will be validated and stored in EEPROM
cfull <integer>Set the battery design capacity C_{full} in mAh, the value provided as an argument will be validated and stored in EEPROM
ichrg <integer>Set the battery charging current I_{chrg}, the value provided as an argument will be validated and stored in EEPROM
ifull <integer>Set the end-of-charge current I_{full} in mA, the value provided as an argument will be validated and stored in EEPROM
lut <index> <voltage>Configure the state-of-charge lookup table (LUT). This command takes and index i =0,1,2,\dots,8 and the reference voltage l_i in mV as arguments. Each time this command is called, a new reference voltage value l_i is populated into the LUT and stored into EEPROM, more on this in the following section
rshunt <integer>Set the shunt resistor value R_{shunt} in mΩ, The value provided as an argument will be validated and stored in EEPROM
cal <start| stop| v1| v2> [mv]The voltage calibration mode is entered by calling cal start and exited by calling cal stop.
V_{1} is calibrated using cal v1 <mv>.
V_{2} is calibrated using cal v2 <mv>.
<mv> is the measured voltage level in millivolts. Please refer to the next section for more details about the calibration procedure.

Calibration Procedure

This section provides an example on how to perform the first-time calibration of the Lithium-Ion battery charger using the CLI over the serial monitor.

The calibration values are stored into the Arduino’s electrically erasable programmable read-only memory (EEPROM). A cyclic redundancy check (CRC) checksum is appended to the configuration parameters set and stored into EEPROM as well. All configuration parameters are validated and out-of-range values are automatically replaced with the corresponding failsafe values.

The current example assumes a system consisting of N_{cells} = 4 connected in series having a design capacity of C_{max} = \SI{2500}{mAh} charged using a current of I_{chrg} = \SI{1500}{mA} .

Important:

  • Do not connect the battery during the calibration procedure unless instructed otherwise.
  • Ensure that the voltage calibration procedure has been properly executed and verified prior to attempting to connect a Lithium-Ion battery. It is mandatory to connect a good quality battery protection board between the charger and battery. Failing to observe these precautions may lead to permanent damage or even explosion of the Lithium-Ion cells.

Initial Configuration

A a first step, the initial configuration parameters need to be loaded into EEPROM by executing the command sequence below:

ncells 4
cfull 2500
ichrg 1500
ifull 150
rshunt 500
lut 0 3200
lut 1 3450
lut 2 3530
lut 3 3610
lut 4 3650
lut 5 3710
lut 6 3825
lut 7 3920
lut 8 4020

A confirmation message will be printed on the serial monitor following each value entry.

Voltage Calibration

Having performed the above initial step, please proceed for calibrating the ADC readings for the voltages V_1, V_2 as shown below:

  1. Enter the command cal start into the serial monitor, this will activate the calibration mode. The message Calibration start should appear on the serial monitor.
  2. Connect a constant voltage source of approximately 750 mV between the B- terminal and the power supply ground (0 V) and measure its exact value using a digital multimeter. Note that 750 mV corresponds to 1.5 A flowing through the shunt resistors R8 and R9.
  3. Enter the command cal v2 <value> into the serial monitor, where <value> is the value in mV of the voltage measured in the previous step (e.g. 754). The value of the calibration constant V_{2,cal} will be displayed upon the successful calibration of V_2. If the calibration fails, the message Out of range will appear in the serial monitor.
  4. Connect a constant voltage source of approximately 16800 mV (4200 mV per cell) between the B+ terminal and the power supply ground (0 V) and measure its exact voltage using a digital multimeter.
  5. Enter the command cal v1 <value> into the serial monitor, where <value> is the value in mV of the voltage measured in the previous step (e.g. 16450). The value of the calibration constant V_{1,cal} will be displayed upon the successful calibration of V_1. If the calibration fails, the message Out of range will appear in the serial monitor.
  6. Verify the voltage calibration by applying a known voltage to each of B+ and B- (relative to 0 V), then enter the . (dot) command and check the displayed values for V_1 and V_2 which must match the measured voltages at B+ and B- as closely as possible.
  7. Repeat steps 2, 3, 4, 5 and 6 until the voltage readings are correct.
  8. Enter the command cal stop in order to exit the voltage calibration mode. The message Calibration stop should appear on the serial monitor.

Current Calibration

Please proceed with calibrating the reading of the current I by following the steps below:

  1. Connect a discharged Lithium-Ion battery to in series with a digital ampere meter (set to the 10 A range) to the terminals B+ and B-.
  2. The message Charging should appear in the serial monitor and the measured current value should start to gradually increase until it reaches a maximum of approximately 1.5 A.
  3. Enter the . (dot) command and check the displayed value for I which must match the measured current as closely as possible.
  4. If the output of the . command is higher than the amperemeter reading: increase the value of R_{shunt} by 10 mΩ by calling the rshunt command.
  5. If the output of the . command is lower than the amperemeter reading: decrease the value of R_{shunt} by 10 mΩ by calling the rshunt command.
  6. Repeat steps 3, 4 and 5 until you get an accurate reading of I.

Trace Buffer

The Lithium-Ion battery charger logs the events that occur during the charging process into a circular buffer within the available EEPROM space. The contents of the trace buffer are dumped using the t command. Following is a sample trace log output for a complete charging cycle:

  0: * 16760
  0: % 0
  0: v 7820
  0: T 135
  0: C 3263
  0: S 150
  0: I 1500
  2: v 13222
  2: i 1495
  4: v 13719
  4: i 1499
  6: v 13982
  6: i 1495
  8: v 14137
  8: i 1503
 10: v 14206
(skipped...)
100: v 16767
100: i 638
102: v 16764
102: i 529
104: v 16761
104: i 381
106: v 16754
106: i 241
108: v 16759
108: i 231
110: v 16764
110: i 221
112: v 16761
112: i 150
113: F 1
113: t 113
113: c 2508
113: v 16767
113: i 139

The trace messages have the format of <timestamp>: <event> <value>. Whereas the timestamp counts the minutes elapsed since the beginning of the charging process. The following table shows available events and their descriptions:

EventDescription
*Beginning of the charging cycle, indicates the maximum battery voltage V_{max} in V
%Initial state-of-charge in %
TMaximum allowable charge duration T_{max} in minutes
CMaximum allowable charge capacity C_{max} in mAh
SSafety charge in progress, indicates I_{safe} in mA
INormal charge in progress, indicates I_{chrg} in mA
vInstantaneous battery voltage V=V_1-V_2 in V
iInstantaneous battery current I in mA
FBattery full, indicates the end-of-charge condition (1 = I_{full} reached, 2 = C_{max} reached, 3 = T_{max} reached)
tActual charge duration T in minutes
cActual charged capacity C in mAh
EError (1 = overvolt, 2 = undervolt, 3 = open circuit, 99 = CRC fail)

Downloads

Below you can find GitHub download links for the Arduino firmware source code, Eagle schematic source files and bill of material. All of the source code is distributed under the GNU General Public License v3.0.

Please note that the current implementation uses the watchdog timer functionality which requires the customized Arduino bootloader found under the link below. For more details, please follow the installation instructions found within the README file on GitHub.

Customized Arduino Bootloader

Lithium-Ion Charger Firmware

Eagle Schematic Source Files

Bill of Material

Last updated on February 10, 2021

53 thoughts on “Lithium-Ion Battery Charger”

  1. Dear Mr. Hraibi,
    Thank you for this useful project. I want to set up this circuit to be used for both 2S and 3S cells. But I have a few questions. According to the 15v upper limit for 2S and 14v lower limit for 3s in the power supply circuit, it will be appropriate to feed the circuit with 15v. The resistors R2 and R4 will be adjusted by a switch. But there is a difficulty as the “ncells” variable that changes with calibration. Could the ncells variable be set according to whether a port of the arduino gets low or high logic level? If this happens, I think it will be possible to use the circuit for 2s and 3s.

  2. Hi Frank,

    many thanks for your detailed feedback. Of course as the disclaimer says, everyone shall implement this project at his/her own risk. Nevertheless, here is my feedback to the points you have mentioned:
    – There are definitely good off the shelf SOCs, specifically designed for the task of charging a Lithium-Ion battery, however implementing the charging algorithm in SW may have the following benefits:
    1. Cost: If your project already features an microcontroller (such as https://www.microfarad.de/pi-ups/), you may spare yourself the additional PCB area and cost required for a dedicated charger IC.
    2. Flexibility: With a SW implementation enables full control over the voltage thresholds (e.g. in the pi-ups project, I prefer to charge the battery up to only 4.00 V). You also have the ability to implement features such as advanced logging.
    3. Last but not least, educational value: Implementing a Lithium-Ion charging algorithm on a microcontroller as a perfect topic for a university project.
    – If we are to fully trust a dedicated charger IC, why shouldn’t we trust the BMS IC, whose very purpose is to protect the battery from over- and under-voltage conditions? Of course the redundancy of simultaneous use of two commercial devices for both charger and BMS would be the optimal solution.
    – Assuming that all software is due to malfunction is a very generalized statement. Many mission-critical applications such as car and airplane systems fully rely on software. The SW development process in such applications must comply to very strict coding standards such as the MISRA in automotive.

    Best regards,
    Karim

  3. Hi Karim
    This is an excellent and interesting software project as an exercise in controlling and logging a Li-ion charger. However I have major concerns about safety in this design. You mention safety concerns and you caution against abusing Li-ion batteries and I want to extend that theme to the whole approach of this design.
    Top of the list, I would simply not entrust the charging algorithm for Li-ion batteries to software. There are so many hardware solutions and devices out there that would do a far better and more reliable job of charging than doing it in software. Many devices will allow you to connect to them through hardware interfaces and those could be used in software to calculate any number of parameters. Of course reading variables such as voltages and currents is always available. Software should only be used for monitoring, reporting, communicating and as another safety net by taking precautionary actions when critical parameters are outside limits.
    In the hardware as it stands, my other safety concern is the failure modes of the PWM output stage. For example if Q2 fails ON due to hardware or software malfunction then the whole supply voltage is applied to the batteries and to the load. If the BMS is doing its job then the batteries may survive but the load may not. If the BMS hiccups then thats it for the batteries.
    Bottom line, I would not be comfortable running this charger unattended for any length of time.

  4. Well done Karim, overall this is a great project however some hardware issues around safety need a closer look. I get the impression you are more on the firmware/software side of the equation. My main concern is around failure modes of the PWM output stage. Should either a software or hardware failure cause Q2 to turn on then the full supply voltage will be applied to B+ with possibly catastrophic consequences for the Li cells. How the BMS reacts to this OV condition and how quickly it reacts is unknown, but IMHO you need some protection in the B+ line to disconnect it from the battery under Q2 ON condition. Remember also that the load will see this voltage as well and even if the BMS protects the batteries the load may not like it at all. Entrusting the Li-ion charging algorithm to software is another concern. There are so many excellent dedicated hardware devices out there to do the job more reliably. Something like the MAX745 would do a very adequate job of looking after the charging side, while software would control it according to your needs. You do raise safety concerns in your article and warn of the dangers of abusing Li-ion cells but I would not entrust the total safety of this project to the BMS. I would not be comfortable to run this charger unattended for any length of time.

  5. Thanks, ATtiny85 features 4 10-bit ADC channels. For this project you only need two of them, so I believe the implementation could be easily ported to ATtiny85. Please feel free to fork the Github repository to perform the required code adaptations. Unfortunately, I have no bandwidth to support, however I think it’s perfectly feasible. Best Regards, Karim

  6. Hi Eric,
    Thanks for your feedback. This is a simplified design using plain PWM. A commercial product would usually use a buck converter circuit consisting of an inductor, capacitor and a diode. The buck converter design is more power efficient and provides more constant voltage output. Buck converters are however more difficult to design implement and require a correct PCB layout, so using a prototyping board will not work. Regarding the voltage peaks you have mentioned, I have thought about it and came to the following hypothesis: The battery itself acts as a large capacitor, which results in a low pass filter when combined with the shunt resistor. At 31.250 kHz PWM frequency, the maximum pulse duration amounts to 32 microseconds. This duration is way too short to cause any significant voltage rise at the battery terminals, given that the battery voltage does not rise instantaneously but follows the battery charge curve instead.

  7. Hi Karim,

    Interesting project. Have you considered adding a low pass filter after Q1? I don’t believe the circuit as designed can truly perform CV charging and even in CC mode would potentially cause the pack to pulse with each PWM cycle above their absolute max voltage ratings. Maybe I’m missing something here and would like to hear your thoughts as I’m planning a similar project.

  8. Hi Mike,
    No problem, thanks for elaborating on you project’s details. Having reviewed your schematics, both of them have the issue where inserting the Lithium cell with inverted polarity will apply a negative voltage on A2. This will cause a current to flow through the following path (https://i.imgur.com/MD4bGs1.png): Cell+ -> R8/R9 -> 0V -> (ATmega internal clamping diode) -> A2 -> R11 -> D4 -> Cell-. For https://i.imgur.com/Z0adVIF.png, a very high current will flow out of A2 due to the missing R11; this will very likely damage the ATmega.
    Regarding VREF, I think that the best option would be to use the internal 1.1V reference voltage as it happens to be the most stable voltage source. Using the output of the 5V regulator U1 would be a sub-optimal solution, the output voltage of the regulator being subject to load regulation and may vary depending on the overall current consumption. This might be problematic as it will result in inaccurate voltage readings at the A0 and A1 pins.

  9. Karim,

    My apologies for the name mistake, I was trying to find your name on your write-up but I couldn’t find it. So I looked at other comments and thought I got it, but obviously not.

    And I’ve never worked with the pro mini before – I mainly use the Nano and lately, I’ve been tinkering with the Teensy 4.0 which is a really nice microcontroller.

    This project would be ideal for a custom-designed PCB using just the Mega 328 chip at which point you could easily incorporate the AREF pin.

    I’ve been wanting to build my own Li-Ion charger for a long time now to charge 18650 batteries individually. Not because doing so would be cost-effective, but because I’ve always wanted to learn about the process of charging LiIon and LiPo cells and because I want some features that you can’t find in retail chargers, such as the ability to run a process that determines how much life a battery has left in it, which from what I understand is determined by how long a battery can sustain a specific current draw. Also, being able to keep a recorded history of charges on specific batteries – could tell me about the overall quality of a battery so that I would know whether or not that battery was worth purchasing again.

    After reading your write-up, I’m wanting to really get on that project now.

    In my charger though, I wanted a way for the microcontroller to use an RGB LED and light it red if the battery is inserted backwards and I came with two different ways of detecting a reverse connection, though I’m not sure either of them would work because I’m not sure if the shunt resistor would interfere with current flow. Do you think either of these would work? In either case, if there was a voltage detected on pin A2, then the red LED would be lit.

    https://i.imgur.com/Z0adVIF.png
    https://i.imgur.com/MD4bGs1.png

    Mike

Leave a Reply

Your email address will not be published. Required fields are marked with an *.