Project Summary
Project Title:
Design and Implementation of a Smart Grid Load Redistribution System Using IoT
This project presents an IoT-based smart electrical load management system designed to monitor grid voltage and current and automatically manage multiple electrical loads according to the measured load condition.
The system uses an Arduino as the main controller and an ESP8266 Wi-Fi module for IoT connectivity. A ZMP101B voltage sensor measures the AC supply voltage, while an ACS712 current sensor measures the load current. The Arduino processes these measurements and controls three relay channels, each connected to a different AC bulb representing an individual electrical load.
When the monitored load reaches a predefined limit, the controller can activate the alarm and progressively disconnect selected loads through the relays. This demonstrates the basic concept of automatic load shedding and load redistribution. The ESP8266 sends electrical parameters and load status to an IoT/web dashboard for remote monitoring.
Main Components
- Arduino
- ESP8266 Wi-Fi module
- ZMP101B voltage sensor
- ACS712 current sensor
- 3 relay modules/coils
- 3 AC bulbs as demonstration loads
- Alarm/buzzer
- Power supply
Working Flow
AC Grid Supply → Voltage & Current Sensors → Arduino → Load Analysis → Relay Control → 3 Loads
At the same time:
Arduino → ESP8266 → Wi-Fi → IoT/Web Dashboard
Major Features
- Real-time voltage monitoring
- Real-time current monitoring
- Electrical load/power estimation
- Automatic load management
- Three independent relay-controlled loads
- Overload detection
- Automatic load shedding
- Alarm indication
- ESP8266 Wi-Fi communication
- IoT/web-based remote monitoring
- Load status monitoring
- Improved electrical load management
Expected Operation
Normal condition:
All three loads remain ON.
High-load condition:
The system detects excessive current/power and disconnects a selected lower-priority load.
Persistent overload:
Additional loads can be disconnected according to the programmed priority.
Critical condition:
The alarm is activated and the system reports the condition through the IoT interface.
Safety: The three bulbs represent AC/mains loads in the prototype. Properly rated relays, fuses/MCBs, isolation, insulated wiring, and an enclosed mains section should be used.
Project Documentation
Below is a complete documentation structure for your project, including the project description, objectives, hardware, working principle, block diagram, circuit/pin connections, flowcharts, control algorithm, Arduino code, ESP8266 IoT code, testing procedure, advantages, limitations, applications, and future scope.
Design and Implementation of a Smart Grid Load Redistribution System Using IoT
- Abstract
The Smart Grid Load Redistribution System Using IoT is an intelligent electrical load monitoring and management system designed to monitor the voltage and current of an electrical supply and automatically control multiple electrical loads according to the measured load condition.
The proposed system uses an Arduino as the main controller, an ESP8266 Wi-Fi module for IoT communication, a ZMPT101B voltage sensor for AC voltage measurement, and an ACS712 current sensor for AC current measurement. Three relay channels are used to control three separate electrical loads represented by AC bulbs. An alarm/buzzer provides a local indication when an overload or abnormal electrical condition is detected.
The Arduino continuously measures the electrical parameters, calculates the approximate load power, compares the measured load with predefined safety limits, and controls the relay channels according to load priority. During normal operation, all loads can remain active. When excessive loading is detected, the system can disconnect lower-priority loads sequentially. The ESP8266 transmits the measured parameters and load status to an IoT/web platform for remote monitoring.
The project demonstrates the basic principles of smart load management, automatic load shedding, electrical parameter monitoring, IoT connectivity, and intelligent energy management.
Technical terminology: In this prototype, "load redistribution" is implemented primarily through priority-based load management/load shedding. It does not physically redistribute power between utility-grid phases.
- Introduction
Traditional electrical systems generally depend on manual monitoring and switching of loads. When several loads operate simultaneously, the total current can increase beyond the desired operating limit. This can result in excessive loading, unnecessary energy consumption, or activation of protective devices.
A smart load management system can continuously monitor electrical parameters and automatically control non-critical loads.
The proposed system combines:
- Electrical sensing
- Microcontroller processing
- Automatic relay control
- Overload detection
- Alarm indication
- Wi-Fi communication
- IoT monitoring
The Arduino performs the real-time sensing and control functions, while the ESP8266 provides wireless communication between the physical system and an IoT/web platform.
- Project Objectives
The main objectives are:
- To continuously monitor AC voltage.
- To continuously monitor load current.
- To estimate electrical power consumption.
- To monitor multiple electrical loads.
- To control three independent loads using relays.
- To detect excessive electrical loading.
- To automatically disconnect lower-priority loads when required.
- To activate an alarm during abnormal conditions.
- To transmit electrical data through Wi-Fi.
- To provide IoT-based remote monitoring.
- To demonstrate intelligent electrical load management.
- Proposed System
The proposed system consists of five major sections:
Section 1 — Measurement
The ZMPT101B measures AC voltage and the ACS712 measures AC current.
Section 2 — Processing
The Arduino receives the sensor signals and calculates:
- Voltage
- Current
- Approximate power
- Load condition
Section 3 — Load Control
Three relay channels control three separate loads:
Relay 1 → Bulb 1 → Load 1
Relay 2 → Bulb 2 → Load 2
Relay 3 → Bulb 3 → Load 3
Section 4 — Protection
When the load exceeds the configured limit:
Overload
↓
Alarm ON
↓
Disconnect Load 3
↓
Check Load
↓
Still High?
↓
Disconnect Load 2
Section 5 — IoT
The ESP8266 sends information through Wi-Fi to an IoT/web dashboard.
- System Architecture
AC GRID SUPPLY
│
┌─────────────┴─────────────┐
│ │
ZMPT101B Sensor ACS712 Sensor
Voltage Measurement Current Measurement
│ │
└─────────────┬─────────────┘
│
ARDUINO UNO
Main Controller
│
┌───────────────────┼──────────────────┐
│ │ │
Relay 1 Relay 2 Relay 3
│ │ │
Bulb 1 Bulb 2 Bulb 3
Load 1 Load 2 Load 3
│
└───────────────┐
│
Alarm/Buzzer
│
ESP8266
Wi-Fi
│
INTERNET / IoT
│
WEB DASHBOARD
- Hardware Components
|
Component |
Quantity |
Function |
|
Arduino UNO |
1 |
Main controller |
|
ESP8266 |
1 |
Wi-Fi/IoT communication |
|
ZMPT101B |
1 |
AC voltage measurement |
|
ACS712 |
1 |
AC current measurement |
|
Relay module |
3 |
Load switching |
|
AC Bulb |
3 |
Demonstration loads |
|
Buzzer/Alarm |
1 |
Overload indication |
|
5V Power Supply |
1 |
Controller/relay supply |
|
Connecting wires |
As required |
Connections |
|
Fuse/MCB |
1 |
AC protection |
- ZMPT101B Voltage Sensor
The ZMPT101B is an isolated AC voltage sensing module.
It provides a low-voltage analog signal corresponding to the measured AC voltage.
Connection
ZMPT101B
├── VCC → 5V
├── GND → Arduino GND
└── OUT → Arduino A0
The actual voltage calibration depends on the sensor module and its potentiometer/calibration setting.
Therefore, the voltage calibration constant in the software should be adjusted using a properly rated measuring instrument.
- ACS712 Current Sensor
The ACS712 measures current using the Hall-effect principle.
Typical versions include:
- ACS712 5A
- ACS712 20A
- ACS712 30A
The output is an analog voltage proportional to the current.
ACS712
├── VCC → 5V
├── GND → Arduino GND
└── OUT → Arduino A1
The sensitivity depends on the exact ACS712 version.
Typical nominal sensitivities are:
|
Version |
Approx. Sensitivity |
|
5A |
185 mV/A |
|
20A |
100 mV/A |
|
30A |
66 mV/A |
The correct value must match the actual module used.
- Relay and Load Section
Three relays are used to control three separate loads.
Arduino D5 → Relay 1 → Bulb 1
Arduino D6 → Relay 2 → Bulb 2
Arduino D7 → Relay 3 → Bulb 3
Suggested priority:
Load 1 = Highest Priority
Load 2 = Medium Priority
Load 3 = Lowest Priority
Therefore, during overload:
First disconnect → Load 3
Second disconnect → Load 2
Last disconnect → Load 1
This priority can be changed in the program.
- Alarm Circuit
The alarm/buzzer is controlled by the Arduino.
Arduino D8 → Buzzer control
When an overload condition occurs:
Overload detected
↓
Buzzer ON
↓
Load management begins
For a higher-power alarm, use a transistor/MOSFET driver rather than connecting the alarm directly to an Arduino pin.
- ESP8266 IoT Section
The ESP8266 provides Wi-Fi connectivity.
The communication structure is:
Sensors
↓
Arduino
↓
Serial Communication
↓
ESP8266
↓
Wi-Fi Router
↓
Internet
↓
IoT Platform / Web Dashboard
The ESP8266 can transmit:
- Voltage
- Current
- Power
- Load 1 status
- Load 2 status
- Load 3 status
- Overload status
- Alarm status
- Arduino Pin Configuration
A practical pin assignment is:
|
Arduino Pin |
Connection |
|
A0 |
ZMPT101B voltage output |
|
A1 |
ACS712 current output |
|
D2 |
ESP8266 TX → Arduino RX |
|
D3 |
Arduino TX → ESP8266 RX through level shifting |
|
D5 |
Relay 1 |
|
D6 |
Relay 2 |
|
D7 |
Relay 3 |
|
D8 |
Alarm/Buzzer |
|
5V |
Sensor/relay supply as appropriate |
|
GND |
Common low-voltage ground |
Important ESP8266 note
The ESP8266 uses 3.3 V logic. Do not directly feed a 5 V Arduino TX signal into an ESP8266 RX pin. Use an appropriate 3.3 V logic-level interface/voltage divider.
- Complete Working Principle
Step 1 — System Initialization
When the system starts, the Arduino initializes:
- Analog sensor inputs
- Relay outputs
- Alarm output
- Serial communication
- ESP8266 communication
Initially:
Load 1 → ON
Load 2 → ON
Load 3 → ON
Alarm → OFF
Step 2 — Sensor Measurement
The Arduino reads the ZMPT101B and ACS712 signals.
Voltage Sensor → Voltage
Current Sensor → Current
The controller then estimates the electrical power.
For a simplified resistive-load demonstration:
P=V×IP = V \times I
where:
- P = power in watts
- V = RMS voltage
- I = RMS current
For real AC loads with significant power factor, actual real power requires power-factor measurement rather than simply multiplying RMS voltage and RMS current.
- Load Decision Algorithm
The controller compares measured power against a configured limit.
Example:
Power Limit = 1000 W
Normal
Power ≤ 1000 W
Load 1 = ON
Load 2 = ON
Load 3 = ON
Alarm = OFF
Overload
Power > 1000 W
↓
Alarm ON
↓
Load 3 OFF
↓
Measure again
If the load is still excessive:
Load 2 OFF
↓
Measure again
If still excessive:
Load 1 OFF
- Load Redistribution Flow
START
│
▼
Initialize Arduino
│
▼
Initialize ESP8266
│
▼
Connect Wi-Fi
│
▼
Read Voltage
│
▼
Read Current
│
▼
Calculate Power
│
▼
Send Data to IoT
│
▼
Is Load Safe?
/ \
YES NO
│ │
▼ ▼
Keep Loads Alarm ON
ON │
│ ▼
│ Turn OFF
│ Load 3
│ │
│ ▼
│ Check Load Again
│ │
│ Still Excessive?
│ / \
│ NO YES
│ │ │
│ │ ▼
│ │ Turn OFF
│ │ Load 2
│ │ │
│ │ ▼
│ │ Check Again
│ │
└────────┴───────────┐
▼
Update IoT Data
│
▼
Continuous Monitoring
│
└──→ Repeat
- Detailed Circuit Concept
AC 230V SUPPLY
L N
│ │
│ └───────────────────────┐
│ │
FUSE │
│ │
├──── ZMPT101B ─────┐ │
│ │ │
│ Voltage OUT │
│ │ │
│ A0 │
│ │ │
└──── ACS712 ───────┐ │
│ │
Current OUT │
│ │
A1 │
│
ARDUINO UNO │
┌───────────────────┐ │
│ │ │
A0 ◄─────┤ ZMPT101B │ │
A1 ◄─────┤ ACS712 │ │
│ │ │
D5 ─────►│ Relay 1 │────► Load 1
D6 ─────►│ Relay 2 │────► Load 2
D7 ─────►│ Relay 3 │────► Load 3
D8 ─────►│ Alarm │
│ │
D2 ◄─────┤ ESP8266 TX │
D3 ─────►│ ESP8266 RX* │
└───────────────────┘
│
▼
ESP8266
│
Wi-Fi
│
▼
IoT Dashboard
* Use appropriate 3.3 V level shifting between Arduino TX and ESP8266 RX.
- Control Logic
The software follows this logic:
IF voltage/current readings are valid
↓
Calculate electrical load
↓
IF load <= safe limit
↓
Keep all required loads ON
ELSE
↓
Activate alarm
↓
Turn OFF lowest-priority load
↓
Wait for stabilization
↓
Measure again
IF load is still high
↓
Turn OFF next lower-priority load
IF load becomes safe
↓
Maintain remaining loads
↓
Continue IoT monitoring
- Arduino Software
The following example assumes:
- ZMPT101B OUT → A0
- ACS712 OUT → A1
- Relay 1 → D5
- Relay 2 → D6
- Relay 3 → D7
- Buzzer → D8
- ESP8266 serial → D2/D3
It also assumes an active-LOW relay module. If your relay is active-HIGH, reverse the relay logic.
#include <SoftwareSerial.h>
#include <math.h>
// ---------------- PIN DEFINITIONS ----------------
#define VOLTAGE_PIN A0
#define CURRENT_PIN A1
#define RELAY1 5
#define RELAY2 6
#define RELAY3 7
#define BUZZER 8
// Arduino RX, TX
SoftwareSerial espSerial(2, 3);
// ---------------- SETTINGS ----------------
// Adjust these after calibration
float VOLTAGE_CALIBRATION = 1.00;
// ACS712 sensitivity.
// Change according to your actual ACS712 version.
float ACS_SENSITIVITY = 0.100; // 20A version = approx 100mV/A
// ADC reference
float ADC_REFERENCE = 5.0;
// Approximate safe power limit
float POWER_LIMIT = 1000.0;
// Recovery threshold with hysteresis
float RECOVERY_LIMIT = 800.0;
// Relay active LOW
#define RELAY_ON LOW
#define RELAY_OFF HIGH
bool load1 = true;
bool load2 = true;
bool load3 = true;
unsigned long lastSend = 0;
// ------------------------------------------------
void setup()
{
Serial.begin(9600);
espSerial.begin(9600);
pinMode(RELAY1, OUTPUT);
pinMode(RELAY2, OUTPUT);
pinMode(RELAY3, OUTPUT);
pinMode(BUZZER, OUTPUT);
digitalWrite(RELAY1, RELAY_ON);
digitalWrite(RELAY2, RELAY_ON);
digitalWrite(RELAY3, RELAY_ON);
digitalWrite(BUZZER, LOW);
delay(2000);
Serial.println("SMART GRID LOAD MANAGEMENT SYSTEM");
}
// ------------------------------------------------
float readVoltage()
{
long sum = 0;
for (int i = 0; i < 500; i++)
{
sum += analogRead(VOLTAGE_PIN);
delayMicroseconds(200);
}
float averageADC = sum / 500.0;
float sensorVoltage =
(averageADC * ADC_REFERENCE) / 1023.0;
/*
The exact conversion from sensor output
to AC RMS voltage depends on calibration.
Replace this factor after calibration.
*/
float mainsVoltage =
sensorVoltage * VOLTAGE_CALIBRATION;
return mainsVoltage;
}
// ------------------------------------------------
float readCurrent()
{
const int samples = 500;
float sumSquares = 0;
// Estimate ACS712 zero-current offset
float offset = 512.0;
for (int i = 0; i < samples; i++)
{
int adcValue = analogRead(CURRENT_PIN);
float centered =
adcValue - offset;
float voltage =
(centered * ADC_REFERENCE) / 1023.0;
sumSquares += voltage * voltage;
delayMicroseconds(200);
}
float rmsVoltage =
sqrt(sumSquares / samples);
float current =
rmsVoltage / ACS_SENSITIVITY;
return current;
}
// ------------------------------------------------
void controlLoads(float power)
{
if (power > POWER_LIMIT)
{
digitalWrite(BUZZER, HIGH);
// First shed lowest-priority load
if (load3)
{
digitalWrite(RELAY3, RELAY_OFF);
load3 = false;
Serial.println("OVERLOAD: LOAD 3 OFF");
delay(1000);
return;
}
// Second priority
if (load2)
{
digitalWrite(RELAY2, RELAY_OFF);
load2 = false;
Serial.println("OVERLOAD: LOAD 2 OFF");
delay(1000);
return;
}
// Last priority
if (load1)
{
digitalWrite(RELAY1, RELAY_OFF);
load1 = false;
Serial.println("CRITICAL: LOAD 1 OFF");
delay(1000);
return;
}
}
else
{
digitalWrite(BUZZER, LOW);
}
}
// ------------------------------------------------
void sendData(float voltage,
float current,
float power)
{
espSerial.print("V=");
espSerial.print(voltage, 2);
espSerial.print(",I=");
espSerial.print(current, 2);
espSerial.print(",P=");
espSerial.print(power, 2);
espSerial.print(",L1=");
espSerial.print(load1 ? 1 : 0);
espSerial.print(",L2=");
espSerial.print(load2 ? 1 : 0);
espSerial.print(",L3=");
espSerial.print(load3 ? 1 : 0);
espSerial.println();
}
// ------------------------------------------------
void loop()
{
float voltage = readVoltage();
float current = readCurrent();
float power = voltage * current;
Serial.print("Voltage: ");
Serial.print(voltage);
Serial.println(" V");
Serial.print("Current: ");
Serial.print(current);
Serial.println(" A");
Serial.print("Power: ");
Serial.print(power);
Serial.println(" W");
controlLoads(power);
if (millis() - lastSend > 5000)
{
sendData(voltage, current, power);
lastSend = millis();
}
delay(1000);
}
- Important Sensor Calibration
The above program intentionally leaves the voltage conversion as a calibration parameter because the actual ZMPT101B module output depends on the particular module and adjustment.
For example:
float VOLTAGE_CALIBRATION = 1.00;
should be experimentally calibrated.
Calibration procedure
Use a properly rated AC measuring instrument.
- Apply the intended AC input.
- Measure the actual RMS voltage using the reference instrument.
- Observe the Arduino calculated voltage.
- Adjust the calibration factor.
- Repeat until the displayed value is reasonably close.
- Do the same for the ACS712 current measurement.
Do not calibrate or probe exposed mains wiring by hand.
- ESP8266 IoT Software
The ESP8266 can receive the Arduino data through serial communication and upload it to an IoT service.
One practical implementation is ThingSpeak.
Replace:
YOUR_WIFI_NAME
YOUR_WIFI_PASSWORD
YOUR_THINGSPEAK_API_KEY
with your actual credentials.
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
const char* ssid = "YOUR_WIFI_NAME";
const char* password = "YOUR_WIFI_PASSWORD";
String apiKey = "YOUR_THINGSPEAK_API_KEY";
WiFiClient client;
String serialData = "";
float voltage = 0;
float current = 0;
float power = 0;
int load1 = 0;
int load2 = 0;
int load3 = 0;
void setup()
{
Serial.begin(9600);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED)
{
delay(500);
}
Serial.println();
Serial.println("ESP8266 CONNECTED");
Serial.println(WiFi.localIP());
}
void parseData(String data)
{
int p;
p = data.indexOf("V=");
if (p >= 0)
{
voltage =
data.substring(p + 2,
data.indexOf(",", p)).toFloat();
}
p = data.indexOf("I=");
if (p >= 0)
{
current =
data.substring(p + 2,
data.indexOf(",", p)).toFloat();
}
p = data.indexOf("P=");
if (p >= 0)
{
power =
data.substring(p + 2,
data.indexOf(",", p)).toFloat();
}
p = data.indexOf("L1=");
if (p >= 0)
{
load1 =
data.substring(p + 3,
data.indexOf(",", p)).toInt();
}
p = data.indexOf("L2=");
if (p >= 0)
{
load2 =
data.substring(p + 3,
data.indexOf(",", p)).toInt();
}
p = data.indexOf("L3=");
if (p >= 0)
{
load3 =
data.substring(p + 3).toInt();
}
}
void uploadData()
{
if (WiFi.status() != WL_CONNECTED)
{
WiFi.begin(ssid, password);
return;
}
HTTPClient http;
String url =
"http://api.thingspeak.com/update?api_key="
+ apiKey
+ "&field1=" + String(voltage, 2)
+ "&field2=" + String(current, 2)
+ "&field3=" + String(power, 2)
+ "&field4=" + String(load1)
+ "&field5=" + String(load2)
+ "&field6=" + String(load3);
http.begin(client, url);
int httpCode = http.GET();
Serial.print("ThingSpeak Response: ");
Serial.println(httpCode);
http.end();
}
void loop()
{
if (Serial.available())
{
serialData = Serial.readStringUntil('\n');
serialData.trim();
if (serialData.length() > 0)
{
parseData(serialData);
Serial.print("Voltage = ");
Serial.println(voltage);
Serial.print("Current = ");
Serial.println(current);
Serial.print("Power = ");
Serial.println(power);
uploadData();
}
}
delay(100);
}
- IoT Data Fields
The IoT dashboard can contain:
|
Field |
Parameter |
|
Field 1 |
Voltage |
|
Field 2 |
Current |
|
Field 3 |
Power |
|
Field 4 |
Load 1 |
|
Field 5 |
Load 2 |
|
Field 6 |
Load 3 |
Example:
Voltage : 231 V
Current : 3.25 A
Power : 750 W
Load 1 : ON
Load 2 : ON
Load 3 : OFF
System Status : LOAD MANAGED
- Software Flowchart
┌───────────┐
│ START │
└─────┬─────┘
↓
┌──────────────────┐
│ Initialize System│
└────────┬─────────┘
↓
┌──────────────────┐
│ Initialize Wi-Fi │
└────────┬─────────┘
↓
┌──────────────────┐
│ Read Voltage │
│ Read Current │
└────────┬─────────┘
↓
┌──────────────────┐
│ Calculate Power │
└────────┬─────────┘
↓
┌──────────────────┐
│ Send IoT Data │
└────────┬─────────┘
↓
┌────────────┐
│ Load Safe? │
└─────┬──┬───┘
YES│ │NO
│ │
↓ ↓
┌─────────┐ ┌─────────────┐
│ Keep ON │ │ Alarm ON │
└────┬────┘ └──────┬──────┘
│ ↓
│ ┌──────────────┐
│ │ Load 3 OFF │
│ └──────┬───────┘
│ ↓
│ ┌──────────────┐
│ │ Measure Again│
│ └──────┬───────┘
│ ↓
│ Still High?
│ / \
│ NO YES
│ │ ↓
│ │ Load 2 OFF
│ │ ↓
│ │ Measure Again
│ │
└───────┴───────────────→
↓
CONTINUOUS LOOP
- Hardware Flow
AC Supply
↓
┌──────────────────────┐
│ Voltage Measurement │
│ ZMPT101B │
└──────────┬───────────┘
│
├─────────────┐
↓ ↓
Arduino ACS712
│ Current
│ Measurement
└─────┬───────┘
↓
Load Calculation
↓
Decision Making
↓
┌─────────┼─────────┐
↓ ↓ ↓
Relay 1 Relay 2 Relay 3
↓ ↓ ↓
Bulb 1 Bulb 2 Bulb 3
│
↓
Alarm
│
↓
ESP8266
↓
Wi-Fi
↓
IoT Dashboard
- Operating Modes
Mode 1 — Normal
Voltage Normal
Current Normal
Power Normal
Relay 1 = ON
Relay 2 = ON
Relay 3 = ON
Alarm = OFF
Mode 2 — High Load
Power > Limit
Alarm = ON
Relay 3 = OFF
Mode 3 — Continued Overload
Power still > Limit
Relay 2 = OFF
Mode 4 — Critical Load
Power remains excessive
Relay 1 = OFF
Alarm = ON
- Example Demonstration
Suppose:
Voltage = 230 V
Load 1 = 200 W
Load 2 = 300 W
Load 3 = 600 W
Total:
Ptotal=200+300+600P_{total}=200+300+600 Ptotal=1100WP_{total}=1100W
If the configured limit is:
1000 W
then:
1100 W > 1000 W
Therefore:
Alarm ON
Load 3 OFF
After Load 3 is disconnected:
200 W + 300 W = 500 W
The system is now below the limit.
Therefore:
Load 1 = ON
Load 2 = ON
Load 3 = OFF
Alarm = OFF/managed according to program
This demonstrates priority-based automatic load management.
- Expected Results
The expected prototype results are:
|
Condition |
Load 1 |
Load 2 |
Load 3 |
Alarm |
|
Normal |
ON |
ON |
ON |
OFF |
|
High Load |
ON |
ON |
OFF |
ON |
|
Continued High Load |
ON |
OFF |
OFF |
ON |
|
Critical |
OFF |
OFF |
OFF |
ON |
|
Load Normalized |
Controlled recovery |
Controlled recovery |
Controlled recovery |
OFF |
The exact thresholds and recovery behavior should be determined from the actual prototype and programmed requirements.
- Testing Procedure
Test 1 — Voltage Sensor
Verify that the Arduino receives a changing analog signal when the monitored AC voltage changes.
Record:
Reference Voltage
Sensor Reading
Error
Test 2 — Current Sensor
Connect an appropriate test load and compare the ACS712 reading with a suitable reference meter.
Record:
Reference Current
ACS712 Current
Measurement Error
Test 3 — Relay Test
Test each relay individually:
Relay 1 → Bulb 1
Relay 2 → Bulb 2
Relay 3 → Bulb 3
Test 4 — Overload Test
Increase the demonstration load within safe limits.
Observe:
Power increases
↓
Threshold exceeded
↓
Alarm activates
↓
Lowest-priority relay switches OFF
↓
Power decreases
Test 5 — IoT Test
Check:
Arduino
↓
ESP8266
↓
Wi-Fi
↓
IoT platform
Verify that voltage, current, power and load status are updated.
- Advantages
- Automatic electrical load management.
- Real-time voltage monitoring.
- Real-time current monitoring.
- Multiple load control.
- Overload protection logic.
- Local alarm indication.
- IoT-based remote monitoring.
- Wireless communication.
- Reduced dependence on manual switching.
- Expandable architecture.
- Suitable for educational smart-grid demonstrations.
- Limitations
- The prototype uses simplified load-control logic.
- Voltage/current sensor calibration is required.
- ACS712 accuracy depends on the selected version and installation.
- Simple V × I gives apparent power for general AC loads unless power factor is accounted for.
- Wi-Fi-based monitoring depends on network availability.
- The prototype demonstrates load shedding rather than utility-scale grid power redistribution.
- Relay ratings must match the connected loads.
- Applications
The concept can be adapted for:
- Smart homes
- Smart buildings
- Industrial load management
- Energy monitoring systems
- Educational smart-grid prototypes
- Laboratory load management
- Commercial building automation
- IoT energy-management systems
- Automatic non-critical-load shedding
- Electrical safety monitoring
- Future Enhancements
The project can be extended with:
AI-Based Load Prediction
Historical power data can be analyzed to predict future load conditions.
Mobile Application
A mobile application can display:
Voltage
Current
Power
Load Status
Alarm Status
Remote Load Control
Authorized users could control individual loads through an IoT dashboard.
Cloud Database
Historical electrical data can be stored for:
- Daily analysis
- Weekly analysis
- Monthly consumption
- Peak-load identification
Energy Metering
Energy consumption can be calculated:
Energy=Power×TimeEnergy = Power \times Time
and displayed in kWh.
Advanced Power Measurement
A dedicated energy-metering IC or suitable power-monitoring hardware can be added for more accurate real-power and power-factor measurements.
AI-Based Load Scheduling
The system could automatically determine which loads should operate according to priority and predicted demand.
- Conclusion
The Design and Implementation of a Smart Grid Load Redistribution System Using IoT demonstrates how embedded systems and wireless communication can be combined to create an intelligent electrical load-management solution.
The ZMPT101B voltage sensor and ACS712 current sensor provide electrical measurements to the Arduino. The Arduino processes these measurements and controls three relay-operated loads. When the electrical load exceeds a predefined limit, the system can activate an alarm and progressively disconnect lower-priority loads. The ESP8266 provides wireless connectivity, allowing electrical parameters and load status to be monitored through an IoT platform.
The prototype therefore combines sensing, processing, automatic load control, alarm indication, and IoT monitoring into one integrated system.
- One-Line Project Architecture
ZMPT101B + ACS712
↓
Arduino
↓
Load Calculation & Decision
↓
┌──────┼──────┐
↓ ↓ ↓
R1 R2 R3
↓ ↓ ↓
B1 B2 B3
↓
Alarm
↓
ESP8266 Wi-Fi
↓
IoT / Web Dashboard
Important implementation note
For your actual prototype, use the exact sensor designation printed on your module—ZMPT101B is the commonly used AC voltage-sensor module. Also, the three bulbs are mains loads, so the AC side should use appropriately rated relays, fuse/MCB protection, insulated terminals/enclosure, and proper isolation from the Arduino/ESP8266 low-voltage circuitry. The circuit should be assembled and tested by someone qualified to work with mains voltage.
No comments:
Post a Comment