Battery Management System for Lithium-Ion Battery Pack using Arduino

A battery management system (BMS) for a lithium-ion battery pack is the circuit that watches every cell in the pack and disconnects the charger or the load before any single cell is damaged. This project builds that system for a 3S pack of three 18650 cells using an Arduino Uno: three voltage-divider taps feed each cell voltage to the Arduino, an ACS712 sensor measures pack current, and a DS18B20 sensor measures cell temperature. The Arduino compares every reading with safe limits, switches on a bleed resistor to balance any cell that runs high, and opens a MOSFET switch to cut off charging above 4.25 V per cell or discharge below 3.00 V per cell. A 16x2 LCD shows cell voltages, current, temperature and state of charge, with a 3S protection board as hardware backup. The build is an educational prototype, not a certified or vehicle-grade BMS, demonstrated with a 12 V DC bulb as the load.

Lithium-ion cells are unforgiving: a single cell charged past 4.2 V or drained below about 3.0 V loses capacity permanently, and in the worst case overheats. In a series pack the risk is worse, because cells never age identically — one cell reaches full charge while the others are still catching up, so charging by pack voltage alone quietly overcharges the strongest cell every cycle. Most student battery projects ignore this entirely and connect cells straight to a charger and a load. This project closes that gap with a working monitor-and-protect loop the student can demonstrate live: force one cell high or low and watch the system cut off, balance, and report. It pairs naturally with a solar charge controller project, a home inverter or UPS build, and an e-bike battery pack project.

A battery management system does not charge the battery — it watches every cell and opens a switch the instant any single cell leaves its safe window. Builder note: each divider tap is sized so the voltage at the Arduino pin never exceeds 5 V, because the top tap of a 3S pack reaches 12.6 V at full charge, and a raw tap wired straight to an analog pin would destroy that input.

A battery management system works as a continuous sense-decide-protect loop, and this build runs that loop once every second. It starts by sensing: three voltage-divider taps bring each cell voltage down into the Arduino's 0–5 V analog range, the ACS712 sensor reports pack current, and the DS18B20 reports cell temperature. The Arduino then decides: it compares each cell against the over-charge limit of 4.25 V and the over-discharge limit of 3.00 V, compares current against 3 A, and temperature against 45 °C, while updating the state-of-charge estimate from the integrated current. Finally it protects: if a cell is high during charging, its balance resistor switches on; if any limit is crossed, the charge or load MOSFET opens and the LCD names the fault. A 3S protection board wired in series provides a second, hardware-only cut-off if the Arduino ever fails to act.

1. Three 18650 cells in series form the 3S pack (11.1 V nominal, 12.6 V at full charge), with a tap wired from the top of each cell into its own voltage divider.
2. Each divider scales its tap below 5 V and feeds one Arduino analog pin (A0–A2); the 10-bit ADC converts each reading at approximately 4.9 mV per step (datasheet value).
3. The ACS712-05B current sensor measures pack current at 185 mV/A sensitivity (datasheet value), and the DS18B20 measures cell temperature on a single digital pin.
4. Every second the firmware computes the three cell voltages, pack voltage, current, temperature and state of charge, and refreshes the 16x2 LCD and serial log.
5. During charging, any cell above its neighbours has its bleed resistor switched on by a MOSFET, draining approximately 100 mA (design target) until the cells match.
6. If any cell exceeds 4.25 V (design target), the charge MOSFET opens and charging stops; if any cell drops below 3.00 V (design target), the load MOSFET opens and the load is disconnected.
7. If current exceeds 3 A or temperature exceeds 45 °C (design targets), the load is disconnected and the LCD shows the fault; the 3S protection board provides an independent hardware backup cut-off.

Comparing battery protection approaches

Tech stack:

• Arduino Uno (ATmega328P)
• Arduino IDE (C/C++ firmware)
• 18650 lithium-ion cells (3S pack)
• ACS712-05B current sensor
• DS18B20 temperature sensor
• 16x2 LCD with I2C backpack
• N-channel MOSFETs · bleed resistors
• 3S protection board (HX-3S class)

A battery management system for a lithium-ion pack stands or falls on four capabilities, and this build implements all four. First, per-cell voltage monitoring: each of the three 18650 cells is measured individually through its own divider tap, so an unbalanced cell is visible instead of hidden inside the pack voltage. Second, passive cell balancing: a MOSFET-switched bleed resistor drains any cell that runs above its neighbours during charging. Third, three independent cut-offs: over-charge, over-discharge and over-current each open a MOSFET switch to disconnect the charger or the load. Fourth, state-of-charge estimation: the firmware combines coulomb counting from the current sensor with a voltage lookup, and shows the result live on the LCD. Temperature and current complete the picture: the DS18B20 watches cell temperature and the ACS712 watches pack current, so a hot cell or a heavy load triggers the same protective cut-off as a bad voltage.

• [Per-cell voltage monitoring] Three divider taps feed each 18650 cell voltage to separate Arduino analog pins, so the firmware sees every cell individually instead of only the 11.1 V pack total.
• [Passive cell balancing] A MOSFET-switched bleed resistor across each cell drains a high cell at approximately 100 mA (design target) during charging, pulling the three cells back toward the same voltage.
• [Over-charge cut-off] When any cell crosses 4.25 V (design target), the charge MOSFET opens and charging stops, with the LCD flagging which cell tripped.
• [Over-discharge cut-off] When any cell falls below 3.00 V (design target), the load MOSFET opens and the pack is disconnected from the load before deep discharge can damage a cell.
• [Over-current and short-circuit cut-off] An ACS712-05B Hall-effect current sensor watches pack current, and the firmware opens the load switch above 3 A (design target).
• [Temperature monitoring with thermal cut-off] A DS18B20 sensor taped to a cell reports temperature to ±0.5 °C (datasheet value, −10 °C to +85 °C), and charging and discharge stop above 45 °C (design target).
• [State-of-charge estimation and display] The firmware integrates pack current over time (coulomb counting) and cross-checks it against an open-circuit-voltage lookup table, showing SOC, cell voltages, current and temperature on a 16x2 LCD and the serial monitor.

• Working 3S lithium-ion BMS prototype (Arduino Uno, 3-cell 18650 holder, BMS board, LCD, sensors, MOSFET cut-off stage)
• Complete Arduino firmware with per-cell monitoring, balancing, cut-offs, SOC estimation and LCD/serial display
• Circuit diagram and wiring documentation, including divider sizing and the calibration procedure
• Project report PDF (background, BMS theory, methodology, results, safety notes)
• PPT presentation for final review
• Viva Q&A preparation document (cell chemistry, balancing, cut-off logic, SOC methods, safety limits)
• Demonstration guide: how to show balancing, over-charge cut-off and over-discharge cut-off live