 The components used are as follows:

 ESP32 Microcontroller
 DS18B20 (Temp Sensor)
 SCT-013 (Current Sensor)
 ZMPT101B (Voltage Sensor)
 3 20x4 LCD Display
 3 Indicator Lamp
 Emeregency Stop Button
 Start Button
 Terminal Blocks
 Voltage Regulator
 Jumper Wires
 Blynk Application

 Working Principle
 The system continuously monitors the current, voltage,
and temperature associated with an induction motor using
the SCT-013, ZMPT101B, and DS18B20 sensors,
respectively. Each sensor has a dedicated LCD display and
indicator light to show its status, and individual start/stop
buttons to enable or disable each sensor's monitoring
function.
 A main start button powers on all sensors, while an
emergency stop button immediately halts motor operation
and sensor monitoring. In case of a detected fault (e.g.,
overcurrent, voltage anomaly, or overtemperature), a
buzzer sounds, and an alert is sent to the Blynk app for
remote monitoring.

COMPONENTS AND WORKING PRINCIPLE

1. ESP32 Microcontroller:
The ESP32 acts as the system’s central processor. It reads
data from sensors, displays it on individual LCD screens, monitors
fault conditions, controls indicators and buttons, and sends updates
to the Blynk app for remote monitoring.
The ESP32's GPIO pins handle inputs from the start/stop buttons and
outputs for indicator lights and the buzzer.

2. Voltage Regulator:
This component ensures a steady voltage supply to the ESP32
and other components. If using a higher voltage power supply (e.g.,
12V or 24V), the regulator steps it down to 3.3V or 5V, suitable for
the ESP32 and LCDs.

3. SCT-013 (Current Sensor):

The SCT-013 measures the current flowing through the motor.
It outputs a small AC signal proportional to the current, which is
converted to a readable voltage using a burden resistor. The ESP32
reads this voltage through an analog pin and calculates the RMS
(Root Mean Square) current. If the current exceeds a preset
threshold, indicating overcurrent or overload, the ESP32 triggers a
fault.

4. ZMPT101B (Voltage Sensor):

This sensor measures the AC voltage supplied to the motor. It
scales down the high AC voltage to a safe, low-level analog signal.
The ESP32 reads this output through an analog pin to monitor the
voltage. If a voltage anomaly is detected (overvoltage or
undervoltage), the ESP32 triggers a fault condition.

5. DS18B20 (Temperature Sensor):

This digital sensor measures the temperature around or on
the motor’s surface. The DS18B20 communicates with the ESP32 via
a single data pin, using the 1-Wire protocol. If the temperature
exceeds a predefined limit, the ESP32 recognizes this as a fault and
activates protective measures.

6. Individual 20x6 LCD Displays:

Each sensor (current, voltage, temperature) has its own 20x6
LCD display. The ESP32 continuously updates these displays to
show real-time readings, providing on-site visibility of the motor’s
operating conditions.

7. Indicator Lights:
Each sensor has its own indicator light that illuminates if a
fault condition is detected. These LEDs are connected to the
ESP32’s GPIO pins and are controlled by the ESP32 based on sensor
readings.

8. Start/Stop Buttons for Individual Sensors:

Each sensor has a dedicated start/stop button, allowing
manual control to enable or disable monitoring for that sensor.
When pressed, these buttons toggle the monitoring state for each
sensor, providing flexibility for maintenance or testing.

9. Main Start Button:

This button activates the system, powering on all sensors and
initializing monitoring functions. The main start button is connected
to a GPIO pin on the ESP32 and can activate all sensors at once.

10. Emergency Stop Button:

Pressing this button immediately stops the motor and
deactivates monitoring for all sensors, serving as a safety measure.
This button is connected to the ESP32 and overrides all other
controls in case of an emergency.
11. Buzzer for Fault Alert:
The buzzer sounds when any fault is detected, acting as an
auditory alert. This buzzer is connected to a GPIO pin on the ESP32
and activated alongside the indicator lights when a fault occurs.

12. Blynk Application for Remote Monitoring:

The ESP32 connects to Wi-Fi and sends sensor data and fault
alerts to the Blynk app, allowing remote monitoring. In case of a
fault, the Blynk app receives a notification, ensuring remote
personnel are aware of potential motor issues.

WORKING FLOW

 System Initialization:
When the main start button is pressed, the ESP32 initializes
each sensor and display. The voltage regulator supplies a stable
voltage to all components, ensuring smooth operation.

 Sensor Monitoring:
The ESP32 reads data from the SCT-013 (current), ZMPT101B
(voltage), and DS18B20 (temperature) sensors.
Each reading is displayed on the respective LCD, providing real-time
monitoring of the motor’s operating conditions.

 Fault Detection:
The ESP32 continuously compares sensor readings to preset
thresholds.

For example:
Overcurrent: The current exceeds a safe limit, indicating an
overload.
Voltage Anomaly: The voltage goes above or below a predefined
range, which could damage the motor.
Overtemperature: The motor’s temperature exceeds a safe
operating level.

If any of these conditions are detected, the ESP32:

Activates the respective indicator light.
Sounds the buzzer.
Sends a notification to the Blynk app for remote monitoring.

 Individual Sensor Control:

The start/stop button for each sensor allows users to disable
monitoring of that specific sensor. For example, if maintenance is
required on the current sensor, its start/stop button can disable
current monitoring without affecting other sensors.

 Emergency Stop:
 If the emergency stop button is pressed, the ESP32
immediately stops monitoring all sensors, sounds the buzzer, and
optionally deactivates the motor.
This is an overriding control to prevent damage or accidents in
critical situations.

 Remote Monitoring via Blynk:

The ESP32 communicates with the Blynk app, continuously
updating it with real-time sensor readings. If a fault is detected, the
Blynk app receives an alert, allowing users to respond quickly from
a remote location.

 System Reset and Restart:

After addressing a fault, users can reset the system by
pressing the main start button to reinitialize the sensors and
displays.

Key Benefits:
On-site Monitoring: Real-time sensor readings on individual
displays provide visibility of motor conditions.

Fault Indicators: Indicator lights and a buzzer immediately

alert on-site personnel of any issues. Remote Monitoring: The Blynk
app allows users to monitor the motor remotely and receive
notifications for potential faults.

Safety Controls: The main start button, individual sensor

buttons, and emergency stop button provide flexible control and a
reliable emergency response.

Motor Protection: This system helps prevent motor damage by

detecting overcurrent, overvoltage, and overheating, enabling quick
response to faults.

Note: This system design ensures robust protection for the induction
motor and enhances operational safety through real-time
monitoring, fault alerts, and flexible control options both on-site and
remotely.
Here's a detailed, step-by-step guide on how to connect each
component in this motor protection system with the ESP32. Each
connection must be carefully made to ensure safe operation and
functionality.

### **Components Required**

- **ESP32 microcontroller**
- **Voltage Regulator** (e.g., LM7805 for 5V or AMS1117 for 3.3V)
- **SCT-013 Current Transformer** (with burden resistor)
- **ZMPT101B Voltage Sensor Module**
- **DS18B20 Temperature Sensor**
- **3 x 20x6 LCD Display Modules** (one for each sensor)
- **3 x Indicator LEDs** (with resistors)
- **Individual Start/Stop Buttons** (one for each sensor)
- **Main Start Button**
- **Emergency Stop Button**
- **Buzzer**
- **Blynk-compatible app** for remote monitoring

---

### **1. ESP32 Microcontroller Setup**

- **Power Supply**: The ESP32 requires a stable 5V or 3.3V
supply. The voltage regulator steps down a higher voltage (e.g.,
12V) to the ESP32’s operating voltage.
- **Wi-Fi Configuration**: Program the ESP32 to connect to Wi-Fi
for remote monitoring with Blynk. Install the necessary libraries and
set Wi-Fi credentials in the code.
### **2. Voltage Regulator Setup**
- **Input Voltage**: Connect a 12V DC supply to the **IN**
terminal of the voltage regulator.
- **Ground**: Connect the **GND** of the power supply to the
GND terminal on the voltage regulator and ESP32.
- **Output Voltage**: Connect the **OUT** terminal of the voltage
regulator to the ESP32’s **VIN (5V) or 3.3V** pin (depending on the
regulator output).
- **Stabilizing Capacitors**: Add a **10µF** capacitor between
**IN** and **GND** and another between **OUT** and **GND** for
stable operation.

### **3. SCT-013 Current Sensor Setup**

- **Burden Resistor**: Connect a **10-22Ω resistor** across the
SCT-013’s output to convert its output to a readable voltage for the
ESP32.
- **Analog Output**: Connect the **output wire** of the SCT-013
to an **analog input pin** (e.g., **A0**) on the ESP32.
- **Ground**: Connect the other output wire to the **GND** of the
ESP32.
- This sensor does not require an additional power connection as it
is a passive device.

### **4. ZMPT101B Voltage Sensor Setup**

- **Power Supply**: Connect the **VCC** pin of the ZMPT101B to
the ESP32’s **3.3V** or **5V** pin (as supported by your ZMPT101B
module).
- **Ground**: Connect the **GND** pin of the ZMPT101B to the
ESP32’s **GND**.
- **Analog Output**: Connect the **analog output pin (OUT)** of
the ZMPT101B to an **analog pin** on the ESP32 (e.g., **A1**).
- The AC voltage side of the ZMPT101B should be connected only
by a certified electrician to safely read motor voltage.

### **5. DS18B20 Temperature Sensor Setup**

- **Power Supply**: Connect the **VCC** pin of the DS18B20 to
the **3.3V** pin on the ESP32.
- **Ground**: Connect the **GND** pin of the DS18B20 to the
ESP32’s **GND**.
- **Data Line**: Connect the **DATA** pin to a **digital pin** on
the ESP32 (e.g., **D4**).
- **Pull-up Resistor**: Place a **4.7kΩ resistor** between the
DATA pin and VCC to stabilize communication.
- The DS18B20 communicates with the ESP32 via a 1-Wire
protocol.

### **6. 20x6 LCD Display Modules Setup**

 - **Power Supply**: Connect **VCC** and **GND** of each LCD
module to the ESP32’s **5V** and **GND** pins (use a shared
GND).
- **I2C Communication** (if I2C-based): Connect the **SDA** and
**SCL** pins to ESP32’s **GPIO 21** (SDA) and **GPIO 22** (SCL).
- **I2C Addressing**: Ensure each LCD has a unique I2C address,
which may require modifying the module’s address pins.
- If using **parallel displays**, use separate GPIO pins for each
LCD’s data/control connections.

### **7. Indicator Lights (LEDs) Setup**

- **Connection**: Connect each LED’s anode to an ESP32 **GPIO
pin** (e.g., **D5, D6, and D7** for each sensor) and the cathode to
the **GND**.
- **Resistor**: Connect a **330Ω resistor** in series with each LED
to prevent excess current.
- The ESP32 controls each LED to turn on when a specific fault is
detected.

### **8. Individual Start/Stop Buttons for Sensors Setup**

- **Connection**: Connect each button between an ESP32 **GPIO
pin** (e.g., **D8, D9, and D10**) and **GND**.
- **Pull-up Resistors**: Enable **internal pull-up** in the ESP32
code, or add **10kΩ external pull-up resistors** if necessary.
- Each button toggles the monitoring status of a specific sensor,
allowing individual control.

### **9. Main Start Button Setup**

- **Connection**: Connect the main start button between a **GPIO
pin** (e.g., **D11**) and **GND** on the ESP32.
- **Pull-up Resistor**: Enable an internal pull-up resistor in the
ESP32 code.
- When pressed, the main start button activates all sensors,
beginning the monitoring process.

### **10. Emergency Stop Button Setup**

- **Connection**: Connect the emergency stop button between a
**GPIO pin** (e.g., **D12**) and **GND** on the ESP32.
- **Pull-up Resistor**: Enable an internal pull-up resistor in the
ESP32 code.
- When pressed, the emergency stop button immediately halts
monitoring and disables motor operation if interfaced accordingly.

### **11. Buzzer Setup**

- **Connection**: Connect the positive terminal of the buzzer to an
available **GPIO pin** (e.g., **D13**) and the negative terminal to
**GND**.
- **Resistor (optional)**: Use a **220Ω resistor** in series if the
buzzer’s current draw is high.
 - The buzzer is programmed to activate when any fault is
detected.

### **12. Blynk App for Remote Monitoring**

- **Code Integration**: In the ESP32 code, include the Blynk library
and define virtual pins for each sensor’s data and fault status.
- **Wi-Fi Credentials**: Add your Wi-Fi SSID and password for the
ESP32 to connect to the internet.
- **Blynk Virtual Pins**: Define virtual pins in the Blynk app for
each parameter (current, voltage, temperature), setting up real-
time monitoring and fault notifications.

---

### **Testing the System**

1. **Power On**: Supply power to the system by connecting the 12V

input to the voltage regulator.
2. **Initialize Sensors**: The ESP32 initializes each sensor and starts
monitoring once the main start button is pressed.
3. **Readings Display**: Each LCD displays real-time sensor data.
Confirm each sensor’s output on its respective display.
4. **Fault Detection and Indicators**:
- Test each fault scenario by adjusting values or simulating
conditions (e.g., overcurrent).
- Ensure the corresponding LED, buzzer, and Blynk alert are
triggered for each fault condition.
5. **Remote Monitoring**: Open the Blynk app to verify real-time
monitoring and receive alerts if faults are detected.
6. **Start/Stop and Emergency Stop**:
- Test each start/stop button to verify it toggles the monitoring of
the respective sensor.
- Test the emergency stop button to ensure it overrides all other
functions and halts monitoring.

### **Safety Tips**

- Ensure safe handling and insulation of AC voltage inputs for the

ZMPT101B module.
- Double-check all connections to avoid accidental short circuits.
- Use a separate power supply for the motor, isolated from the
sensor circuit, for safety and stable readings.

---

This setup provides a fully functional motor protection system that

monitors current, voltage, and temperature, and alerts on-site and
remotely in case of faults, ensuring industrial motor safety and
reliability.
 VARIABLES
1. Independent Variable
2. Dependent Variable
3. Control Variable

 SUBJECTS: Machines & Users

 SETTINGS: Contolled Lab Environment at EVSU Luna Campus
 OBJECTIVES: The objective of the study is to design a motor
control protection of a trainer board design that is fully
functional, fulfills the gaps that had been addressed above and,
ensures safety of end-users, and is cost efficient.
 HYPOTHESIS:
 METHODS:
 ANALYSIS PLAN:

SCOPE AND DELIMITATION