Getting Started with Lithium Battery Monitoring on Raspberry Pi

Battery monitoring is a fundamental capability for any hardware-driven project that relies on lithium-ion (Li-ion) power sources. Whether you're building a remote IoT sensor, portable robotics, or a solar-powered data logger, understanding battery health, charge state, and voltage stability is critical. Accurate battery monitoring ensures reliability, improves user trust, prolongs battery lifespan, and helps prevent failures or safety issues.

This guide walks you through setting up a lithium battery monitoring system using a Raspberry Pi. We’ll cover hardware selection, sensor integration, Python programming, real-time data logging, visualization, and best practices for safety and calibration. The complete solution empowers any maker or developer—regardless of embedded experience—to monitor battery systems effectively.

1. Why Monitor Lithium Batteries?

Li-ion batteries require careful handling because their performance and safety depend on several factors:

• State of Charge (SoC) Monitoring: Prevents deep discharge or overcharge that harm lifespan.
• Voltage Stability: Identifies power supply issues or load-induced drops.
• Temperature Tracking: Detects excessive heat from charge/discharge cycles.
• Health Assessment: Tracks capacity fade over time for predictive maintenance.
• Safety: Avoids thermal runaway resulting in fire or explosion.

By implementing monitoring at the software level, you gain live insights into battery behavior under real-world operating conditions.

2. Hardware Overview

You’ll need the following components:

• Raspberry Pi – Model B-series or Zero W; essential for computing and connectivity.
• INA219 Sensor Module – An I²C-based current/power sensor with an integrated shunt resistor.
• Voltage Divider (Optional) – Required if monitoring battery voltage beyond INA219 range.
• DS18B20 Temperature Sensor – One-wire digital sensor for temperature readings.
• Jumpers and Breadboard – For prototyping connections.
• Proper Lithium Battery Pack – Include a Battery Management System (BMS) for safe charging/discharging.
• Safety Components – Inline fuse and robust wiring to protect against high current faults.

2.1 Sensor Roles

• INA219: Measures both voltage and current simultaneously and communicates over I²C.
• DS18B20: Provides accurate temperature readings directly from the battery surface.

3. Wiring Diagram

Connect components as follows:

INA219 to Raspberry Pi

• VCC → 3.3 V
• GND → Pi ground
• SDA → I2C SDA pin (GPIO2, pin 3)
• SCL → I2C SCL pin (GPIO3, pin 5)
• VIN+ → Battery positive terminal
• VIN– → Battery-side supply node

• GND → Battery negative
  DS18B20 to Raspberry Pi

• Data → GPIO4 (pin 7)

• VCC → 3.3 V

• GND → Pi ground

• 4.7kΩ resistor between Data and 3.3 V

Safety Tips

Insert inline fuse on the battery positive path.

Double-check wire polarity before powering on.

Ensure breadboard connections support the current you expect.

4. Raspberry Pi Software Setup

Start with Raspberry Pi OS on your device.

sudo apt update
sudo apt upgrade
sudo apt install python3-pip i2c-tools

Enable I²C and one-wire support via raspi-config:

sudo raspi-config
# Enable I2C under Interface Options
# Enable 1-Wire under Interface Options
sudo reboot

Once the Pi reboots, verify I²C detection:

i2cdetect -y 1

You should see the INA219 at address 0x40.
Install Python libraries:

pip3 install adafruit-circuitpython-ina219 w1thermsensor pandas matplotlib flask

5. Python Script: Data Collection and Logging

Create battery_monitor.py, which logs voltage, current, power, and temperature every 5 seconds.

import time
import csv
import datetime
from ina219 import INA219, BusVoltageRange
from w1thermsensor import W1ThermSensor

SHUNT_OHMS = 0.1
MAX_EXPECTED_AMPS = 5.0

ina = INA219(SHUNT_OHMS, MAX_EXPECTED_AMPS)
ina.bus_voltage_range = BusVoltageRange.RANGE_16V
ina.configure(ina.RANGE_16V, ina.GAIN_AUTO)

temp_sensor = W1ThermSensor()

CSV_FILE = "battery_log.csv"
with open(CSV_FILE, mode='a') as f:
    if f.tell() == 0:
        f.write("timestamp,voltage_V,current_mA,power_mW,temperature_C\n")

def read_metrics():
    timestamp = datetime.datetime.utcnow().isoformat()
    voltage = ina.voltage()
    current_mA = ina.current()
    power_mW = ina.power()
    temperature = temp_sensor.get_temperature()
    return [timestamp, voltage, current_mA, power_mW, temperature]

try:
    while True:
        data = read_metrics()
        with open(CSV_FILE, mode='a') as f:
            f.write(",".join(map(str, data)) + "\n")
        print(f"Logged: {data}")
        time.sleep(5)

except KeyboardInterrupt:
    print("Monitoring stopped.")

Script Breakdown:

• Initialization: INA219 with a 0.1Ω shunt and 5 A max current.
• Configuration: Set bus range, gain, current/shunt settings to support your battery voltage.
• Data Logging: Appends readings to a CSV file for later analysis.

6. Visualizing and Analyzing Data

Leverage Jupyter or a standalone Python script to process and visualize data.

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv("battery_log.csv", parse_dates=["timestamp"])
df.set_index("timestamp", inplace=True)

# Plot voltage vs time
plt.figure(figsize=(12, 6))
plt.plot(df.index, df.voltage_V, label="Voltage (V)")
plt.plot(df.index, df.temperature_C, label="Temperature (°C)", alpha=0.5)
plt.legend()
plt.title("Battery Voltage and Temperature Over Time")
plt.xlabel("Time")
plt.ylabel("Value")
plt.show()

# Calculate and plot State of Charge
CAPACITY_AH = 2.0
df["age_Ah"] = (df.current_mA.diff().fillna(0) / 1000) * (df.index.to_series().diff().dt.total_seconds() / 3600)
df["SoC_%"] = 100 - df.age_Ah.cumsum() / CAPACITY_AH * 100

df["SoC_%"].plot(title="Estimated State of Charge")
plt.ylabel("SoC (%)")
plt.xlabel("Time")
plt.show()

Why This Matters:

• Visual patterns reveal battery discharge or charging cycles.
• Temperature plots highlight thermal issues.
• SoC trends can indicate baseline capacity fade.

7. Building a Real-Time Dashboard (Flask Example)

Provide a basic web interface to see live metrics:

from flask import Flask, jsonify, render_template_string
import pandas as pd

app = Flask(__name__)
CSV_FILE = "battery_log.csv"

@app.route("/metrics")
def metrics():
    df = pd.read_csv(CSV_FILE, parse_dates=["timestamp"])
    latest = df.iloc[-1].to_dict()
    return jsonify(latest)

@app.route("/")
def homepage():
    return render_template_string("""
    <h1>Battery Monitor</h1>
    <pre id="data"></pre>
    <script>
      async function fetchData(){
        const resp = await fetch('/metrics');
        document.getElementById('data').innerText = JSON.stringify(await resp.json(), null, 2);
      }
      fetchData();
      setInterval(fetchData, 5000);
    </script>
    """)

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)

Navigate to http://:8000 to view live voltage, current, power, and temperature.

8. Calibration and Accuracy Considerations

To ensure trustworthy readings:

• Shunt Calibration: Verifying INA219 output with a known load allows you to adjust or confirm accuracy.
• Temperature Placement: Position DS18B20 in physical contact with the battery surface for real data.
• High Current Situations: Ensure fuse and wiring can handle real-world current spikes or charging surges.
• Voltage Divider Accuracy: If your battery exceeds 16 V, design a precise voltage divider and calibrate it.

9. Safety Best Practices

• Always Use Protection: Include inline fuses and adhere to safety guidelines.
• Never Overcharge: Use BMS or firmware parameters to stop charging at safe voltage.
• Thermal Monitoring: Suspend logging or alerts if temperature exceeds 45 °C.
• Backup Logs: Store historical data to analyze degradation trends or safety incidents.

10. Scaling and Advanced Features

With this foundation, you can extend the system in several ways:

• MQTT Integration: Send telemetry to cloud services for remote monitoring.
• Advanced Visualization: Use Grafana and InfluxDB for industrial-grade dashboards.
• Alerting: Trigger notifications via email or SMS for critical threshold breaches.
• Predictive Analytics: Estimate battery aging or run predictive maintenance routines.

Conclusion

By combining a Raspberry Pi, INA219 current sensor, DS18B20 temperature module, and Python software, you now have a robust, low-cost lithium battery monitoring solution. Whether deployed in portable devices, field sensors, or robotics, this tool empowers developers to:

• Monitor battery health in real time
• Detect early warning signs of failure
• Log historical data for performance insights
• Make informed decisions about charging and discharging strategies