DEV Community: Shilleh

ESP32 Telegram Bot: Remote Relay Pump Control

Shilleh — Tue, 22 Sep 2026 19:35:01 +0000

Originally published on ShillehTek IoT & Beyond.

Project Overview

ESP32 Telegram Bot - Switch a Pump or Any Relay From Your Phone With Chat Commands, Timers and Status Replies: Build an ESP32 + Telegram bot relay controller that switches a pump (or any relay load) from your phone using chat commands, timed runs, and status replies. The ESP32 polls Telegram every second, answers commands like /on, /on60, /off and /status, drives a relay for a water pump (or a lamp, heater, or fan), and tells you when a timed run finishes. A physical button on the board still works and reports what it did. No port forwarding, no cloud dashboard, no monthly fee.

Time: ~45 minutes
Skill level: Intermediate
What you will build: A private Telegram bot with on/off/timed commands, a status query, chat-ID security, a local override button, and push notifications back to your phone.

Type a command in Telegram and the relay clicks in the garden.

Parts List

From ShillehTek

ESP32 38-Pin Dev Board (CP2102, USB-C) - runs the Wi-Fi + Telegram bot code and controls the relay
1-Channel 5V Relay Module - switches the pump (or any other load) safely using isolated contacts
Tactile Button Kit - local override button input
MB102 Breadboard Power Supply - provides clean 5 V for the relay coil
400-Point Breadboard - quick, solderless wiring for the build
Dupont Jumper Wires - connects the ESP32, relay module, and button

External

A small submersible pump (5 V or 12 V) with its own supply, plus tubing, or any load you want to switch
A Telegram account

Note: The relay contacts are isolated, so the pump gets its own supply and only its positive wire passes through COM/NO. Keep this to low-voltage DC loads unless you are comfortable with mains wiring and a proper enclosure. The bot only obeys your own chat ID; anyone else who finds it gets a polite refusal.

Step-by-Step Guide

Step 1 - Create the Bot and Find Your Chat ID

Goal: Get the two strings the sketch needs.

What to do: In Telegram, open @BotFather, send /newbot, give it a display name and a username ending in "bot", and copy the token it replies with (looks like 123456789:AAF…). Then open @userinfobot (or @myidbot and send /getid) to get your numeric chat ID.

Finally open your new bot and press Start. A bot cannot message you until you have messaged it once.

Expected result: A bot token and a chat ID.

Step 2 - Wire the Relay and Button

Goal: Put the ESP32 in control of the pump.

What to do: Relay module: IN → GPIO22, VCC → 5V (from the ESP32's VIN/5V pin or the MB102), GND → GND. Pump: supply + → relay COM, relay NO → pump +, pump − → supply −. Button: GPIO23 to GND (internal pull-up).

Most of these relay modules are active-LOW. The sketch has a RELAY_ON constant to flip if yours clicks the wrong way.

Expected result: Relay off at boot and pump silent.

Step 3 - The Sketch

Code:

#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <UniversalTelegramBot.h>      // "UniversalTelegramBot" by Brian Lough (+ ArduinoJson)
#include <ArduinoJson.h>

const char* SSID = "YourNetwork";
const char* PASS = "YourPassword";
#define BOT_TOKEN "123456789:AAF-your-token-from-BotFather"
#define CHAT_ID   "123456789"           // your numeric chat id: only this chat is obeyed

const int RELAY = 22, BTN = 23;
const int RELAY_ON = LOW;               // most 1-channel modules are active-LOW; use HIGH if yours isn't

WiFiClientSecure client;
UniversalTelegramBot bot(BOT_TOKEN, client);
bool pumpOn = false;
unsigned long offAt = 0;                // millis() when a timed run should stop (0 = no timer)

void setPump(bool on, unsigned long ms = 0) {
  pumpOn = on;
  digitalWrite(RELAY, on ? RELAY_ON : !RELAY_ON);
  offAt = (on && ms) ? millis() + ms : 0;
}

void handleMessages(int n) {
  for (int i = 0; i < n; i++) {
    String chat = bot.messages[i].chat_id, text = bot.messages[i].text;
    if (chat != CHAT_ID) { bot.sendMessage(chat, "Sorry, this bot is private.", ""); continue; }
    if      (text == "/on")     { setPump(true);        bot.sendMessage(chat, "Pump ON", ""); }
    else if (text == "/on10")   { setPump(true, 10000); bot.sendMessage(chat, "Pump ON for 10 s", ""); }
    else if (text == "/on60")   { setPump(true, 60000); bot.sendMessage(chat, "Pump ON for 60 s", ""); }
    else if (text == "/off")    { setPump(false);       bot.sendMessage(chat, "Pump OFF", ""); }
    else if (text == "/status") {
      bot.sendMessage(chat, String("Pump is ") + (pumpOn ? "ON" : "OFF") + (offAt ? " (timed)" : ""), "");
    } else {
      bot.sendMessage(chat, "Commands:\n/on - run\n/on10 - run 10 s\n/on60 - run 60 s\n/off - stop\n/status", "");
    }
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(RELAY, OUTPUT); setPump(false);
  pinMode(BTN, INPUT_PULLUP);
  WiFi.begin(SSID, PASS);
  while (WiFi.status() != WL_CONNECTED) delay(250);
  client.setCACert(TELEGRAM_CERTIFICATE_ROOT);    // ships with the library (or client.setInsecure())
  configTime(0, 0, "pool.ntp.org");                // TLS needs the real time
  bot.sendMessage(CHAT_ID, "Pump controller online at " + WiFi.localIP().toString(), "");
}

void loop() {
  static unsigned long lastPoll = 0; static bool btnWas = true;

  if (millis() - lastPoll >= 1000) {                                 // ask Telegram for new messages
    lastPoll = millis();
    int n = bot.getUpdates(bot.last_message_received + 1);
    while (n) { handleMessages(n); n = bot.getUpdates(bot.last_message_received + 1); }
  }

  if (offAt && millis() >= offAt) {                                  // timed run finished
    setPump(false);
    bot.sendMessage(CHAT_ID, "Timer done, pump OFF", "");
  }

  bool btn = digitalRead(BTN);                                       // local override button
  if (!btn && btnWas) {
    setPump(!pumpOn);
    bot.sendMessage(CHAT_ID, pumpOn ? "Button: pump ON" : "Button: pump OFF", "");
    delay(50);
  }
  btnWas = btn;
}

What to do: Install "UniversalTelegramBot" and ArduinoJson from the Library Manager, paste in Wi-Fi details, token and chat ID, then upload.

Expected result: Your phone buzzes: "Pump controller online at 192.168.x.x". Send /on10 and the relay clicks, "Pump ON for 10 s" comes back, and ten seconds later "Timer done, pump OFF". Press the button and the bot reports "Button: pump ON". Send anything else and you get the command list.

Step 4 - How It Works (and Why It's Safe)

Goal: Understand polling and the security model.

What to do: The ESP32 makes an outbound HTTPS request to Telegram once a second asking "anything new since message N?". That is why it works behind any home router with no open ports. Replies are just more outbound requests.

Because every message carries the sender's chat ID, the sketch compares it to yours and ignores everyone else. The bot token is the only secret, so keep it out of screenshots. The library's certificate keeps the connection verified. If Telegram rotates certificates years from now, setInsecure() is the quick fix.

Expected result: A remote control you would trust with a pump.

Step 5 - Make It a Garden System

Goal: Go beyond one relay.

What to do: Add a capacitive soil sensor and a /soil command, or have the bot message you when the soil dries out and ask "water for 60 s? /on60". Add a second relay for a light with /lamp. Send a daily report at 8 am. Add a flow sensor and report litres delivered after each run. Use Telegram's inline keyboards (sendMessageWithInlineKeyboard) for tappable ON/OFF buttons instead of typed commands.

Expected result: A garden that texts you.

Conclusion

A bot token, a chat ID, and a polling loop turn Telegram into a free, secure remote control for anything an ESP32 can switch through a relay. This same pattern can also carry sensors and alerts back to your phone.

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.

Image credit and reference: carlosvolt on Hackster.io (LGPL license).

Arduino Nano WS2812 Matrix: Play Tetris on 8x8

Shilleh — Tue, 22 Sep 2026 19:33:04 +0000

Originally published on ShillehTek IoT & Beyond.

Project Overview

Tetris on an 8x8 WS2812 Matrix on an Arduino Nano: Build a complete Tetris game on an Arduino Nano using a WS2812 8x8 LED matrix, three buttons (left, right, rotate), and a buzzer so you can play falling-block Tetris on a tiny pixel board.

This version includes all seven standard tetrominoes in their classic colours, rotation with wall kicks, flashing line clears, scoring, speed-up as you score, and game over with restart.

Time: ~1 hour
Skill level: Intermediate
What you will build: A complete Tetris with 7 tetrominoes x 4 rotations stored in flash, collision detection, wall kicks, line clears with a flash, scoring, speed-up, and game over/restart.

Seven colours, sixty-four pixels, one very old idea.

Parts List

From ShillehTek

Arduino Nano V3.0 Pre-Soldered - runs the Tetris sketch and reads the buttons.
WS2812 8x8 LED Matrix - the 64-pixel display for the game (get two for an 8x16 board, see Step 5).
KY-006 Passive Buzzer - sound effects for locks, line clears, and game over.
Tactile Button Kit x3 - left, right, and rotate controls.
Resistor Kit - 330 ohm in series with the WS2812 data line.
Electrolytic Capacitor Kit - 220 uF across the matrix 5V and GND near the matrix.
830-Point Breadboard - prototyping the wiring.
Dupont Jumper Wires - connections between the Nano, matrix, buttons, and buzzer.

External

None

Note: the sketch runs the matrix at brightness 40/255 so USB power is enough. For a boxed game at full brightness, power the matrix from a 5 V 3 A supply and share GND with the Nano. 64 pixels at full white can draw close to 4 A.

Step-by-Step Guide

Step 1 - Wire It

Goal: Connect the WS2812 matrix, three buttons, and buzzer to the Arduino Nano.

What to do: Wire the matrix DIN to Arduino D6 through a 330 ohm resistor. Connect matrix 5V to Nano 5V and matrix GND to Nano GND. Place a 220 uF capacitor across 5V and GND near the matrix.

Wire the buttons to GND and the input pins using the Nano internal pull-ups: left to D9, right to D10, rotate to D8. Wire the KY-006 buzzer: S to D2 and negative to GND.

Orient the matrix so its first pixel is at the top-left and the data runs in a snake pattern row by row.

Same wiring family as the Breakout build, plus a third button for rotate.

Expected result: You have five Arduino pins in use and can install FastLED from the Arduino Library Manager.

Step 2 - How the Pieces Are Stored

Goal: Understand the compact tetromino shape table used by the sketch.

What to do: Each tetromino lives in a 4x4 box. Each of its four cells is stored as one byte: the cell index in that box, calculated as row x 4 + column. That means one rotation is four bytes, and all 7 pieces x 4 rotations fit in 112 bytes of flash.

Moving a piece is changing the box position (px, py). Rotating is selecting the next of its four stored states. The legality check unpacks the four cells and tests them against the walls, the floor, and the locked blocks.

Expected result: You can add or edit shapes by changing four numbers per rotation.

Step 3 - Upload the Sketch

Goal: Compile and upload the complete Arduino Nano Tetris sketch.

What to do: Install the FastLED library, paste the code below into the Arduino IDE, select the correct Nano board/port, and upload.

Code:

#include <FastLED.h>
#define DATA_PIN 6
#define BTN_L   9
#define BTN_R   10
#define BTN_ROT 8
#define BUZZ    2
CRGB leds[64];
CRGB field[8][8];                              // locked blocks (black = empty)

// 7 pieces x 4 rotations x 4 cells; each cell is an index into a 4x4 box: row*4 + column
const uint8_t SHAPE[7][4][4] PROGMEM = {
  {{4,5,6,7},  {2,6,10,14}, {4,5,6,7},  {2,6,10,14}},   // I
  {{1,2,5,6},  {1,2,5,6},   {1,2,5,6},  {1,2,5,6}},     // O
  {{1,4,5,6},  {1,5,6,9},   {4,5,6,9},  {1,4,5,9}},     // T
  {{1,2,4,5},  {1,5,6,10},  {1,2,4,5},  {1,5,6,10}},    // S
  {{0,1,5,6},  {2,5,6,9},   {0,1,5,6},  {2,5,6,9}},     // Z
  {{0,4,5,6},  {1,2,5,9},   {4,5,6,10}, {1,5,8,9}},     // J
  {{2,4,5,6},  {1,5,9,10},  {4,5,6,8},  {0,1,5,9}}      // L
};
const CRGB COLOR[7] = {CRGB::Cyan, CRGB::Yellow, CRGB::Purple, CRGB::Green, CRGB::Red, CRGB::Blue, CRGB::OrangeRed};

int piece, rot, px, py;
unsigned int speedMs = 500;
unsigned long lastFall = 0, score = 0;

uint16_t XY(int x, int y) { return (y & 1) ? y * 8 + (7 - x) : y * 8 + x; }   // serpentine matrix
void beep(int f, int ms) { tone(BUZZ, f, ms); }
bool occupied(int x, int y) { return field[y][x].r | field[y][x].g | field[y][x].b; }

bool fits(int x, int y, int r) {                // can the piece sit at box position (x,y) in rotation r?
  for (int i = 0; i < 4; i++) {
    uint8_t c = pgm_read_byte(&SHAPE[piece][r][i]);
    int cx = x + (c & 3), cy = y + (c >> 2);
    if (cx < 0 || cx > 7 || cy > 7) return false;          // walls and floor
    if (cy >= 0 && occupied(cx, cy)) return false;          // locked blocks (cells above the top are fine)
  }
  return true;
}

void spawn() { piece = random(7); rot = 0; px = 2; py = -2; }

void gameOver() {
  for (int i = 0; i < 3; i++) {
    fill_solid(leds, 64, CRGB::Red); FastLED.show(); beep(200, 150); delay(200);
    FastLED.clear(true); delay(200);
  }
  memset(field, 0, sizeof field); score = 0; speedMs = 500;
  while (digitalRead(BTN_L) && digitalRead(BTN_R) && digitalRead(BTN_ROT)) {}   // any button restarts
  delay(300);
}

void clearLines() {
  int n = 0;
  for (int y = 7; y >= 0; y--) {
    bool full = true;
    for (int x = 0; x < 8; x++) if (!occupied(x, y)) { full = false; break; }
    if (!full) continue;
    n++;
    for (int x = 0; x < 8; x++) leds[XY(x, y)] = CRGB::White;      // flash the row
    FastLED.show(); delay(120);
    for (int yy = y; yy > 0; yy--) for (int x = 0; x < 8; x++) field[yy][x] = field[yy - 1][x];
    for (int x = 0; x < 8; x++) field[0][x] = CRGB::Black;
    y++;                                                            // re-check the row that dropped in
  }
  if (n) {
    score += (n == 1) ? 100 : 400 * (n - 1);                        // 100, 400, 800, 1200
    beep(1200, 80);
    if (speedMs > 150) speedMs -= 10 * n;                           // faster every line
    Serial.print("score "); Serial.println(score);
  }
}

void tick() {                                   // one gravity step
  if (fits(px, py + 1, rot)) { py++; return; }
  bool over = false;                            // can't fall: lock the piece
  for (int i = 0; i < 4; i++) {
    uint8_t c = pgm_read_byte(&SHAPE[piece][rot][i]);
    int cx = px + (c & 3), cy = py + (c >> 2);
    if (cy < 0) over = true; else field[cy][cx] = COLOR[piece];
  }
  beep(300, 20);
  if (over) gameOver(); else clearLines();
  spawn();
}

void handleButtons() {
  static unsigned long lastMove = 0; static bool rotWasDown = false;
  if (millis() - lastMove >= 120) {                                 // slide: one cell per 120 ms while held
    if (!digitalRead(BTN_L) && fits(px - 1, py, rot)) { px--; lastMove = millis(); }
    if (!digitalRead(BTN_R) && fits(px + 1, py, rot)) { px++; lastMove = millis(); }
  }
  bool rotDown = !digitalRead(BTN_ROT);
  if (rotDown && !rotWasDown) {                                    // rotate once per press
    int r = (rot + 1) % 4;
    if (fits(px, py, r))          { rot = r; beep(700, 15); }
    else if (fits(px - 1, py, r)) { px--; rot = r; beep(700, 15); }   // wall kick left
    else if (fits(px + 1, py, r)) { px++; rot = r; beep(700, 15); }   // wall kick right
  }
  rotWasDown = rotDown;
}

void draw() {
  for (int y = 0; y < 8; y++) for (int x = 0; x < 8; x++) leds[XY(x, y)] = field[y][x];
  for (int i = 0; i < 4; i++) {                                     // the falling piece on top
    uint8_t c = pgm_read_byte(&SHAPE[piece][rot][i]);
    int cx = px + (c & 3), cy = py + (c >> 2);
    if (cy >= 0) leds[XY(cx, cy)] = COLOR[piece];
  }
  FastLED.show();
}

void setup() {
  Serial.begin(9600);
  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, 64);
  FastLED.setBrightness(40);
  pinMode(BTN_L, INPUT_PULLUP); pinMode(BTN_R, INPUT_PULLUP); pinMode(BTN_ROT, INPUT_PULLUP);
  randomSeed(analogRead(A0));
  spawn();
}

void loop() {
  handleButtons();
  if (millis() - lastFall >= speedMs) { lastFall = millis(); tick(); }
  draw();
}

Expected result: A coloured piece drops in from above the top row. Slide it with left/right and rotate with the third button. If you rotate against a wall, it can nudge sideways (wall kick). Complete a row and it flashes white, collapses, and the buzzer chirps. The fall speed increases as you clear lines. Fill the board and it flashes red, then press any button for a new game. The score prints to the Serial Monitor.

Step 4 - Read the Logic

Goal: Understand how movement, collision, rotation, and game over work.

What to do: Everything routes through fits(). Moving, rotating, and falling all check whether the piece would be legal before updating anything, so collision logic stays consistent.

Pieces spawn two rows above the top (py = -2) so they enter smoothly. Cells above the top are ignored by the check. Game over is detected when a piece locks while any cell is still above row 0.

Line clearing scans from the bottom up and re-checks a row after collapsing, so double and triple clears work.

Expected result: You know where to modify the code to add features.

Step 5 - Go Taller, Go Further

Goal: Extend the same approach to a larger playfield and extra gameplay features.

What to do: Chain a second 8x8 matrix (DOUT of the first to DIN of the second) for an 8-wide by 16-tall board. Make the field 16 rows, allocate 128 LEDs, and extend XY() so rows 8 to 15 map to the second panel (index + 64, same snake).

You can also add features like soft drop, hard drop, a next-piece preview, and a high score in EEPROM. Show the score on a TM1637 or an OLED. Swap the buttons for a joystick module for an arcade feel.

Expected result: A bigger board and a clear path to enhancements using the same core logic.

Conclusion

A 112-byte shape table, one fits() function, and a gravity timer are enough to run Tetris on an Arduino Nano with a WS2812 8x8 LED matrix. With wall kicks, line clears, scoring, and speed-up, you have a complete falling-block game in a compact and readable sketch.

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

All photos and images in this tutorial are credited to Mirko Pavleski (mircemk) on Hackster.io. The original guide by Mirko Pavleski served as the reference for this ShillehTek version. We thank them for their excellent work in the maker community.

Arduino Nano OLED: Triggered Waveforms to ~30 kHz

Shilleh — Tue, 22 Sep 2026 19:32:38 +0000

Originally published on ShillehTek IoT & Beyond.

Project Overview

Arduino Nano OLED Oscilloscope: This project uses an Arduino Nano and a 0.96 inch I2C OLED (SSD1306) to build a single-channel mini oscilloscope that can display waveforms up to about 30 kHz with a software trigger, plus Vpp and frequency readout.

A real oscilloscope is the best debugging tool there is, and a surprisingly useful one fits on a breadboard. The ADC is sped up to about 75,000 samples per second, a software trigger locks the trace so repeating signals stand still, three buttons set the timebase and hold the display, and the top line shows peak-to-peak voltage and frequency. It will not replace a bench scope, but it will show you PWM, serial bursts, sensor ripple and audio in a way a multimeter never can.

Time: ~1 hour
Skill level: Intermediate
What you will build: A 0 to 5 V single-channel oscilloscope with seven timebases (about 0.2 ms to 80 ms per screen), rising-edge trigger, hold, and automatic Vpp/frequency measurement.

A waveform, a trigger and a readout on a display the size of a stamp.

Parts List

From ShillehTek

Arduino Nano V3.0 Pre-Soldered - the microcontroller running the fast ADC capture and display code
0.96 inch I2C OLED (SSD1306) - shows the waveform and measurements (the original used a 128x64 ST7920 LCD)
Tactile Button Kit x3 - faster, slower, and hold controls
Resistor Kit - 10k ohm series input resistor, plus 2x100k ohm for optional AC coupling bias
Electrolytic Capacitor Kit - 1 uF for optional AC coupling
24 MHz Logic Analyzer - helpful companion for decoding digital buses this analog scope cannot
830-Point Breadboard - quick prototyping for the build
Dupont Jumper Wires - makes wiring the OLED, buttons, and input fast

External

Two 1N4148 diodes for input clamping, and a pair of probe leads

Note: this is a 0 to 5 V instrument. The clamp diodes and 10k ohm series resistor protect the pin from brief over-voltage, but never probe mains, motor supplies or anything above about 12 V. For higher voltages add a 10:1 divider (90k ohm + 10k ohm) and multiply the readout by ten.

Step-by-Step Guide

Step 1 - Wire the Input, Buttons and Display

Goal: A protected probe input and three controls.

What to do: Probe tip to 10k ohm to A0. Clamps at A0: 1N4148 from A0 to 5V (cathode/band to 5V) and 1N4148 from GND to A0 (band to A0). Probe ground to GND.

Buttons: D8 (faster), D9 (slower), D10 (hold) each to GND. OLED: SDA to A4, SCL to A5, VCC to 5V, GND to GND.

The original wiring uses the same input on A0 and three buttons; this version uses an I2C OLED instead of the LCD.

Expected result: An input that can survive a careless probe.

Step 2 - Upload the Sketch

Goal: Get the oscilloscope running on the OLED with Vpp and frequency readout.

What to do: Install the Adafruit GFX and Adafruit SSD1306 libraries, then compile and upload the sketch below. After upload, touch the probe to D5. The sketch outputs a built-in test signal there (about a 980 Hz square wave).

Code:

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
Adafruit_SSD1306 oled(128, 64, &Wire, -1);

const int BTN_FAST = 8, BTN_SLOW = 9, BTN_HOLD = 10;
const int N = 128;                       // one sample per pixel column
uint8_t buf[N];
// microseconds per sample for each timebase, and the ADC prescaler that gives it
const unsigned int STEP_US[7] = {13, 26, 52, 104, 250, 1000, 5000};
const uint8_t      PRESC[7]   = {4,  5,  6,  7,   7,   7,    7};     // 16, 32, 64, 128 ...
int tb = 3; bool hold = false;
float vpp = 0, freq = 0;

inline uint8_t sample() {                // 8-bit read, left-adjusted result in ADCH
  ADCSRA |= (1 << ADSC); while (ADCSRA & (1 << ADSC)); return ADCH;
}

void capture() {
  ADCSRA = (1 << ADEN) | PRESC[tb];       // ADC on, speed set by the timebase
  bool armed = false; unsigned long t0 = micros();
  while (micros() - t0 < 20000) {         // trigger: rising edge through mid-scale, 20 ms timeout
    uint8_t v = sample();
    if (v < 110) armed = true;
    else if (armed && v >= 128) break;
  }
  for (int i = 0; i < N; i++) {
    if (tb < 4) buf[i] = sample();                          // fast ranges: as quick as the ADC allows
    else { unsigned long t = micros(); buf[i] = sample(); while (micros() - t < STEP_US[tb]) {} }
  }
}

void measure() {
  uint8_t lo = 255, hi = 0; int crossings = 0, first = -1, last = -1; bool below = buf[0] < 118;
  for (int i = 0; i < N; i++) {
    lo = min(lo, buf[i]); hi = max(hi, buf[i]);
    if (below && buf[i] >= 138) { below = false; crossings++; if (first < 0) first = i; last = i; }
    else if (!below && buf[i] < 118) below = true;
  }
  vpp = (hi - lo) * 5.0 / 255.0;
  float span = (last - first) * (STEP_US[tb] * 1e-6);            // seconds between first and last edge
  freq = (crossings >= 2) ? (crossings - 1) / span : 0;
}

void draw() {
  oled.clearDisplay();
  oled.setCursor(0, 0);
  oled.print((unsigned long)STEP_US[tb] * 16); oled.print("us ");   // per 16-pixel division
  oled.print(vpp, 2); oled.print("V ");
  if (freq >= 1000) { oled.print(freq / 1000, 1); oled.print("kHz"); }
  else              { oled.print(freq, 0);        oled.print("Hz"); }
  if (hold) oled.print(" H");
  for (int x = 0; x < 128; x += 16) for (int y = 12; y < 64; y += 4) oled.drawPixel(x, y, SSD1306_WHITE);   // grid
  for (int i = 1; i < N; i++)
    oled.drawLine(i - 1, 63 - buf[i - 1] * 51 / 255, i, 63 - buf[i] * 51 / 255, SSD1306_WHITE);
  oled.display();
}

void setup() {
  pinMode(BTN_FAST, INPUT_PULLUP); pinMode(BTN_SLOW, INPUT_PULLUP); pinMode(BTN_HOLD, INPUT_PULLUP);
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C); oled.setTextColor(SSD1306_WHITE);
  ADMUX = (1 << REFS0) | (1 << ADLAR);    // AVcc reference, left-adjust, channel A0
  analogWrite(5, 128);                    // built-in test signal: 980 Hz square wave on D5
}

void loop() {
  if (!digitalRead(BTN_FAST) && tb > 0) { tb--; delay(200); }
  if (!digitalRead(BTN_SLOW) && tb < 6) { tb++; delay(200); }
  if (!digitalRead(BTN_HOLD)) { hold = !hold; delay(300); }
  if (!hold) { capture(); measure(); }
  draw();
}

Expected result: A steady square wave on the screen with something like "1664us 4.96V 980Hz" along the top. Press D8/D9 to zoom the timebase in and out, and press D10 to freeze the trace.

Step 3 - Understand How the Speed and Trigger Work

Goal: Know what is under the hood.

What to do: analogRead() takes about 112 us. This sketch talks to the ADC registers directly, keeps only the top 8 bits (ADLAR) and drops the clock prescaler to 16, which brings one sample down to about 13 us (about 75 ksps). The trigger loop waits for the signal to dip below mid-scale and then cross above it, so every capture starts at the same point of the waveform and a repeating signal appears frozen.

The frequency readout counts those crossings across the buffer, so it is only valid when at least two full cycles fit on screen. Zoom out if it reads 0.

Expected result: You can explain every number on the display.

Step 4 - Add AC Coupling (Optional)

Goal: View audio and signals that swing below ground.

What to do: Put the 1 uF capacitor in series with the probe tip (before the 10k ohm), and add a bias divider at A0: 100k ohm from A0 to 5V and 100k ohm from A0 to GND. The trace now sits at mid-screen and shows the AC part of the signal, like a headphone output, ripple on a power rail, or a microphone module output.

Expected result: Music from a phone jack draws itself across the OLED.

Step 5 - Use It

Goal: Do real debugging with the scope.

What to do: Look at PWM from a motor driver (is it the duty cycle you set?), the output of an LM35 or a potentiometer (is it noisy?), the 38 kHz burst from an IR remote via a receiver module, or the ripple on a buck converter output.

For digital buses (I2C, SPI, serial), use a logic analyzer instead. It captures eight channels at 24 MHz and decodes the protocol, which this scope cannot.

Expected result: Fewer guesses, more looking.

Conclusion

Direct ADC control, a software trigger and a small amount of drawing code turn an Arduino Nano into a pocket oscilloscope. It is limited, but it is limited in ways you can measure and understand. It is a practical tool for quickly seeing what signals in your projects are really doing.

Photo and reference credit: Mirko Pavleski (mircemk) on Hackster.io.

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 LM339: Measure Inductance on OLED

Shilleh — Tue, 22 Sep 2026 19:32:32 +0000

Originally published on ShillehTek IoT & Beyond.

Project Overview

Arduino Nano + LM339 comparator + SSD1306 OLED inductance meter: Build an Arduino-based LC pulse-and-ring meter that measures unknown coils from about 5 uH to 100 mH, then displays the result on a 0.96 inch I2C OLED.

Most multimeters cannot measure inductance, and coils often have no value markings. This meter puts the unknown coil in parallel with a known capacitor, “kicks” the LC tank with a pulse, then times the ringing frequency. A comparator converts the decaying sine wave into clean pulses the Arduino can measure, and one formula converts the period into henries.

Time: ~45 minutes
Skill level: Intermediate
What you will build: A pulse-and-ring LC meter with averaging, automatic uH/mH units, and a one-capacitor calibration.

Kick the tank, time the ring, print the henries.

Parts List

From ShillehTek

Arduino Nano V3.0 Pre-Soldered - runs the timing and OLED display code
0.96" I2C OLED (SSD1306) - shows inductance in uH or mH
Resistor Kit - provides 150 ohm and 1k ohm resistors
830-Point Breadboard - easy prototyping for the LC and comparator circuit
Dupont Jumper Wires - wiring between the Nano, OLED, and LM339

External

LM339 quad comparator (DIP-14)
2.2 uF film (polyester/MKT) capacitor - must be non-polarized, not electrolytic
1N4007 (or 1N4148) diode
A few coils to test: a 100 uH axial inductor, a toroid, a salvaged transformer winding

Note: the tank capacitor’s real value drives the meter’s accuracy. Film capacitors are typically ±5 to 10%. If you built our capacitance meter, measure it and enter the exact number into the sketch. An electrolytic will not work because the tank swings below ground on every cycle.

Step-by-Step Guide

Step 1 - Build the Tank and Pulse Circuit

Goal: Create an LC tank the Arduino can kick.

What to do: Pick a breadboard row as the “tank node”. Connect the 2.2 uF capacitor from the node to GND. Connect the unknown coil from the node to GND (two clip leads make handy probes).

What to do: Build the pulse path: D13 to 150 ohm to diode anode, diode cathode to the tank node. The diode lets the pulse charge the tank, then disconnects so the tank can ring freely.

Expected result: The coil and capacitor are in parallel, fed through a one-way gate from D13.

Step 2 - Add the Comparator

Goal: Convert a decaying sine wave into square pulses the Arduino can time.

What to do: Power the LM339: pin 3 (VCC) to 5V, pin 12 (GND) to GND.

What to do: Wire comparator 1: pin 5 (IN+) to the tank node, pin 4 (IN-) to GND, pin 2 (OUT) to D11. Add a 1k ohm pull-up from pin 2 to 5V (the LM339 output is open-collector; without the pull-up it never goes HIGH).

What to do: Wire the OLED: SDA to A4, SCL to A5, VCC to 5V, GND to GND.

Expected result: Each time the tank swings above 0 V the comparator output is HIGH, and each HIGH pulse lasts half a period.

Step 3 - Upload the Sketch

Goal: Time the ringing and compute inductance from frequency.

Code:

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
Adafruit_SSD1306 oled(128, 64, &Wire, -1);

const int PULSE = 13, SENSE = 11;
const double C = 2.2e-6;                     // tank capacitor in farads: enter the measured value

double readInductance() {
  digitalWrite(PULSE, HIGH); delay(5);       // charge the tank
  digitalWrite(PULSE, LOW);  delayMicroseconds(100);
  double half = pulseIn(SENSE, HIGH, 5000);  // one HIGH pulse = half a period, in microseconds
  if (half == 0) return -1;                  // nothing rang: no coil, or out of range
  double f = 1.0 / (2.0 * half * 1e-6);      // resonant frequency in Hz
  return 1.0 / (4.0 * PI * PI * f * f * C);  // L = 1 / (4 pi^2 f^2 C), in henries
}

void setup() {
  pinMode(PULSE, OUTPUT); pinMode(SENSE, INPUT);
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  oled.setTextColor(SSD1306_WHITE);
}

void loop() {
  double sum = 0; int n = 0;
  for (int i = 0; i < 10; i++) {             // average ten kicks
    double L = readInductance();
    if (L > 0) { sum += L; n++; }
  }
  oled.clearDisplay();
  oled.setTextSize(2); oled.setCursor(0, 0); oled.print("Inductance");
  oled.setCursor(0, 30);
  if (n == 0) oled.print("no coil");
  else {
    double L = sum / n;
    if (L < 1e-3) { oled.print(L * 1e6, 1); oled.print(" uH"); }
    else          { oled.print(L * 1e3, 2); oled.print(" mH"); }
  }
  oled.display();
  delay(300);
}

What to do: Install Adafruit GFX and Adafruit SSD1306, upload the sketch, then clip a 100 uH inductor between the probes (tank node to GND).

Expected result: The OLED reads close to “100.0 uH” and settles within about a second. Disconnect the coil and it shows “no coil”. A 10 mH choke reads in mH.

Step 4 - Calibrate

Goal: Improve accuracy by correcting the capacitor value.

What to do: Inductance is proportional to 1/C, so a 10% capacitor error becomes a 10% reading error. Either measure the capacitor and enter the measured value in the sketch, or measure a known inductor (for example a 5% axial part) and scale C until the reading matches.

What to do: Keep probe leads short (long leads add inductance). Coils with iron or ferrite cores can read slightly differently at this test frequency than at their rated frequency.

Expected result: Readings within a few percent from about 5 uH up to about 100 mH.

Step 5 - Understand and Extend

Goal: Understand the measurement and optional improvements.

What to do: The math is the resonance equation rearranged: f = 1 / (2π√(LC)). The comparator is key: the ringing decays quickly, but pulseIn() only needs one clean half-cycle.

What to do: You can swap in a 100 nF capacitor to push the low end below 1 uH (higher frequency and shorter pulses, so watch pulseIn()’s practical floor of about 10 us). You can also print the resonant frequency to quickly check a coil-capacitor pair for a filter or a crystal radio.

Expected result: A meter that makes junk-box coils usable.

Conclusion

A capacitor, a diode, a comparator, and one line of physics turn an Arduino Nano into a practical inductance meter. With the LM339 cleaning up the tank waveform and the SSD1306 OLED displaying the result, you can quickly label coils and sort unknown parts from about 5 uH to 100 mH.

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: Photos and the reference design are credited to carlosvolt on Hackster.io (LGPL license). The original guide by carlosvolt served as the reference for this ShillehTek version.

ESP32 WebSocket Dashboard: Live Browser Sensor Chart

Shilleh — Tue, 22 Sep 2026 19:32:27 +0000

Originally published on ShillehTek IoT & Beyond.

Project Overview

ESP32 WebSocket Dashboard: Build an ESP32 live dashboard that streams KY-018 light readings plus DHT11 temperature and humidity to a browser chart twice a second using WebSockets, with a button that toggles the onboard LED.

A normal ESP32 web page shows a number when you load it; a WebSocket page shows the number changing while you watch. The board keeps a two-way connection open to every browser on the page and pushes a JSON packet every 500 ms, and the page draws a scrolling chart and updates the readouts instantly. Everything is served from the ESP32: no server, no internet, no libraries loaded from the web.

Time: ~45 minutes
Skill level: Intermediate
What you will build: A self-hosted live dashboard with a canvas chart, three sensor readouts, and a browser-to-board control using ESPAsyncWebServer's built-in WebSocket support.

Readings stream to the browser as they happen.

Parts List

From ShillehTek

ESP32 38-Pin Dev Board (CP2102, USB-C) - runs the web server and WebSocket endpoint
KY-018 Photoresistor Module - provides the analog light level signal for the live chart
DHT11 Temperature & Humidity Sensor - adds temperature and humidity readouts
400-Point Breadboard - makes it easy to prototype the wiring
Dupont Jumper Wires - connects the sensors to the ESP32 pins

External

None - the page is served by the ESP32 itself

Note: On the ESP32, analogRead() only works on ADC1 pins (GPIO32-39) while Wi-Fi is on because ADC2 pins are taken over by the radio. That's why the light sensor goes on GPIO34.

Step-by-Step Guide

Step 1 - Wire the Sensors

Goal: Connect the KY-018 and DHT11 to the ESP32 so the sketch can read light, temperature, and humidity.

What to do: Wire the KY-018: S to GPIO34, + to 3V3, and - to GND. Wire the DHT11: DATA to GPIO4, VCC to 3V3, and GND to GND. The onboard LED on GPIO2 is the control target.

The original used a bare LDR with a divider resistor; the KY-018 module has the divider built in.

Expected result: Hardware is wired and ready for code upload.

Step 2 - Install the Libraries

Goal: Set up the async web server and sensor libraries required by the sketch.

What to do: In the Arduino IDE Library Manager, install "ESP Async WebServer" (the ESP32Async release) and its companion "Async TCP", plus the Adafruit DHT sensor library and Adafruit Unified Sensor.

Expected result: The sketch in the next step compiles successfully.

Step 3 - Upload the Sketch (Board + Web Page)

Goal: Flash the ESP32 with firmware that serves the dashboard and streams data over WebSockets.

What to do: Paste the sketch below into the Arduino IDE.

Code:

#include <WiFi.h>
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include <DHT.h>

const char* SSID = "YourNetwork";
const char* PASS = "YourPassword";
const int LDR_PIN = 34, LED_PIN = 2;
DHT dht(4, DHT11);
AsyncWebServer server(80);
AsyncWebSocket ws("/ws");

// The whole web page lives in flash. No external files, no CDN.
const char PAGE[] PROGMEM = R"rawliteral(
<!DOCTYPE html><html><head><meta name="viewport" content="width=device-width,initial-scale=1">
<title>ESP32 Live</title>
<style>body{font-family:sans-serif;background:#111;color:#eee;text-align:center;margin:0;padding:16px}
.v{font-size:2em;margin:0 8px}canvas{width:100%;max-width:640px;background:#222;border-radius:8px}
button{font-size:1.1em;padding:10px 24px;border:0;border-radius:6px;background:#2a7;color:#fff}</style></head>
<body><h2>ESP32 Live Dashboard</h2>
<div>Light <span class="v" id="L">--</span> Temp <span class="v" id="T">--</span>C  Hum <span class="v" id="H">--</span>%</div>
<canvas id="c" width="640" height="200"></canvas>
<button onclick="ws.send('toggle')">Toggle LED</button>
<script>
const c=document.getElementById('c'),g=c.getContext('2d'),hist=[];
const ws=new WebSocket('ws://'+location.host+'/ws');
ws.onmessage=e=>{const d=JSON.parse(e.data);
  document.getElementById('L').textContent=d.light;
  document.getElementById('T').textContent=d.temp.toFixed(1);
  document.getElementById('H').textContent=d.hum.toFixed(0);
  hist.push(d.light); if(hist.length>128) hist.shift(); draw();};
function draw(){g.clearRect(0,0,640,200);g.strokeStyle='#2a7';g.lineWidth=2;g.beginPath();
  hist.forEach((v,i)=>{const x=i*5,y=195-v/4095*190; i?g.lineTo(x,y):g.moveTo(x,y);});g.stroke();}
</script></body></html>)rawliteral";

void onWsEvent(AsyncWebSocket* s, AsyncWebSocketClient* client, AwsEventType type,
               void* arg, uint8_t* data, size_t len) {
  if (type == WS_EVT_CONNECT) Serial.printf("client %u connected\n", client->id());
  if (type == WS_EVT_DATA) {                                  // a message from the browser
    String msg; for (size_t i = 0; i < len; i++) msg += (char)data[i];
    if (msg == "toggle") digitalWrite(LED_PIN, !digitalRead(LED_PIN));
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(LED_PIN, OUTPUT); dht.begin();
  WiFi.begin(SSID, PASS);
  while (WiFi.status() != WL_CONNECTED) delay(250);
  Serial.println("Open http://" + WiFi.localIP().toString());
  ws.onEvent(onWsEvent);
  server.addHandler(&ws);
  server.on("/", HTTP_GET, [](AsyncWebServerRequest* r) { r->send(200, "text/html", PAGE); });
  server.begin();
}

void loop() {
  static unsigned long last = 0; static int tick = 0; static float t = 0, h = 0;
  if (millis() - last >= 500) {                               // push twice a second
    last = millis();
    if (++tick % 4 == 0) {                                    // DHT11 only every 2 s
      float nt = dht.readTemperature(), nh = dht.readHumidity();
      if (!isnan(nt)) { t = nt; h = nh; }
    }
    int light = analogRead(LDR_PIN);                          // 0..4095
    String json = "{\"light\":" + String(light) + ",\"temp\":" + String(t, 1) + ",\"hum\":" + String(h, 0) + "}";
    ws.textAll(json);                                         // to every connected browser
    ws.cleanupClients();
  }
}

What to do: Fill in your Wi-Fi details, upload, open the Serial Monitor for the IP address, and open it in a browser (phone or laptop on the same network).

Expected result: The readouts appear within a second and the light trace scrolls across the chart. Cover the KY-018 with your hand and the line dives immediately. Tap "Toggle LED" and the blue LED on the board flips. Open the page on a second device and both update in step.

Step 4 - Understand the WebSocket Flow

Goal: Understand how the browser and ESP32 communicate without refreshing.

What to do: The browser loads the page once over plain HTTP, then the script opens a WebSocket to /ws. From then on, the connection stays open: ws.textAll() on the board pushes to every client with no request, and ws.send() in the page pushes to the board. Compare that with polling (reloading a URL every second), which costs a full TCP handshake and headers per update. WebSockets carry a few bytes per message and react in milliseconds. The async server means loop() never blocks on a client either.

Expected result: You understand why the dashboard feels instant compared to refresh-based updates.

Step 5 - Make It Yours

Goal: Adapt the dashboard pattern to your own sensors and controls.

What to do: Add fields to the JSON and spans to the page for any sensor (a BME280, soil probe, or the JSN-SR04T). Send commands the other way ("fan:1", "set:24.5") and parse them in onWsEvent to drive relays or servos. Draw a second trace for temperature, or log the readings to an SD card while streaming them. For access away from home, keep the local dashboard and add MQTT for the cloud side, as in our Home Assistant guide.

Expected result: A live view of any device you build, on any phone in the house.

Conclusion

With one page stored in flash and one WebSocket connection, your ESP32 streams live KY-018 and DHT11 readings to every browser on your network while also accepting a button command to toggle the onboard LED. WebSockets are the difference between a web page about your sensor and a live instrument.

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.

Photo credit: Original reference guide and images from donskytech on Hackster.io (MIT license).

Arduino Nano MPU6050: Build a Self-Balancing Robot

Shilleh — Tue, 22 Sep 2026 19:32:23 +0000

Originally published on ShillehTek IoT & Beyond.

Project Overview

Arduino Nano + MPU6050 self-balancing robot: In this build, an Arduino Nano reads an MPU6050 IMU to estimate tilt angle, then uses a PID loop to drive an L298N motor driver so a two-wheeled robot stays upright.

An MPU6050 measures how far the body is leaning, a complementary filter turns the noisy accelerometer and drifting gyro into one clean angle, and a PID loop drives the wheels under the robot fast enough that it never falls.

Time: ~2 hours (plus tuning)
Skill level: Intermediate-Advanced
What you will build: A balancing robot with a 200 Hz control loop, gyro auto-calibration, fall detection, and a tuning procedure that converges.

Two wheels, one angle, one loop.

Parts List

From ShillehTek

Arduino Nano V3.0 Pre-Soldered - runs the 200 Hz control loop and PWM motor control
MPU-6050 Accelerometer/Gyro (pre-soldered) - measures tilt using accelerometer + gyro over I2C
L298N Motor Driver - drives both DC motors from the battery (the original used an L293D; same pins, less current)
TT Gear Motor 1:48 ×2 - left and right drive motors
Electrolytic Capacitor Kit - use a 220 µF cap across the Nano 5V and GND to smooth supply dips
400-Point Breadboard - quick prototyping and wiring
Dupont Jumper Wires - connections between Nano, MPU6050, and L298N

External

Two wheels for TT motors, and a tall narrow chassis (two acrylic/plywood decks on standoffs, or a 3D print)
A 7.4 V battery: two 18650 cells in a 2S holder, or 6×AA

Note: Geometry matters more than code. Mount the battery (the heaviest part) as high as possible. A tall robot falls slowly and is easier to balance; a squat one falls fast and is nearly impossible. Mount the MPU6050 rigidly, close to the wheel axle, with its board flat and one edge facing straight forward.

Step-by-Step Guide

Step 1 - Build the Chassis

Goal: A tall, stiff body on two wheels.

What to do: Bolt the two TT motors to the bottom deck, wheels on the outside, axles in line. Stack a second deck above for the Nano, breadboard, and driver, and put the battery on the top deck.

Anything that wobbles adds noise the loop has to fight, so tighten everything.

Expected result: The robot stands (held) with its centre of mass well above the axle.

Step 2 - Wire It

Goal: Sensor to Nano, Nano to driver, driver to motors.

What to do: Wire the MPU6050 to the Nano: VCC → 5V, GND → GND, SDA → A4, SCL → A5.

Wire the L298N to the Nano: ENA → D3, IN1 → D4, IN2 → D8, IN3 → D5, IN4 → D7, ENB → D6. Connect OUT1/OUT2 → left motor and OUT3/OUT4 → right motor.

Power wiring: +12V → battery +, GND → battery − and Nano GND. Leave the L298N 5 V jumper on and feed its 5V pin to the Nano 5V pin.

Add the 220 µF capacitor across the Nano 5V and GND. Remove the ENA/ENB jumpers so the PWM pins control speed.

The original layout: sensor on I2C, six lines to the driver.

Expected result: Everything is powered from one battery through the driver regulator.

Step 3 - Upload the Sketch

Goal: Read tilt angle, run a complementary filter, and drive the motors with PID at 200 Hz.

Code:

#include <Wire.h>
const int ENA = 3, IN1 = 4, IN2 = 8, IN3 = 5, IN4 = 7, ENB = 6;
const uint8_t MPU = 0x68;

// ---- tuning (see Step 5) ----
float Kp = 20.0, Ki = 150.0, Kd = 0.6;
float setpoint  = 0.0;          // degrees: the angle at which the robot is truly balanced
const int   MIN_PWM    = 40;    // motors don't turn below this
const float FALL_ANGLE = 35.0;  // give up beyond this

float angle = 0, integral = 0, lastErr = 0, gyroOffset = 0;
unsigned long lastUs;

void mpuWrite(uint8_t reg, uint8_t val) {
  Wire.beginTransmission(MPU); Wire.write(reg); Wire.write(val); Wire.endTransmission();
}
void mpuRead(int16_t& ax, int16_t& az, int16_t& gy) {
  Wire.beginTransmission(MPU); Wire.write(0x3B); Wire.endTransmission(false);
  Wire.requestFrom(MPU, (uint8_t)14);
  ax = Wire.read() << 8 | Wire.read();  Wire.read(); Wire.read();   // ax, (ay skipped)
  az = Wire.read() << 8 | Wire.read();
  Wire.read(); Wire.read();                                        // temperature
  Wire.read(); Wire.read();                                        // gx
  gy = Wire.read() << 8 | Wire.read();                              // gyro around the axle
  Wire.read(); Wire.read();                                        // gz
}

void drive(int pwm) {                       // -215..215, positive = forward
  bool fwd = pwm > 0; pwm = abs(pwm);
  if (pwm > 0) pwm = constrain(pwm + MIN_PWM, 0, 255);   // jump over the dead band
  digitalWrite(IN1, fwd);  digitalWrite(IN2, !fwd);
  digitalWrite(IN3, fwd);  digitalWrite(IN4, !fwd);
  analogWrite(ENA, pwm);   analogWrite(ENB, pwm);
}

void setup() {
  pinMode(ENA, OUTPUT); pinMode(ENB, OUTPUT);
  pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT); pinMode(IN3, OUTPUT); pinMode(IN4, OUTPUT);
  Wire.begin(); Wire.setClock(400000);
  mpuWrite(0x6B, 0x00);        // wake up
  mpuWrite(0x1B, 0x00);        // gyro  +/-250 deg/s  -> 131 LSB per deg/s
  mpuWrite(0x1C, 0x00);        // accel +/-2 g
  mpuWrite(0x1A, 0x03);        // 44 Hz low-pass filter
  delay(500);
  long sum = 0;                // gyro offset: keep the robot still for one second after power-up
  for (int i = 0; i < 500; i++) { int16_t ax, az, gy; mpuRead(ax, az, gy); sum += gy; delay(2); }
  gyroOffset = sum / 500.0;
  lastUs = micros();
}

void loop() {
  int16_t ax, az, gy; mpuRead(ax, az, gy);
  unsigned long now = micros(); float dt = (now - lastUs) / 1e6; lastUs = now;

  float accAngle = atan2((float)ax, (float)az) * 57.296;            // lean angle from gravity
  float gyroRate = (gy - gyroOffset) / 131.0;                        // deg/s
  angle = 0.98 * (angle + gyroRate * dt) + 0.02 * accAngle;          // complementary filter

  if (abs(angle) > FALL_ANGLE) { drive(0); integral = 0; lastErr = 0; return; }   // fallen over

  float err = angle - setpoint;                                      // positive = leaning forward
  integral = constrain(integral + err * dt, -30, 30);
  float deriv = (err - lastErr) / dt; lastErr = err;
  float out = Kp * err + Ki * integral + Kd * deriv;
  drive(constrain(out, -215, 215));                                  // drive INTO the lean

  while (micros() - lastUs < 5000) {}                                // fixed 200 Hz loop
}

What to do: Upload with the motors disconnected from the wheels (or the robot held in the air). Lay it flat and still for the first second while the gyro calibrates, then pick it up and tilt it.

Expected result: The wheels spin in the direction the robot leans and speed up the further it leans.

If they spin the wrong way, swap both motors’ wires (or negate out). If the wheels twitch or the angle wanders instead of tracking your tilt, the gyro sign is opposite to the accelerometer’s: change (gy - gyroOffset) to (gyroOffset - gy).

Step 4 - Find the Balance Point

Goal: Set setpoint to the angle where it truly stands.

What to do: Temporarily print angle to Serial. Hold the robot upright at the spot where it would balance on its own, where the weight feels neutral over the axle, and read the number.

Use that number as your setpoint (typically -3 to +3 degrees, because the sensor is never perfectly level).

Expected result: A robot that does not creep steadily in one direction when it balances.

Step 5 - Tune the PID

Goal: Go from wobbling to standing.

What to do: Set Ki and Kd to 0. Raise Kp until the robot oscillates steadily around upright (it balances for a moment, then rocks harder and harder). Back Kp off by a third.

Raise Kd until the rocking damps out within a couple of swings. Too much Kd makes the wheels chatter.

Finally raise Ki from zero until a gentle push no longer leaves it leaning. Too much Ki brings back slow oscillation.

Change one number at a time and re-upload. Typical results on a robot like this land near Kp 15-30, Ki 100-250, Kd 0.3-1.2.

Expected result: The robot stands, shrugs off a nudge, and stays put on a flat floor.

Conclusion

You built an Arduino Nano self-balancing robot that uses an MPU6050 for tilt sensing, a complementary filter for angle estimation, and a PID loop to command an L298N motor driver fast enough to stay upright.

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

Arduino Nano DS3231: Build a Binary LED Clock

Shilleh — Tue, 22 Sep 2026 19:32:18 +0000

Originally published on ShillehTek IoT & Beyond.

Project Overview

Arduino Binary Clock: Build an Arduino Nano + DS3231 RTC binary clock where 12 LEDs display the hour and minute in binary, plus a blinking seconds heartbeat LED. The DS3231 keeps accurate time and preserves it through power cuts with its coin cell, so the Nano only needs to read the time and light the correct bits.

A clock nobody else in the house can read is a very satisfying object. Along the way you will learn to read binary at a glance, and you can optionally mount it in a simple wooden or acrylic enclosure for a shelf-ready finish.

Time: ~45 minutes (plus the enclosure if you build one)
Skill level: Beginner
What you will build: A battery-backed 24-hour binary clock with a seconds heartbeat, set automatically from your computer's clock on the first upload.

Twelve LEDs, one RTC, and a time only you can read.

Parts List

From ShillehTek

Arduino Nano V3.0 Pre-Soldered - runs the sketch and drives the LEDs
DS3231 Precision RTC Module (with CR2032) - keeps accurate time with battery backup
Arduino Uno R3 Super Starter Kit - includes LEDs in several colours
Resistor Kit - 220Ω x12 for current limiting
830-Point Breadboard - quick prototyping
Dupont Jumper Wires - easy connections on the breadboard

External

Twelve 5 mm LEDs (two colours make the hour and minute rows easier to read)
Optional: a plywood or acrylic front panel with twelve 5 mm holes

Note: the DS3231 module includes a CR2032 backup cell, so the time survives unplugging. Some modules ship with a rechargeable LIR2032 and a charging resistor. If yours has a non-rechargeable CR2032 and you power the module from 5 V, snip the charging diode/resistor as the module's documentation describes, or just use it as-is for a few years and replace the cell.

Step-by-Step Guide

Step 1 - Wire the LED Rows

Goal: Connect twelve LED outputs to twelve Arduino Nano pins.

What to do: Wire the hour row (five LEDs, values 16-8-4-2-1 from left to right): anodes to D2, D3, D4, D5, D6. Wire the minute row (six LEDs, values 32-16-8-4-2-1): anodes to D7, D8, D9, D10, D11, D12. Wire the seconds LED anode to D13.

For every LED, connect the cathode through its own 220Ω resistor to GND. Keep the rows physically aligned so the place values line up.

The prototype layout: one resistor per LED, RTC on the I2C pins.

Expected result: Two rows of LEDs plus a heartbeat LED, all wired to their own pins.

Step 2 - Add the RTC

Goal: Add battery-backed timekeeping with a DS3231.

What to do: Connect the DS3231 module: SDA to A4, SCL to A5, VCC to 5V, and GND to GND.

In the Arduino IDE, install the RTClib library by Adafruit from the Library Manager.

Expected result: The RTC's red power LED (if present) lights.

Step 3 - Upload the Sketch

Goal: Read time from the DS3231 and display it in binary on the LEDs.

What to do: Paste this sketch into the Arduino IDE and upload it to your Nano.

Code:

#include <Wire.h>
#include <RTClib.h>
RTC_DS3231 rtc;

const int HOUR_PINS[5] = {2, 3, 4, 5, 6};        // place values 16 8 4 2 1
const int MIN_PINS[6]  = {7, 8, 9, 10, 11, 12};  // place values 32 16 8 4 2 1
const int TICK = 13;                             // blinks once a second

void showBits(const int* pins, int n, int value) {   // MSB on the left-most LED
  for (int i = 0; i < n; i++) digitalWrite(pins[i], (value >> (n - 1 - i)) & 1);
}

void setup() {
  for (int i = 0; i < 5; i++) pinMode(HOUR_PINS[i], OUTPUT);
  for (int i = 0; i < 6; i++) pinMode(MIN_PINS[i], OUTPUT);
  pinMode(TICK, OUTPUT);
  rtc.begin();
  if (rtc.lostPower()) {                                     // fresh module or dead cell:
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));          // set from the time this sketch was compiled
  }
  // to set the time by hand once, uncomment, upload, then comment out and upload again:
  // rtc.adjust(DateTime(2026, 9, 13, 21, 45, 0));
}

void loop() {
  DateTime now = rtc.now();
  showBits(HOUR_PINS, 5, now.hour());        // 0..23
  showBits(MIN_PINS, 6, now.minute());       // 0..59
  digitalWrite(TICK, now.second() % 2);      // heartbeat
  delay(200);
}

On the first run, the sketch detects the RTC has no valid time and sets it from your computer's clock at compile time (a few seconds slow is normal).

Expected result: The rows light up in a pattern and the seconds LED blinks. Unplug the Nano for a minute and plug it back in: the time is still right.

Step 4 - Learn to Read It

Goal: Read hours and minutes from the binary LED patterns.

What to do: Add up the place values of the lit LEDs in each row. If you write a lit LED as 1 and a dark one as 0: hour row 1 0 1 0 1 = 16 + 4 + 1 = 21; minute row 1 0 1 1 0 1 = 32 + 8 + 4 + 1 = 45. So it is 21:45.

Prefer 12-hour time? Replace the hour line with int h = now.hour() % 12; if (h == 0) h = 12; showBits(HOUR_PINS, 5, h);. You will only ever use the four right-hand hour LEDs.

Expected result: You can read your clock; visitors cannot.

Step 5 - Box It

Goal: Move from a breadboard prototype to a finished display.

What to do: Drill twelve 5 mm holes in a panel in two rows (five above six, right-aligned so place values line up). Push the LEDs through and secure them from behind, then solder the resistors to a strip of perfboard. Power it from a phone charger.

For a dimmer night-time display, drive the LEDs from PWM pins or add a light sensor (KY-018) and lower brightness after dark. You can also add a button to step the minutes for the odd correction, though a DS3231 typically drifts only about two minutes a year.

Expected result: A finished clock that starts a conversation every time someone asks what it is.

Conclusion

You built an Arduino Nano binary clock using a DS3231 RTC module and 12 LEDs to show the hour and minute in binary with a blinking seconds heartbeat. With the DS3231 battery backup, the time stays correct even after unplugging.

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.

Photos and the original project reference are credited to Kalle Wallin (silverskin) on Hackster.io.

Arduino Uno 16x2 LCD: Custom Icons and Animations

Shilleh — Tue, 22 Sep 2026 19:32:13 +0000

Originally published on ShillehTek IoT & Beyond.

Project Overview

Arduino Uno + 16x2 LCD (HD44780 with PCF8574 I2C backpack): In this build you will load custom 5x8 glyphs into the LCDs eight programmable character slots to display your own icons, create a smooth pixel progress bar, and animate a walking figure by redefining a character in place.

You will learn the 8-byte bitmap format, use a free online editor to generate byte arrays, and upload two Arduino sketches: one for custom icons and one that combines animation with an 80-step progress bar.

Time: ~30 minutes
Skill level: Beginner
What you will build: An I2C LCD demo with custom icons, a smooth 80-step progress bar and a walking animation, plus the know-how to make any glyph you want.

Eight programmable slots, five by eight pixels each, enough for icons, bars and animation.

Parts List

From ShillehTek

Arduino Uno R3 Super Starter Kit - the microcontroller board that runs the sketches and drives the display.
LCD1602 16x2 Display + PCF8574 I2C Adapter - HD44780-compatible character LCD plus I2C backpack for a simple 4-wire connection.
Dupont Jumper Wires - to connect SDA, SCL, 5V, and GND between the Uno and the I2C backpack.

External

None

Note: the original used the LCD's parallel pins with the plain LiquidCrystal library; this version uses the I2C backpack and LiquidCrystal_I2C. The createChar() and write() calls are identical in both, so everything here works on either wiring and on a 20x4 display too.

Step-by-Step Guide

Step 1 - Wire the LCD

Goal: Connect the I2C LCD with four wires and prepare the Arduino library.

What to do: Connect the I2C backpack to the Uno: SDA to A4, SCL to A5, VCC to 5V, and GND to GND.

Install LiquidCrystal_I2C from the Arduino Library Manager. If the screen shows nothing later, try address 0x3F and adjust the backpack's contrast potentiometer.

Expected result: Backlight on.

Step 2 - Understand the Bitmap Format

Goal: Read and write custom glyphs as 5x8 pixel bitmaps.

What to do: A custom character is an array of eight bytes, one per row from top to bottom. Only the five low bits of each byte matter: they are the five pixel columns, left to right. Writing them in binary makes the picture visible in the code:

byte heart[8] = {
  B00000,
  B01010,   //  .#.#.
  B11111,   //  #####
  B11111,   //  #####
  B01110,   //  .###.
  B00100,   //  ..#..
  B00000,
  B00000
};

Draw glyphs without counting bits using the online editor screenduino, which produces the array for you.

Click pixels, copy the byte array.

Expected result: You can look at eight bytes and see the picture.

Step 3 - Icons: Load a Slot, Print It

Goal: Load multiple custom glyphs into slots 0 to 7 and print them like normal characters.

What to do: Upload the sketch below.

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

byte heart[8]  = {B00000, B01010, B11111, B11111, B01110, B00100, B00000, B00000};
byte smiley[8] = {B00000, B01010, B01010, B00000, B10001, B01110, B00000, B00000};
byte bell[8]   = {B00100, B01110, B01110, B01110, B11111, B00000, B00100, B00000};
byte degree[8] = {B01100, B10010, B10010, B01100, B00000, B00000, B00000, B00000};

void setup() {
  lcd.init(); lcd.backlight();
  lcd.createChar(0, heart);          // slots 0..7 are yours
  lcd.createChar(1, smiley);
  lcd.createChar(2, bell);
  lcd.createChar(3, degree);
  lcd.setCursor(0, 0);               // always set the cursor after createChar()
  lcd.print("I "); lcd.write(byte(0)); lcd.print(" Arduino "); lcd.write(byte(1));
  lcd.setCursor(0, 1);
  lcd.write(byte(2)); lcd.print(" 23.5"); lcd.write(byte(3)); lcd.print("C");
}

void loop() {}

Expected result: "I", a heart, "Arduino" and a smiley on the top line; a bell and "23.5" with a proper degree sign and "C" on the bottom. (Note lcd.write(byte(0)): plain write(0) is ambiguous to the compiler.)

Step 4 - Animation: Redefine a Slot in Place, Plus a Pixel Progress Bar

Goal: Animate a character by redefining it in place, and build a progress bar with 80 fill steps across a 16x2 LCD row.

What to do: The character memory is live: if a slot is already on screen and you call createChar() with a new bitmap, the pixels change instantly without reprinting. That is the trick for animation: one cell, redefined every frame.

For the bar, five slots hold glyphs with 1 to 5 columns filled, so each of the 16 cells can show five levels.

Upload the sketch below and watch the top row.

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

byte walk[2][8] = {                          // two frames of a walking figure
  {B01110, B01110, B00100, B01110, B10101, B00100, B01010, B10001},   // legs apart
  {B01110, B01110, B00100, B11111, B00100, B00100, B00100, B00110}    // legs together
};

void makeBarChars() {                        // slots 1..5 = 1..5 columns filled
  for (int n = 1; n <= 5; n++) {
    byte row = 0, g[8];
    for (int c = 0; c < n; c++) row |= (B10000 >> c);
    for (int r = 0; r < 8; r++) g[r] = row;
    lcd.createChar(n, g);
  }
}

void bar(int pct) {                          // 0..100 % across the bottom row, 80 pixel columns
  int cols = map(pct, 0, 100, 0, 80);
  lcd.setCursor(0, 1);
  for (int cell = 0; cell < 16; cell++) {
    int fill = constrain(cols - cell * 5, 0, 5);
    if (fill == 0) lcd.print(" "); else lcd.write(byte(fill));
  }
}

void setup() { lcd.init(); lcd.backlight(); makeBarChars(); }

void loop() {
  static int x = 0, frame = 0, pct = 0;
  lcd.createChar(0, walk[frame]);            // redefine slot 0 -> the figure on screen changes instantly
  lcd.setCursor(x, 0); lcd.write(byte(0));   // draw the walker at its current cell
  bar(pct);
  delay(250);
  lcd.setCursor(x, 0); lcd.print(" ");       // erase before moving on
  frame ^= 1;                                // next frame
  x = (x + 1) % 16;                          // next cell
  pct = (pct + 3) % 101;
}

Expected result: A little figure walks across the top line with alternating legs, while a progress bar fills the bottom line in fine pixel steps rather than jumping a whole cell at a time.

Step 5 - Ideas and Limits

Goal: Plan around the eight custom-character slot limit.

What to do: Eight slots is the hard limit, so plan them. A project might use 5 for a bar, 1 for an animated icon, and 2 for units. Big digits for a clock are made by tiling several custom glyphs into 2-row numerals. Signal strength, battery level and Wi-Fi icons all fit in one glyph each. For a spinner, redefine one slot through four frames. On a 20x4 display the same eight slots are shared by all lines.

Expected result: Displays that look designed, not defaulted.

Conclusion

By using the Arduino Uno with a 16x2 HD44780 LCD, you turned a text-only display into a flexible UI that can show custom icons, a smooth multi-step progress bar, and animation by redefining characters in place.

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: Photos and the original reference tutorial are by tusindfryd on Hackster.io.

Arduino Nano OLED: LED Pendulum Metronome BPM Display

Shilleh — Tue, 22 Sep 2026 19:32:06 +0000

Originally published on ShillehTek IoT & Beyond.

Project Overview

Arduino LED Pendulum Metronome: Build an Arduino Nano metronome using an SSD1306 0.96 inch I2C OLED, a KY-006 passive buzzer, and eight LEDs so the lights sweep like a pendulum, the buzzer clicks the beat with a 4/4 accent, and the OLED shows BPM and the Italian tempo marking.

A mechanical metronome is a swinging arm you can see across a room and a click you can hear over an instrument. This build recreates both with a Nano: eight LEDs in a row “swing” like the pendulum, a buzzer clicks at each end of the swing (louder on beat one of the bar), and a small OLED shows the tempo in BPM with its Italian marking. A potentiometer sets anything from a 40 BPM Largo to a 208 BPM Presto.

Time: ~40 minutes
Skill level: Beginner
What you will build: A visual-plus-audible metronome with a 40 to 208 BPM knob, 4/4 accents, drift-free millis() timing and a live OLED readout.

A row of LEDs as the pendulum, an OLED for the tempo.

Parts List

From ShillehTek

Arduino Nano V3.0 Pre-Soldered - runs the LED sweep, BPM timing, OLED display, and buzzer accent.
0.96" I2C OLED (SSD1306) - displays BPM, tempo marking, and beat count.
KY-006 Passive Buzzer - provides the audible click with a higher accent on beat 1.
Arduino Uno R3 Super Starter Kit - provides eight LEDs (two red, six green) and a potentiometer for tempo control.
Resistor Kit - use one 470Ω resistor for the shared LED cathode return.
830-Point Breadboard - mounts the LEDs, resistor, and interconnects.
Dupont Jumper Wires - connects the Nano to the LEDs, OLED, buzzer, and potentiometer.

External

None

Note: One resistor for eight LEDs works here because only one LED is ever lit at a time. The cathodes all meet at a single 470Ω to ground. If you later want several LEDs on together, give each its own resistor.

Step-by-Step Guide

Step 1 - Wire the LED Row

Goal: An eight-LED pendulum.

What to do: Place eight LEDs in a line. Anodes (long legs) go to D2, D3, D4, D5, D6, D7, D8, D9 in order. Connect all cathodes to one breadboard row, then through a 470Ω resistor to GND. Use red LEDs at both ends (the beat positions) and green in the middle.

Eight LEDs, one shared resistor, an OLED, a pot and a buzzer.

Expected result: A row that can light any single LED.

Step 2 - Wire OLED, Pot and Buzzer

Goal: Tempo control and readout.

What to do: Wire the OLED as SDA to A4, SCL to A5, VCC to 5V, and GND to GND. Wire the potentiometer ends to 5V and GND, and the wiper to A0. Wire the KY-006 buzzer module as S to D11 and minus to GND.

Expected result: All inputs and outputs in place.

Step 3 - The Sketch

Goal: Program the Nano to sweep LEDs, compute BPM timing, click accents, and update the OLED.

What to do: Install the Adafruit GFX and Adafruit SSD1306 libraries, then upload the sketch below. Turn the potentiometer to change the tempo.

Code:

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
Adafruit_SSD1306 oled(128, 64, &Wire, -1);

const int LED[8] = {2, 3, 4, 5, 6, 7, 8, 9};
const int POT = A0, BUZZ = 11;
const int BEATS_PER_BAR = 4;

int pos = 0, dir = 1, beat = 0, bpm = 120;
unsigned long nextStep = 0;

const char* marking(int b) {
  if (b < 60)  return "Largo";
  if (b < 76)  return "Adagio";
  if (b < 108) return "Andante";
  if (b < 120) return "Moderato";
  if (b < 156) return "Allegro";
  if (b < 176) return "Vivace";
  return "Presto";
}

void showBpm() {
  oled.clearDisplay();
  oled.setTextSize(3); oled.setCursor(10, 8);  oled.print(bpm);
  oled.setTextSize(2); oled.setCursor(76, 14); oled.print("BPM");
  oled.setTextSize(1); oled.setCursor(10, 44); oled.print(marking(bpm));
  oled.setCursor(10, 54); oled.print("4/4   beat "); oled.print(beat + 1);
  oled.display();
}

int readBpm() {                                   // averaged, so the number doesn't jitter
  long s = 0; for (int i = 0; i < 8; i++) s += analogRead(POT);
  return map(s / 8, 0, 1023, 40, 208);
}

void setup() {
  for (int i = 0; i < 8; i++) pinMode(LED[i], OUTPUT);
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  oled.setTextColor(SSD1306_WHITE);
  digitalWrite(LED[0], HIGH);
  showBpm();
  nextStep = millis();
}

void loop() {
  int b = readBpm();
  if (abs(b - bpm) >= 2) { bpm = b; showBpm(); }  // small dead band = no flicker

  unsigned long stepMs = 60000UL / bpm / 7;       // one beat = 7 steps, end to end
  if ((long)(millis() - nextStep) >= 0) {
    nextStep += stepMs;                           // schedule from the last due time: no drift
    digitalWrite(LED[pos], LOW);
    pos += dir;
    digitalWrite(LED[pos], HIGH);
    if (pos == 0 || pos == 7) {                   // an end of the swing = a beat
      dir = -dir;
      tone(BUZZ, beat == 0 ? 1500 : 1000, 30);    // higher click on beat 1
      beat = (beat + 1) % BEATS_PER_BAR;
      showBpm();
    }
  }
}

Expected result: The lit LED sweeps left, right, left like a pendulum. Each time it reaches a red end LED the buzzer clicks, with a higher click every fourth beat, and the OLED shows the tempo, its name (for example, “Allegro”) and the beat number. Turning the pot changes the speed immediately.

Step 4 - Why the Timing Is Trustworthy

Goal: A metronome that stays in time.

What to do: Two details matter. Timing is scheduled (nextStep += stepMs) rather than measured from “now”, so a slow OLED redraw cannot push every following beat late because the sketch catches up. Also, the OLED only redraws on a beat or a tempo change, not on every LED step. Check it against a phone metronome app at 120 BPM: they should stay locked for minutes.

Expected result: No drift, which is the property a metronome exists for.

Step 5 - Make It a Practice Tool

Goal: Outline common extensions musicians ask for.

What to do: Add a button to cycle time signatures (3/4, 4/4, 6/8 by changing BEATS_PER_BAR). Add a “tap tempo” button by measuring the gap between taps and setting bpm from it. Mute the buzzer with a switch for silent visual practice. Store the last tempo in EEPROM. Run it from a TP4056 and a cell in a small case for portable use.

Expected result: A metronome you would rather use than an app.

Conclusion

This Arduino Nano LED pendulum metronome uses eight LEDs for a clear visual beat, a KY-006 buzzer for audible accents, and an SSD1306 OLED to show BPM and tempo marking. The scheduled timing approach keeps the beat stable, even when the display updates.

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

Arduino Nano WS2812 Matrix: Build Breakout Game

Shilleh — Tue, 22 Sep 2026 19:32:01 +0000

Originally published on ShillehTek IoT & Beyond.

Project Overview

Breakout on an 8x8 WS2812 Matrix: Build a two-button Breakout arcade game on an Arduino Nano using a WS2812 8x8 RGB LED matrix, complete with bricks, lives, increasing ball speed, and buzzer sound effects.

Sixty-four RGB pixels are enough for a real game. This Breakout has three rows of coloured bricks, a three-pixel paddle you steer with two buttons, a ball that speeds up as you clear the wall, three lives, a buzzer for every bounce, and a win animation. Behind it is a clean game loop with non-blocking timers, a serpentine XY() mapping, and collision checks in the right order that you can reuse for Snake, Pong or Tetris on the same matrix.

Time: ~45 minutes
Skill level: Intermediate
What you will build: A complete, replayable Breakout with 24 bricks, edge "english" on the paddle, increasing speed and sound effects, using FastLED.

Bricks, paddle and ball on 64 pixels.

Parts List

From ShillehTek

Arduino Nano V3.0 Pre-Soldered - runs the game loop and reads the buttons
WS2812 8x8 LED Matrix - displays the bricks, paddle, and ball
KY-006 Passive Buzzer - sound effects for bounces and events
Tactile Button Kit - two inputs for left and right control
Resistor Kit - 330Ω in series with the WS2812 data line
Electrolytic Capacitor Kit - 220 µF across the matrix supply to reduce power spikes
MB102 Breadboard Power Supply - optional, for full-brightness play
830-Point Breadboard - mounting and wiring the build
Dupont Jumper Wires - connections between Nano, matrix, buttons, and buzzer

External

None

Note: 64 WS2812 pixels at full white draw up to 3.8 A. The sketch caps brightness at 40/255 so a USB port copes, but for a bright, boxed-up game feed the matrix from the MB102 or a 5 V 3 A supply, and always share GND with the Nano.

Step-by-Step Guide

Step 1 - Wire the Matrix, Buttons and Buzzer

Goal: Connect the WS2812 matrix, two buttons, and the buzzer to the Arduino Nano.

What to do: Wire the matrix DIN through a 330Ω resistor to D6. Connect matrix 5V to 5V (or the MB102 5V rail) and matrix GND to Nano GND. Place a 220 µF capacitor across 5V and GND near the matrix.

Wire the left button from D9 to GND and the right button from D10 to GND (the sketch uses internal pull-ups, so no external resistors are needed). Wire the KY-006 buzzer S pin to D3 and the minus pin to GND.

One data pin for 64 LEDs, two buttons, one buzzer.

Expected result: The matrix, both buttons, and the buzzer are connected and ready for code upload.

Step 2 - Map X and Y to LED Numbers

Goal: Address LEDs by (x, y) coordinates instead of raw LED indices.

What to do: Most 8x8 matrices are wired in a snake pattern: row 0 runs left to right, row 1 right to left, and so on. A small XY(x, y) function hides that mapping.

If your matrix is a straight raster instead, replace the body of the function with y * 8 + x. Install FastLED from the Arduino Library Manager.

Expected result: The rest of the code can say "light pixel (3, 5)" and it lands on the correct LED.

Step 3 - Upload the Sketch

Goal: Load the full Breakout game onto the Arduino Nano.

What to do: Paste this sketch into the Arduino IDE, select the correct board and port, and upload. After upload, press either button to start.

Code:

#include <FastLED.h>
#define DATA_PIN 6
#define BTN_L 9
#define BTN_R 10
#define BUZZ  3
CRGB leds[64];

bool brick[3][8]; int bricksLeft;
int px, bx, by, dx, dy, lives;
unsigned long tickMs, lastTick = 0, lastMove = 0;

uint16_t XY(uint8_t x, uint8_t y) { return (y & 1) ? y * 8 + (7 - x) : y * 8 + x; }   // serpentine
void beep(int f, int ms) { tone(BUZZ, f, ms); }

void resetBall() { bx = px + 1; by = 6; dx = random(2) ? 1 : -1; dy = -1; }
void newGame() {
  for (int y = 0; y < 3; y++) for (int x = 0; x < 8; x++) brick[y][x] = true;
  bricksLeft = 24; px = 2; lives = 3; tickMs = 200; resetBall();
}

void draw() {
  FastLED.clear();
  const CRGB rowCol[3] = { CRGB::Red, CRGB::Orange, CRGB::Yellow };
  for (int y = 0; y < 3; y++) for (int x = 0; x < 8; x++) if (brick[y][x]) leds[XY(x, y)] = rowCol[y];
  for (int i = 0; i < 3; i++) leds[XY(px + i, 7)] = CRGB::Blue;
  leds[XY(bx, by)] = CRGB::White;
  FastLED.show();
}

void flash(CRGB c, int times) {
  for (int i = 0; i < times; i++) {
    fill_solid(leds, 64, c); FastLED.show(); delay(150);
    FastLED.clear(true); delay(150);
  }
}

void setup() {
  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, 64);
  FastLED.setBrightness(40);
  pinMode(BTN_L, INPUT_PULLUP); pinMode(BTN_R, INPUT_PULLUP);
  randomSeed(analogRead(A0));
  newGame(); draw();
  while (digitalRead(BTN_L) && digitalRead(BTN_R)) {}      // press either button to start
}

void loop() {
  unsigned long now = millis();

  if (now - lastMove >= 70) {                              // paddle: one cell per 70 ms while held
    lastMove = now;
    if (!digitalRead(BTN_L) && px > 0) px--;
    if (!digitalRead(BTN_R) && px < 5) px++;
  }

  if (now - lastTick >= tickMs) {                          // ball: one cell per tick
    lastTick = now;
    int nx = bx + dx, ny = by + dy;
    if (nx < 0 || nx > 7) { dx = -dx; nx = bx + dx; beep(300, 20); }   // side walls
    if (ny < 0)           { dy = -dy; ny = by + dy; beep(300, 20); }   // ceiling
    if (ny <= 2 && brick[ny][nx]) {                                    // brick hit
      brick[ny][nx] = false; bricksLeft--; beep(900, 30);
      dy = -dy; ny = by + dy;
      if (tickMs > 90) tickMs -= 4;                                    // speed up
      if (bricksLeft == 0) { draw(); beep(1200, 400); flash(CRGB::Green, 4); newGame(); return; }
    }
    if (ny == 7) {                                                     // paddle row
      if (nx >= px && nx < px + 3) {
        dy = -1; ny = 6; beep(600, 20);
        if (nx == px) dx = -1; else if (nx == px + 2) dx = 1;          // paddle edges steer the ball
      } else {                                                         // missed
        lives--; beep(150, 300); flash(CRGB::Red, 1);
        if (lives == 0) { flash(CRGB::Red, 3); newGame(); }
        else resetBall();
        draw(); return;
      }
    }
    bx = nx; by = ny;
  }
  draw();
}

Expected result: Red, orange and yellow brick rows at the top, a blue paddle at the bottom, and a white ball moving upward. Hold the buttons to slide the paddle. Every bounce chirps, every brick beeps higher, and the ball gets faster as bricks disappear. Miss three times and the screen flashes red and resets; clear all 24 and it flashes green.

Step 4 - Read the Game Loop

Goal: Understand the structure so you can reuse it for other pixel games.

What to do: Notice the two independent timers: the paddle updates every 70 ms while a button is held, and the ball updates every tickMs. The ball logic calculates the next cell first, then checks walls, ceiling, bricks and paddle in that order, adjusting direction before the ball moves. This ordering prevents the ball from tunnelling through objects.

Also note the paddle edge behavior: hitting the left or right edge pixel nudges the ball sideways, which makes the game controllable instead of random.

Expected result: You can change rules like lives, paddle width, or starting speed by tweaking a few numbers.

Step 5 - Level It Up

Goal: Extend the same codebase into a more complete arcade project.

What to do: Add levels with different brick patterns (store them as 3-byte bitmaps). Give some bricks two hits (dim them after the first). Show lives as green dots in the top row between rounds. Replace the buttons with a potentiometer on A0 mapped to px for arcade-style analogue control, or use a joystick module. Save the high score (fewest lives lost) in EEPROM.

Expected result: A more custom arcade-style Breakout that still fits on the 8x8 matrix.

Conclusion

You built a complete Breakout game on an Arduino Nano using a WS2812 8x8 LED matrix, two buttons, and a buzzer, with real timing, collision checks, lives, and a win animation. The same non-blocking loop and XY mapping are a solid foundation for other 8x8 games.

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: All photos and images in this tutorial are credited to Mirko Pavleski (mircemk) on Hackster.io. The original guide by Mirko Pavleski served as the reference for this ShillehTek version.

Arduino Nano LCD1602: Auto-Ranging Ohmmeter Build

Shilleh — Tue, 22 Sep 2026 19:31:41 +0000

Originally published on ShillehTek IoT & Beyond.

Project Overview

Arduino Nano + LCD1602 auto-ranging ohmmeter: Build an Arduino Nano resistance meter that switches between five reference resistors and displays the best-range reading (Ω, kΩ, or MΩ) on a 16x2 LCD.

A voltage divider with one known resistor can only measure accurately across a limited decade. This project fixes that the way real meters do: it tries multiple reference resistors (100Ω to 1MΩ) and keeps the range that lands closest to mid-scale on the ADC, where readings are most trustworthy.

Time: ~45 minutes
Skill level: Intermediate
What you will build: A five-range, auto-selecting resistance meter with open/short detection, unit-aware formatting, and a simple calibration table.

Five references, one ADC pin, and the code picks the best range.

Parts List

From ShillehTek

Arduino Nano V3.0 Pre-Soldered - runs the ADC measurements and controls the reference ranges
LCD1602 16x2 Display + PCF8574 I2C Adapter - displays resistance and the selected range
Resistor Kit (1 % metal film) - provides 100Ω, 1kΩ, 10kΩ, 100kΩ, 1MΩ references and test resistors
830-Point Breadboard - quick prototyping for the reference ladder
Dupont Jumper Wires - wiring between Arduino, resistors, and LCD

External

Two alligator-clip leads for probes (optional)

Note: only measure resistors that are out of circuit and unpowered. In a live circuit the meter reads the whole network (and a 5 V probe can upset it). On a charged capacitor the ADC pin can be damaged. Discharge, remove, then measure.

Step-by-Step Guide

Step 1 - Build the Reference Ladder

Goal: Create five known resistors that all meet at one sense node.

What to do: Pick a breadboard row as the sense node. Connect 100Ω from D8 to the node, 1kΩ from D9, 10kΩ from D10, 100kΩ from D11, and 1MΩ from D12. Connect A0 to the node.

Connect the unknown resistor between the node and GND (use two clip leads as probes). Wire the I2C LCD as follows: SDA to A4, SCL to A5, VCC to 5V, and GND to GND.

Every reference resistor meets at the sense node; the unknown goes from there to ground.

Expected result: A star of five resistors around one row, plus two probe leads from the node to GND for measuring unknown resistors.

Step 2 - How Auto-Ranging Works

Goal: Understand the measurement method before uploading the sketch.

What to do: The sketch drives one reference pin HIGH (5 V) and sets the other four pins to INPUT (high-impedance). That effectively disconnects the unused reference resistors, so exactly one voltage divider exists: Rref on top, Rx on the bottom, and A0 in the middle.

The ADC reading gives:

Rx = Rref × adc / (1023 - adc)

The code repeats this for all five references and keeps the one whose ADC reading is closest to 512 (mid-scale). Mid-scale is chosen because a one-count ADC error changes the result the least there. No diodes or analog switches are required because tri-stating the pins provides the isolation.

Expected result: You understand why a 10kΩ reference is inaccurate for measuring 10Ω, and how this design avoids that by selecting the best range automatically.

Step 3 - Upload the Sketch

Goal: Program the Arduino Nano to measure resistance, select the best range, and print to the LCD.

Code:

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

const int PIN[5] = {8, 9, 10, 11, 12};
// Measured reference values. Add ~30 ohms to the lowest one for the pin's own output resistance.
float REF[5] = {130.0, 1000.0, 10000.0, 100000.0, 1000000.0};
const char* NAME[5] = {"100", "1k", "10k", "100k", "1M"};
const int SENSE = A0;

int readRange(int r) {
  pinMode(PIN[r], OUTPUT); digitalWrite(PIN[r], HIGH);   // only this reference is "connected"
  delay(5);                                              // let the high ranges settle
  long s = 0; for (int i = 0; i < 16; i++) s += analogRead(SENSE);
  digitalWrite(PIN[r], LOW); pinMode(PIN[r], INPUT);     // back to high-impedance
  return s / 16;
}

void printOhms(float r) {
  if (r < 1000)     { lcd.print(r, 1);         lcd.print(" ");  }
  else if (r < 1e6) { lcd.print(r / 1000, 2);  lcd.print(" k"); }
  else              { lcd.print(r / 1e6, 2);   lcd.print(" M"); }
  lcd.write(0xF4);                                       // the omega symbol in the LCD's character ROM
  lcd.print("      ");
}

void setup() {
  lcd.init(); lcd.backlight();
  for (int i = 0; i < 5; i++) pinMode(PIN[i], INPUT);
}

void loop() {
  int adc[5], lo = 1023, hi = 0, best = 0;
  for (int r = 0; r < 5; r++) {
    adc[r] = readRange(r);
    lo = min(lo, adc[r]); hi = max(hi, adc[r]);
    if (abs(adc[r] - 512) < abs(adc[best] - 512)) best = r;   // closest to mid-scale wins
  }
  lcd.setCursor(0, 0);
  if (lo >= 1015)      lcd.print("Open  (> 5 M)   ");         // every range reads ~5 V
  else if (hi <= 4)    lcd.print("Short / < 2 ohm ");         // every range reads ~0 V
  else printOhms(REF[best] * adc[best] / (1023.0 - adc[best]));
  lcd.setCursor(0, 1);
  lcd.print("Range "); lcd.print(NAME[best]); lcd.print("  adc "); lcd.print(adc[best]); lcd.print("   ");
  delay(300);
}

What to do: Install the LiquidCrystal_I2C library, upload the sketch, then clip a 4.7kΩ resistor between the probes.

Expected result: You should see something like “4.68 kΩ” (or close) on the top line and “Range 10k adc 327” underneath. Try 47Ω, 220kΩ, and 2.2MΩ; the range label should change automatically. Open probes should display “Open”, and touching the probes together should display “Short”.

Step 4 - Calibrate

Goal: Improve accuracy from about ±5% toward about ±1%.

What to do: The references are 1% parts, but the Arduino pin adds about 25 to 40Ω in series when HIGH, which matters on the 100Ω range. That is why REF[0] starts at 130. Measure a known resistor on each range (a second 1% resistor of similar value is a fine standard) and adjust each REF[] entry until the display matches.

The 1MΩ range is the twitchiest. Keep leads short and keep fingers off the probes, since your body can be a few hundred kΩ.

Expected result: Readings within a couple of percent across all five ranges.

Step 5 - Improve It

Goal: Add useful meter-style features.

What to do: Add a hold button that freezes the reading. Print the nearest E12 standard value and color code beneath the measurement. Average ten readings for a steadier display. For better low-ohm accuracy, use the ADC’s 1.1 V internal reference on the lowest range (analogReference(INTERNAL)) with a smaller reference resistor. Log to Serial to sort a tray of unmarked resistors.

Expected result: A homemade instrument you will reach for regularly.

Conclusion

Using five reference resistors and Arduino pin tri-stating, you built an Arduino Nano auto-ranging ohmmeter that keeps the ADC near mid-scale and displays the result on an LCD1602 in Ω, kΩ, or MΩ. This is the same core ranging idea used inside common bench and handheld multimeters.

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

Arduino Nano Relay: Measure 18650 Capacity in mAh

Shilleh — Tue, 22 Sep 2026 19:31:36 +0000

Originally published on ShillehTek IoT & Beyond.

Project Overview

18650 Battery Capacity Tester: Build an Arduino Nano battery tester that uses a 5V relay module and a power resistor to discharge an 18650 cell, then calculates real capacity in mAh and mWh on a 16x2 LCD.

The number printed on a lithium cell is a promise; the number this tester prints is the truth. It discharges a charged 18650 through a known resistor, reads the voltage every half second, integrates current over time, and cuts the load off with a relay the moment the cell reaches 3.0 V, leaving you with the real milliamp-hours (and milliwatt-hours) on a 16x2 LCD. It is the tool that sorts a bag of salvaged laptop cells into keepers and recyclers.

Time: ~1 hour (plus 2 to 3 hours per test)
Skill level: Intermediate
What you will build: A push-to-start constant-resistance discharge tester with live voltage, current and elapsed time, an automatic low-voltage cutoff, and a final mAh/mWh result.

Discharge, integrate, cut off: the real capacity in mAh.

Parts List

From ShillehTek

Arduino Nano V3.0 Pre-Soldered - runs the sketch, reads battery voltage, and controls the relay
LCD1602 16x2 Display + PCF8574 I2C Adapter - displays voltage, current, time, and final mAh/mWh
1-Channel 5V Relay Module - switches the discharge load on and off for cutoff safety
Tactile Button Kit - start/reset input
TP4056 Charger Board - to recharge cells after testing
830-Point Breadboard - prototyping the wiring
Dupont Jumper Wires - quick connections between modules

External

An 18650 cell holder with leads
A 4Ω power resistor rated 10 W (or two 8.2Ω 5 W resistors in parallel); it dissipates over 4 W and gets hot
A multimeter to measure the resistor's real value and your board's 5 V rail

Note: lithium cells are unforgiving. Never discharge below 2.8 V (this tester stops at 3.0 V), never test a swollen, dented or leaking cell, keep the resistor on a ceramic tile away from anything that melts, and never leave the first run unattended. The relay is wired so a dead Arduino means an open circuit.

Step-by-Step Guide

Step 1 - Wire the Discharge Path

Goal: Battery to relay to resistor and back to the battery.

What to do: Battery holder + to relay COM. Relay NO to one end of the 4Ω resistor. Other end of the resistor to battery holder -, and battery - to Arduino GND (shared ground is essential).

Battery + to A0 as well, so the Nano reads the cell voltage directly (a full cell is 4.2 V, safely under the 5 V ADC limit). Relay module: VCC to 5V, GND to GND, IN to D10.

The relay sits between the cell and the load; A0 watches the cell.

Expected result: With the relay off, nothing flows. With it on, the cell drives about 1 A through the resistor.

Step 2 - Wire LCD and Button

Goal: Readout and a start button.

What to do: I2C LCD: SDA to A4, SCL to A5, VCC to 5V, GND to GND. Button between D9 and GND (internal pull-up).

Expected result: Backlight on, ready for code.

Step 3 - Calibrate Two Numbers

Goal: Improve accuracy by measuring instead of assuming.

What to do: With the multimeter, measure the resistor's actual resistance (a "4Ω" part may read 3.8 to 4.3Ω) and the Nano's 5V pin voltage while powered as it will be during the test (USB 5 V is often 4.8 to 5.1 V). Enter both as R_LOAD and VREF in the sketch. This is the difference between plus or minus 10% and plus or minus 2% results.

Expected result: Two constants that match your hardware.

Step 4 - Upload the Sketch

Goal: Run the discharge test, integrate current over time, and stop automatically at cutoff voltage.

Code:

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

const int RELAY = 10, BTN = 9, VBAT = A0;
const bool  RELAY_ON = LOW;      // most 1-channel modules are active-LOW; flip if yours clicks the wrong way
const float VREF     = 5.00;     // measured 5V pin voltage
const float R_LOAD   = 4.0;      // measured load resistance in ohms
const float V_CUTOFF = 3.0;      // stop here (never below 2.8 V)

enum { IDLE, RUNNING, DONE } state = IDLE;
float mAh = 0, mWh = 0;
unsigned long t0, lastStep;

float readV() {                                  // average 32 samples for a steady reading
  long s = 0; for (int i = 0; i < 32; i++) s += analogRead(VBAT);
  return s / 32.0 * VREF / 1023.0;
}

void setup() {
  pinMode(RELAY, OUTPUT); digitalWrite(RELAY, !RELAY_ON);   // load OFF
  pinMode(BTN, INPUT_PULLUP);
  lcd.init(); lcd.backlight();
}

void loop() {
  float v = readV();

  if (state == IDLE) {
    lcd.setCursor(0, 0); lcd.print("Batt "); lcd.print(v, 2); lcd.print("V      ");
    lcd.setCursor(0, 1); lcd.print(v > 3.3 ? "Press to start  " : "Charge battery  ");
    if (digitalRead(BTN) == LOW && v > 3.3) {
      mAh = 0; mWh = 0; t0 = lastStep = millis();
      digitalWrite(RELAY, RELAY_ON);             // load ON
      state = RUNNING; delay(300);
    }

  } else if (state == RUNNING) {
    unsigned long now = millis();
    if (now - lastStep >= 500) {
      float dtH = (now - lastStep) / 3600000.0;  // elapsed hours since last step
      lastStep = now;
      float i = v / R_LOAD;                      // amps through the load
      mAh += i * 1000.0 * dtH;                   // integrate current  -> mAh
      mWh += v * i * 1000.0 * dtH;               // integrate power    -> mWh
      lcd.setCursor(0, 0);
      lcd.print(v, 2); lcd.print("V "); lcd.print(i, 2); lcd.print("A ");
      lcd.print((now - t0) / 60000); lcd.print("m ");
      lcd.setCursor(0, 1);
      lcd.print((int)mAh); lcd.print("mAh "); lcd.print((int)mWh); lcd.print("mWh ");
      if (v <= V_CUTOFF) { digitalWrite(RELAY, !RELAY_ON); state = DONE; }   // load OFF
    }

  } else {                                       // DONE
    lcd.setCursor(0, 0); lcd.print("Done: "); lcd.print((int)mAh); lcd.print(" mAh   ");
    lcd.setCursor(0, 1); lcd.print((int)mWh); lcd.print(" mWh - reset ");
    if (digitalRead(BTN) == LOW) { state = IDLE; delay(300); }
  }
}

What to do: Install LiquidCrystal_I2C, upload, insert a fully charged cell, press the button.

Expected result: The relay clicks, the top line shows something like "4.08V 1.02A 0m", and the mAh count climbs. Two to three hours later the voltage reaches 3.00 V, the relay clicks off, and the LCD shows the capacity, typically 1,800 to 2,800 mAh for a healthy salvaged cell and far less for a tired one.

Step 5 - Read the Result Honestly

Goal: Understand what the capacity number represents.

What to do: Manufacturers rate cells at a gentle 0.2 C discharge down to 2.5 to 2.75 V; our ~1 A load to 3.0 V reads about 5 to 10% lower than the label on a perfect cell. Compare cells against each other with the same rig rather than against the label.

Cells that show under 60% of their rating, get warm, or drop voltage quickly under load are best recycled. Recharge keepers on the TP4056 and mark the measured mAh on the wrapper.

Expected result: A sorted, labeled set of cells you can trust in a pack.

Conclusion

This Arduino Nano relay-based 18650 capacity tester discharges a cell through a known resistor, tracks voltage over time, integrates current, and shuts off at 3.0 V to report real mAh and mWh on a 16x2 LCD. It is a practical way to evaluate and match salvaged cells using a consistent test method.

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.

Photo credit and reference: Mirko Pavleski (mircemk) on Hackster.io.