Smart Buck-Boost MPPT Solar Charger Circuit for 12V 24V Battery

In this post we are going to learn how we can make one real working smart solar battery charger circuit which can do MPPT charging. We are using Arduino Nano as the brain for controlling everything. We will also use INA219 sensor module so that we can read the solar voltage and current properly.

And then we will use buck-boost converter so that it can reduce or increase voltage depending on battery level and panel level.

After that we are going to show everything on lcd screen so that we can see solar voltage current battery voltage and power.

This one will support both 12V and 24V batteries and we can also add two batteries and charge them one by one automatically using relay switch.

So this project is very useful for people who have solar panel and want to charge different batteries with smart control.

Parts Required

Main Features

So this charger is having many smart features which makes it better than normal pwm charger. First thing is that it is doing real mppt by tracking power point from solar panel.

Then it can charge both 12V and 24V battery. Also it can handle low voltage panel or high voltage panel and still charge properly because we are using buck boost converter.

Also we are using two relay output so that we can connect two batteries and charge them one after one. On top of that we can see all reading on lcd like voltage current power and pwm value.

How this MPPT Charger Works

So what we are doing here is very simple to understand in basic way. We are giving solar panel output to one current sensor module INA219. This one reads the voltage and current from panel. Then we give that to buck boost converter input.

The output of this converter goes to battery through one mosfet and schottky diode. Arduino Nano is reading everything and checking solar power value. It increases or decreases pwm to find the maximum point.

This is called perturb and observe technique which is used for mppt. It also checks battery voltage and cutoff when full. And it switches between battery 1 and battery 2 using relays.

Step by Step Connection Guide

1. how to connect solar panel to the current sensor ina219

So first we will take the two output wires from our solar panel. One will be the positive wire and other will be the negative wire.

Now we take the positive wire of the solar panel and connect that one to the Vin+ pin of the INA219 module. After that we take the negative wire of the panel and connect it to the GND pin of the INA219.

Now after doing that we have to connect the Vin– pin of the INA219 module to the positive input terminal of the buck-boost converter.

Then the GND pin from the INA219 (which is also connected to solar panel negative) should also go to the negative input terminal of the buck-boost converter. So this way the INA219 module comes in series with the solar positive line and reads the current correctly.

So final:

• solar positive → ina219 Vin+
• ina219 Vin– → buck-boost input +
• solar negative → ina219 GND → buck-boost input –

2. how to connect the output of buck-boost to the battery through mosfet and diode

Now we will take the output positive terminal of the buck-boost module and connect that to the Source pin of the IRF540N or IRLZ44N mosfet. This source pin is usually the first leg from the left side when the flat face is in front of us.

Now the Drain pin of the same mosfet should go to the Anode of one Schottky diode like 1N5822. Then the Cathode of this diode should be connected to the positive terminal of the battery. This diode will stop the battery from discharging back into the converter.

The negative output terminal of the buck-boost converter should be connected directly to the negative terminal of the battery. No switching is needed here.

So this completes the controlled battery charging path using the mosfet and diode.

So final:

• buck-boost output + → mosfet source
• mosfet drain → diode anode → battery positive
• buck-boost output – → battery negative

3. how to connect battery voltage sensing to arduino

Now we have to read the battery voltage using Arduino. But since battery voltage can be 12V or 24V and Arduino can only read up to 5V, we must use a voltage divider.

We will use two resistors in series, one 10k and one 2.2k resistor. First we connect the battery positive to the top end of the 10k resistor. Then the bottom end of the 10k goes to the top of the 2.2k resistor. And the bottom of the 2.2k resistor goes to GND.

Now we take the middle point between 10k and 2.2k and connect that one to A1 pin of the Arduino Nano. This will give scaled down battery voltage.

So final:

• battery positive → 10k → 2.2k → GND
• 10k-2.2k middle point → Arduino A1

why we must monitor battery voltage during charging

The main purpose of sensing the battery voltage using a voltage divider in the MPPT Arduino code is exactly that, to monitor the battery level and cut off charging when the battery becomes fully charged.

So when we are using MPPT solar charging system with Arduino, the solar panel is giving full power to the battery based on sunlight and maximum power point. But if we do not check the battery voltage then the charging will continue forever. That will make the battery overcharged which is very dangerous. It can overheat, bulge, leak or even blast in some rare cases.

So we must always keep track of the battery voltage during charging and we must stop the charging when battery reaches safe full charge limit.

4. how to connect pwm signal to buck boost converter

Now we have to control the duty cycle of the buck boost converter using PWM signal from Arduino. If the buck-boost module already has a PWM input pin, then we simply connect Arduino D9 pin to that PWM control pin of the module.

But if the module does not support pwm, then we must build a custom circuit using mosfet, diode, inductor and capacitor that behaves like buck-boost and then drive the mosfet with PWM from D9.

So final:

• Arduino D9 → PWM input of converter (or mosfet gate in custom build)

5. how to connect two batteries using relay module

So now if we want to connect two batteries, then we use one 2-channel relay module. This module has two relays, each with three terminals — NO (Normally Open), COM (Common), and NC (Normally Closed).

We connect the NO terminal of Relay 1 to the positive terminal of Battery 1. We connect the NO terminal of Relay 2 to the positive terminal of Battery 2.

Now we take both COM terminals from Relay 1 and Relay 2 and join them together, and then connect that to the output of the converter through a Schottky diode. That diode blocks reverse flow from battery to converter.

This way when Relay 1 is activated, Battery 1 gets charged. When Relay 2 is activated, Battery 2 gets charged.

The IN1 and IN2 pins of the relay module are connected to D6 and D7 of Arduino. Arduino will switch them as needed.

So final:

• Relay1 NO → Battery1 +
• Relay2 NO → Battery2 +
• Relay1 COM and Relay2 COM joined → Diode → converter output +
• Relay IN1 → Arduino D6
• Relay IN2 → Arduino D7

6. how to connect lcd i2c display

Now we connect the 16x2 LCD with I2C module to Arduino.

• Connect the SDA pin of the LCD to A4 of Arduino Nano.
• Connect the SCL pin of the LCD to A5 of Arduino Nano.
• Connect the VCC of LCD to 5V pin of Arduino.
• Connect the GND of LCD to GND of Arduino.

So final:

• LCD SDA → Arduino A4
• LCD SCL → Arduino A5
• LCD VCC → 5V
• LCD GND → GND

Arduino Logic

Now I will tell how Arduino is working in this project. First Arduino will take readings from solar panel using INA219 module. It will get voltage and current and then multiply both to get power.

Then it compares that with last reading. If power is increased then it increases pwm little. If power is decreased then it reduces pwm.

This way it finds maximum point of power and keeps it there. Then it reads battery voltage using voltage divider and analog read.

It shows all values on LCD screen. It also controls relay 1 and relay 2 so that we can charge both batteries one after one. If battery is full then it cuts charging.

Circuit Diagram

Arduino Code

#include <Wire.h>
#include <Adafruit_INA219.h>
#include <LiquidCrystal_I2C.h>

Adafruit_INA219 ina219;
LiquidCrystal_I2C lcd(0x27, 16, 2); // LCD with I2C

int pwmPin = 9;
int battPin = A1;

float voltage = 0;
float current = 0;
float oldPower = 0;
int pwmValue = 100;

float batteryVolt = 0;
float fullLimit = 14.4; // full charge cutoff voltage
bool cutoff = false;    // latch flag

void setup() {
  Serial.begin(9600);
  ina219.begin();
  lcd.begin();
  lcd.backlight();
  pinMode(pwmPin, OUTPUT);
  analogWrite(pwmPin, pwmValue);
}

void loop() {
  // read battery voltage
  float raw = analogRead(battPin);
  float sensed = raw * (5.0 / 1023.0);
  batteryVolt = sensed * ((10.0 + 2.2) / 2.2);  // voltage divider scaling

  // check for full charge
  if (batteryVolt >= fullLimit) {
    analogWrite(pwmPin, 0);  // turn off PWM
    cutoff = true;           // set latch
  }

  // do mppt only if not cutoff
  if (!cutoff) {
    voltage = ina219.getBusVoltage_V();
    current = ina219.getCurrent_mA() / 1000.0;
    float power = voltage * current;

    if (power > oldPower) pwmValue += 1;
    else pwmValue -= 1;
    pwmValue = constrain(pwmValue, 50, 230);
    analogWrite(pwmPin, pwmValue);
    oldPower = power;
  }

  // display everything
  lcd.setCursor(0, 0);
  lcd.print("S:");
  lcd.print(voltage, 1); lcd.print("V ");
  lcd.print(current, 1); lcd.print("A");

  lcd.setCursor(0, 1);
  lcd.print("B:");
  lcd.print(batteryVolt, 1); lcd.print("V ");
  lcd.print(pwmValue);

  delay(1000);
}