Forem: Mohamed Ahmed

🔐 Control a Solenoid Lock with Arduino Mega (Using a Relay & Push Button)

Mohamed Ahmed — Wed, 19 Nov 2025 09:11:53 +0000

Introduction

Welcome back, makers! 👋
If you enjoyed building Wi-Fi-controlled LEDs, let’s take things a step further into the world of physical security. Today, we’re working with solenoid locks — the same mechanism used in lockers, cabinets, and access-control systems.

In this project, you’ll learn how to lock and unlock a solenoid lock using:

1. Arduino Mega
2. A relay module
3. 12V power supply
4. Simple push button
Breadboard
Jumper wires(male to male and male to female)

By the end, you’ll push a button → the solenoid will pull → the lock will OPEN.
Push the button again → the solenoid releases → the lock goes back to LOCKED.

Let’s dive in!

🧰 What You’ll Need

Component	Image	Description
Arduino Mega		Microcontroller to read button and control relay
12V Solenoid Lock		The physical locking mechanism
Relay Module (5V Control)		Acts as a switch to send 12V to the solenoid
12V Power Adapter		Powers the solenoid and Arduino
Push Button		Triggers lock/unlock
Breadboard & Jumper Wires		For easy wiring

⚡ Step 1: Wiring Diagram

Here’s the wiring logic broken down clearly:

🔘 Button to Arduino

Component	Arduino Pin	Purpose
Button Lead 1	D2	Reads button press
Button Lead 2	GND	Completes button circuit

🔁 Relay Module to Arduino

Component	Arduino Pin	Purpose
VCC	5V	Powers relay coil
GND	GND	Ground
IN	D8	Arduino signal to toggle solenoid

🔌 Power + Solenoid Connection

Component	Connected To	Purpose
12V Adapter	Arduino Barrel Jack	Powers Arduino and relay
12V Adapter + (Positive)	Relay COM	12V source for switching
Solenoid Red Wire	Relay NO	Receives switched 12V
Solenoid Blue Wire	GND	Completes 12V circuit

💡 We use the relay because the solenoid draws more current than Arduino can provide.

💻 Step 2: Write the Code

Open your Arduino IDE and paste the following code:

// Define the pins used
const int buttonPin = 2;   
const int relayPin = 8;    

bool isLocked = true; 

void setup() {
  pinMode(relayPin, OUTPUT); 
  // Use INPUT_PULLUP for simpler button wiring
  pinMode(buttonPin, INPUT_PULLUP); 

  // SET INITIAL STATE: LOCK the door (Solenoid needs POWER ON to be locked)
  digitalWrite(relayPin, HIGH); 
}

void loop() {
  // Read the button state (it reads LOW when pressed)
  int buttonState = digitalRead(buttonPin);

  if (buttonState == LOW) { // Button pressed
    delay(50); // Debounce
    if (digitalRead(buttonPin) == LOW) {
      isLocked = !isLocked; // Toggle the state

      if (isLocked) {
        // LOCK: Solenoid ON (Power applied)
        digitalWrite(relayPin, HIGH); 
      } else {
        // UNLOCK: Solenoid OFF (Power removed)
        digitalWrite(relayPin, LOW); 
      }

      // Wait for the button to be released 
      while(digitalRead(buttonPin) == LOW){
        // Do nothing 
      }
    }
  }
}

🧠 Explanation

The button uses INPUT_PULLUP, meaning:
- Released → HIGH
- Pressed → LOW
When pressed, Arduino sets relay HIGH → relay sends 12V to solenoid → it unlocks.
When pushed again → relay turns OFF → the solenoid locks again.

🧪 Step 3: Test the Setup

Power the Arduino using your 12V adapter.
Open the Serial Monitor — you should see "Solenoid Lock System Ready".
Press the button:
- You should hear a click from the relay.
- Solenoid retracts (unlock).
Press the button again:
- Solenoid extends (lock).

🔐⚡ If everything is wired correctly — congratulations, you’ve built your own electromechanical locking system!

🌐 Control Your LED from a Web Server Using ESP32 Introduction

Mohamed Ahmed — Fri, 24 Oct 2025 14:00:00 +0000

Introduction

Welcome back, makers! 👋
So far, we’ve learned how to blink an LED, connect an external one, and control it using a button. Now, it’s time to make things even more exciting — we’ll control the LED using a simple web interface hosted directly on your ESP32!

By the end of this tutorial, you’ll be able to open a webpage on your phone or computer and turn the LED ON or OFF wirelessly.

🧰 What You’ll Need

- ESP32 development board (e.g., ESP32 DevKit C)
- 1 × LED (any color)
- 1 × 220 Ω resistor
- Breadboard and jumper wires
- Arduino IDE installed and configured
- A Wi-Fi network (SSID and password)

⚡ Step 1: Breadboard/Circuit Setup

Component	ESP32 Pin	Description
LED (anode – long leg)	GPIO 4	Digital output pin
LED (cathode – short leg)	GND	Ground
Resistor (220 Ω)	In series with LED	Limits current

💡 Use the same wiring as in the previous post — we’ll just control it differently this time.

💻 Step 2: Write the Code

Open your Arduino IDE and paste the following code:

#include <WiFi.h>

// Replace with your network credentials
const char* ssid = "YOUR_WIFI_NAME";
const char* password = "YOUR_WIFI_PASSWORD";

WiFiServer server(80);  // Port 80 for HTTP
int ledPin = 4;         // GPIO 4 for LED

void setup() {
  Serial.begin(115200);
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);

  Serial.println("Connecting to WiFi...");
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi connected!");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());  // Your web server address

  server.begin();
}

void loop() {
  WiFiClient client = server.available();   // Listen for incoming clients

  if (client) {
    Serial.println("New Client Connected.");
    String request = client.readStringUntil('\r');
    Serial.println(request);
    client.flush();

    // Control LED
    if (request.indexOf("/LED=ON") != -1) {
      digitalWrite(ledPin, HIGH);
    } else if (request.indexOf("/LED=OFF") != -1) {
      digitalWrite(ledPin, LOW);
    }

    // Build Web Page
    String html = "<!DOCTYPE html><html>";
    html += "<head><meta name='viewport' content='width=device-width, initial-scale=1'>";
    html += "<title>ESP32 LED Control</title></head>";
    html += "<body style='text-align:center; font-family:sans-serif;'>";
    html += "<h2>ESP32 Web LED Controller 💡</h2>";
    html += "<p><a href='/LED=ON'><button style='padding:10px 20px; background:green; color:white; border:none;'>TURN ON</button></a></p>";
    html += "<p><a href='/LED=OFF'><button style='padding:10px 20px; background:red; color:white; border:none;'>TURN OFF</button></a></p>";
    html += "</body></html>";

    client.println("HTTP/1.1 200 OK");
    client.println("Content-type:text/html");
    client.println();
    client.println(html);
    client.stop();
    Serial.println("Client disconnected.");
  }
}

🧠 How It Works

The ESP32 connects to your Wi-Fi network using your SSID and password.
It starts a simple web server that listens for incoming connections on port 80.
When you open the ESP32’s IP address in your browser, it serves a web page with two buttons.
Clicking TURN ON or TURN OFF sends a request (/LED=ON or /LED=OFF) that toggles the LED.

🖥️ Step 3: Upload and Test

- Connect your ESP32 to your computer.
- Select your board and port in the Arduino IDE.
- Replace YOUR_WIFI_NAME and YOUR_WIFI_PASSWORD with your Wi-Fi credentials.
- Click Upload.
- Open Serial Monitor (115200 baud).
- After connecting, note the IP address displayed (e.g., 192.168.0.105).
- Type that IP address in your browser — you’ll see your control page!

Click the buttons — your LED should respond instantly! ⚡

⚡ Troubleshooting
1.No IP address shown?

Double-check your Wi-Fi name and password.

2.Page not loading?

Ensure your computer/phone is on the same Wi-Fi network as your ESP32.

3.LED not turning on?

Verify your wiring and GPIO pin number in the code.

🎯 What’s Next
You’ve now built your first IoT web interface! 🌍
✅ Connected ESP32 to Wi-Fi
✅ Hosted a mini web server
✅ Controlled hardware from a browser

In the next post, we’ll go further — read sensor data (like temperature or light) and display it on your web dashboard in real time. 📊

💬 Your Turn
Did you manage to control your LED from your browser? 💡
Share your setup, screenshots, or questions in the comments — let’s keep learning and building together! 🙌

🕹️ Control an LED with a Button Using ESP32 and Arduino IDE Introduction

Mohamed Ahmed — Fri, 17 Oct 2025 14:00:00 +0000

Introduction

Welcome back, makers! 👋
In the previous post, we connected and controlled an external LED using the ESP32.

Now, let’s take it a step further — by using a push button to turn the LED on and off.
This is a fundamental IoT concept: using input devices (like buttons or sensors) to control output devices (like LEDs or motors).

🧰 What You’ll Need

ESP32 development board (e.g., ESP32 DevKit C)
1 × LED (any color)
1 × 220 Ω resistor (for the LED)
1 × Push button
Breadboard
Jumper wires
USB cable connected to your computer

⚙️ Step 1: Breadboard/circuit Connections

Here’s how to wire everything:

Component	ESP32 Pin	Description
LED (long leg – anode)	GPIO 4	Digital output pin
LED (short leg – cathode)	GND	Ground
Resistor (220 Ω)	In series with LED	Limits current to protect the LED
Button	GPIO 21	Digital input pin
Other side of Button	GND	Pulls the button LOW when pressed

💡 Tip: We’ll use the ESP32’s internal pull-up resistor to keep things simple, so you don’t need an extra resistor for the button.

💻 Step 2: Write the Code

Open the Arduino IDE and paste this code:

// Control an LED with a button using ESP32
int ledPin = 4;      // LED connected to GPIO 4
int buttonPin = 21;  // Button connected to GPIO 15
int buttonState = 0; // Variable to store button state

void setup() {
  pinMode(ledPin, OUTPUT);        // Set LED pin as output
  pinMode(buttonPin, INPUT_PULLUP); // Use internal pull-up resistor
  Serial.begin(115200);
  Serial.println("Button Control Test Started");
}

void loop() {
  buttonState = digitalRead(buttonPin); // Read the button state

  if (buttonState == LOW) {  // Button pressed (active LOW)
    digitalWrite(ledPin, HIGH);
    Serial.println("Button Pressed - LED ON");
  } else {  // Button not pressed
    digitalWrite(ledPin, LOW);
    Serial.println("Button Released - LED OFF");
  }

  delay(100); // Small delay for stability
}

🧠 Explanation

pinMode(buttonPin, INPUT_PULLUP) enables the internal resistor that keeps the button HIGH until pressed.
When you press the button, the pin reads LOW.
The LED turns ON when the button is pressed and OFF when released.
The Serial Monitor displays real-time button states.

🖥️ Step 3: Upload and Test

- Connect your ESP32 to your computer.
- Select the correct Board and Port.
- Click Upload.
- Open Tools → Serial Monitor and set the baud rate to 115200.

Now press and release the button — you should see:

Button Pressed - LED ON
Button Released - LED OFF

1.LED doesn’t turn on:

Check your wiring (especially button → GPIO21 → GND).
Make sure the LED’s anode (+) is connected to the correct GPIO pin.
Verify resistor placement (in series with LED).

2.Serial Monitor not showing messages:

Ensure baud rate = 115200.
Confirm you added Serial.begin(115200); in setup().

🎯 What’s Next

You’ve now learned how to:
✅ Read digital input from a button
✅ Control an LED based on input
✅ Display data in the Serial Monitor

In the next post, we’ll take it online 🌐 — you’ll learn how to control your LED using a simple web server hosted on the ESP32 itself!
That means you’ll be able to turn your LED on and off right from your browser or phone — no button required. 💡📱

💬 Your Turn!
Did your LED respond to the button? 🕹️💡
Share your results in the comments — I’d love to see your setup and help troubleshoot if needed.

💡 Controlling an External LED with ESP32 and Arduino IDE

Mohamed Ahmed — Fri, 10 Oct 2025 14:00:00 +0000

Introduction

Welcome back, makers! 👋
In the previous post we successfully uploaded our first program — the classic “Blink” — to make the built-in LED on the ESP32 blink.

Now, we’ll take it a step further by connecting and controlling an external LED.
This is your first step into hardware interaction — where your ESP32 begins to control real-world devices!

🧰 What You’ll Need

- ESP32 development board (e.g., ESP32 DevKit C)
- 1 × LED (any color)
- 1 × 220 Ω resistor
- Breadboard
- Jumper wires
- USB cable connected to your computer

⚙️ Step 1: Breadboard/circuit Connections

Component	ESP32 pin	Description
LED (long leg – anode)	GPIO 4	Digital output pin
LED (short leg – cathode)	GND	Ground
Resistor (220 Ω)	In series with LED	Limits current to protect LED

You can use GPIO 5, 13, or 14 — just make sure to update the code accordingly.

💡 Tip: You can use GPIO 5, 13, or 14 instead — just update the code accordingly.
Always use a resistor in series with your LED to prevent burning it out!

💻 Step 2: Write the Code

In the Arduino IDE, open a new sketch and paste this:

// Control an external LED using ESP32
int ledPin = 4; // The GPIO pin connected to the LED

void setup() {
  pinMode(ledPin, OUTPUT); // Set the LED pin as output
  Serial.begin(115200);      // Start the Serial Monitor
  Serial.println("External LED Test Started");
}

void loop() {
  digitalWrite(ledPin, HIGH); // Turn LED on
  Serial.println("LED is ON");
  delay(1000);                // Wait 1 second

  digitalWrite(ledPin, LOW);  // Turn LED off
  Serial.println("LED is OFF");
  delay(1000);                // Wait 1 second
}

🧠 Explanation:

pinMode(ledPin, OUTPUT) tells the ESP32 that GPIO 4 will send signals.
digitalWrite(ledPin, HIGH/LOW) turns the LED on and off.
The Serial Monitor prints real-time messages so you can see what the board is doing.

🖥️ Step 3: Upload and Monitor

Connect your ESP32 to your computer.
Select the correct board and port (as before).
Click Upload.
After uploading, open Tools → Serial Monitor.
Set the baud rate to 115200. You should see messages like:

Your external LED should blink in sync! ✨
_💡 Tip: On some boards, you may need to hold the BOOT button while uploading the code._

⚡ Troubleshooting

1.LED not lighting up?

Check your wiring (make sure anode and cathode aren’t reversed).
Try a different GPIO pin and update the code.
Verify that your resistor is not too large (220 Ω–330 Ω works best).

2.No Serial Output?

Ensure you opened the Serial Monitor at 115200 baud.
Make sure the code includes Serial.begin(115200);.

🎯 What’s Next
✅ You’ve now controlled an external LED with your ESP32!
In the next post, we’ll add a button so you can turn the LED on and off manually. 🕹️

Get ready to make your first interactive circuit!

💬 Your Turn!

Did your external LED blink? 🔴💡
Share your success (or any issues you faced) in the comments — I’d love to see your first working circuit!

🚀 Uploading Your Code with Arduino IDE

Mohamed Ahmed — Sun, 05 Oct 2025 16:09:46 +0000

Introduction

Welcome back to our IoT journey! 👋
In the previous post
, we installed the Arduino IDE and configured it to recognize our ESP32 board.

Now, it’s time to bring our board to life by uploading our very first program — the classic “Blink”. This small project will make the onboard LED on your ESP32 blink at regular intervals — a simple but exciting sign that everything is working!

🧰 What You’ll Need

Your ESP32 development board (e.g., ESP32 DevKit C)
A USB cable (connected to your computer)
The Arduino IDE (already configured for ESP32)

⚡ Step 1: Open the Arduino IDE

Launch the Arduino IDE on your computer.
Make sure your ESP32 is connected to your PC via USB.

🧩 Step 2: Select the Correct Board and Port

Before writing any code, confirm that you’ve selected your ESP32 board and port correctly:

Go to Tools → Board → ESP32 Arduino → ESP32 Dev Module
Go to Tools → Port → select the one that says something like COM7

_💡 If no port is visible, you may need to install the USB driver for your board (CH340 or CP210x depending on your model). You can check the chip model next to your USB port.
_

💻 Step 3: Write the Blink Code

In your Arduino IDE, copy and paste the following code:

// The classic Blink program for ESP32
int ledPin = 2; // Built-in LED on most ESP32 boards is on GPIO 2

void setup() {
  pinMode(ledPin, OUTPUT); // Initialize the LED pin as an output
}

void loop() {
  digitalWrite(ledPin, HIGH); // Turn the LED on
  delay(1000);                // Wait 1 second
  digitalWrite(ledPin, LOW);  // Turn the LED off
  delay(1000);                // Wait 1 second
}

Explanation:

setup() runs once when your board starts.
loop() runs continuously, making the LED turn on and off.
delay(1000) means 1000 milliseconds (1 second).

⚠️ If the upload fails, try holding the BOOT button on your ESP32 while uploading.

⬆️ Step 4: Upload the Code

Now the fun part! 🎉
Click the Upload button (the right-pointing arrow in the toolbar).

You should see messages like “Compiling…” and “Uploading…” at the bottom.
When it finishes, the onboard LED should start blinking once per second.

LED not blinking Some boards use different pins for the built-in LED. Try changing int ledPin = 2; to int ledPin = 5; or int ledPin = 13;

💡 If the LED isn’t blinking, some boards use different pins for the built-in LED. Try changing int ledPin = 2; to int ledPin = 5; or int ledPin = 13;.

🎯 What’s Next
In the next post, we’ll take things a step further — moving from the built-in LED to controlling an external LED using wires, resistors, and ESP32 pins — all while monitoring outputs through the Serial Monitor.

Until then — happy tinkering! 🔧✨

*Did your LED blink? *😄
Share your success (or any errors you faced) in the comments — I’d love to help you troubleshoot and celebrate your first ESP32 project!

Getting Started with IoT: Your First Steps with Arduino IDE and ESP32

Mohamed Ahmed — Tue, 30 Sep 2025 16:36:28 +0000

Introduction

👋 Hello, world! I’m starting this blog to share my journey into the Internet of Things (IoT) using the ESP32 microcontroller. Whether you’re a hobbyist, student, or just curious, you can follow along as we go from zero to working IoT projects—starting with setting up the Arduino IDE.d.

What You'll Need

A computer
An ESP32 development board (like the ESP32 DevKit C)
A USB cable (typically Micro-USB or USB-C, depending on your board)

STEP 1: Installing the Arduino IDE

The Arduino IDE (Integrated Development Environment) is where we will write our code, compile it, and upload it to the ESP32.

Download the IDE: Go to the official Arduino Software page. Avoid the "Web Editor" for now; we want the IDE. Download the version for your operating system.
Run the Installer:

Windows: Run the downloaded .exe file. It's recommended to let it install the necessary drivers.

3.Open the Arduino IDE: Once installed, open the application. You should see a clean, mostly empty window. This is your coding canvas!

STEP 2: Configuring the IDE for ESP32

The Arduino IDE doesn’t support ESP32 boards out of the box. To add support:

Open Preferences: Go to File > Preferences.
Add the ESP32 Board Manager URL: In the "Additional Boards Manager URLs" field, paste the following URL:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

If you already have other URLs, separate them with a comma(,).

3.Open Boards Manager: Go to Tools > Board > Boards Manager

4.Install ESP32 Support: In the search bar, type "esp32". You should see an entry by "Espressif Systems". Click on it and press the "Install" button.

This will take a few minutes. Once it's done, you'll see "INSTALLED" next to the package.

STEP 3: Selecting Your Board and Port

Now that the software is installed, let's connect the hardware.

Connect your ESP32: Plug your ESP32 board into your computer using the USB cable.

Select Your Board: Go to Tools > Board. You should now see a new section for "ESP32 Arduino". Scroll through it and select your specific board. If you're using a common ESP32 Dev Module, you can select that.

Select the Port: Go to Tools > Port.
It will be something like COM3 or COM4.
but am using Port COM7

If the port is grayed out or you don't see it, your computer might not have the correct drivers. A quick web search should lead you to the solution.

Congratulations!

What's Next?
In the next post, we'll upload a simple code to verify everything is working. We'll use the classic "Blink". Get ready to make your hardware interact with you!

What’s the first project you’d love to try with your ESP32? Drop your ideas in the comments—I’d love to hear them!