DEV Community: Shilleh

Arduino Nano A4988: Mini CNC Pen Plotter

Shilleh — Mon, 29 Jun 2026 02:38:52 +0000

Project Overview

Arduino Nano + A4988 stepper drivers + MG90S servo pen lift: Build a mini CNC pen plotter where two steppers move the pen on X and Y, and a servo lifts and lowers the pen so you can draw from G-code streamed over USB.

Send G-code from your computer and the Arduino will draw anything from logos to circuit diagrams to your kid's name. It is a practical entry point to real CNC with a low parts cost.

Time: ~4 hours (build) + ~1 hour (software setup)
Skill level: Advanced
What you will build: A 2-axis pen plotter driven by G-code from your PC, capable of A6-size drawings.

Two stepper motors + servo + Arduino = CNC plotter under $30.

Parts List

From ShillehTek

2× A4988 Stepper Driver - drives each stepper motor from Arduino STEP/DIR signals
MG90S Servo (pen lift) - lifts and lowers the pen between strokes
Arduino Nano V3.0 Pre-Soldered - runs GRBL and outputs step/dir and servo control
120 PCS Dupont Jumper Wires - quick, reliable interconnects for prototyping and wiring

External

2× NEMA 17 (or smaller) stepper motors
2× linear rails + carriages (or scavenged from old DVD drives)
Pen + holder + 12V DC supply
3D-printed or laser-cut frame

Note: This is an entry point to real CNC. Once you have a working pen plotter, you understand 90% of what is needed for a laser engraver or 3D printer.

Step-by-Step Guide

Step 1 - Build the Frame

Goal: Create a rigid base that holds the two axis rails square to each other.

What to do: Assemble the frame so the X and Y rails sit perpendicular and the carriages can move without binding. Keep everything aligned before tightening hardware.

Two perpendicular linear rails: X moves the pen, Y moves the paper carriage.

Expected result: The carriages slide smoothly by hand across the full travel on both axes.

Step 2 - Set Up the Axes

Goal: Convert stepper rotation into repeatable linear movement on both axes.

What to do: Mount each stepper, align the pulley and belt, and connect the belt to the moving carriage. Adjust belt tension so it is firm but not overstretched.

Each axis: stepper - toothed pulley - belt - carriage. Smooth, repeatable motion.

Expected result: Turning the stepper pulley by hand moves the carriage smoothly with minimal backlash.

Step 3 - Wire Electronics

Goal: Connect the Arduino Nano to two A4988 drivers and the pen-lift servo, then share power and ground correctly.

What to do: Wire STEP and DIR from the Arduino to each A4988, connect the servo signal to the Arduino, and power both drivers from the 12V supply. Ensure the Arduino ground and the 12V supply ground are common.

Each A4988 takes STEP + DIR from the Arduino, and motor power from a 12V supply.

X-axis A4988: STEP - D2, DIR - D5
Y-axis A4988: STEP - D3, DIR - D6
Servo signal - D11 (pen up/down)
Both A4988s share VMOT - 12V, EN - GND, common Arduino + supply ground

Expected result: Your wiring matches the pin mapping above, and all grounds are tied together (Arduino ground to motor supply ground).

Step 4 - Pen Mechanism

Goal: Add a reliable pen lift so the plotter can move between strokes without drawing.

What to do: Mount the MG90S servo and link it to the pen holder so the pen can move up and down freely. Use the intended angles for up/down movement as you configure GRBL/your workflow.

Servo lifts the pen between strokes: write 0° to drop pen, write 90° to lift.

Expected result: The servo can lift the pen cleanly off the page and lower it back down without sticking.

Step 5 - Flash GRBL

Goal: Install GRBL so the Arduino Nano can accept and execute G-code.

What to do: Flash GRBL 1.1f firmware to the Arduino. On your PC, use Universal Gcode Sender (UGS) to stream G-code over USB. UGS includes a tool to convert SVG to G-code.

Expected result: UGS connects to the Arduino over USB and you can send commands/jobs to the controller.

Step 6 - Draw Something

Goal: Run your first real G-code drawing to validate mechanics, wiring, and workflow.

What to do: Load a simple G-code file (or convert an SVG in UGS) and run it at conservative speeds until you confirm the axes move correctly and the pen lift timing is right.

From SVG to paper: first prints are crude, the 5th is impressive.

Expected result: The plotter produces a recognizable drawing, and the quality improves as you refine alignment and settings.

Step 7 - Where to Take It Next

Goal: Identify practical upgrades and follow-on projects based on the same CNC fundamentals.

What to do: Choose one path below and plan your next iteration using the same G-code and motion-control concepts.

Swap pen for a 500mW laser - small laser engraver
Add a Z axis with a third A4988 + stepper - 3-axis CNC
Upgrade to TMC2209 stepper drivers for silent motion
Build a touchscreen UI for offline G-code playback (ILI9341 + ESP32)

Expected result: You have a clear next upgrade direction after validating the core plotter build.

Conclusion

This mini CNC pen plotter uses an Arduino Nano with A4988 stepper drivers and a servo pen lift to turn G-code into real drawings on paper. Once you understand the workflow here, the same concepts transfer directly to other CNC platforms.

Want the exact parts used in this build? Grab them from ShillehTek.com. If you want help customizing this project or building something for your product, check out our IoT consulting services.

ESP32 DHT22: Automate Greenhouse Fan and Pump

Shilleh — Mon, 29 Jun 2026 02:36:00 +0000

Project Overview

ESP32 smart greenhouse with DHT22 + soil moisture sensor: In this build, an ESP32 reads air temperature and humidity from a DHT22 and soil moisture from an analog probe, then switches a fan and water pump using a 2-channel relay based on simple thresholds.

You will also output live readings over Serial, and you can optionally stream the data to a phone dashboard (Blynk) or MQTT for remote monitoring.

Time: ~2 hours
Skill level: Intermediate
What you will build: An ESP32 monitoring air + soil, auto-controlling fan + pump, and streaming readings to Serial (with optional Blynk/MQTT dashboard).

Smart greenhouse: sense, decide, act, broadcast.

Parts List

From ShillehTek

DHT22 Temperature & Humidity Sensor - measures greenhouse air temperature and humidity.
Soil Moisture Sensor - provides an analog moisture reading for watering decisions.
2-Channel 5V Relay Module - switches the pump and fan from ESP32 GPIO pins.
ESP32-WROOM Dev Board (USB-C) - main controller with Wi-Fi and analog input.
120 PCS Dupont Jumper Wires - makes quick sensor and relay connections.
400-Point Breadboard - simplifies prototyping before a permanent build.

External

5V mini water pump + tubing
12V cooling fan
12V power supply for fan + pump

Note: Always common-ground the microcontroller (ESP32/Arduino), relay module, and the relay-switched external supply.

Step-by-Step Guide

Step 1 - Wire the Sensors

Goal: Connect the DHT22 and the soil moisture module to the ESP32 so you can read air and soil conditions.

What to do: Wire the DHT22 data line to GPIO 4 (D4). Wire the soil moisture analog output to the ESP32 analog input on GPIO 36. Provide correct power and ground to both sensors.

DHT22 on D4, soil moisture on A0 (GPIO 36 on ESP32).

Expected result: Your ESP32 has both sensors physically connected and ready for code.

Step 2 - Add Relays for the Pump and Fan

Goal: Add two relay channels so the ESP32 can switch a water pump and a cooling fan.

What to do: Connect relay IN1 to GPIO 26 for the pump and relay IN2 to GPIO 27 for the fan. Wire your pump and fan through the relay contacts appropriate for your power setup, and ensure all grounds are common between the ESP32, relay module, and the external supply.

2-channel relay: IN1 to GPIO 26 (pump), IN2 to GPIO 27 (fan).

Expected result: The ESP32 can control both relay inputs, and the pump and fan are ready to be switched by the relays.

Step 3 - Upload the Sketch

Goal: Flash the ESP32 with code that reads the DHT22 and soil sensor, then switches the pump and fan based on thresholds.

What to do: Update the Wi-Fi credentials in the sketch, compile, and upload to your ESP32. Open Serial Monitor at 115200 baud to view temperature, humidity, and soil readings.

Code:

#include <WiFi.h>
#include <DHT.h>
#define DHTPIN 4
#define DHTTYPE DHT22
#define SOIL_PIN 36
#define PUMP 26
#define FAN 27
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(115200);
  dht.begin();
  pinMode(PUMP, OUTPUT); pinMode(FAN, OUTPUT);
  WiFi.begin("YOUR_SSID","YOUR_PASS");
}
void loop() {
  float t = dht.readTemperature(), h = dht.readHumidity();
  int soil = analogRead(SOIL_PIN);
  // Lower soil reading = drier. Threshold ~2500/4095 for "dry".
  digitalWrite(PUMP, (soil > 2500) ? HIGH : LOW);
  digitalWrite(FAN,  (t > 30.0)   ? HIGH : LOW);
  Serial.printf("T=%.1fC H=%.1f%% soil=%d\n", t, h, soil);
  delay(5000);
}

Expected result: Every 5 seconds you see T/H/soil values in Serial, and the relays switch when the soil reading and temperature cross the set thresholds.

Step 4 - See It Run

Goal: Verify the automation logic with real sensor changes.

What to do: Test the soil sensor by changing moisture conditions and confirm the pump relay reacts. Warm the temperature sensor area (carefully) and confirm the fan relay triggers around the 30 C threshold used in the code.

Relays click as soil dries; fan kicks in past 30 C.

Expected result: You can hear or see relay activity when conditions change, and Serial output confirms the readings and decisions.

Step 5 - Where to Take It Next

Goal: Extend the project with dashboards, logging, and extra sensors.

What to do: Consider these optional upgrades:

Push readings to Blynk for a phone dashboard
Add a BH1750 light sensor for grow-light scheduling
Log to ThingSpeak for long-term trend graphs
Add LoRa for an off-grid garden tower

Expected result: A clear plan for expanding the ESP32 greenhouse controller beyond the basic automation loop.

Conclusion

You built an ESP32 smart greenhouse controller that reads a DHT22 and soil moisture sensor, then switches a fan and pump through a 2-channel relay based on simple thresholds. This setup scales from a small plant enclosure to larger indoor garden monitoring with dashboards and logging.

Want the exact parts used in this build? Grab them from ShillehTek.com. If you want help customizing this project or building something for your product, check out our IoT consulting services.

Arduino 24MHz Logic Analyzer: Decode I2C, SPI, UART

Shilleh — Mon, 29 Jun 2026 02:33:26 +0000

Project Overview

Arduino + 24MHz USB Logic Analyzer: In this guide, you use an Arduino (Nano) and a 24MHz 8-channel USB logic analyzer to capture an I2C transaction and decode it in PulseView, so you can stop debugging SPI, I2C, UART, or 1-Wire blind.

The 24MHz / 8-channel USB analyzer is a low-cost option that works with PulseView/sigrok and Saleae Logic.

Time: ~25 minutes
Skill level: Beginner / Intermediate
What you will build: An Arduino I2C transaction captured live and decoded in PulseView.

The 24MHz USB logic analyzer - 8 channels, USB powered, $10.

Parts List

From ShillehTek

24MHz 8-Channel USB Logic Analyzer - captures and decodes digital buses like I2C, SPI, and UART.
Arduino Nano V3.0 Pre-Soldered - easy target to generate I2C traffic to probe.
120 PCS Dupont Jumper Wires - quick connections from analyzer leads to Arduino pins.

External

A computer running PulseView (free) or Saleae Logic
A target circuit to probe (any Arduino + I2C sensor works)

Note: 24MHz is fast enough for SPI up to ~10MHz, I2C at any speed, UART up to ~115200 baud, and most slow digital protocols. Not enough for high-speed SDIO or 100MHz QSPI.

Step-by-Step Guide

Step 1 - Inspect the Analyzer

Goal: Identify the connector and channel pins so you know what to hook up.

What to do: Locate the USB-Mini connector and the 10-pin header. The header typically provides 8 channels plus two ground pins.

USB-Mini on one side, 10 pins on the other: 8 channels + GND + GND.

Expected result: You can point to the channel pins and at least one GND pin before wiring anything.

Step 2 - Install PulseView

Goal: Install capture software and the firmware support needed for the analyzer.

What to do: Download and install PulseView from sigrok.org. It includes the fx2lafw firmware needed by the CY7C68013A chip inside many of these analyzers.

PulseView decodes I2C / SPI / UART out of the box.

Expected result: PulseView launches and is ready to connect to the logic analyzer.

Step 3 - Probe an I2C Transaction

Goal: Capture SDA and SCL while your Arduino talks to an I2C device.

What to do: Wire any I2C sensor (BME280, MPU6050, OLED) to your Arduino. Then connect the analyzer leads:

Analyzer GND to Arduino GND
Channel 0 to SDA (Arduino A4)
Channel 1 to SCL (Arduino A5)

In PulseView, set the sample rate to 8 MS/s and set total samples to 1 M, then click Start. Run your Arduino sketch to generate I2C traffic.

Expected result: You see two digital traces toggling (SDA and SCL) during I2C activity.

Step 4 - Decode

Goal: Turn the raw SDA/SCL waveforms into readable I2C bytes.

What to do: In PulseView, right-click on the channels and choose Add decoder → I2C. Assign which channel is SDA and which is SCL. PulseView will annotate addresses and data on top of the captured signals.

Each I2C address byte, register byte, and data byte appears decoded above the raw lines.

Expected result: You can read every byte your Arduino writes or reads over I2C directly in the capture timeline.

Step 5 - Where to Take It Next

Goal: Apply the same capture-and-decode workflow to other digital protocols.

What to do: Use the analyzer on other buses and modules you work with:

Capture SPI traffic to confirm a sensor library is sending what you think
Decode UART at the wire level when Serial Monitor lies
Verify NEC IR remote codes by probing the IR receiver output
Reverse-engineer cheap modules whose datasheets are wrong

Expected result: You have a repeatable workflow for validating digital communications with real signals.

Conclusion

A 24MHz USB logic analyzer paired with PulseView makes it practical to inspect Arduino I2C, SPI, and UART signals and decode real traffic in minutes. Once you can see the bus, debugging turns from guesswork into verification.

Want the exact parts used in this build? Grab them from ShillehTek.com. If you want help customizing this project or need embedded debugging and reverse-engineering support, check out our IoT consulting services.

Credits: The USB logic analyzer photos and PulseView screenshots in this tutorial are credited to Instructables.

ESP32 BH1750: Motorized Wi-Fi Blinds Control

Shilleh — Mon, 29 Jun 2026 02:29:20 +0000

Project Overview

ESP32 + BH1750 smart blinds: Use an ESP32 with a BH1750 light sensor and a 28BYJ-48 stepper motor to roll your blinds up at sunrise and down at sunset, with simple Wi-Fi phone control on your local network.

A 28BYJ-48 stepper motor drives the blind's pull cord through a small pulley. The BH1750 reads ambient brightness, and the ESP32 exposes basic web endpoints so you can raise or lower the blinds from a phone on the same network.

Time: ~3 hours
Skill level: Intermediate
What you will build: Wi-Fi controlled motorized blinds with light-aware automatic behavior (optional lux thresholds), plus an RTC option for backup scheduling.

28BYJ-48 stepper + ULN2003 + ESP32 + BH1750 = smart blinds with local control.

Parts List

From ShillehTek

28BYJ-48 Stepper + ULN2003 Driver - provides the geared motor and driver board to pull the blind cord from ESP32 GPIO pins.
ESP32-WROOM Dev Board - runs the Wi-Fi web server and controls the stepper.
BH1750 Light Sensor - measures ambient brightness (lux) for optional auto open/close behavior.
DS3231 RTC (backup schedule) - optional real-time clock for scheduling if you want time-based control.
Dupont Jumper Wires - makes prototyping the wiring on a breadboard faster.

External

3D-printed mounting bracket + pulley - holds the stepper next to the blind cord and transfers motion to the pull cord.
5V power supply - powers the stepper driver and electronics.

Note: The ULN2003 inputs connect to ESP32 GPIOs. The BH1750 and DS3231 share the I2C bus (SDA/SCL). Use a stable 5V supply sized for stepper load.

Step-by-Step Guide

Step 1 - The Mechanism

Goal: Build a simple pulley and bracket so the 28BYJ-48 can pull the roller blind cord.

What to do: Fit a pulley to the stepper shaft and position the stepper next to the blind's pull cord. Ensure the cord tracks consistently on the pulley and does not slip during direction changes.

3D-printed pulley on the stepper shaft engages the blind's pull cord.

Expected result: Turning the stepper by hand (or briefly under power later) moves the blind cord smoothly without binding.

Step 2 - Wire It

Goal: Connect the ESP32 to the ULN2003 stepper driver and connect BH1750 (and optional DS3231) over I2C.

What to do: Wire the four ULN2003 input pins to ESP32 GPIOs 12 to 15 as shown. Connect the stepper motor to the ULN2003 motor header. Wire BH1750 to the ESP32 I2C pins (SDA/SCL) and power. If using DS3231, wire it to the same I2C bus and power.

ESP32 + ULN2003 driver + BH1750 + DS3231 on a breadboard.

4 stepper wires to ULN2003 to ESP32 GPIOs 12 to 15. BH1750 + DS3231 on I2C.

Expected result: Your wiring matches the diagram, with the stepper controlled through the ULN2003 and sensors sharing the I2C bus.

Step 3 - Sketch

Goal: Flash a simple ESP32 sketch that connects to Wi-Fi, reads BH1750 lux, and exposes /up and /down web endpoints to move the stepper.

What to do: Update the Wi-Fi SSID and password, flash the code, and open the Serial Monitor to find the ESP32 IP on your network. Use a phone or browser on the same network to visit http:///up and http:///down.

Code:

#include <Stepper.h>
#include <WiFi.h>
#include <WebServer.h>
#include <Wire.h>
#include <BH1750.h>
Stepper stepper(2048, 12, 14, 13, 15);
BH1750 light;
WebServer server(80);
void up()    { stepper.step(2048 * 10); }    // 10 turns to roll up
void down()  { stepper.step(-2048 * 10); }
void setup() {
  Wire.begin(); light.begin();
  WiFi.begin("SSID","PASS");
  while (WiFi.status() != WL_CONNECTED) delay(500);
  stepper.setSpeed(15);   // RPM
  server.on("/up",   [](){ up();   server.send(200, "text/plain", "UP"); });
  server.on("/down", [](){ down(); server.send(200, "text/plain", "DOWN"); });
  server.begin();
}
void loop() {
  server.handleClient();
  float lux = light.readLightLevel();
  // Optional: auto-roll based on lux thresholds
}

Expected result: The ESP32 connects to Wi-Fi, and hitting /up or /down moves the blinds. BH1750 lux readings are available in code for optional automation.

Step 4 - Mount It

Goal: Secure the motor and pulley so the mechanism can run reliably on the window frame.

What to do: Attach the bracket to the window frame near the blind cord path. Align the pulley so the cord runs straight and does not rub. Make sure the assembly is rigid enough that the motor does not twist under load.

Stepper bracket attached to the window frame; pulley grabs the blind cord.

Expected result: The cord tracks cleanly and the motor stays aligned while the blinds move.

Step 5 - Use It

Goal: Control the blinds from a phone on your local Wi-Fi network.

What to do: On a device connected to the same network, navigate to the ESP32 IP address followed by /up or /down. If desired, adjust step counts and speed in the sketch to match your blind travel and torque needs.

Visit the ESP32 IP with /up or /down from any phone on the network.

Expected result: The blinds roll up and down on demand using the ESP32 web endpoints.

Step 6 - Where to Take It Next

Goal: Identify safe, optional improvements you can add after the basic build works.

What to do: Consider expanding the project with one of these additions.

Schedule via DS3231 - open at sunrise, close at sunset, no Wi-Fi needed
Integrate with Home Assistant via MQTT for whole-house control
Add a closed-state limit switch - never over-rotate the stepper
Voice control via Alexa/Google through Home Assistant

Expected result: You have a clear path to add scheduling, integrations, and safer end-stops without changing the core wiring concept.

Conclusion

You built ESP32-controlled motorized blinds using a 28BYJ-48 stepper motor, ULN2003 driver, and a BH1750 light sensor, with simple /up and /down web control and the option to automate based on brightness.

Want the exact parts used in this build? Grab them from ShillehTek.com. If you want help customizing this project or building something for your product, check out our IoT consulting services.

Reference: Original project inspiration credited to Instructables.

ESP32 MQ-135: Air Quality Dashboard with OLED

Shilleh — Mon, 29 Jun 2026 02:26:30 +0000

Project Overview

ESP32 + MQ-135 + DHT22 + SSD1306 OLED: Build an indoor air quality dashboard where the MQ-135 tracks gas and smoke trends, the DHT22 measures temperature and humidity, and an OLED plus Wi-Fi web page shows the readings live.

This gives you a quick, desk-friendly way to spot stale indoor air without relying on a cloud app.

Time: ~1.5 hours
Skill level: Intermediate
What you will build: A desk-mounted air quality station with OLED + Wi-Fi dashboard.

MQ-135 + DHT22 + OLED + ESP32 = complete air quality station.

Parts List

From ShillehTek

MQ-135 Air Quality Gas Sensor - provides an analog air quality trend signal (CO2/NOx/ammonia/smoke sensitivity).
DHT22 Temperature & Humidity Sensor - measures ambient temperature and humidity.
0.96" I²C SSD1306 OLED - shows live readings locally on the device.
ESP32-WROOM Dev Board - reads sensors and hosts a simple web dashboard over Wi-Fi.
120 PCS Dupont Jumper Wires - makes breadboard wiring quick and reliable.

External

USB power supply
Wi-Fi network

Note: MQ-135 needs about 24 hours of burn-in the first time you power it up. Readings stabilise after that.

Step-by-Step Guide

Step 1 - Gather the components

Goal: Make sure you have the ESP32, MQ-135, DHT22, and SSD1306 OLED ready before wiring.

What to do: Lay out the parts on your bench and confirm you have jumper wires and USB power for the ESP32.

Three sensors, one ESP32. Everything fits on a small breadboard.

Expected result: All modules are identified and ready to connect.

Step 2 - Wire the MQ-135, DHT22, and OLED to the ESP32

Goal: Connect each module to the correct ESP32 pins for analog input, a digital GPIO, and I2C.

What to do: Wire the MQ-135 analog output (AOUT) to GPIO 36. Wire the DHT22 data pin to GPIO 4. Connect the OLED on I2C using GPIO 21 (SDA) and GPIO 22 (SCL). Provide power and ground to each module as required by your boards.

MQ-135 AOUT to GPIO 36, DHT22 to GPIO 4, OLED on I2C (GPIO 21/22).

Expected result: The full circuit is wired and ready to power on without loose connections.

Step 3 - Assemble the station on the breadboard

Goal: Turn the wired modules into a stable, desk-ready build.

What to do: Mount the ESP32, MQ-135, DHT22, and OLED on a breadboard so the wiring is secure and the OLED is visible from the front.

All three modules + ESP32 on one board.

Expected result: A compact build that can sit on a desk and run from USB power.

Step 4 - Upload the sketch

Goal: Program the ESP32 to read the MQ-135 analog value, read temperature and humidity from the DHT22, display results on the OLED, and serve a basic web dashboard.

What to do: In your Arduino IDE (or compatible ESP32 toolchain), paste the sketch below. Update SSID and PASS with your Wi-Fi credentials, then compile and upload to the ESP32.

Code:

#include <WiFi.h>
#include <WebServer.h>
#include <DHT.h>
#include <Wire.h>
#include <Adafruit_SSD1306.h>
DHT dht(4, DHT22);
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
WebServer server(80);
const int MQ_PIN = 36;
float t=0, h=0; int aq=0;
void handle() {
  server.send(200, "text/html",
    "<h1>Air Quality</h1><p>T: " + String(t) + " C</p><p>H: " + String(h) +
    "%</p><p>AQ: " + String(aq) + "</p>");
}
void setup() {
  Serial.begin(115200); dht.begin();
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  WiFi.begin("SSID","PASS");
  while (WiFi.status() != WL_CONNECTED) delay(500);
  server.on("/", handle); server.begin();
}
void loop() {
  t = dht.readTemperature(); h = dht.readHumidity();
  aq = analogRead(MQ_PIN);
  oled.clearDisplay();
  oled.setTextSize(1); oled.setTextColor(SSD1306_WHITE); oled.setCursor(0,0);
  oled.printf("T: %.1f C\nH: %.1f%%\nAQ: %d\n%s", t, h, aq, WiFi.localIP().toString().c_str());
  oled.display();
  server.handleClient();
  delay(2000);
}

Expected result: The ESP32 connects to Wi-Fi, the OLED updates every couple seconds, and the serial monitor shows normal startup output.

Step 5 - View the OLED and open the web dashboard

Goal: Confirm the readings appear locally on the OLED and remotely in a browser.

What to do: Power the device and check the OLED for temperature, humidity, air quality value (analog reading), and the ESP32 IP address. On a phone or computer on the same Wi-Fi network, open the ESP32 IP address in a browser.

OLED shows live T / H / AQ; phone shows same on the dashboard URL.

Open the ESP32's IP in any browser on your network for the live readout.

Expected result: You see live values on the OLED and the same values on the web page served by the ESP32.

Step 6 - Extend the project

Goal: Plan safe, practical next upgrades once the base station works.

What to do: Pick one improvement and implement it after your baseline readings are stable.

Log readings to ThingSpeak for long-term graphs
Trigger a relay-controlled fan above AQ threshold
Add a second MQ sensor for CO specifically (MQ-7)
Send a Telegram alert when CO2 exceeds a danger threshold

Expected result: You have a clear path for turning a simple dashboard into a more complete monitoring system.

Conclusion

You built an ESP32 air quality dashboard that reads an MQ-135 for air quality trends, uses a DHT22 for temperature and humidity, and shows everything on an SSD1306 OLED plus a Wi-Fi web page.

Want the exact parts used in this build? Grab them from ShillehTek.com. If you want help customizing this project or building something for your product, check out our IoT consulting services.

Credit: This build is based on a reference guide from Instructables.

Arduino RC522 RFID: Smart Door Lock with OLED

Shilleh — Mon, 29 Jun 2026 02:23:46 +0000

Project Overview

Arduino Nano + RC522 RFID smart door lock: Combine an RC522 RFID reader, a servo, and a 0.96 inch SSD1306 OLED to build a tap-to-unlock door system where authorized cards unlock the latch and the OLED shows status messages.

Tap a registered card or fob and the servo throws a latch while the OLED prints "ACCESS GRANTED". Tap an unknown card and the OLED prints "ACCESS DENIED".

Time: ~1 hour
Skill level: Beginner / Intermediate
What you will build: An RFID-driven door lock with an OLED status display.

RC522 + servo + OLED + Arduino Nano for a complete access-control build.

Parts List

From ShillehTek

RC522 RFID Reader Writer Kit (with card + fob) - reads 13.56 MHz RFID card UIDs over SPI.
MG90S Metal-Gear Servo - actuates the latch for lock and unlock motion.
0.96 inch I2C SSD1306 OLED - displays "ACCESS GRANTED" and "ACCESS DENIED".
Arduino Nano V3.0 Pre-Soldered - runs the RFID read, UID check, OLED messages, and servo control.
Extra 13.56 MHz Key Fobs - add more users to your lock.
120 PCS Dupont Jumper Wires - makes breadboard wiring quick and clean.
400-Point Breadboard - prototyping the full circuit before mounting.

External

A door, drawer, or box you want to lock
3D-printed or wood servo bracket (optional but recommended)

Note: The RC522 is 3.3 V on the logic side. Power VCC from 3.3 V, not 5 V. The servo runs on 5 V.

Step-by-Step Guide

Step 1 - Lay Out the Modules

Goal: Identify each module and confirm you have all the core parts before wiring.

What to do: Place the Arduino Nano, RC522 RFID module, MG90S servo, and SSD1306 OLED on your work surface. If you are using a breadboard, position parts so wiring to SPI pins, I2C pins, and the servo PWM pin is easy.

RFID reader, servo, OLED, and Arduino Nano are the four main pieces of the access system.

Expected result: All modules are ready and oriented so you can wire them without crossing too many jumpers.

Step 2 - Wire the RFID Reader (SPI)

Goal: Connect the RC522 to the Arduino Nano over SPI so the Nano can read card UIDs.

What to do: Wire the RC522 using the standard SPI connections plus RST and CS (SDA on many RC522 boards is the CS pin).

SPI hookup for RC522 with RST and CS lines.

RC522 VCC → 3.3 V (NOT 5 V)
RC522 GND → GND
RST → D9, SDA(CS) → D10
MOSI → D11, MISO → D12, SCK → D13

Expected result: The RC522 is powered from 3.3 V and shares the SPI bus pins correctly with the Arduino Nano.

Step 3 - Wire the Servo and OLED

Goal: Connect the servo for latch movement and the OLED for status messages.

What to do: Wire the servo signal to a PWM-capable pin and connect servo power to 5 V and GND. Then wire the SSD1306 OLED via I2C on A4 (SDA) and A5 (SCL).

Servo signal on D6 (PWM-capable), 5 V and GND for power.

OLED on I2C with SDA to A4 and SCL to A5.

Servo: signal → D6, V+ → 5 V, GND → GND
OLED: VCC → 5 V, GND → GND, SDA → A4, SCL → A5

Expected result: The servo has a PWM control line and power, and the OLED is on the I2C bus at the typical address used by SSD1306 modules.

Step 4 - Full Wiring Diagram

Goal: Verify the complete wiring matches the intended circuit before uploading code.

What to do: Compare your connections to the diagram. Confirm RC522 VCC is on 3.3 V, the OLED is on A4/A5, and all grounds are common.

Complete circuit: SPI for RC522, I2C for OLED, and PWM for the servo.

Expected result: Your wiring matches the diagram with correct voltages and shared ground.

Step 5 - Upload the Sketch

Goal: Program the Arduino Nano to read RFID tags, compare UIDs, move the servo, and show OLED messages.

What to do: In the Arduino IDE, install these libraries: MFRC522, Adafruit SSD1306, Adafruit GFX, and the built-in Servo. Then paste and upload the sketch below.

One sketch combines RFID read, UID compare, servo control, and OLED status.

Code:

#include <SPI.h>
#include <MFRC522.h>
#include <Wire.h>
#include <Adafruit_SSD1306.h>
#include <Servo.h>

const int RST_PIN = 9, SS_PIN = 10, SERVO_PIN = 6;
MFRC522 rfid(SS_PIN, RST_PIN);
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
Servo lock;

// Replace with the UID(s) of your authorized cards
const byte AUTHORIZED[][4] = {
  {0xDE, 0xAD, 0xBE, 0xEF}
};

void msg(const char* line1, const char* line2) {
  oled.clearDisplay();
  oled.setTextSize(2); oled.setTextColor(SSD1306_WHITE);
  oled.setCursor(0, 8);  oled.println(line1);
  oled.setCursor(0, 36); oled.println(line2);
  oled.display();
}

void setup() {
  Serial.begin(9600);
  SPI.begin(); rfid.PCD_Init();
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  lock.attach(SERVO_PIN); lock.write(0);
  msg("ShillehTek", "Tap card...");
}

bool isAuthorized(byte* uid) {
  for (auto& tag : AUTHORIZED) {
    if (memcmp(uid, tag, 4) == 0) return true;
  }
  return false;
}

void loop() {
  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) return;

  if (isAuthorized(rfid.uid.uidByte)) {
    msg("ACCESS", "GRANTED");
    lock.write(90); delay(3000); lock.write(0);
  } else {
    msg("ACCESS", "DENIED");
    delay(2000);
  }
  msg("ShillehTek", "Tap card...");
  rfid.PICC_HaltA(); rfid.PCD_StopCrypto1();
}

To register a card: run the ReadUIDSimple example from the MFRC522 library, tap each card, note the 4 UID bytes, and paste them into the AUTHORIZED array.

Expected result: The OLED shows "Tap card..." and the system reacts differently to authorized versus unauthorized tags.

Step 6 - Tap and Watch

Goal: Confirm RFID reads work and the lock behavior matches "granted" and "denied".

What to do: Tap an authorized card or fob to the RC522, then tap an unauthorized one. Watch the OLED and the servo position.

13.56 MHz cards and fobs can be registered for multiple users.

"ACCESS GRANTED" displays while the servo throws the latch.

Expected result: Authorized tags show "ACCESS GRANTED" and move the servo for about 3 seconds, and unauthorized tags show "ACCESS DENIED".

Step 7 - Where to Take It Next

Goal: Identify safe extensions you can add after the basic lock is working.

What to do: If you want to expand the project, consider these options:

Log every tap (UID + timestamp) to a microSD for attendance or an audit trail
Push events over Wi-Fi (D1 Mini / ESP-01) to a server for cloud logging
Add a 4x4 keypad for two-factor access (card + PIN)
Replace the servo with a 12 V solenoid lock via a 1-channel relay for real doors

Expected result: You have a clear list of next upgrades without changing the core wiring and logic you built.

Conclusion

You built an Arduino Nano smart door lock using an RC522 RFID reader, an MG90S servo for the latch, and an SSD1306 OLED to show access status. With one sketch, the system reads a tag UID, decides if it is authorized, and then unlocks or denies access.

Want the exact parts used in this build? Grab them from ShillehTek.com. If you want help customizing this project or building something for your product, check out our IoT consulting services.

Credits: The smart door lock photos and code in this tutorial are credited to Instructables, which served as the reference for this ShillehTek version.

Arduino PCA9685: Joystick-Controlled 6-DOF Robot Arm

Shilleh — Mon, 29 Jun 2026 02:20:52 +0000

Project Overview

Arduino Nano + PCA9685 servo driver robotic arm: Build a 6-axis robotic arm controlled by a joystick, with six MG90S micro servos driven over I2C and an OLED that shows the current angles.

Six MG90S micro servos give the arm 6 degrees of freedom: base rotation, shoulder, elbow, wrist twist, wrist tilt, and gripper. A 2-axis joystick maps to the most-used joints; the OLED shows current angles. The foundation of every robotics project - from animatronics to entry-level industrial pick-and-place.

Time: ~4 hours
Skill level: Advanced
What you will build: A 6-DOF robotic arm with joystick control + saved positions.

PCA9685 + 6x MG90S + joystick = 6-DOF robotic arm.

Parts List

From ShillehTek

PCA9685 16-Ch PWM Servo Driver - drives multiple servos from a single I2C interface
MG90S Metal-Gear Servo (x6) - provides the 6 joints of motion
KY-023 Joystick Module - analog input for manual joint control
0.96" SSD1306 OLED - displays current joint angles
Arduino Nano V3.0 - microcontroller for reading inputs and commanding servos
Dupont Jumper Wires - wiring between modules

External

3D-printed or laser-cut arm frame (open-source designs everywhere)
5V/2-3A external supply for the servos

Note: Do not power 6 servos from the Arduino's 5V. They can pull ~700mA each at peak. Use a separate 5V supply with a common ground.

Step-by-Step Guide

Step 1 - Wire the PCA9685

Goal: Connect the Arduino Nano, PCA9685, joystick, OLED, and external 5V servo power safely.

What to do: Connect the PCA9685 to the Arduino over I2C (SDA/SCL). Connect six MG90S servos to PCA9685 channels 0 to 5. Power the servos from a separate 5V supply connected to the PCA9685 V+ input, and make sure the external supply ground and Arduino ground are tied together (common ground).

PCA9685 has 16 channels - connect 6 MG90S servos to channels 0 to 5.

Arduino + PCA9685 on I2C, joystick on A0/A1, external 5V to PCA9685's V+.

Expected result: All modules are connected, and the PCA9685 has a dedicated 5V supply for servo power with a shared ground.

Step 2 - Install Library + Test

Goal: Verify the PCA9685 is communicating and can center the servos.

What to do: Install the Adafruit PWM Servo Driver library in the Arduino IDE. Upload the following sketch to initialize the driver and set channels 0 to 5 to their midpoint pulse.

Code:

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
const int SERVO_MIN = 150, SERVO_MAX = 600;
void setup() {
  pwm.begin(); pwm.setPWMFreq(50);
  for (int s = 0; s < 6; s++) pwm.setPWM(s, 0, (SERVO_MIN + SERVO_MAX) / 2);
}
void loop() {}

Expected result: All connected servos move to a centered position and hold steady.

Step 3 - Joystick Control Sketch

Goal: Control the base and shoulder joints using the joystick analog axes.

What to do: Wire the joystick outputs to A0 and A1 (as shown in the wiring diagram). Upload this loop code that reads analog values, applies a deadband, updates target angles, and writes PWM values to the PCA9685 on channels 0 and 1.

Code:

int curBase = 90, curShoulder = 90;
void loop() {
  int xRaw = analogRead(A0) - 512;
  int yRaw = analogRead(A1) - 512;
  if (abs(xRaw) > 50) curBase = constrain(curBase + xRaw/200, 0, 180);
  if (abs(yRaw) > 50) curShoulder = constrain(curShoulder + yRaw/200, 0, 180);
  pwm.setPWM(0, 0, map(curBase, 0, 180, SERVO_MIN, SERVO_MAX));
  pwm.setPWM(1, 0, map(curShoulder, 0, 180, SERVO_MIN, SERVO_MAX));
  delay(20);
}

Expected result: Moving the joystick smoothly rotates the base and moves the shoulder, without jitter when the joystick is near center.

Step 4 - Use It

Goal: Operate the arm with joystick control and confirm the display and joint mapping.

What to do: Use joystick X for base rotation and joystick Y for shoulder movement. Use the additional buttons to cycle through elbow, wrist, and gripper control. Watch the OLED to confirm the current joint angle values.

Joystick X -> base rotation, Y -> shoulder. Two more buttons cycle through elbow / wrist / gripper.

Smooth servo motion; OLED shows current angle on each joint.

Expected result: The arm responds smoothly to joystick input, and the OLED updates with the joint angles.

Step 5 - Where to Take It Next

Goal: Identify practical next upgrades once basic motion control is working.

What to do: Consider these extensions after your core wiring and control loop are stable:

Add a Bluetooth/Wi-Fi link - phone-app control (HM-10 or ESP32)
Record/playback joint positions for repeatable demos (animatronics)
Add inverse-kinematics math - control by target (x, y, z) instead of joint angles
Pair with a webcam + computer vision - pick objects by color or shape

Expected result: You have a clear roadmap for expanding the project beyond manual joystick control.

Conclusion

This build uses an Arduino Nano, a PCA9685 servo driver, and six MG90S servos to create a 6-DOF robotic arm you can drive with a joystick while viewing joint angles on an SSD1306 OLED.

Want the exact parts used in this build? Grab them from ShillehTek.com. If you want help customizing this project or building something for your product, check out our IoT consulting services.

Arduino Nano MPU6050 + NEO-6M: GPS + IMU Data Logger

Shilleh — Mon, 29 Jun 2026 02:17:57 +0000

Project Overview

Arduino Nano V3.0 vehicle data logger: Use an MPU6050 IMU for G-force (acceleration and braking) plus a GT-U7 NEO-6M GPS for position and speed, then write everything to a microSD card as a CSV you can analyze later.

The logger records a new row on each GPS update (about 1 Hz). After a drive, you can plot speed and G-forces over your route for track-day telemetry or general driving analysis.

Time: ~2 hours
Skill level: Intermediate
What you will build: A self-contained data logger that records GPS + IMU data to microSD for offline analysis.

MPU6050 + NEO-6M + microSD = track-day data logger, no subscription.

Parts List

From ShillehTek

MPU6050 IMU - measures acceleration and gyro data for G-force logging.
GT-U7 NEO-6M GPS - provides latitude/longitude and speed fixes.
Micro SD Card Adapter - writes the CSV log to a microSD card over SPI.
Arduino Nano V3.0 - reads sensors and stores the data.
Dupont Jumper Wires - makes the breadboard and module connections.

External

microSD card (≤32 GB FAT32)
12V to 5V buck (or USB-C car charger) for power
Project enclosure

Note: The microSD card should be formatted as FAT32. The GPS module is connected using SoftwareSerial, the MPU6050 uses I2C, and the SD adapter uses SPI.

Step-by-Step Guide

Step 1 - Wire It Up

Goal: Connect the Arduino Nano to the MPU6050 (I2C), the NEO-6M GPS (SoftwareSerial), and the microSD adapter (SPI).

What to do: Build the circuit on a breadboard and double-check power and signal wiring before plugging into your vehicle power source.

Arduino + MPU6050 + GPS + SD adapter on a small breadboard.

GPS on SoftwareSerial; MPU6050 on I2C; SD adapter on SPI.

Expected result: All modules are powered and connected, ready for uploading the sketch.

Step 2 - Upload the Sketch

Goal: Read GPS and IMU data, then log it to a CSV file on the microSD card.

What to do: Install the required libraries, compile, and upload the sketch to the Arduino Nano. The logger opens trip.csv and appends a header row on startup.

Code:

#include <Wire.h>
#include <Adafruit_MPU6050.h>
#include <TinyGPS++.h>
#include <SoftwareSerial.h>
#include <SD.h>
Adafruit_MPU6050 mpu;
TinyGPSPlus gps;
SoftwareSerial gpsSer(4, 3);
File log;
void setup() {
  Serial.begin(9600); gpsSer.begin(9600);
  mpu.begin(); SD.begin(10);
  log = SD.open("trip.csv", FILE_WRITE);
  log.println("time,lat,lng,speed_kmh,ax,ay,az,gz");
}
void loop() {
  while (gpsSer.available()) gps.encode(gpsSer.read());
  if (gps.location.isUpdated()) {
    sensors_event_t a, g, t; mpu.getEvent(&a, &g, &t);
    log.printf("%lu,%.6f,%.6f,%.1f,%.2f,%.2f,%.2f,%.2f\n",
      millis(), gps.location.lat(), gps.location.lng(), gps.speed.kmph(),
      a.acceleration.x, a.acceleration.y, a.acceleration.z, g.gyro.z);
    log.flush();
  }
}

Expected result: When the GPS gets fixes, the Arduino writes rows to trip.csv on the microSD card.

Step 3 - Build the Enclosure

Goal: Secure the electronics so they can run reliably in a vehicle.

What to do: Mount the breadboard/modules inside an enclosure and route the power cable so the logger can be powered from a car USB port or a regulated 5V supply.

All in a small box; ribbon cable carries USB power from a car USB port.

Expected result: A compact, protected logger that can be placed in the vehicle for driving tests.

Step 4 - Drive and Log

Goal: Record a trip so you have real GPS and IMU data to analyze.

What to do: Plug the logger into power in the car and drive. The sketch logs a CSV row each time the GPS reports an updated location (about 1 Hz).

Plug into car USB; logger writes CSV row every GPS fix (~1Hz).

Expected result: After your drive, the microSD card contains trip.csv with time, location, speed, and acceleration/gyro readings.

Step 5 - Analyze the CSV

Goal: Turn the logged data into something you can visualize and learn from.

What to do: Remove the microSD card and open the CSV in Python, Excel, or import it into mapping tools (for example, Google Earth workflows) to plot the route and overlay speed or G-force data.

Open the CSV in Python/Excel/Google Earth; plot the route with speed/G-force heatmaps.

Expected result: A plotted route and telemetry that helps you review braking, cornering, and speed patterns.

Step 6 - Where to Take It Next

Goal: Identify optional upgrades you can add after the basic logger works.

What to do: Consider expanding the build with extra sensors or connectivity.

Add a BME280 for cabin temperature/humidity logs
Stream live data to a phone over HM-10 BLE for in-car display
OBD-II integration via MCP2515 to log RPM, throttle, and coolant temp
ESP32 + Wi-Fi sync to auto-upload trip logs when you get home

Expected result: A clear roadmap for upgrades without changing the core data-logging workflow.

Conclusion

With an Arduino Nano V3.0, an MPU6050, a NEO-6M GPS, and a microSD adapter, you can build a vehicle data logger that records GPS position, speed, and G-forces into a CSV for offline analysis. Commercial track-day loggers do the same job, but this approach keeps costs low and gives you full ownership of your data.

Want the exact parts used in this build? Grab them from ShillehTek.com. If you want help customizing this project or building automotive telematics firmware for your product, check out our IoT consulting services.

ESP32 HX711: Beehive Weight and Climate Dashboard

Shilleh — Mon, 29 Jun 2026 02:15:29 +0000

Project Overview

ESP32 + HX711 + DS18B20 + DHT22 beehive monitor: Build a Wi-Fi connected beehive monitor that tracks hive weight (honey yield), internal temperature, and humidity, then streams the readings to a phone-accessible dashboard.

The HX711 with a load cell measures hive weight in grams. The DS18B20 waterproof probe reads internal temperature. The DHT22 measures ambient temperature and humidity. The ESP32 sends everything over Wi-Fi for remote viewing.

Time: ~3 hours
Skill level: Intermediate / Advanced
What you will build: A solar-friendly beehive monitor logging weight, temperature, and humidity to a dashboard.

HX711 + load cell + DS18B20 + DHT22 + ESP32 for remote beekeeping data.

Parts List

From ShillehTek

HX711 Load Cell Amplifier - reads the strain gauge bridge and outputs stable weight readings to the ESP32.
DS18B20 Waterproof Probe - measures internal hive temperature.
DHT22 Temperature & Humidity Sensor - measures ambient temperature and relative humidity.
ESP32-WROOM Dev Board - runs the firmware and provides Wi-Fi connectivity.
TP4056 LiPo Charger - charges and protects a single-cell LiPo/18650 battery for off-grid power.
120 PCS Dupont Jumper Wires - makes prototyping and sensor wiring easier.

External

50-100 kg strain-gauge load cell (4 half-bridge cells in a Wheatstone configuration) - supports the hive and provides the strain signal for the HX711.
2 plywood platforms (one above, one below the cells) - creates a rigid sandwich so only vertical load reaches the cells.
Optional: 6V solar panel for permanent off-grid power.

Note: Load cells need to be mechanically isolated so only the hive's weight passes through them. Use rubber feet between everything.

Step-by-Step Guide

Step 1 - Set up the hive

Goal: Start with a stable hive placement before adding the scale and sensors.

What to do: Choose a level location in the apiary and confirm the hive sits solidly without rocking. You will add a scale platform underneath in the next step.

Standard Langstroth hive to instrument.

Expected result: A stable hive location ready for the scale platform.

Step 2 - Build the scale platform

Goal: Create a mechanical platform that routes the hive weight through the load cells.

What to do: Mount four half-bridge load cells at the corners between two plywood platforms so the hive sits on the top platform and the bottom platform contacts the ground. Ensure the assembly is rigid and mechanically isolated.

Wire the 4 half-bridge cells into a single full-bridge Wheatstone configuration so you can read them with one HX711 module. Many beekeeper kits ship pre-wired.

Four load cells at the corners with a plywood sandwich above and below.

Expected result: A complete platform that can measure hive weight changes reliably.

Step 3 - Wire the electronics

Goal: Connect the HX711, DS18B20, and DHT22 to the ESP32 GPIO pins.

What to do: Assemble the ESP32 and sensors on your mounting board/enclosure. Wire the sensors as shown in the wiring diagram: HX711 to GPIO 16 and 17, DS18B20 to GPIO 4, and DHT22 to GPIO 5.

ESP32 with three sensors: HX711, DS18B20, and DHT22.

HX711 to GPIO 16/17, DS18B20 to GPIO 4, DHT22 to GPIO 5.

Expected result: All sensors are wired to the ESP32 and ready for firmware.

Step 4 - Upload the sketch

Goal: Read weight, internal temperature, ambient temperature, and humidity, then print the values to Serial (and optionally push to a server).

What to do: Compile and upload the following Arduino sketch to the ESP32. Update the Wi-Fi SSID and password, and calibrate the CAL value for your specific load cell setup.

Code:

#include <WiFi.h>
#include <HX711.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <DHT.h>
HX711 scale;
OneWire bus(4); DallasTemperature ds(&bus);
DHT dht(5, DHT22);
const float CAL = 420.0;   // calibrate this for your load cell
void setup() {
  Serial.begin(115200);
  WiFi.begin("SSID","PASS");
  scale.begin(16, 17); scale.set_scale(CAL); scale.tare();
  ds.begin(); dht.begin();
}
void loop() {
  float w = scale.get_units(10);
  ds.requestTemperatures();
  float internalT = ds.getTempCByIndex(0);
  float ambientT = dht.readTemperature();
  float h = dht.readHumidity();
  Serial.printf("kg=%.2f intT=%.1fC ambT=%.1fC RH=%.0f%%\n", w/1000.0, internalT, ambientT, h);
  // ...push to ThingSpeak / your own server every 5 minutes
  delay(300000);
}

Expected result: Serial output shows weight plus internal and ambient temperature and humidity readings at the configured interval.

Step 5 - Deploy at the apiary

Goal: Install the monitor so it runs continuously in real conditions.

What to do: Mount the electronics securely, protect the sensors and wiring from weather, and place the hive on the scale platform. If using solar power, install the panel and verify the charging setup.

Solar-powered deployment reporting every 5 minutes.

Live weight, internal and ambient temperature, and humidity from anywhere.

Expected result: The system runs in place and you can view readings in your dashboard or logs.

Step 6 - Extend the project

Goal: Identify safe next upgrades without changing the core build.

What to do: Consider expanding with one of the following additions:

Add LoRa (SX1262) for off-grid apiaries beyond Wi-Fi range
Detect swarm events from sudden weight drops plus a spike in audio (microphone)
Log to ThingSpeak / InfluxDB for multi-year datasets
Alert on temperature anomalies (overheating risk for the colony)

Expected result: A clear roadmap for future enhancements once the baseline monitor is stable.

Conclusion

You built an ESP32-based beehive monitor using an HX711 load cell amplifier for weight tracking, plus a DS18B20 probe and DHT22 sensor for temperature and humidity readings. With the data streaming over Wi-Fi, you can watch hive health and honey flow trends without opening the hive as often.

Want the exact parts used in this build? Grab them from ShillehTek.com. If you want help customizing this project or building something for your product, check out our IoT consulting services.

ESP32 DS18B20: Wi-Fi Smoker Thermometer Alerts

Shilleh — Mon, 29 Jun 2026 02:12:50 +0000

Project Overview

ESP32 + DS18B20 Wi-Fi BBQ / smoker thermometer: A waterproof DS18B20 probe measures meat or smoker temperature while an ESP32 shows it on a small OLED and sends a Telegram alert when your target temperature is reached.

This build is designed for long cooks so you can step away and still get notified the moment the food is ready.

Time: ~1.5 hours
Skill level: Intermediate
What you will build: A Wi-Fi-connected meat thermometer with OLED display and Telegram alerts.

DS18B20 waterproof probe + ESP32 + OLED + Telegram alerts.

Parts List

From ShillehTek

DS18B20 Waterproof Probe (1m) - food-safe stainless probe for meat or smoker chamber temperature.
ESP32-WROOM Dev Board - reads the sensor, drives the display, and connects to Wi-Fi.
0.96" I²C SSD1306 OLED - shows live temperature and status on the device.
KY-006 Buzzer (audible alarm) - local audible alert when target temperature is reached.
TP4056 LiPo Charger - optional charging module for portable power.
120 PCS Dupont Jumper Wires - wiring for the probe, OLED, and buzzer.

External

4.7kΩ resistor - required 1-Wire pull-up resistor for the DS18B20 data line
18650 cell - optional battery for portability
Telegram bot token + chat ID - required for Telegram notifications

Note: The DS18B20 probe is rated 0 to 125°C, which is suitable for meat and smoker chamber temperatures. The stainless steel sheath is food-safe, but wipe it with food-safe sanitizer before each use.

Step-by-Step Guide

Step 1 - Inspect the probe

Goal: Confirm you have a waterproof DS18B20 probe and understand its role in the build.

What to do: Check the cable jacket and stainless tip for damage. Identify the three probe wires used for power, ground, and data (your probe colors may vary).

1m stainless steel waterproof DS18B20 probe.

Expected result: You are ready to wire the DS18B20 to the ESP32 using a 1-Wire pull-up resistor.

Step 2 - Wire the ESP32, DS18B20, OLED, and buzzer

Goal: Connect the temperature probe, OLED display (I2C), and buzzer to the ESP32.

What to do: Make the connections below. Add the 4.7kΩ pull-up resistor from the DS18B20 data line to 3.3V.

Probe data to GPIO 4 (with 4.7kΩ pull-up). OLED on I2C. Buzzer on GPIO 13.

Probe red to 3.3V, black to GND, yellow to GPIO 4 (with 4.7kΩ to 3.3V)
OLED VCC to 3.3V, GND to GND, SDA to GPIO 21, SCL to GPIO 22
Buzzer signal to GPIO 13, GND to GND

Expected result: All modules are powered from 3.3V and share a common ground, and the DS18B20 data line has a pull-up resistor.

Step 3 - Upload the sketch

Goal: Program the ESP32 to read the DS18B20, display the temperature on the OLED, and send a Telegram alert at the target temperature.

What to do: Install the required libraries in your Arduino IDE, then paste and upload the sketch. Replace SSID, PASS, TOKEN, and CHAT with your Wi-Fi and Telegram details.

Compact ESP32-based controller suitable for a small project box.

Code:

#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <UniversalTelegramBot.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

const char* SSID="WIFI", *PASS="PWD", *TOKEN="BOT", *CHAT="CHAT";
const float TARGET = 95.0;   // target meat temp (e.g. brisket)
const int BUZZ = 13;

OneWire bus(4); DallasTemperature ds(&bus);
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
WiFiClientSecure client;
UniversalTelegramBot bot(TOKEN, client);
bool alerted = false;

void setup() {
  Serial.begin(115200); ds.begin();
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  pinMode(BUZZ, OUTPUT);
  WiFi.begin(SSID, PASS);
  while (WiFi.status() != WL_CONNECTED) delay(500);
  client.setCACert(TELEGRAM_CERTIFICATE_ROOT);
}

void loop() {
  ds.requestTemperatures();
  float t = ds.getTempCByIndex(0);

  oled.clearDisplay(); oled.setTextSize(3); oled.setCursor(0, 8);
  oled.setTextColor(SSD1306_WHITE); oled.print(t, 1);
  oled.setTextSize(1); oled.setCursor(70, 50);
  oled.print(t >= TARGET ? "READY" : "...");
  oled.display();

  if (t >= TARGET && !alerted) {
    bot.sendMessage(CHAT, "🥩 Meat is ready! " + String(t,1) + "C");
    tone(BUZZ, 1500, 500); delay(700);
    tone(BUZZ, 1500, 500);
    alerted = true;
  }
  delay(1000);
}

Expected result: The OLED shows the current temperature, and when the reading reaches TARGET, the buzzer sounds and a Telegram message is sent once.

Step 4 - Build the enclosure

Goal: Package the electronics so they can sit outside the smoker while the probe stays inside.

What to do: Place the ESP32, OLED, and buzzer in a heat-resistant enclosure. Route the probe cable through a grommet or strain relief so the cable is protected.

Heat-resistant enclosure with probe cable routed through a grommet.

Expected result: A portable controller you can place safely away from heat and moisture.

Step 5 - Use it during a cook

Goal: Monitor meat temperature in real time and receive an alert when it is ready.

What to do: Insert the DS18B20 probe into the meat (or position it where you want to measure chamber temperature). Keep the ESP32 enclosure outside the smoker. Power the device and connect it to your Wi-Fi network.

Live temperature on the OLED, with Telegram alerts when target is reached.

Expected result: You can read temperature on the OLED, and you receive a Telegram notification when the temperature crosses the target value.

Step 6 - Optional next improvements

Goal: Extend the project after the basic build is working.

What to do: Consider adding features such as a second probe, data logging, or active temperature control.

Add a second probe to track meat and smoker chamber temperature
Log data over time for low-and-slow cook curves
Add a relay-controlled fan for active smoker temperature control
Pair with a meat-doneness lookup table (brisket 93°C, pork shoulder 88°C, chicken 74°C)

Expected result: A clear path to expand the project while keeping the current build as the foundation.

Conclusion

You built an ESP32 and DS18B20 Wi-Fi BBQ / smoker thermometer that displays live temperature on an SSD1306 OLED and sends a Telegram alert at your target temperature. This makes long cooks easier because you can monitor the temperature without standing by the smoker.

Want the exact parts used in this build? Grab them from ShillehTek.com. If you want help customizing this project or building something for your product, check out our IoT consulting services. Reference inspiration: Instructables.

TP4056 18650: Build a USB-C Power Bank

Shilleh — Mon, 29 Jun 2026 02:09:52 +0000

Project Overview

TP4056 USB-C charging board + 18650 cells: Build a repairable 9000 mAh USB-C power bank that charges from a USB-C charger and outputs 5 V over USB-A using a boost converter.

Commercial USB-C power banks cost $30+ for about 10,000 mAh. With three 18650 cells you can reach roughly the same capacity for under $15, and you can replace individual cells when they wear out. The basic setup is a TP4056 USB-C charger up front, three 18650s in parallel, and a small DC-DC boost converter on the back end to deliver 5 V USB output.

Time: 45 to 90 minutes (plus charge and rest time for cell matching)
Skill level: Beginner to Intermediate
What you will build: A 3-cell (3P) 18650 power bank charged by TP4056 and boosted to 5 V USB output

Parts List

From ShillehTek

TP4056 USB-C Charging Board (with protection) - charges the 1S (3.7 V nominal) 18650 pack and provides protected output pads
1S 3A BMS Protection Board - use this if your TP4056 board does not include protection
4 x 18650 Battery Holder - holds the cells; populate 3 slots for a 3P pack
DuPont Wires - wiring and quick connections during testing

External

Three matched 18650 cells (3000 mAh each for an approximate 9000 mAh parallel pack)
A small DC-DC boost converter (5 V, 2 A output), for example MT3608, or a dedicated USB-out booster module
3D-printed or off-the-shelf project enclosure
USB-A panel-mount jack for the output (or use the booster module's onboard USB-A)

Note: For safety, use a TP4056 module with proper protection (or add a 1S BMS). Do not parallel cells with significantly different voltages.

Step-by-Step Guide

Step 1 - Plan the architecture (charger + parallel pack + boost)

Goal: Understand the correct block diagram before wiring anything.

What to do: Build a single-cell-voltage pack (3.7 V nominal) by putting your 18650 cells in parallel, not series. Three parallel 3000 mAh cells behave like one large 9000 mAh cell at the same voltage. A single TP4056 charges the bank as if it were one cell, and a single 5 V boost converter provides the USB output.

Overall signal and power flow for the power bank.

Code:

USB-C IN -> TP4056 -> B+/B- -> 3x 18650 (parallel)
                            -> Boost Converter VIN
                                           VOUT -> USB-A

Expected result: You know where the battery connects (B+/B-) and where the load connects (OUT+/OUT- into the boost converter).

Step 2 - Match the 18650 cells before paralleling

Goal: Prevent large equalization currents when connecting cells in parallel.

What to do: Match the cells' resting voltage to within about 50 mV before paralleling. Charge all three to 4.20 V individually first, let them rest for 24 hours, then measure again. They should be within about 10 mV.

Expected result: All three cells are at nearly the same voltage before you wire them together in parallel.

Step 3 - Wire the battery holder for a 3P pack

Goal: Create one high-capacity 1S pack with two output wires.

What to do: Use the 4-cell holder but populate only 3 positions. Orient all three cells the same way (parallel means all positives on one end, all negatives on the other). Solder a thick wire across all three positive tabs and a thick wire across all three negative tabs. This forms a 9000 mAh equivalent "cell" with two leads.

All cells face the same direction to form a parallel pack.

Expected result: You have a single pair of battery leads representing the combined parallel pack.

Step 4 - Connect the TP4056 and (optional) BMS correctly

Goal: Wire charging and protected output safely.

What to do: If your TP4056 USB-C board has built-in protection (often indicated by a DW01 protection chip on the bottom), it typically exposes four pads: B+/B- to the battery, and OUT+/OUT- to the load. The default charge current is usually 1 A. If your TP4056 board lacks protection, add a 1S BMS protection board as appropriate for your module and wiring plan.

Expected result: The battery is connected to B+/B-, and you have a protected output (OUT+/OUT-) ready to feed the boost converter.

Step 5 - Add and adjust the 5V boost converter

Goal: Convert the battery voltage (about 3.0 to 4.2 V) into a stable 5 V USB output.

What to do: Connect the boost converter input to the TP4056 output pads (OUT+/OUT-). If using an adjustable module like an MT3608, set the output with a multimeter to about 5.05 V before connecting a phone or other device. Alternatively, use a dedicated "5V USB power-bank booster" module that already includes a USB-A jack.

Adjust the trim pot to set a safe 5 V output.

Expected result: You can measure a steady ~5 V at the boost converter output (or at the USB-A output jack).

Step 6 - Estimate capacity, runtime, and charge time

Goal: Set realistic expectations for usable 5 V output and recharge time.

What to do: Use the following reference calculations.

Pack capacity: 3 x 3000 mAh @ 3.7 V = 11.1 Wh
Usable at 5 V output (boost is ~85% efficient): ~9.4 Wh / 5 V = 1880 mAh of "USB 5V" output
iPhone 15 (battery ~12 Wh): roughly 0.8 full charges per power-bank fill
Charge time from a 1 A USB-C charger: ~12 hours for a full empty-to-full bank

Expected result: You understand why a "9000 mAh" 3.7 V pack delivers significantly less mAh at 5 V after conversion losses.

Step 7 - (Optional) Add battery-level LED indication

Goal: Add a simple battery level indicator similar to commercial power banks.

What to do: Add a 4-LED voltage meter solution (for example, an LM3914-based indicator or a small ATtiny reading cell voltage) to create a four-bar indicator. This is a low-cost upgrade that improves usability.

Expected result: You have a basic LED indicator that reflects battery voltage level.

Conclusion

You built a DIY 18650 power bank using a TP4056 USB-C charging board, a 3P parallel cell pack, and a 5 V boost converter for USB output. This project covers lithium charging basics, protection, boost conversion, and pack assembly in a design where you can replace individual cells instead of discarding the whole bank.

Want the exact parts used in this build? Grab them from ShillehTek.com. If you want help customizing this project or building something for your product, check out our IoT consulting services.

Inspiration source: "Homemade DIY Power Bank Using 18650 Battery" on Instructables.

ESP32 LVGL: Touchscreen Smart Switch UI

Shilleh — Mon, 29 Jun 2026 02:07:29 +0000

Project Overview

ESP32 + LVGL touchscreen display smart switch UI: Build a slick touchscreen interface on an ESP32 LVGL 2.8-inch Smart Display that can toggle a relay, show live temperature data, and publish state to Home Assistant over MQTT.

Using the LVGL graphics library gets you modern UI widgets (buttons, sliders, gauges, charts) and smooth partial redraws that feel closer to commercial panels. The trade-off is higher RAM usage, but the ESP32 has enough SRAM for typical LVGL projects.

Time: About 30 minutes
Skill level: Intermediate
What you will build: A working ESP32 touchscreen smart switch UI with relay control, sensor display, and MQTT publishing

Parts List

From ShillehTek

ESP32 LVGL 2.8" Smart Display (Resistive Touch) - ESP32 + TFT + touch controller on one board for LVGL UI builds.
1-Channel 5V Relay Module - for switching a load from the touchscreen (or use the 4-channel version for multiple loads).
DHT22 Sensor - provides the temperature reading for the on-screen gauge.
DuPont Wires - for quick sensor and relay connections.

External

USB-C cable - to power and program the ESP32 display board.
An MQTT broker - Mosquitto on a Raspberry Pi or Home Assistant's built-in broker.
Arduino IDE 2.x with the ESP32 board package and LVGL / TFT_eSPI libraries.

Note: The ESP32 LVGL display board referenced here is a single PCB with ESP32-WROOM-32, a 240x320 ILI9341 TFT, and an XPT2046 resistive touch controller. Use the product page pinout and library configuration for your specific board revision.

Step-by-Step Guide

Step 1 - Understand why LVGL is a better UI toolkit

Goal: Pick the right graphics approach for a touchscreen smart switch UI.

What to do: If you are coming from direct-draw libraries like Adafruit_GFX (or raw TFT_eSPI drawing calls), note that those are great for simple primitives. LVGL is a retained-mode UI toolkit where widgets keep state, redraws are partial and smooth, and you can design layouts visually with SquareLine Studio and export C code.

Expected result: You understand the main trade-off: LVGL uses more RAM (around 30 KB minimum), but the ESP32's SRAM is typically sufficient for this class of UI.

LVGL widgets and styling enable a more polished touchscreen UI than simple direct-draw graphics.

Step 2 - Set up the ESP32 LVGL display hardware

Goal: Confirm what is already integrated on the display board and what you need to wire.

What to do: The ShillehTek ESP32 LVGL display is a single PCB with the ESP32 module, ILI9341 240x320 TFT, XPT2046 resistive touch, and USB-C. Plug in USB-C to power and program the board. Use the board's product page for the correct library and pin configuration.

Expected result: Your board powers up over USB-C and you are ready to compile and upload an Arduino sketch.

Step 3 - Upload a quick "Hello LVGL" sketch

Goal: Initialize LVGL and draw a basic button on the display.

What to do: Install the required libraries (LVGL and TFT_eSPI) in Arduino IDE, then upload a minimal LVGL example that initializes the display driver, sets up a draw buffer, and creates a centered button with a label.

Code:

#include <lvgl.h>
#include <TFT_eSPI.h>
#include "touch.h"   // XPT2046 helper

static lv_disp_draw_buf_t draw_buf;
static lv_color_t buf1[240 * 10];

void my_disp_flush(lv_disp_drv_t *d, const lv_area_t *a, lv_color_t *p) {
  tft.startWrite();
  tft.setAddrWindow(a->x1, a->y1, a->x2-a->x1+1, a->y2-a->y1+1);
  tft.pushColors((uint16_t*)&p->full, (a->x2-a->x1+1)*(a->y2-a->y1+1), true);
  tft.endWrite();
  lv_disp_flush_ready(d);
}

void setup() {
  tft.begin(); tft.setRotation(1);
  lv_init();
  lv_disp_draw_buf_init(&draw_buf, buf1, NULL, 240*10);
  static lv_disp_drv_t drv;
  lv_disp_drv_init(&drv);
  drv.flush_cb = my_disp_flush;
  drv.hor_res = 320; drv.ver_res = 240;
  drv.draw_buf = &draw_buf;
  lv_disp_drv_register(&drv);

  lv_obj_t* btn = lv_btn_create(lv_scr_act());
  lv_obj_center(btn);
  lv_obj_t* lbl = lv_label_create(btn);
  lv_label_set_text(lbl, "Hello LVGL!");
}
void loop() { lv_timer_handler(); delay(5); }

Expected result: The screen shows a centered LVGL button with the text "Hello LVGL!".

Step 4 - Add a relay-toggle button to the UI

Goal: Toggle a GPIO that controls a relay module from the touchscreen button.

What to do: Choose the relay GPIO (example below uses GPIO 32). Create an LVGL button, attach an event callback, and update both the relay output level and the on-screen label when the user taps.

A simple LVGL button can act as a smart switch for a relay output.

Code:

const int RELAY = 32;
bool relayOn = false;

static void toggle_cb(lv_event_t* e) {
  relayOn = !relayOn;
  digitalWrite(RELAY, relayOn ? HIGH : LOW);
  lv_obj_t* btn = lv_event_get_target(e);
  lv_label_set_text(lv_obj_get_child(btn, 0),
                     relayOn ? "Light ON" : "Light OFF");
}

void setup() {
  pinMode(RELAY, OUTPUT);
  // ... LVGL init from step 3 ...
  lv_obj_t* btn = lv_btn_create(lv_scr_act());
  lv_obj_set_size(btn, 200, 80);
  lv_obj_center(btn);
  lv_obj_add_event_cb(btn, toggle_cb, LV_EVENT_CLICKED, NULL);
  lv_obj_t* lbl = lv_label_create(btn);
  lv_label_set_text(lbl, "Light OFF");
}

Expected result: Tapping the on-screen button flips the relay GPIO and updates the label between "Light OFF" and "Light ON".

Step 5 - Display live data with an animated gauge

Goal: Show a live temperature reading on the UI.

What to do: Read the DHT22 periodically (for example, every 2 seconds) and feed the value into an lv_meter widget. This gives you a swept-needle style gauge that updates smoothly.

Expected result: The screen shows a temperature gauge that updates on a timed interval as new DHT22 readings arrive.

Step 6 - Publish state to Home Assistant over MQTT

Goal: Send button/relay state changes to your MQTT broker so Home Assistant can track and control the entity.

What to do: Add the PubSubClient library, connect the ESP32 to WiFi, and publish a message (example topic: home/livingroom/light) whenever the LVGL button is pressed. You can also subscribe to the same topic (or a command topic) to reflect state changes initiated in Home Assistant back on the display.

MQTT is a straightforward bridge between the touchscreen UI and Home Assistant entities.

Expected result: Home Assistant detects the MQTT messages and you can control or monitor the smart switch state from other devices.

Step 7 - Use SquareLine Studio for more complex UIs

Goal: Speed up multi-screen UI creation without manually calculating layout positions.

What to do: For multi-page interfaces (settings, dashboards, animated transitions), use SquareLine Studio to design the UI visually, then export the generated C code and integrate it into your Arduino project.

Expected result: You can iterate on a polished UI faster, while still running everything locally on the ESP32.

Conclusion

You built an ESP32 LVGL touchscreen smart switch UI that can toggle a relay, display live DHT22 temperature data, and publish state changes over MQTT for Home Assistant integration. This workflow gives you a modern, smooth UI on inexpensive hardware while keeping the firmware fully under your control.

Want the exact parts used in this build? Grab them from ShillehTek.com. If you want help customizing this project or building something for your product, check out our IoT consulting services.

Attribution: This guide was inspired by "Building an ESP32-based Smart Switch With LVGL Display" on Instructables.