Below is a complete documentation framework for the project shown in your photographs and block diagram.
Smart Hybrid Solar–Wind EV Charging Station with Battery Storage and Intelligent Energy Management
Project type: Embedded systems / renewable energy / EV charging prototype
Controller: Arduino Nano ATmega328P
Energy sources: Solar panel + wind turbine
Storage: 1-cell Li-ion battery in the prototype
Detection: IR vehicle/object sensor
Display: 16×2 LCD
Control: Relay + LEDs + buzzer
Prototype charging output: Low-voltage DC charging for a small EV/toy EV or demonstration load
Important: The hardware visible in your photographs is a low-voltage educational prototype, not a charger for a full-size road EV. A real EV charging station requires an appropriately rated DC/DC or AC/DC charger, BMS, isolation, fusing, contactors, charge-control/communication hardware, enclosure and electrical protection. Do not connect this prototype directly to a vehicle traction battery.
The classic Arduino Nano uses an ATmega328P and provides digital/analog I/O suitable for this type of monitoring and control prototype. Arduino Documentation+1
1. Project title
Advanced Hybrid Solar–Wind EV Charging System with Battery Energy Storage and Continuous Dynamic Charging of Vehicles
A slightly more professional title for a report is:
Design and Implementation of a Smart Hybrid Solar–Wind Powered EV Charging Station with Battery Storage and Intelligent Energy Management
2. Abstract
The proposed system is a renewable-energy-based EV charging prototype that combines solar energy and wind energy as two independent renewable sources.
The generated electrical energy is conditioned and stored in a rechargeable battery. An Arduino Nano acts as the central energy-management controller. It monitors vehicle presence, battery/energy conditions and the charging state, then controls the charging path through a relay.
A 16×2 LCD provides information to the user. Red and green LEDs indicate system/charging status, while a buzzer provides an audible indication.
The main objective is to demonstrate how multiple intermittent renewable sources can be combined with energy storage and intelligent control to provide a more continuous charging supply.
The system can operate according to the following general priority:
Solar/Wind generation → Battery charging → Energy storage → EV charging
When renewable generation is insufficient, the stored battery energy can be used for the demonstration load. When sufficient renewable energy is available, charging can be enabled.
3. Main objectives
The project has the following objectives:
-
Generate electrical energy from a solar panel.
-
Generate electrical energy from a small wind turbine.
-
Combine/manage the renewable-energy sources.
-
Store generated energy in a rechargeable battery.
-
Detect the presence of a vehicle using an IR sensor.
-
Automatically enable/disable charging.
-
Display system status on a 16×2 LCD.
-
Provide red/green visual indication.
-
Provide buzzer indication.
-
Demonstrate intelligent energy management.
-
Reduce dependence on a conventional power source.
-
Demonstrate the concept of continuous/dynamic charging.
-
Provide a platform that can later be expanded with IoT monitoring, current sensing and proper EV charging hardware.
4. Basic working principle
The overall operation is:
SOLAR PANEL
│
│
▼
Solar regulator
│
│
├──────────────┐
│ │
│ ▼
│ ENERGY STORAGE
│ Li-ion Battery
│ │
│ │
WIND TURBINE │ ▼
│ │ DC/DC / Charger
│ │ │
▼ │ ▼
Rectifier ─────────┘ CHARGING OUTPUT
│
▼
EV LOAD
The Arduino is the supervisory controller:
┌─────────────────┐
│ SOLAR SOURCE │
└────────┬────────┘
│
▼
┌─────────────────┐
│ SOLAR CHARGING │
│ / REGULATION │
└────────┬────────┘
│
│
┌───────────────┐ ▼
│ WIND TURBINE │────► ENERGY MANAGEMENT
└───────┬───────┘ │
│ ▼
│ ┌─────────────┐
└────────────►│ BATTERY │
└──────┬──────┘
│
▼
┌───────────┐
│ DC/DC │
│ CHARGER │
└─────┬─────┘
│
▼
┌───────────┐
│ EV/LOAD │
└───────────┘
▲
│
┌───────┴────────┐
│ Arduino Nano │
└───────┬────────┘
│
┌──────────────┼───────────────┐
▼ ▼ ▼
IR Sensor LCD Relay/LED/Buzzer
5. Important improvement to the circuit in your photograph
Your hand-drawn diagram shows 5 V coming from both the solar panel and wind mill.
That is fine for a classroom demonstration only if the actual source voltage is regulated to 5 V.
A real small solar panel or wind generator does not necessarily produce a constant 5 V.
Therefore, the improved architecture should be:
SOLAR PANEL
│
▼
SOLAR REGULATOR / DC-DC
│
├─────────────┐
│ │
▼ ▼
BATTERY
▲ │
│ │
WIND TURBINE │
│ │
▼ │
RECTIFIER │
│ │
▼ │
WIND DC-DC ───────┘
For the Li-ion portion, a TP4056-type module is designed for a single-cell Li-ion battery, with approximately 4.2 V charge termination; protected versions commonly add over-discharge and over-current protection. Manuals++1
However, do not connect an unregulated solar/wind source directly to a TP4056. Its input is intended for approximately 5 V, and the charging current must be appropriate for the cell. Art of Circuits
6. Components required
A. Controller
| Component | Quantity | Purpose |
|---|---|---|
| Arduino Nano ATmega328P | 1 | Main controller |
| USB cable | 1 | Programming |
| Breadboard/PCB | 1 | Circuit assembly |
The classic Nano provides 20 digital I/O and 8 analog inputs, with six PWM outputs. Arduino Documentation
B. Renewable energy section
| Component | Qty | Function |
|---|---|---|
| Small solar panel | 1 | Solar generation |
| Small DC wind turbine/generator | 1 | Wind generation |
| Solar DC/DC regulator | 1 | Regulates solar output |
| Bridge rectifier | 1 | Rectifies generator output if necessary |
| Wind DC/DC regulator | 1 | Regulates wind output |
| Blocking diode/MOSFET arrangement | 1 | Prevents unwanted reverse current |
| Fuse | 1+ | Protection |
| Connecting wires | — | Connections |
7. Battery section
For the prototype shown:
-
1 × 3.7 V Li-ion/18650 cell
-
1 × protected TP4056 charger module
-
Battery holder
-
Fuse where appropriate
-
DC/DC boost/buck converter as required by the load
A protected TP4056 module is intended for a single Li-ion cell, not a series battery pack. FindMyChips+1
Important
Do not assume that connecting two 18650 cells together automatically makes a suitable battery pack.
For:
1S = one cell / one-cell voltage
2S = two cells in series
3S = three cells in series
a multi-cell pack requires an appropriately designed BMS/charger.
8. Vehicle detection
Use:
IR obstacle/vehicle sensor
The sensor detects whether the small EV/vehicle is positioned at the charging location.
Example:
Vehicle absent
│
▼
Charging disabled
Vehicle present
│
▼
Check battery/energy
│
▼
Charging enabled
9. Display
Use a standard:
16×2 LCD
The LCD can show:
HYBRID EV CHARGER
READY
or:
SOL: 4.8V
WIND: 3.9V
or:
BAT: 3.92V
CHARGING
or:
VEHICLE DETECTED
CHARGING ON
10. LEDs
Use two LEDs:
Green LED
Indicates:
System ready
or
Charging active
Red LED
Indicates:
Low battery
Fault
Charging disabled
Each LED should have an appropriate series resistor. Do not connect bare LEDs directly to Arduino I/O.
The ATmega328P datasheet specifies a 40 mA absolute maximum per I/O pin, while the normal test conditions for the I/O specifications are lower; design LEDs with resistors and stay well below those limits. Arduino Documentation
11. Buzzer
The buzzer can indicate:
-
Vehicle detected
-
Charging started
-
Charging completed
-
Low battery
-
Fault condition
For a larger buzzer, use a transistor driver instead of driving the buzzer directly from the Arduino pin.
12. Relay
The relay controls the charging path.
Arduino
Arduino D7
│
▼
Relay driver
│
▼
Relay
│
▼
Charging output
Do not connect a bare relay coil directly to an Arduino pin.
Use:
Arduino
│
▼
NPN transistor/MOSFET
│
▼
Relay coil
with a flyback diode for a conventional DC relay coil.
A ready-made 5 V relay module is easier for a student prototype.
13. Recommended Arduino pin configuration
Based on your photographed hand-drawn diagram, I recommend making the connections explicit as follows.
| Arduino Nano | Component |
|---|---|
| D2 | IR vehicle sensor |
| D3 | Speed/dynamic charging sensor, optional |
| D4 | Green LED |
| D5 | Red LED |
| D6 | Buzzer |
| D7 | Relay |
| D8 | LCD EN |
| D9 | LCD RS |
| D10 | LCD D4 |
| D11 | LCD D5 |
| D12 | LCD D6 |
| D13 | LCD D7 |
| A0 | Battery voltage sensing |
| A1 | Solar voltage sensing |
| A2 | Wind voltage sensing |
| A3 | Charging current sensor, optional |
| 5V | Logic supply |
| GND | Common ground |
This is a cleaned-up implementation of the wiring concept in your drawing rather than claiming every unclear hand-written connection in the photograph is exactly this mapping.
The official classic Nano pinout confirms the digital and analog pin arrangement used here. Arduino Documentation
14. Circuit schematic
Here is the recommended low-voltage prototype schematic.
┌─────────────────┐
│ SOLAR PANEL │
└────────┬────────┘
│
DC-DC
REGULATOR
│
│
├───────────────┐
│ │
│ ▼
│ BATTERY CHARGER
│ / POWER PATH
│ │
│ ▼
│ Li-ion Battery
│ │
│ ▼
│ DC/DC CONVERTER
│ │
│ ▼
│ EV LOAD
│
│
┌─────────────────┐ │
│ WIND TURBINE │ │
└────────┬────────┘ │
│ │
RECTIFIER │
│ │
DC-DC REGULATOR ─────┘
┌────────────────────┐
│ ARDUINO NANO │
│ │
Battery voltage ───────►│ A0 │
Solar voltage ─────────►│ A1 │
Wind voltage ──────────►│ A2 │
Current sensor ────────►│ A3 │
│ │
IR sensor ─────────────►│ D2 │
Speed sensor ──────────►│ D3 │
│ │
Green LED ◄─────────────│ D4 │
Red LED ◄───────────────│ D5 │
Buzzer ◄────────────────│ D6 │
Relay driver ◄──────────│ D7 │
│ │
LCD EN ◄────────────────│ D8 │
LCD RS ◄────────────────│ D9 │
LCD D4 ◄────────────────│ D10 │
LCD D5 ◄────────────────│ D11 │
LCD D6 ◄────────────────│ D12 │
LCD D7 ◄────────────────│ D13 │
└────────────────────┘
15. Battery voltage measurement circuit
Never connect a battery voltage higher than the Arduino input limit directly to an analog pin.
Use a voltage divider.
For example:
Battery +
│
│
R1
10kΩ
│
├──────────────► A0
│
R2
10kΩ
│
│
GND
For a 1-cell Li-ion battery:
Battery maximum ≈ 4.2 V
A0 voltage =
4.2 × 10k/(10k + 10k)
≈ 2.1 V
The software can then reconstruct the battery voltage.
16. Solar voltage measurement
Similarly:
Solar +
│
R3
│
├────────────► A1
│
R4
│
GND
Choose resistor values based on the maximum possible solar-panel voltage, not its nominal rating.
For example, if your regulated solar source is guaranteed to remain below 5 V, a 10 kΩ/10 kΩ divider gives:
5 V → 2.5 V at A1
17. Wind voltage measurement
Wind generator
│
▼
Rectifier
│
▼
Regulator
│
├──────────► Power system
│
▼
Voltage divider
│
▼
Arduino A2
This allows the controller to display the approximate wind-source voltage.
18. Relay schematic
Use a relay module:
Arduino D7
│
▼
┌─────────────┐
│ 5V RELAY │
│ MODULE │
│ │
│ IN ◄────────┤
│ VCC ◄── 5V │
│ GND ◄── GND │
└──────┬──────┘
│
▼
COM
│
├──── NO ───► EV charging supply
│
└──── NC ───► Normally disconnected
For the demonstration:
Relay OFF → charging output isolated
Relay ON → charging output connected
19. Complete system flowchart
START
│
▼
Initialize Arduino
│
▼
Initialize LCD / sensors
│
▼
Read solar voltage
│
▼
Read wind voltage
│
▼
Read battery voltage
│
▼
Check vehicle presence
│
┌───────┴────────┐
│ │
NO YES
│ │
▼ ▼
Charging OFF Check battery
│ │
│ ┌───────┴────────┐
│ │ │
│ LOW NORMAL
│ │ │
│ ▼ ▼
│ Charging OFF Check energy
│ │ │
│ │ ┌───────┴────────┐
│ │ │ │
│ │ AVAILABLE LOW
│ │ │ │
│ │ ▼ ▼
│ │ Relay ON Relay OFF
│ │ │ │
└────────┴────────┴────────────────┘
│
▼
Update LCD
│
▼
Update LEDs
│
▼
Check buzzer
│
▼
LOOP
20. Intelligent energy-management algorithm
The important part of the project is the energy-management logic.
A simple algorithm is:
IF vehicle absent:
Charging OFF
ELSE IF battery voltage < minimum:
Charging OFF
Red LED ON
Display LOW BATTERY
ELSE IF renewable energy available:
Charging ON
Green LED ON
Display CHARGING
ELSE:
Use stored battery energy if permitted
IF battery reaches upper threshold:
Charging OFF
Display BATTERY FULL
For the actual prototype, the threshold values should be experimentally calibrated for your particular battery, converter and load.
21. Dynamic charging concept
Your project title mentions:
Continuous Dynamic Charging Vehicles
For the prototype, this can be demonstrated by detecting a moving or positioned vehicle.
For example:
IR sensor 1
│
▼
Vehicle enters charging zone
│
▼
Charging enabled
│
▼
Vehicle moves through zone
│
▼
Charging condition maintained
│
▼
Vehicle leaves
│
▼
Charging disabled
A more advanced implementation can use multiple sensors:
IR-1 ───────► Arduino ◄────── IR-2
│
▼
Vehicle direction
│
▼
Dynamic charging
For a real moving-EV wireless/dynamic-charging system, however, the power-transfer hardware would be substantially more complex than the low-voltage prototype shown in your photographs.
22. Arduino software
Below is a complete starting program for the proposed prototype.
Required library
Install:
LiquidCrystal
It is normally included with the Arduino environment.
Arduino code
#include <LiquidCrystal.h>
/*
SMART HYBRID SOLAR-WIND EV CHARGING STATION
Arduino Nano ATmega328P
Prototype / educational low-voltage system
*/
// ---------------- LCD ----------------
// RS, EN, D4, D5, D6, D7
LiquidCrystal lcd(9, 8, 10, 11, 12, 13);
// ---------------- DIGITAL PINS ----------------
const byte IR_PIN = 2;
const byte SPEED_PIN = 3;
const byte GREEN_LED = 4;
const byte RED_LED = 5;
const byte BUZZER = 6;
const byte RELAY_PIN = 7;
// ---------------- ANALOG PINS ----------------
const byte BATTERY_PIN = A0;
const byte SOLAR_PIN = A1;
const byte WIND_PIN = A2;
const byte CURRENT_PIN = A3;
// ---------------- ADC ----------------
const float ADC_REF = 5.0;
const float ADC_MAX = 1023.0;
// Voltage-divider ratios
//
// Example:
// 10k upper + 10k lower = ratio 2.0
//
// Change these values to match your actual resistor network.
const float BATTERY_DIVIDER = 2.0;
const float SOLAR_DIVIDER = 2.0;
const float WIND_DIVIDER = 2.0;
// ---------------- BATTERY LIMITS ----------------
// These are prototype values.
// Calibrate for your actual battery chemistry/system.
const float BATTERY_LOW = 3.20;
const float BATTERY_HIGH = 4.15;
// Minimum renewable-source voltage
const float SOLAR_MIN = 4.0;
const float WIND_MIN = 3.0;
// ---------------- STATUS ----------------
bool vehiclePresent = false;
bool charging = false;
unsigned long lastDisplayUpdate = 0;
unsigned long lastBeep = 0;
// ------------------------------------------------
// Read voltage through ADC
// ------------------------------------------------
float readVoltage(byte pin, float dividerRatio)
{
int adcValue = analogRead(pin);
float adcVoltage =
(adcValue * ADC_REF) / ADC_MAX;
float actualVoltage =
adcVoltage * dividerRatio;
return actualVoltage;
}
// ------------------------------------------------
// Beep function
// ------------------------------------------------
void beep(unsigned int frequency, unsigned int duration)
{
tone(BUZZER, frequency, duration);
}
// ------------------------------------------------
// Setup
// ------------------------------------------------
void setup()
{
pinMode(IR_PIN, INPUT);
pinMode(SPEED_PIN, INPUT);
pinMode(GREEN_LED, OUTPUT);
pinMode(RED_LED, OUTPUT);
pinMode(BUZZER, OUTPUT);
pinMode(RELAY_PIN, OUTPUT);
// Start with charger OFF
digitalWrite(RELAY_PIN, LOW);
digitalWrite(GREEN_LED, LOW);
digitalWrite(RED_LED, LOW);
lcd.begin(16, 2);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("HYBRID EV");
lcd.setCursor(0, 1);
lcd.print("CHARGER");
delay(2000);
lcd.clear();
beep(2000, 150);
}
// ------------------------------------------------
// Main loop
// ------------------------------------------------
void loop()
{
// -------- Read sensors --------
float batteryVoltage =
readVoltage(BATTERY_PIN, BATTERY_DIVIDER);
float solarVoltage =
readVoltage(SOLAR_PIN, SOLAR_DIVIDER);
float windVoltage =
readVoltage(WIND_PIN, WIND_DIVIDER);
// Depending on the particular IR sensor module,
// LOW may mean vehicle detected.
vehiclePresent = (digitalRead(IR_PIN) == LOW);
// -------- Determine renewable energy --------
bool solarAvailable =
solarVoltage >= SOLAR_MIN;
bool windAvailable =
windVoltage >= WIND_MIN;
bool renewableAvailable =
solarAvailable || windAvailable;
// -------- Energy management --------
if (!vehiclePresent)
{
// No vehicle
charging = false;
digitalWrite(RELAY_PIN, LOW);
digitalWrite(GREEN_LED, LOW);
digitalWrite(RED_LED, LOW);
}
else
{
// Vehicle detected
if (batteryVoltage < BATTERY_LOW)
{
// Battery too low
charging = false;
digitalWrite(RELAY_PIN, LOW);
digitalWrite(GREEN_LED, LOW);
digitalWrite(RED_LED, HIGH);
if (millis() - lastBeep > 5000)
{
beep(1000, 300);
lastBeep = millis();
}
}
else if (batteryVoltage >= BATTERY_HIGH)
{
// Battery is at upper limit
charging = false;
digitalWrite(RELAY_PIN, LOW);
digitalWrite(GREEN_LED, HIGH);
digitalWrite(RED_LED, LOW);
}
else if (renewableAvailable)
{
// Renewable energy available
charging = true;
digitalWrite(RELAY_PIN, HIGH);
digitalWrite(GREEN_LED, HIGH);
digitalWrite(RED_LED, LOW);
}
else
{
// Vehicle present but insufficient renewable energy
charging = false;
digitalWrite(RELAY_PIN, LOW);
digitalWrite(GREEN_LED, LOW);
digitalWrite(RED_LED, HIGH);
}
}
// -------- LCD display --------
if (millis() - lastDisplayUpdate >= 1000)
{
lastDisplayUpdate = millis();
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("B:");
lcd.print(batteryVoltage, 2);
lcd.print("V ");
if (vehiclePresent)
lcd.print("VEH");
else
lcd.print("NO");
lcd.setCursor(0, 1);
if (charging)
{
lcd.print("CHARGING ");
}
else if (batteryVoltage < BATTERY_LOW)
{
lcd.print("LOW BAT ");
}
else if (batteryVoltage >= BATTERY_HIGH)
{
lcd.print("BAT FULL ");
}
else
{
lcd.print("READY ");
}
if (solarAvailable)
lcd.print("S");
if (windAvailable)
lcd.print("W");
}
delay(100);
}
23. How the software works
The software starts by initializing:
lcd.begin(16, 2);
Then it configures the sensors and outputs:
pinMode(IR_PIN, INPUT);
pinMode(RELAY_PIN, OUTPUT);
The Arduino repeatedly reads:
Battery voltage
Solar voltage
Wind voltage
Vehicle presence
It then makes a decision.
24. Vehicle detection logic
The code contains:
vehiclePresent = (digitalRead(IR_PIN) == LOW);
Many inexpensive IR modules produce LOW when an object is detected.
However, some modules work in the opposite direction.
If yours behaves opposite to the code, change it to:
vehiclePresent = (digitalRead(IR_PIN) == HIGH);
25. Charging decision
The most important section is:
if (!vehiclePresent)
{
charging = false;
}
Therefore:
No vehicle → charger OFF
Then:
if (batteryVoltage < BATTERY_LOW)
{
charging = false;
}
Therefore:
Battery too low → charger OFF
Then:
else if (renewableAvailable)
{
charging = true;
}
Therefore:
Vehicle present
+
Renewable energy available
+
Battery acceptable
↓
Charging ON
26. LCD information
The LCD can show:
Normal
B:3.91V VEH
CHARGING SW
where:
S = Solar available
W = Wind available
No vehicle
B:3.91V NO
READY
Low battery
B:3.15V VEH
LOW BAT
Battery full
B:4.15V VEH
BAT FULL
27. Improved LCD version
If you want the project to look more professional during demonstration, rotate several screens.
Screen 1
HYBRID EV SYSTEM
SOLAR + WIND
Screen 2
SOL: 4.8V
WIND: 4.1V
Screen 3
BAT: 3.92V
VEHICLE: YES
Screen 4
CHARGING
ENERGY: HYBRID
This gives the impression of an actual energy-management interface.
28. Complete software flow
POWER ON
│
▼
Initialize Arduino
│
▼
Initialize LCD
│
▼
Read solar voltage
│
▼
Read wind voltage
│
▼
Read battery voltage
│
▼
Read IR sensor
│
▼
Is vehicle present?
/ \
NO YES
│ │
▼ ▼
Relay OFF Check battery
│
┌───────┴───────┐
│ │
LOW ACCEPTABLE
│ │
▼ ▼
Relay OFF Renewable energy?
│
┌─────┴─────┐
NO YES
│ │
▼ ▼
Relay OFF Relay ON
│ │
└──────┬──────┘
│
▼
Update LCD
│
▼
Update LEDs
│
▼
LOOP AGAIN
29. Energy flow diagram
The most important diagram for your project report is:
RENEWABLE ENERGY
│
┌──────────────┴──────────────┐
│ │
▼ ▼
┌───────────┐ ┌───────────┐
│ SOLAR │ │ WIND │
│ PANEL │ │ GENERATOR │
└─────┬─────┘ └─────┬─────┘
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ Solar DC/DC │ │ Rectifier + │
│ Regulator │ │ Wind DC/DC │
└──────┬──────┘ └──────┬──────┘
│ │
└──────────────┬─────────────┘
│
▼
┌─────────────────┐
│ ENERGY STORAGE │
│ BATTERY │
└────────┬────────┘
│
▼
┌─────────────────┐
│ DC/DC CHARGING │
│ CONVERTER │
└────────┬────────┘
│
▼
┌─────────────────┐
│ EV / TEST LOAD │
└─────────────────┘
▲
│
┌────────┴────────┐
│ ARDUINO NANO │
│ ENERGY MANAGER │
└────────┬────────┘
│
┌───────────────┬───────┼───────────────┐
│ │ │ │
▼ ▼ ▼ ▼
IR SENSOR LCD RELAY LED/BUZZER
30. Detailed hardware operation
Step 1 — Solar generation
Solar radiation falls on the photovoltaic panel.
The solar panel converts:
Solar energy
↓
Electrical DC energy
The output depends on:
-
Solar irradiance
-
Panel size
-
Temperature
-
Panel orientation
-
Load
Therefore, the output isn't inherently a fixed 5 V source.
31. Step 2 — Wind generation
The wind turbine converts:
Wind kinetic energy
↓
Mechanical rotation
↓
Generator
↓
Electrical energy
If the generator produces AC:
Wind generator
↓
Bridge rectifier
↓
DC
Then:
DC
↓
DC/DC regulator
↓
Battery/power bus
32. Step 3 — Energy combination
The two sources are brought into a controlled DC power system.
Conceptually:
Solar ──► Regulation ──┐
├──► DC ENERGY BUS
Wind ───► Regulation ──┘
For a more advanced system, use separate charge controllers or an appropriate hybrid renewable-energy controller rather than simply joining two uncontrolled sources together.
33. Step 4 — Battery storage
The battery stores excess renewable energy.
For example:
Renewable generation > load
│
▼
Battery charging
When generation decreases:
Renewable generation < load
│
▼
Battery supplies load
This is the fundamental reason for including battery storage.
34. Step 5 — Vehicle detection
The IR sensor detects the small vehicle.
Vehicle enters
↓
IR sensor detects object
↓
Arduino receives signal
↓
Arduino checks battery
↓
Arduino checks energy
↓
Charging decision
35. Step 6 — Intelligent decision
The Arduino acts as the energy-management controller.
Example:
| Vehicle | Battery | Renewable energy | Result |
|---|---|---|---|
| No | Normal | Yes | Charging OFF |
| Yes | Low | Yes | Charging OFF |
| Yes | Normal | Yes | Charging ON |
| Yes | Full | Yes | Charging OFF |
| Yes | Normal | No | Battery/backup policy |
| No | Any | Any | Charging OFF |
This table can go directly into your project report.
36. Step 7 — Relay operation
When charging is permitted:
Arduino D7
↓
Relay driver
↓
Relay ON
↓
Charging supply connected
When charging is not permitted:
Arduino D7
↓
Relay OFF
↓
Charging supply disconnected
37. Step 8 — User indication
The user receives three forms of feedback:
LCD
Detailed information.
LED
Quick visual status.
Buzzer
Audible notification.
Example:
GREEN = charging/ready
RED = low battery/fault
BEEP = event/alert
38. Project state diagram
┌─────────────┐
│ IDLE │
└──────┬──────┘
│
Vehicle detected
│
▼
┌─────────────┐
│ CHECK │
│ ENERGY │
└──────┬──────┘
│
┌────────────┼─────────────┐
│ │ │
▼ ▼ ▼
LOW BATTERY ENERGY OK BATTERY FULL
│ │ │
▼ ▼ ▼
FAULT/ CHARGING COMPLETE
STOP │ │
│ │
└──────┬──────┘
│
Vehicle leaves
│
▼
IDLE
39. Suggested project enclosure
For a finished model, arrange the components like this:
┌───────────────────────────────────────────┐
│ HYBRID SOLAR-WIND EV │
│ CHARGING STATION │
│ │
│ ┌─────────────────────┐ │
│ │ 16 × 2 LCD │ │
│ └─────────────────────┘ │
│ │
│ GREEN ● RED ● │
│ │
│ ┌─────────────────────┐ │
│ │ CHARGING CONNECTOR │ │
│ └─────────────────────┘ │
│ │
│ IR SENSOR │
│ ▼ │
└───────────────────────────────────────────┘
40. Prototype testing procedure
Do not start by connecting everything simultaneously.
Test in stages.
Test 1 — Arduino
Connect only:
Arduino + USB
Upload a Blink program.
Confirm that the Nano works.
Test 2 — LCD
Connect LCD.
Upload:
#include <LiquidCrystal.h>
LiquidCrystal lcd(9, 8, 10, 11, 12, 13);
void setup()
{
lcd.begin(16, 2);
lcd.print("HYBRID EV");
}
void loop()
{
}
Expected:
HYBRID EV
41. Test 3 — IR sensor
Upload:
const int IR = 2;
void setup()
{
Serial.begin(9600);
pinMode(IR, INPUT);
}
void loop()
{
Serial.println(digitalRead(IR));
delay(500);
}
Open Serial Monitor.
Move an object in front of the sensor.
Record whether:
0 = detected
1 = not detected
or the reverse.
42. Test 4 — LEDs
Test:
D4 → Green
D5 → Red
with appropriate resistors.
43. Test 5 — Buzzer
Test:
tone(6, 2000, 500);
The buzzer should sound.
44. Test 6 — Relay
First test the relay without connecting the charging load.
digitalWrite(7, HIGH);
delay(2000);
digitalWrite(7, LOW);
delay(2000);
You should hear the relay switching.
45. Test 7 — Battery measurement
Measure the actual battery voltage using a multimeter.
Suppose:
Multimeter = 3.91 V
Arduino calculation should be close to:
3.91 V
If the LCD says 4.30 V, adjust the voltage-divider calibration.
46. Test 8 — Solar input
Connect the regulated solar supply.
Measure with a multimeter.
Compare:
Multimeter solar = 4.85 V
LCD = 4.81 V
Calibrate the software if necessary.
47. Test 9 — Wind input
Rotate the turbine or expose it to airflow.
Measure the regulated output.
Verify that the Arduino detects it.
48. Test 10 — Complete charging sequence
Perform:
Power ON
↓
No vehicle
↓
Charging OFF
↓
Vehicle detected
↓
Battery acceptable
↓
Solar/wind available
↓
Relay ON
↓
Charging ON
Then remove the vehicle:
Vehicle removed
↓
Arduino detects absence
↓
Relay OFF
↓
Charging OFF
49. Test-case table for your report
| Test | Input condition | Expected result |
|---|---|---|
| T1 | Power ON | Arduino initializes |
| T2 | No vehicle | Charging OFF |
| T3 | Vehicle detected | System checks energy |
| T4 | Low battery | Red LED + charging OFF |
| T5 | Battery normal + renewable energy | Charging ON |
| T6 | Battery full | Charging OFF |
| T7 | Solar available | Solar status displayed |
| T8 | Wind available | Wind status displayed |
| T9 | Vehicle removed | Relay OFF |
| T10 | Fault/low energy | Alert indication |
50. Advantages
Renewable energy
Solar and wind reduce reliance on conventional electrical energy.
Energy storage
Battery storage allows energy to be retained for later use.
Intelligent control
The Arduino automatically makes charging decisions.
User feedback
LCD, LEDs and buzzer provide clear information.
Modular design
The system can later be expanded.
Educational value
It combines:
-
Renewable energy
-
Power electronics
-
Embedded programming
-
Sensors
-
Battery technology
-
Automation
-
EV charging concepts
51. Limitations of the prototype
Your current prototype has several limitations that should be stated honestly in the documentation.
-
Solar and wind generation is relatively small.
-
The prototype battery has limited energy capacity.
-
The Arduino does not itself perform high-power EV charging.
-
A relay provides simple ON/OFF control rather than sophisticated charge regulation.
-
The IR sensor only provides vehicle/object detection.
-
There is no full EV communication protocol.
-
There is no automotive-grade BMS.
-
There is no galvanic isolation suitable for a commercial EV charger.
-
Renewable generation varies with environmental conditions.
-
The prototype is intended for demonstration rather than road-EV charging.
52. Future enhancements
For an advanced version, add:
┌───────────────┐
│ IoT / ESP32 │
└───────┬───────┘
│
▼
Cloud dashboard
│
┌────────────────┼────────────────┐
▼ ▼ ▼
Voltage Current Energy
monitoring monitoring calculation
Possible improvements:
-
ESP32 Wi-Fi
-
Mobile application
-
Real-time power monitoring
-
Solar MPPT controller
-
Wind MPPT/control
-
Current sensor
-
Temperature sensor
-
Battery SOC estimation
-
Battery BMS
-
Data logging
-
Energy meter
-
Fault detection
-
Over-current protection
-
Over-voltage protection
-
Under-voltage protection
-
Short-circuit protection
-
Real EVSE hardware for a full-size vehicle
53. Recommended advanced architecture
For a more technically correct second-generation project:
SOLAR PV
│
▼
MPPT CONTROLLER
│
│
├─────────────┐
│ │
│ ▼
WIND GENERATOR │ DC BUS
│ │ │
▼ │ │
RECTIFIER │ │
│ │ │
▼ │ ▼
WIND CONTROLLER ──────┘ BATTERY BMS
│
▼
BATTERY PACK
│
▼
DC/DC CONVERTER
│
▼
EV CHARGER
│
▼
EV
┌─────────────────────┐
│ ENERGY MANAGEMENT │
│ CONTROLLER │
│ Arduino / ESP32 │
└──────────┬──────────┘
│
┌────────────────────┼──────────────────┐
▼ ▼ ▼
Sensors Display Relay/
Voltage LCD/OLED Contactor
Current
Temperature
54. Key difference between your prototype and a real EV charger
This is especially important for your viva.
Your prototype demonstrates:
Renewable-energy generation + storage + automatic low-voltage charging control.
A commercial EV charger additionally needs to address:
High-power conversion + protection + battery/vehicle communication + charging protocol + isolation + thermal management + appropriately rated switching equipment.
So if an examiner asks:
“Can this circuit directly charge a real electric car?”
The technically correct answer is:
“No. The demonstrated circuit is a low-voltage educational prototype. It demonstrates the renewable-energy management and charging-control concept. A practical road-EV implementation would require a properly rated EVSE, DC/DC or AC/DC power stage, BMS/vehicle communication, isolation and electrical protection.”
55. Important battery safety
The Li-ion battery is the part of this project that requires particular care.
Use:
Protected Li-ion cell
+
Correct charger
+
Correct charge current
+
Correct battery configuration
+
Fuse/protection
A TP4056 is for a single-cell Li-ion charging application; it should not be treated as a universal charger for arbitrary battery packs. FindMyChips+1
Also, do not experiment with damaged, swollen or overheated cells.
56. Suggested final report structure
You can submit the project documentation in this sequence:
Chapter 1 — Introduction
-
EV charging
-
Renewable energy
-
Solar energy
-
Wind energy
-
Need for energy storage
Chapter 2 — Literature/technology background
-
Solar PV
-
Wind generation
-
Li-ion battery
-
Battery charging
-
Arduino
-
Sensors
-
Energy management
Chapter 3 — Proposed system
-
Objectives
-
System architecture
-
Block diagram
-
Energy flow
Chapter 4 — Hardware
-
Solar panel
-
Wind turbine
-
Rectifier
-
Regulators
-
Battery
-
Charger
-
Arduino Nano
-
IR sensor
-
LCD
-
Relay
-
LEDs
-
Buzzer
Chapter 5 — Circuit design
-
Complete schematic
-
Arduino connections
-
Voltage divider
-
Relay driver
-
LCD connections
-
Sensor connections
Chapter 6 — Software
-
Algorithm
-
Flowchart
-
Arduino program
-
Sensor processing
-
Energy-management logic
Chapter 7 — Implementation
-
Hardware assembly
-
Wiring
-
Testing
-
Calibration
Chapter 8 — Results
-
Solar voltage
-
Wind voltage
-
Battery voltage
-
Charging status
-
Sensor operation
-
LCD output
Chapter 9 — Advantages and limitations
Chapter 10 — Future scope
Chapter 11 — Conclusion
57. One-page project summary
PROJECT:
SMART HYBRID SOLAR-WIND EV CHARGING STATION
SOLAR PANEL
│
▼
SOLAR REGULATOR
│
│
WIND TURBINE ─► RECTIFIER ─► WIND REGULATOR
│
▼
ENERGY MANAGEMENT
│
▼
LI-ION BATTERY
│
▼
DC/DC CONVERTER
│
▼
EV LOAD
▲
│
RELAY
▲
│
ARDUINO NANO
│
┌─────────────┼─────────────┐
│ │ │
▼ ▼ ▼
IR SENSOR 16×2 LCD LED + BUZZER
Operating sequence
1. Solar and wind generate energy.
2. The energy is regulated.
3. Battery stores available energy.
4. Arduino monitors system conditions.
5. IR sensor detects the vehicle.
6. Arduino checks battery/energy conditions.
7. If charging is permitted, relay is activated.
8. Charging status appears on LCD.
9. Green/red LEDs indicate status.
10. Buzzer provides alerts.
11. When the vehicle leaves or charging must stop,
the relay is switched OFF.
This architecture closely follows the hardware concept visible in your photographs while making the power-conditioning and control portions safer and clearer for a formal project report. The classic Nano pinout and ATmega328P electrical limits used above are documented by Arduino/Microchip documentation. Arduino Documentation+1
Useful references
-
Arduino Nano official documentation
-
Arduino Nano pinout
-
ATmega328P datasheet
If you are building exactly the circuit in the photographs, the next useful step is to turn your hand-drawn diagram into a clean, labeled circuit schematic with every wire and Arduino pin numbered, and then adapt the code to the exact relay, IR sensor, LCD, battery-sensing and charger modules you have physically installed.
No comments:
Post a Comment