DEV Community: Shilleh

Maker Component Cabinet Resistor Kits: Find Parts Fast

Shilleh — Wed, 22 Jul 2026 15:26:08 +0000

Project Overview

Maker component cabinet setup: Organize resistor, capacitor, and transistor kits (1900+ total parts) into a labeled drawer cabinet so you can find the right value fast and stop buying duplicates.

This guide focuses on a repeatable system: drawers labeled for quick scanning, bags inside for exact values, and a small “everyday” drawer stocked with the parts you use constantly.

Time: 2 to 4 hours (plus optional label printing time)
Skill level: Beginner
What you will build: A scalable component storage cabinet layout for resistors, capacitors, transistors, and modules

Parts List

From ShillehTek

120-Pack DuPont Wire Kit - common “grab-and-go” wiring set to keep in an everyday drawer
830-Point Breadboard - useful to store with core prototyping items so new builds start faster
20-Pack 1x40 Female Header Pins - prototyping staple to sort and restock regularly
10-Pack 1x40 Male Pin Header - keep accessible for quick module and board connections
Alligator Clip Test Leads (10pcs) - handy test leads to store with your everyday tools

External

Multi-drawer plastic storage cabinet (24- to 60-drawer, plastic, about $20 to $50)
Small zip-top antistatic bags for ICs and transistors
A label printer (Brother P-touch / DYMO LetraTag) or a Sharpie plus masking tape
4-pocket card sleeves for IC datasheet printouts (optional)

Note: The drawer counts below assume common kits like an 820-piece resistor assortment, 600-piece ceramic capacitor assortment, 200-piece electrolytic assortment, and a 300-piece transistor assortment. Adjust drawer allocation based on what you actually reach for most.

Step-by-Step Guide

Step 1 - Use frequency-of-use indexing

Goal: Make the parts you use the most the fastest to reach.

What to do: Avoid organizing only by component type (all resistors in one region, all capacitors in another). Instead, arrange drawers by how often you grab the parts. Put everyday values in the top row and long-tail parts in lower rows.

Example everyday parts: 220Ω, 1 kΩ, 10 kΩ, 100 kΩ, 100 nF, 10 µF, BC547, BC557, and common LED colors.

Expected result: You can open the most-used drawers first and find common parts quickly.

Step 2 - Lay out an 820-piece resistor kit by decades

Goal: Store 41 resistor values so you always know which drawer to open first.

What to do: Use one drawer per E12 decade (10s, 100s, 1k, 10k, 100k, 1M). Inside each drawer, keep small bags labeled with the exact value (for example “10k”). Label the drawer front with the range and optionally list the values inside.

Total: 6 drawers for 41 resistor values.

Expected result: You can jump straight to the correct decade drawer and then the exact bag.

Step 3 - Lay out capacitor kits by type and range

Goal: Keep ceramic and electrolytic capacitors easy to scan and restock.

What to do: Split drawers by capacitor type and commonly used ranges:

Ceramic disc / MLCC small values (1pF to 100nF): 2 drawers by decade
Ceramic disc large values (470nF to 10µF): 1 drawer
Electrolytics, low voltage (10µF to 100µF at 16V): 1 drawer with separate bags per value
Electrolytics, high capacitance (220µF to 1000µF): 1 drawer
Electrolytics, high voltage (35V+): 1 drawer for less frequent use

Expected result: Capacitors are grouped the way you choose them in real builds, not buried in a mixed assortment.

Step 4 - Sort a 300-piece transistor kit by part number and family

Goal: Prevent transistor mix-ups and reduce pinout lookups.

What to do: Put each tube or group into a small zip-top antistatic bag labeled with the part number (BC547, 2N2222, 2N3904, TIP120, and similar). Sort labeled bags by family (NPN small-signal, PNP small-signal, NPN power, MOSFET) across one or two drawers.

Add a small printed datasheet card with each bag (pinout, β, VCE max, IC max) so you do not have to re-search pinouts repeatedly.

Expected result: You can grab the correct transistor quickly and verify the pinout without slowing down.

Step 5 - Create an everyday drawer at eye level

Goal: Make 90% of builds start from a single drawer.

What to do: Stock one drawer with the parts you reach for constantly, such as common resistors (1 kΩ, 10 kΩ, 220Ω), 100 nF and 10 µF capacitors, a few BC547 and BC557 transistors, common LEDs, push-buttons, 1N4148 and 1N4007 diodes, and some hookup wire (for example 22 AWG). Refill this drawer from your main stash on a regular schedule.

Expected result: Most prototypes can start without digging through multiple drawers and bags.

Step 6 - Store modules and breakouts by project category

Goal: Keep larger items accessible even when they do not fit small drawers.

What to do: Use one drawer or shoebox per category such as displays, sensors, wireless, motor drivers, USB-to-serial, and power management. Do not sort by alphabet; sort so you can grab a category that matches the project you are building.

Expected result: When you start a project type (for example a weather station), the related hardware is already grouped together.

Step 7 - Apply a three-location labeling system

Goal: Make drawers readable from the front, from above, and when opened.

What to do: Use three labels:

Front label: a quick description of what is inside (for example “Caps 10nF to 100nF”)
Top label: useful for stackable drawers so you can scan from above
Inside label: a small note listing exact values for the bags inside

Expected result: You can locate a part quickly, even months later, without re-learning your own system.

Step 8 - Add a tools drawer for frequent build items

Goal: Keep build tools from scattering across your workspace.

What to do: Dedicate one drawer to common build tools and accessories such as jumper wires, a mini screwdriver, USB-C and USB-A cables, multimeter probes, alligator clips, and an anti-static wristband.

Expected result: You spend less time hunting for tools during prototyping.

Step 9 - Schedule a monthly restock day

Goal: Keep the system accurate as your habits change.

What to do: Once a month, check the everyday drawer. Refill anything below about 5 pieces from your main stash. If something sat untouched for 30 days, move it back to the main bins so the everyday drawer reflects what you use right now.

Expected result: Your fastest-access drawer stays relevant and your cabinet stays organized long term.

Conclusion

After one weekend of setup, this component cabinet system makes resistor, capacitor, and transistor values easy to find, helps you finish builds faster, and reduces duplicate purchases. By indexing drawers by frequency of use and keeping an everyday drawer stocked, your bench stays ready for the next project.

This approach was inspired by "Resistor Organizer and Storage" on Instructables.

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

ESP32 SD Card: Local CSV Data Logging Setup

Shilleh — Wed, 22 Jul 2026 15:14:41 +0000

Project Overview

ESP32 + SD card data logger: Build an ESP32 data logger that writes sensor readings to a microSD card as CSV, optionally adding DS3231 RTC timestamps so your logs stay readable even without internet.

Cloud logging is great until WiFi drops, your MQTT broker restarts, or you deploy somewhere with no connectivity. An ESP32 with a microSD card gives you reliable local logging that keeps writing through network hiccups.

This guide wires an SD card module to an ESP32, writes CSV data, shows how to add timestamps using a DS3231 RTC, and covers file size and speed tradeoffs for higher-rate logging.

Time: 30 to 60 minutes
Skill level: Beginner to Intermediate
What you will build: An ESP32 that appends timestamped sensor data into CSV files on a microSD card.

Parts List

From ShillehTek

ESP-WROOM-32 (USB-C) - main ESP32 dev board used for SPI SD logging.
XIAO ESP32-S3 - PSRAM-heavy alternative for buffered logging.
DHT22 Sensor - example temperature and humidity data source in the code.
BME280 - higher precision environmental sensor alternative.
DS18B20 Waterproof Probe - outdoor-friendly temperature sensor option.

External

MicroSD card module (SPI interface, 5V-tolerant preferred).
microSD card (up to 32 GB, FAT32 format; basic Class 10 is fine).
DS3231 RTC module (optional but recommended for real timestamps).

Note: Many SD modules are not truly 3.3V-safe on all pins. Confirm whether your SD module expects 3.3V or can accept 5V on VCC, and always share GND with the ESP32.

Step-by-Step Guide

Step 1 - Decide when local logging beats cloud logging

Goal: Understand why writing to microSD is a strong default for sensor deployments.

What to do: Use local CSV logs when you need data to survive outages and be easy to retrieve later.

Survives WiFi outages: data keeps writing regardless.
Higher sample rate: SD logging can handle much higher rates than typical cloud endpoints.
No cloud dependency: works where there is no internet.
No monthly fee: large microSD cards can store extremely long time series at low sample rates.
Data ownership: remove the card and open the CSV locally.

Expected result: You have a clear reason to log locally, either as your primary method or as a fallback when cloud connectivity fails.

Step 2 - Wire the SD card module and optional DS3231 RTC

Goal: Connect the SD card module via SPI and (optionally) connect the DS3231 via I2C for timestamps.

What to do: Wire the SD module to the ESP32 SPI pins, then wire DS3231 to ESP32 I2C pins if you want real date and time.

Wiring map:

SD Card Module    ESP32
VCC               --> 5V (some modules need 3.3V, check yours)
GND               --> GND
CS                --> GPIO5
SCK               --> GPIO18
MOSI              --> GPIO23
MISO              --> GPIO19

DS3231 RTC (optional but recommended)
VCC               --> 3.3V
GND               --> GND
SDA               --> GPIO21
SCL               --> GPIO22

Expected result: Your ESP32 can talk to the SD card over SPI. If installed, the DS3231 can provide a stable time source over I2C.

Step 3 - Upload a basic CSV logger sketch

Goal: Create a CSV file on the SD card, write a header once, and append sensor rows.

What to do: Use the SD library to initialize the card, create /log.csv if it does not exist, then append rows on a fixed interval.

Code:

#include <SPI.h>
#include <SD.h>
#include <DHT.h>

DHT dht(4, DHT22);
const int SD_CS = 5;
const char* LOG_FILE = "/log.csv";

void setup() {
  Serial.begin(115200);
  dht.begin();
  if (!SD.begin(SD_CS)) {
    Serial.println("SD failed");
    while (1);
  }
  // Write header if file doesn't exist
  if (!SD.exists(LOG_FILE)) {
    File f = SD.open(LOG_FILE, FILE_WRITE);
    f.println("millis,temp_c,humidity_pct");
    f.close();
  }
}

void loop() {
  float t = dht.readTemperature();
  float h = dht.readHumidity();
  File f = SD.open(LOG_FILE, FILE_APPEND);
  f.print(millis());
  f.print(","); f.print(t, 1);
  f.print(","); f.println(h, 1);
  f.close();
  delay(5000);
}

Expected result: The SD card contains log.csv with a header and new rows appended every 5 seconds.

Step 4 - Add real timestamps using a DS3231

Goal: Replace relative time (millis()) with human-readable timestamps.

What to do: Read the current time from the DS3231 and prepend it to each CSV row.

Code:

#include <RTClib.h>
RTC_DS3231 rtc;

void logRow(float t, float h) {
  DateTime now = rtc.now();
  char buf[24];
  sprintf(buf, "%04d-%02d-%02d %02d:%02d:%02d",
          now.year(), now.month(), now.day(),
          now.hour(), now.minute(), now.second());
  File f = SD.open(LOG_FILE, FILE_APPEND);
  f.print(buf); f.print(",");
  f.print(t, 1); f.print(",");
  f.println(h, 1);
  f.close();
}

Expected result: Each CSV row contains a real timestamp that is readable in Excel or pandas without conversion.

Step 5 - Rotate daily files on boot

Goal: Avoid extremely large CSV files that can become slow to open or process.

What to do: Generate a filename based on the current date and write logs into one file per day.

Code:

char filename[24];
DateTime now = rtc.now();
sprintf(filename, "/log_%04d%02d%02d.csv",
        now.year(), now.month(), now.day());

Expected result: Your logger writes to files like /log_20260710.csv, keeping each file smaller and easier to manage.

Step 6 - Increase throughput for high-rate logging

Goal: Improve performance when logging at 100+ samples per second.

What to do: Keep the file open and flush periodically instead of opening and closing the file every sample.

Code:

File logFile;
void setup() {
  // ...
  logFile = SD.open("/fast.csv", FILE_APPEND);
}
void loop() {
  logFile.print(micros());
  logFile.print(",");
  logFile.println(analogRead(A0));
  static int count = 0;
  if (++count % 100 == 0) logFile.flush();   // flush every 100 rows
}

Expected result: Higher sustained logging rates because SD writes are block-based and frequent flushes waste space and time.

Step 7 - Apply the logger to real deployments

Goal: Map this build to practical sensor logging scenarios.

What to do: Use the same SD CSV approach with the sensor you care about, then retrieve the card periodically for analysis.

Weather station in a remote field - no WiFi needed.
Vehicle GPS and accelerometer black box - second-by-second driving data.
Beehive weight and temperature - log long term, then retrieve the card.
Fermentation temperature curve - brewing, kombucha, sourdough starter tracking.
Fridge or freezer defrost cycle profiling - identify a failing seal.
Bird box camera trigger log - timestamp motion events.

Expected result: You can deploy sensors anywhere and still get complete time series data, even when connectivity is unreliable or unavailable.

Conclusion

An ESP32 with an SD card module and optional DS3231 RTC gives you a durable CSV data logger that keeps working when WiFi fails. You can remove the card and analyze the file in Excel or pandas with no cloud dependencies.

Inspiration credit: SD Card Datalogging With the DHT22 Temp Humidity Sensor on Instructables.

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 EM4100 RFID: EEPROM multi-card door lock

Shilleh — Mon, 20 Jul 2026 15:27:50 +0000

Project Overview

Arduino Nano + EM4100 125 kHz RFID reader: In this build, you will read EM4100 card IDs, store authorized cards in EEPROM, and unlock an electric strike using a relay for a simple multi-card RFID door lock.

Two flavors of RFID dominate maker projects: 13.56 MHz (the RC522, MIFARE) and 125 kHz (the EM4100, HT4168). The 125 kHz family is what many commercial proximity-card door locks use. The EM4100 standard is open and easy to read with an Arduino and a low-cost 125 kHz reader module. For under $15 of parts, you can build an RFID door lock with multi-card support and Wiegand-style access logging.

This guide walks through the wiring, reads cards, stores authorized IDs in EEPROM, drives an electric strike lock through a relay, and covers upgrade ideas like time-of-day rules, master/admin cards, and WiFi-logged entry events.

Time: 45 to 90 minutes
Skill level: Intermediate
What you will build: An Arduino Nano-based RFID access controller that unlocks a strike for authorized EM4100 card IDs stored in EEPROM.

Parts List

From ShillehTek

Arduino Nano V3.0 - reads the RFID module, checks EEPROM, and drives the relay.
1-Channel 12V Relay Module - switches power to the electric strike.
TM1637 4-Bit Display - optional, for showing card ID.
RC522 RFID Reader (13.56 MHz) - optional alternative if you want to use MIFARE cards instead.
ESP8266 D1 Mini - optional upgrade for WiFi logging.

External

125 kHz RFID reader module (RDM6300 or similar) - outputs UART serial when a card is read.
EM4100 RFID cards or HT4168 keytag fobs.
12 V electric strike lock or solenoid.
12 V DC power supply rated for the lock.
Jumper wires, breadboard or perfboard, and basic tools.

Note: The RDM6300 typically uses 5V TTL serial. The relay module in this guide is treated as active-low (IN goes LOW to energize). The lock power (12V) must remain isolated from the Arduino 5V side except through the relay contacts.

Step-by-Step Guide

Step 1 - Choose 125 kHz vs 13.56 MHz for your use case

Goal: Pick the RFID type that matches your cards and security needs.

What to do: If you only need a yes/no check against a list of authorized cards, 125 kHz EM4100 is the simplest and cheapest approach. If you need read/write card storage or more advanced credentials, consider 13.56 MHz MIFARE options instead.

125 kHz EM4100: read-only ID (40 bits / 10 hex chars), passive cards last decades, about 3 to 5 cm read range. Best for "is this a known card?" access control.
13.56 MHz MIFARE: read/write, often around 1 KB user data on the card, about 3 to 5 cm range. Use when you want to store extra info on the card (balance, access level).

Expected result: You know whether you are building for EM4100 125 kHz IDs (this guide) or a 13.56 MHz MIFARE workflow.

Step 2 - Wire the reader and the relay

Goal: Connect the RDM6300 (or similar) to the Arduino Nano, and wire the relay to switch the 12V lock.

What to do: Use the wiring map below. The reader TX goes to the Arduino software-serial RX pin. The relay IN pin is driven by the Arduino and the lock power is routed through COM and NO on the relay.

Wiring map:

RDM6300 / 125kHz Reader     Arduino Nano
VCC                      -> 5V
GND                      -> GND
TX                       -> D2  (RX in SoftwareSerial)
ANT1, ANT2               -> the included coil antenna (already wired)

Relay Module                Arduino Nano
VCC                      -> 5V
GND                      -> GND
IN                       -> D7 (active LOW)
Lock(+)                  -> Relay NO
Lock(-)                  -> 12V GND
+12V                     -> Relay COM

Expected result: The Arduino can receive card data from the reader, and it can energize the relay to apply 12V to the strike lock.

Step 3 - Understand the card data format and test a read

Goal: Verify you can read a 10-character EM4100 ID from the serial stream.

What to do: The RDM6300 streams a 14-byte serial frame whenever a card is in range. Use the format below and upload the test sketch to print the ID to the Serial Monitor.

Frame format:

0x02  [10 hex chars of card ID]  [2 hex chars of checksum]  0x03

Code:

#include <SoftwareSerial.h>
SoftwareSerial rfid(2, 3);  // RX, TX

void setup() {
  Serial.begin(9600);
  rfid.begin(9600);
}

void loop() {
  if (rfid.available() >= 14) {
    if (rfid.read() == 0x02) {
      char id[11] = {0};
      for (int i = 0; i < 10; i++) id[i] = rfid.read();
      Serial.print("ID: "); Serial.println(id);
      while (rfid.available()) rfid.read();   // flush
    }
  }
}

Expected result: When you wave a card, the 10-character ID prints to Serial. Write it down because it is the card's permanent identity.

Step 4 - Store and check authorized cards in EEPROM

Goal: Create a simple authorization check that compares a scanned ID to IDs stored in EEPROM.

What to do: This example stores up to 10 cards (100 bytes total, 10 bytes per ID) in the Nano's EEPROM. The enrollment flow described here is:

Power on with the ENROLL button held.
Wave a card and write its ID to the next free EEPROM slot.
Release the button; the card is now authorized.

Code:

#include <EEPROM.h>
const int MAX_CARDS = 10;

bool isAuthorized(const char* id) {
  for (int i = 0; i < MAX_CARDS; i++) {
    char stored[11] = {0};
    for (int j = 0; j < 10; j++)
      stored[j] = EEPROM.read(i * 10 + j);
    if (strncmp(stored, id, 10) == 0) return true;
  }
  return false;
}

Expected result: You can call isAuthorized(id) and get a true/false result based on what is stored in EEPROM.

Step 5 - Drive the lock relay based on authorization

Goal: Unlock for authorized cards and deny access for unknown cards.

What to do: Use the loop below to read an ID, check authorization, then unlock by pulling the relay pin LOW for a fixed time. Flash an OK LED for success and a FAIL LED for denial.

Code:

const int LOCK_RELAY = 7;
const int OK_LED     = 8;
const int FAIL_LED   = 9;
const unsigned long UNLOCK_MS = 5000;

void loop() {
  if (rfid.available() >= 14 && rfid.read() == 0x02) {
    char id[11] = {0};
    for (int i = 0; i < 10; i++) id[i] = rfid.read();
    while (rfid.available()) rfid.read();
    if (isAuthorized(id)) {
      digitalWrite(LOCK_RELAY, LOW);    // unlock
      digitalWrite(OK_LED, HIGH);
      delay(UNLOCK_MS);
      digitalWrite(LOCK_RELAY, HIGH);   // re-lock
      digitalWrite(OK_LED, LOW);
    } else {
      digitalWrite(FAIL_LED, HIGH);
      delay(1000);
      digitalWrite(FAIL_LED, LOW);
    }
  }
}

Expected result: Authorized cards unlock the door for the configured time; unauthorized cards trigger the failure indicator.

Step 6 - Consider upgrade paths for a more product-like system

Goal: Understand common feature upgrades you can add after the basic lock works.

What to do: If you want to expand the project beyond a basic allow-list door lock, these are common additions:

Master card: reserve EEPROM slot 0 as the master so only it can enroll/delete cards.
Time-of-day rules: add a DS3231 RTC and reject some cards outside allowed hours.
WiFi event log: swap the Nano for an ESP8266 D1 Mini and POST reads to a Google Sheet or Home Assistant.
Backup keypad: add a 4x4 keypad for a PIN fallback.
Anti-tamper: add a tilt switch that triggers a buzzer if the unit is moved.
Time-limited admin cards: create visitor cards that auto-expire.

Expected result: You have a clear roadmap for turning the basic RFID door lock into a more complete access system.

Step 7 - Understand the security limitations of EM4100

Goal: Make an informed decision about when EM4100 is appropriate.

What to do: EM4100 is not a secure protocol. The card ID is broadcast in plaintext and can be cloned with low-cost tools. For workshops, garages, maker spaces, or low-risk doors, it can be acceptable. For higher security needs, use 13.56 MHz credentials designed for encrypted challenge-response (for example, MIFARE DESFire EV2/EV3 or HID iCLASS).

Expected result: You understand the tradeoff between cost and security for 125 kHz EM4100 systems.

Conclusion

Using a 125 kHz EM4100 reader with an Arduino Nano and a relay is one of the cheapest ways to build a working RFID door lock with EEPROM-based multi-card access. Once the basic read-check-unlock loop works, you can expand it with admin controls, time rules, and WiFi logging.

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

Attribution: This guide was inspired by "Open Sesame! Arduino RFID Lock and Automations" on Instructables.

XL4015 Buck Converter: Adjustable Bench PSU Build

Shilleh — Mon, 20 Jul 2026 15:20:54 +0000

Project Overview

XL4015 buck converter module: In this build, you will turn an XL4015 5A CC/CV buck converter (with onboard voltmeter and current display) into an adjustable 1.25V to 36V DIY bench power supply for regulated, current-limited DC output.

This guide wires the XL4015 into an enclosure with binding posts, walks through constant-voltage (CV) and constant-current (CC) adjustment, and highlights a few practical XL4015 use cases.

Time: About 15 to 30 minutes (not including enclosure cutting/printing)
Skill level: Beginner to Intermediate
What you will build: A compact bench-style power supply powered by a 12V to 24V DC brick with adjustable voltage and current limiting

Parts List

From ShillehTek

Arduino Nano V3.0 - optional if you want to add USB monitoring of voltage/current
PDSink PD Decoy Board - optional for a USB-C-powered bench PSU (pull 9V/12V/15V/20V and feed the XL4015)
TM1637 4-Bit Display - optional alternative for displaying voltage/current
DuPont Wires - helpful for internal wiring and prototyping add-ons

External

XL4015 5A 75W buck converter module (variant with onboard voltmeter / current meter and CC/CV adjustment)
24V DC laptop brick or AC-to-DC power supply (rated for 5A+ if you want full output capability)
Project enclosure with binding-post cutouts (or one you can drill/cut)
Two banana-plug binding posts (red and black)
Inline 5A blade fuse on the output (recommended for safety)

Note: XL4015 boards vary by seller. Confirm your specific module has CC (current limit) adjustment and the same terminal labeling before wiring it into an enclosure.

Step-by-Step Guide

Step 1 - Choose XL4015 for higher current projects

Goal: Understand when the XL4015 is a better choice than smaller buck converters.

What to do: If your project needs more than about 2A continuous, the XL4015 is a strong option. Compared with common LM2596 and MP1584 modules, it supports higher continuous current and typically offers better efficiency at higher loads.

	LM2596	MP1584	XL4015
Max current (continuous)	2A	3A	5A
Max input voltage	40V	28V	38V
Switching freq	150kHz	1.5MHz	180kHz
Efficiency (24V to 12V)	~80%	~93%	~96%
Onboard CC/CV?	No	No	Yes (some variants)
Cost	$1.50	$2	$4 to $6

Expected result: You know why the XL4015 is commonly used when you need higher current and want CC/CV adjustment in a low-cost module.

Step 2 - Identify the XL4015 terminal wiring

Goal: Map each terminal to your input power and output binding posts.

What to do: Most XL4015 boards expose screw terminals for input and output, plus an optional enable (EN) pin on some variants. Wire your DC brick to IN+/IN-, and wire your front-panel binding posts to OUT+/OUT-.

Wiring map:

IN+  <-- 24V DC from your power brick
IN-  <-- GND from power brick
OUT+ --> red binding post
OUT- --> black binding post
EN   (optional) <-- pull HIGH or to IN+ to enable

Expected result: You have a clear wiring plan for connecting input power and the bench output terminals.

Step 3 - Set CV (constant voltage) output

Goal: Adjust the output voltage to a known target before connecting a load.

What to do: Use the CV potentiometer (often labeled V-ADJ) to set the output voltage with no load connected.

Power up the input.
Put a multimeter on OUT+ and OUT-.
Turn the V-ADJ pot until the meter reads your target voltage (for example 5.0V or 12.0V).
Confirm the onboard display matches your meter (typically within about 50mV).

Expected result: The output voltage is stable at your target value and matches your multimeter reading closely.

Step 4 - Set CC (constant current) limit

Goal: Configure the current limit so the supply can protect loads and support CC/CV behavior.

What to do: On the XL4015 variant with onboard voltmeter/current display, use the second potentiometer (often labeled I-ADJ or CC) to set the current limit.

Short OUT+ to OUT- through your multimeter set to 10A DC current.
Turn the I-ADJ pot until the meter reads your target current (for example 1.5A).
Remove the short. The supply will deliver up to that current. Above the limit, voltage will drop to maintain the set current.

Expected result: The output current clamps at the value you set when the output is shorted through the meter, confirming CC limiting works.

Step 5 - Install the module into an enclosure

Goal: Make the XL4015 module bench-friendly and safer to use.

What to do: Mount the bare PCB in a project box and add proper panel connectors so it behaves like a small bench power supply.

3D-print or buy a project box with a window for the LED display.
Add front-panel binding posts (red and black).
Add a panel-mount DC barrel jack for the input.
Add an inline 5A fuse on the output. The XL4015 has protection features, but a fuse provides hard protection.
Add a power LED (some kits include this onboard).

Expected result: The module is mechanically protected and you have reliable, repeatable front-panel connections for input and output.

Step 6 - Apply the XL4015 to other common builds

Goal: Understand other practical scenarios where CC/CV and 5A capability are useful.

What to do: Consider these additional use cases where an XL4015 is handy to keep in your parts bin.

Solar-charged 12V system: Use the XL4015 as the buck stage between an MPPT controller and a 12V battery.
LED strip dimmer: Set the CC limit to control brightness without PWM flicker.
Battery charger (1S/2S/3S Li-ion): CC plus CV matches lithium charging needs. Calibrate carefully; dedicated chargers are safer.
Workshop hot-wire foam cutter: 5A at 3V to 6V is useful for cutting foam.
USB-C laptop charger replacement: Pair with a PDSink board to draw 20V from USB-C PD and convert to 5V/12V/other outputs.

Expected result: You can identify where an adjustable CC/CV buck converter solves real power problems beyond a bench PSU.

Step 7 - Account for heat, ripple, and polarity limits

Goal: Avoid common performance and safety issues when using the XL4015 near its limits.

What to do: Keep these constraints in mind when you design your enclosure and choose loads.

Heat: At 5A continuous, the XL4015 can get hot enough to burn. Add a small heatsink or active fan if you draw more than 3A for long periods.
Output ripple: Around 50mV at full load. For sensitive analog circuits (audio, low-noise sensors), add a downstream LC filter.
Reverse polarity: Many XL4015 boards have no input reverse-polarity protection. Add a Schottky diode in series with IN+ if reverse connection is a concern.

Expected result: You know what to upgrade (cooling, filtering, protection) when you push the XL4015 toward higher current or lower-noise applications.

Conclusion

The XL4015 buck converter module with an onboard voltmeter/current display is a simple way to build an adjustable bench power supply that supports CC/CV behavior and can deliver up to 5A in the right thermal setup. With a DC brick, enclosure, binding posts, and a fuse, it becomes a reliable regulated DC source for everyday bench work.

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 + ACS712: Measure AC/DC Current Up to 30A

Shilleh — Sun, 19 Jul 2026 15:24:17 +0000

Project Overview

Arduino Nano + ACS712 current sensor: In this project, you will wire an ACS712 Hall-effect current sensor module to an Arduino and measure AC or DC current up to 30A using the Arduino ADC.

The ACS712 measures current by sensing the magnetic field around the current-carrying conductor and outputs a proportional analog voltage centered around 2.5V at 0A, which an Arduino can read directly. It is available in 5A / 20A / 30A variants, and it is a common choice when you want AC and DC current measurement with galvanic isolation from the measured line.

Time: 30 to 60 minutes
Skill level: Beginner to Intermediate
What you will build: An Arduino sketch that reads ACS712 voltage, calibrates the zero offset, and reports DC current or AC RMS current.

Parts List

From ShillehTek

Arduino Nano V3.0 - reads the ACS712 analog output via the ADC.
ESP32 WROOM Dev Board - optional if you want WiFi logging later (the wiring and concept still apply).
WCS1700 Current Sensor - a higher-current Hall-effect alternative (up to 70A).
INA219 Sensor - a precise I2C shunt-based alternative for DC current measurement.
LCD1602 Display - optional for live readouts without the Serial Monitor.

External

ACS712 module (5A, 20A, or 30A variant) - the current sensor module used in this guide.
DC or AC load (motor, heater, lamp) - something to draw measurable current.
Multimeter - used to validate readings and help with calibration.
Jumper wires and a breadboard (optional) - for easier prototyping.

Note: The ACS712 variant matters. ACS712-05B sensitivity is 0.185 V/A, the 20A variant is 0.100 V/A, and the 30A variant is 0.066 V/A. Also, treat mains/high-current wiring as hazardous: use proper enclosures and fusing, and double-check wiring before powering anything.

Step-by-Step Guide

Step 1 - Choose the right current sensor (ACS712 vs INA219 vs WCS1700)

Goal: Pick the correct sensor type for your use case (AC vs DC, precision vs current range).

What to do: Use these quick differences to choose:

ACS712 (5A / 20A / 30A): Hall effect, measures AC and DC, analog output, galvanically isolated.
WCS1700: Hall effect, up to 70A, hole-through design for heavier cables.
INA219: shunt-based, DC only (or full-wave rectified AC), I2C output, higher precision (down to about mA resolution).

Pick ACS712 for typical hobby AC/DC monitoring up to 30A. Pick INA219 when you need precision DC current in the mA range. Pick WCS1700 for higher-current battery packs and similar projects.

Expected result: You confirm the sensor and variant you are using and note the correct sensitivity constant for your code.

Step 2 - Wire the ACS712 module to the Arduino

Goal: Connect the sensor's signal pins to the Arduino and place the screw terminals inline with your load.

What to do: Wire the 3-pin header for power and signal, then route the load current through the ACS712 screw terminals.

Wiring map:

ACS712 module     Arduino Nano
VCC          ->   5V
GND          ->   GND
OUT          ->   A0

Load wiring:
Power source (+) -> ACS712 IN1
ACS712 IN2       -> Load (+)
Power source (-) -> Load (-)

The current-carrying screw terminals go inline with your load; the 3-pin header is the analog signal side.

Safety note: The sensor is designed for galvanic isolation, but wiring mistakes can still create dangerous situations. Use proper fusing and an enclosure for anything above low current levels, and do not let mains wiring touch your Arduino circuitry.

Expected result: The module powers from 5V/GND, and OUT is connected to A0 with the load current routed through IN1/IN2.

Step 3 - Read DC current in Arduino

Goal: Convert the analog reading to voltage, then to current using your module's sensitivity and a calibrated zero offset.

What to do: Start with a basic sketch that prints current to the Serial Monitor. Use the sensitivity constant that matches your ACS712 variant.

Code:

const int SENSOR = A0;
const float SENSITIVITY_5A = 0.185;   // V per Amp for ACS712-05B
// 20A variant = 0.100, 30A variant = 0.066

float zeroOffset = 2.5;   // will calibrate later

void setup() { Serial.begin(9600); }
void loop() {
  int raw = analogRead(SENSOR);
  float voltage = raw * 5.0 / 1023.0;
  float current = (voltage - zeroOffset) / SENSITIVITY_5A;
  Serial.print(current, 3);
  Serial.println(" A");
  delay(500);
}

Important: If you use a 20A or 30A ACS712, update the sensitivity constant to match your part number, or the current reading will be wrong.

Expected result: The Serial Monitor prints a current value in amps that changes as your DC load changes.

Step 4 - Calibrate the zero-point offset (0A level)

Goal: Measure the true no-load sensor output voltage so the current reads near zero when no current is flowing.

What to do: With no current through the sensor, the output should be near 2.5V, but real modules and ADCs vary (for example 2.45V or 2.53V). Calibrate like this:

Disconnect the load side so there is no current through the sensor terminals.
Print the raw voltage using: voltage = raw * 5.0 / 1023.0;
Take the average over 100 samples.
Update zeroOffset to that averaged voltage.

Expected result: After calibration, no-load current should read very close to 0A (typically under about 5 mA in this guide's setup).

Step 5 - Read AC current using RMS sampling

Goal: Compute RMS current for AC loads by sampling many points of the waveform and calculating the RMS value.

What to do: The ACS712 output for AC is a sine-like waveform centered around the calibrated zero offset. Use an RMS calculation over a time window that covers at least one full mains cycle.

Code:

float readAcRms(int pin, unsigned long window_ms = 200) {
  unsigned long start = millis();
  double sumsq = 0;
  int n = 0;
  while (millis() - start < window_ms) {
    int raw = analogRead(pin);
    float v = raw * 5.0 / 1023.0 - zeroOffset;
    float i = v / SENSITIVITY_5A;
    sumsq += i * i;
    n++;
  }
  return sqrt(sumsq / n);
}

Sample for at least one full mains cycle (20 ms for 50 Hz, 16.7 ms for 60 Hz). A 200 ms window gives 10+ cycles of averaging for smoother readings.

If readings are noisy, you can average more samples in software. A common hardware approach is adding a 10 µF capacitor between OUT and GND.

Expected result: Your AC load produces a stable RMS current value that is more meaningful than instantaneous samples.

Step 6 - Apply the readings to real projects

Goal: Understand practical ways to use the current measurement in your builds.

What to do: Use the measured current as an input signal for monitoring and automation, for example:

Power monitoring: measure load current and log usage over time.
Motor stall detection: a spike in current can indicate a stalled motor; cut power via a relay to protect hardware.
Appliance state sensing: if current is above a threshold (for example > 500 mA), treat the appliance as "running."
Battery monitoring: track DC current into/out of a battery bank to estimate charge/discharge behavior.
Heater duty cycle monitoring: observe ON/OFF cycling to spot abnormal behavior.
EV charging monitor: pair with a WiFi-capable board to publish a simple dashboard.

Expected result: You can map current readings to meaningful states, alerts, or logs in your project.

Conclusion

You wired an ACS712 to an Arduino, calibrated the 0A offset, and computed both DC current and AC RMS current from the module's analog output. This makes the ACS712 a practical choice for power monitoring, motor state detection, and appliance sensing without directly tapping into the measured line electrically.

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

Credit: This guide was inspired by "Simplified Arduino AC Current Measurement Using ACS712 Hall Effect Sensor" on Instructables.

Arduino Nano KY-018: Build a Light-Following Robot

Shilleh — Sun, 19 Jul 2026 15:11:09 +0000

Project Overview

Arduino Nano + KY-018 photoresistors + L298N: In this build you make a light-following robot where two LDR sensors act like eyes, and differential steering drives two DC motors toward the brightest light source.

Two photoresistors (LDRs) detect which side is brighter, the Arduino compares the readings, and two motors steer the chassis toward the light. Shine a flashlight and watch the robot chase it.

This guide wires the KY-018 photoresistor module (or bare LDRs with 10 k pull-down resistors), connects two DC motors through an L298N motor driver, and programs the differential steering behavior.

Time: About 60 minutes
Skill level: Beginner
What you will build: A two-sensor Arduino robot that turns and drives toward a bright light.

Parts List

From ShillehTek

Arduino Nano V3.0 - reads the two photoresistor signals and controls motor speed and direction.
L298N Motor Driver - drives two DC motors from a battery pack using Arduino control pins.
Breadboard + jumper wires - quick prototyping for the sensors and signal wiring.
820pc Resistor Kit - includes 10 k resistors if you are using bare LDRs (not KY-018 modules).
18650 Battery Holder - motor power option (a 4x AA holder also works).

External

Two KY-018 photoresistor modules (or two bare LDRs + two 10 k resistors).
Two DC gearmotors + wheels (yellow TT motors are common).
Chassis (2-wheel + caster).
4x AA battery holder or single 18650 pack (for motor power).
Flashlight or bright phone light for testing.

Note: If you use the L298N for motor power from a battery pack, make sure the Arduino GND is connected to the L298N/battery negative (shared ground), and ensure your motor supply voltage matches your motors.

Step-by-Step Guide

Step 1 - Understand how photoresistors work

Goal: Know what the LDR output means so you can wire and tune it correctly.

What to do: A photoresistor (LDR) is a semiconductor whose resistance drops in bright light. Typical values can range from about 10 M in darkness to about 10 k in room light and around 500 in direct sunlight.

Wire a bare LDR as the top half of a voltage divider (LDR to +5V, 10 k pull-down to GND, analog input pin in the middle). The ADC then reads a voltage proportional to light. On the KY-018 module the divider is already built in, so you get three pins: VCC, GND, AOUT.

Expected result: You can explain why brighter light changes the analog reading and why two sensors let the robot decide which way to turn.

Step 2 - Wire the two-eye sensor setup and motor driver

Goal: Connect two KY-018 sensors to A0/A1 and connect the L298N to the Arduino pins for differential steering.

What to do: Wire the two sensors to 5V, GND, and separate analog inputs, then wire the L298N input pins and enable (PWM) pins to the Arduino. Connect your motor battery pack to the L298N motor power input, and connect battery negative to Arduino GND so they share ground.

Wiring map:

Left KY-018      Arduino Nano
VCC          -> 5V
GND          -> GND
AOUT         -> A0

Right KY-018     Arduino Nano
VCC          -> 5V
GND          -> GND
AOUT         -> A1

L298N            Arduino Nano
IN1          -> D5  (left motor direction A)
IN2          -> D6  (left motor direction B)
IN3          -> D9  (right motor direction A)
IN4          -> D10 (right motor direction B)
ENA          -> D3  (left PWM speed)
ENB          -> D11 (right PWM speed)
+12V         -> battery pack +
GND          -> battery pack - + Arduino GND

Mount the two LDRs facing forward and angled slightly outward, about 5 cm apart at the front of the robot.

Expected result: Both sensors read on A0 and A1, and the L298N is ready to drive each motor forward or backward with PWM speed control.

Step 3 - Upload the differential-steering Arduino sketch

Goal: Make the robot turn toward the brighter sensor by speeding up one motor and slowing the other.

What to do: Upload the sketch below. It reads both analog inputs, computes the difference, and adjusts the left and right motor PWM values around a base speed.

Code:

const int LEFT_LDR  = A0;
const int RIGHT_LDR = A1;
const int LEFT_PWM  = 3;
const int RIGHT_PWM = 11;
const int L_A = 5, L_B = 6;
const int R_A = 9, R_B = 10;
const int BASE_SPEED = 150;

void setMotor(int a, int b, int pwm, int speed) {
  digitalWrite(a, speed > 0 ? HIGH : LOW);
  digitalWrite(b, speed > 0 ? LOW : HIGH);
  analogWrite(pwm, abs(speed));
}

void setup() {
  pinMode(L_A, OUTPUT); pinMode(L_B, OUTPUT);
  pinMode(R_A, OUTPUT); pinMode(R_B, OUTPUT);
}

void loop() {
  int L = analogRead(LEFT_LDR);
  int R = analogRead(RIGHT_LDR);
  int diff = L - R;     // positive = light is on left side

  int leftSpeed  = BASE_SPEED - diff / 4;
  int rightSpeed = BASE_SPEED + diff / 4;
  leftSpeed  = constrain(leftSpeed, 0, 255);
  rightSpeed = constrain(rightSpeed, 0, 255);

  setMotor(L_A, L_B, LEFT_PWM,  leftSpeed);
  setMotor(R_A, R_B, RIGHT_PWM, rightSpeed);

  delay(50);
}

Expected result: If the left LDR sees brighter light, the left motor slows and the right motor speeds up so the robot turns left. If the right LDR sees brighter light, it turns right. Balanced light drives it forward.

Step 4 - Calibrate the behavior for your room lighting

Goal: Prevent wandering when the room is too dark and make the response stable under your ambient light.

What to do: Ambient light varies. Print the raw LDR values with the flashlight ON and OFF and pick a threshold. You can also add a simple stop condition so the robot stops when it is too dark to see anything.

Code (optional stop check):

if (L < 100 && R < 100) {
  // too dark, stop
  analogWrite(LEFT_PWM, 0);
  analogWrite(RIGHT_PWM, 0);
  return;
}

Expected result: In low light the robot stops instead of driving randomly, and with a flashlight it reliably turns toward the brighter side.

Step 5 - Try the line-following variant (same hardware)

Goal: Reuse the same sensors and steering logic to follow a dark line on a bright surface.

What to do: Keep the wiring the same, but mount the LDRs facing downward a few cm above the ground. A dark line reflects less light than a white surface, so the differential steering traces the line.

Expected result: The robot steers to keep the sensor readings balanced while moving along the line.

Step 6 - Explore where this sensor pattern leads

Goal: Understand how the same two-sensor comparison approach applies to other builds.

What to do: Use the same idea of comparing two sensor inputs and steering toward the difference.

Automatic solar tracker: same two-LDR pattern but drives a servo instead of wheels.
Sunflower art installation: multiple servos + LDRs to face the brightest light source.
Interactive room lighting: LDRs decide when to trigger relays based on ambient light.
Turtle-style crawler: three LDRs for triangulated homing on a specific light.

Expected result: You can reuse the exact same "two sensors + difference" logic for new motion and control projects.

Conclusion

With an Arduino Nano, two photoresistors (KY-018 or bare LDRs), and an L298N motor driver, you can build a real autonomous light-following robot using differential steering. The same pattern also works for line-following and other sensor-guided motion projects.

Inspiration credit: Arduino Flashlight Following Robot on Instructables.

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 YF-S201 Water Flow Sensor: Measure L/min

Shilleh — Sat, 18 Jul 2026 22:30:43 +0000

Project Overview

Arduino + YF-S201 water flow sensor: This project reads the YF-S201 hall-effect pulse output on an Arduino and converts it into real-time liters-per-minute (L/min) and total liters.

The YF-S201 contains a small pinwheel with an embedded magnet. Water flow spins the wheel, and a hall-effect sensor produces pulses proportional to flow rate. The datasheet value is about 450 pulses per liter at moderate flow rates.

This guide wires the sensor to an Arduino, converts pulses to L/min and total liters, and shows common applications like volume dosing for watering, consumption tracking, and basic leak detection.

Time: 20 to 40 minutes
Skill level: Beginner
What you will build: A flow meter that prints L/min to Serial and can be extended to total liters and valve shutoff.

Parts List

From ShillehTek

Arduino Nano V3.0 - reads the pulse signal and computes flow rate.
ESP32 WROOM Dev Board - optional, for WiFi reporting and alerts.
LCD1602 Display - optional, for a live on-device flow and total readout.
1-Channel 12V Relay - optional, to control a 12V solenoid shutoff valve.

External

YF-S201 water flow sensor (1/2 inch NPS thread, rated 1 to 30 L/min).
1/2 inch plumbing adapters to fit your hose or pipe.
Optional: 12V solenoid valve for automatic shutoff.
Teflon tape for threaded joints.

Note: The YF-S201 sensor typically runs from 5V to 24V (per common specs) and provides a pulse output. Use an interrupt-capable Arduino pin (like D2 on the Nano) for reliable counting.

Step-by-Step Guide

Step 1 - Understand how the YF-S201 generates pulses

Goal: Know what you are measuring so the code and calibration make sense.

What to do: Review the internal mechanism: a magnetized paddle wheel spins with water flow, and a hall-effect sensor outputs a pulse stream. Faster flow equals more pulses per second.

Expected result: You understand that the Arduino is counting pulses and converting them into flow using a pulses-per-liter constant (often around 450 pulses per liter).

Step 2 - Wire the YF-S201 to the Arduino Nano

Goal: Connect power and the pulse output to an interrupt-capable input pin.

What to do: Use the three sensor wires: red (VCC), black (GND), yellow (pulse output). Wire the pulse output to Arduino D2 so you can use an external interrupt.

Wiring:

YF-S201        Arduino Nano
Red (VCC)  -> 5V
Black (GND)-> GND
Yellow     -> D2  (interrupt-capable pin)

Plumb the sensor inline. Use the arrow molded on the body to match the flow direction. If installed backwards, readings can drop by about 30%.

Expected result: The sensor is powered and the yellow signal wire is connected to D2, ready for pulse counting.

Step 3 - Upload a basic sketch to read liters per minute (L/min)

Goal: Count pulses over a fixed time window and convert them to L/min.

What to do: Upload the sketch below, then open Serial Monitor at 9600 baud. The code counts pulses using an interrupt, measures for 1 second, and converts using 450 pulses per liter.

Code:

const int SENSOR = 2;
volatile unsigned long pulses = 0;

void onPulse() { pulses++; }

void setup() {
  Serial.begin(9600);
  pinMode(SENSOR, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(SENSOR), onPulse, RISING);
}

void loop() {
  unsigned long p = pulses;
  pulses = 0;
  delay(1000);   // measure over 1 second
  float flow_lpm = (p * 60.0) / 450.0;
  Serial.print(flow_lpm, 2);
  Serial.println(" L/min");
}

Expected result: When you open a tap, Serial Monitor prints a live flow rate. Typical kitchen sinks are often around 6 to 9 L/min.

Step 4 - Calibrate pulses-per-liter for your specific sensor

Goal: Improve accuracy, since the nominal constant can vary by up to about 10% from sensor to sensor.

What to do: Measure an actual known volume over a known time and compute your own pulses-per-liter constant.

Run the sensor for exactly 60 seconds into a graduated bucket.
Note the pulse count (print total pulses to Serial).
Measure the actual water in the bucket (in liters).
Compute: pulses_per_liter = total_pulses / actual_liters.
Update the constant in your sketch.

Expected result: Your computed L/min matches your real-world measurements more closely.

Step 5 - Add a running total in liters (and display it on an LCD)

Goal: Track total consumption, not just instantaneous flow rate.

What to do: Accumulate liters each second using the current L/min reading. If you have an LCD1602 connected in your existing project, you can print both values.

Code:

float total_liters = 0.0;
void loop() {
  unsigned long p = pulses;
  pulses = 0;
  delay(1000);
  float lpm = (p * 60.0) / 450.0;
  total_liters += lpm / 60.0;   // 1 second of flow

  lcd.setCursor(0, 0);
  lcd.print(lpm, 1); lcd.print(" L/min ");
  lcd.setCursor(0, 1);
  lcd.print("Total "); lcd.print(total_liters, 2); lcd.print(" L");
}

Expected result: Total liters increases steadily while water flows.

Step 6 - Automatic dosing: water a target volume then stop

Goal: Shut off flow automatically after a set number of liters.

What to do: Add a relay and a 12V solenoid valve on the output side of the sensor, then close the valve when total_liters reaches your target.

Code:

const float TARGET_LITERS = 5.0;
const int VALVE = 7;

void setup() {
  pinMode(VALVE, OUTPUT);
  digitalWrite(VALVE, HIGH);   // valve OPEN (active LOW)
  // ...usual sensor setup...
}
void loop() {
  // ...update total_liters...
  if (total_liters >= TARGET_LITERS) {
    digitalWrite(VALVE, LOW);   // valve CLOSED
  }
}

Expected result: The valve closes automatically once the measured total reaches the target volume. This is useful for garden zones, livestock waterers, aquaponics, or dispensing a fixed amount of water.

Step 7 - Leak detection concept using periodic logging and alerts

Goal: Detect unexpected flow when water usage should be zero.

What to do: Log flow every minute. If flow is greater than 0 at a time like 3 AM, send an alert using an ESP32 integration (for example via Telegram).

Expected result: You can flag suspicious water usage patterns and potentially catch leaks early.

Step 8 - Understand the YF-S201 limitations

Goal: Know when this sensor is not a good fit.

What to do: Keep these constraints in mind when choosing an installation and interpreting readings.

Low flow accuracy: Below 1 L/min the paddle can stall and readings become unreliable.
Chemistry: The plastic body is not rated for hot water, acids, or bleach. Use a stainless-steel variant for harsh fluids.
Pressure: Often rated around 2 MPa (300 psi). This is typically fine for household plumbing, but not necessarily for higher-pressure irrigation mains.

Expected result: You can decide if the YF-S201 is appropriate for your flow range, fluid type, and plumbing conditions.

Conclusion

You built an Arduino-based flow meter using the YF-S201 water flow sensor, converting pulse counts into liters per minute and optionally tracking total liters for dosing and monitoring.

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

Attribution: This guide was inspired by How to Use Water Flow Sensor - Arduino Tutorial on Instructables.

Arduino Nano DRV8825: Smooth NEMA 17 Motor Control

Shilleh — Sat, 18 Jul 2026 22:27:15 +0000

Project Overview

Arduino Nano + DRV8825 stepper driver: In this build, you will wire a DRV8825 to an Arduino Nano to drive a NEMA 17 stepper motor with correct current limiting and optional 1/32 microstepping for smoother motion.

The DRV8825 is a common stepper driver for 3D printers, CNC machines, and precision positioning systems. It shares the same footprint as the A4988, but supports 1/32 microstepping (vs 1/16), higher current capability (2.5 A per coil vs 2 A), and improved thermal behavior.

This guide covers wiring, setting the current limit (critical to avoid damaging the driver), selecting microstepping modes, and using acceleration control for smoother starts and stops.

Time: 30 to 60 minutes
Skill level: Beginner to Intermediate
What you will build: A DRV8825-controlled NEMA 17 stepper setup that spins reliably and can ramp smoothly using AccelStepper.

Parts List

From ShillehTek

Arduino Nano V3.0 - the example controller board used for STEP/DIR control.
ESP32 WROOM Dev Board - optional, for WiFi-controlled motion projects.
Breadboard + DuPont wires - for quick prototyping and clean jumper connections.
L298N Motor Driver - alternative option for DC motors (not for steppers).

External

DRV8825 stepper driver module (use one that includes a 100 uF capacitor, or add one).
NEMA 17 bipolar stepper motor (example: 1.7 A per phase, 200 steps/rev).
12 V or 24 V motor power supply (rated at least 2 A).
Small multimeter for current-limit calibration (Vref measurement).

Note: Connect a 100 uF capacitor between VMOT and GND close to the DRV8825. Without it, motor kickback can create voltage spikes that damage the driver.

Step-by-Step Guide

Step 1 - Understand why DRV8825 is used over A4988

Goal: Know what you gain (and why it matters) before wiring anything.

What to do: Compare the driver limits and capabilities so you choose the right module for your motor and supply voltage.

Current: DRV8825 = 2.5 A/coil (with heatsink), A4988 = 2 A/coil max.
Microstepping: DRV8825 goes to 1/32; A4988 caps at 1/16.
Voltage: DRV8825 accepts 8.2 to 45 V; A4988 accepts 8 to 35 V.
Thermal shutdown: DRV8825 has automatic thermal cutoff.

Expected result: You understand when DRV8825 is the better default (most 3D printer and CNC use cases) and when A4988 can still be acceptable for lower-current experiments.

Step 2 - Wire the DRV8825 to the Arduino Nano and motor supply

Goal: Connect logic, motor power, and coil outputs correctly before powering on.

What to do: Follow the mapping below and double-check polarity for VMOT and GND.

Code:

DRV8825      Arduino Nano
STEP     ->  D3
DIR      ->  D2
ENABLE   ->  D8   (LOW = enabled, HIGH = disabled)
M0, M1, M2 -> GND for full step / +5V combos for microstepping
VMOT     ->  Motor +12V (or +24V)
GND (motor) -> Motor supply GND
VDD      ->  Arduino 5V
GND (logic) -> Arduino GND
1A, 1B, 2A, 2B -> stepper motor coils

Critical: connect the 100 uF capacitor between VMOT and GND as close as possible to the module. Without it, motor kickback voltage can spike into the driver and destroy it. Many modules ship without one soldered on, so add it if needed.

Expected result: Your DRV8825 has correct logic power, motor power, common grounds, and coil wiring ready for calibration and testing.

Step 3 - Set the DRV8825 current limit using Vref

Goal: Prevent overheating and protect the driver and motor by setting the correct coil current.

What to do: Calculate a target current, compute Vref, and adjust the trim pot while measuring with a multimeter.

Look up your motor's rated phase current (example: 1.7 A for a common NEMA 17).
Multiply by 0.7 for a safety margin: 1.7 × 0.7 = 1.19 A.
Calculate Vref = current × 2 × Rsense. Rsense is 0.1Ω on most DRV8825 boards. Example: Vref = 1.19 × 2 × 0.1 = 0.238 V.
Power the driver with motor + logic supply. Do NOT connect the motor yet.
Put a multimeter between the VREF pad (small pad next to the trim pot) and any GND.
Turn the trim pot until the meter reads your calculated Vref.
Now connect the motor.

Expected result: The motor runs with good torque while staying cool to the touch during continuous motion.

Step 4 - Upload a basic sketch to make the motor spin

Goal: Confirm your wiring and driver enable/dir/step control works.

What to do: Upload the sketch below, then change direction by toggling DIR.

Code:

const int STEP_PIN = 3;
const int DIR_PIN  = 2;
const int EN_PIN   = 8;

void setup() {
  pinMode(STEP_PIN, OUTPUT);
  pinMode(DIR_PIN, OUTPUT);
  pinMode(EN_PIN, OUTPUT);
  digitalWrite(EN_PIN, LOW);   // enable driver
  digitalWrite(DIR_PIN, HIGH);
}

void loop() {
  digitalWrite(STEP_PIN, HIGH);
  delayMicroseconds(500);
  digitalWrite(STEP_PIN, LOW);
  delayMicroseconds(500);
}

Expected result: The motor spins. In full-step mode, this sketch outputs 1000 steps/sec which is about 5 revolutions/sec for a 200 steps/rev motor. Reverse by setting DIR_PIN LOW.

Step 5 - Select microstepping modes with M0, M1, and M2

Goal: Use DRV8825 microstepping to reduce vibration and smooth motion.

What to do: Set M0/M1/M2 HIGH or LOW (via wiring) to select the microstepping mode.

Code:

M2 M1 M0 :: Microstep
L  L  L  :: full step (200 steps/rev)
L  L  H  :: 1/2 step
L  H  L  :: 1/4 step
L  H  H  :: 1/8 step
H  L  L  :: 1/16 step
H  H  L  :: 1/32 step (smoothest, quietest)

At 1/32, one motor revolution takes 6400 STEP pulses instead of 200. This greatly smooths motion at slow speeds. Trade-off: lower per-microstep torque and a higher STEP pulse rate needed for the same visible speed.

Expected result: The motor runs quieter and smoother, especially at low RPM, when you switch to higher microstepping.

Step 6 - Add smooth acceleration and deceleration with AccelStepper

Goal: Avoid jerky starts by ramping speed and improving usable torque.

What to do: Use the AccelStepper library to set max speed, acceleration, and a target move.

Code:

#include <AccelStepper.h>

AccelStepper motor(1, 3, 2);   // driver mode, STEP, DIR

void setup() {
  motor.setMaxSpeed(2000);      // steps/sec
  motor.setAcceleration(500);   // steps/sec^2
  motor.moveTo(6400);           // 1 rev at 1/32
}

void loop() {
  motor.run();                  // must call often
}

Expected result: The motor accelerates smoothly toward the target instead of starting instantly at full speed.

Step 7 - Map the setup to real-world motion projects

Goal: Understand where this DRV8825 + stepper approach is commonly used.

What to do: Use the same wiring and control concepts for these typical applications.

3D printer axes (X, Y, Z) where DRV8825 is commonly used on maker control stacks.
Small CNC builds such as MPCNC and similar gantry systems.
Camera sliders and motorized dollies that need smooth microstepped motion.
Automatic curtain openers with a gear reduction.
Focus stacking rails for macro photography.
Astronomy trackers where high microstepping plus gear reduction supports very slow motion rates.

Expected result: You can reuse the same DRV8825 wiring, current limiting, and step control patterns in a wide range of motion projects.

Conclusion

The DRV8825 is a strong upgrade path over the A4988: same footprint and control signals, higher current capability, more microstepping options, and better thermal protection. Once you set the current limit correctly and add the input capacitor on VMOT, it becomes a reliable driver for 3D printers, CNC machines, camera rigs, and precision positioning projects.

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

Credit: This guide was inspired by "Controll a Stepper Motor With the DRV8825" on Instructables. Images credited to the original author.

XIAO nRF52840 BME280: Build a BLE Temp Sensor

Shilleh — Sat, 18 Jul 2026 22:23:53 +0000

Project Overview

Seeed XIAO nRF52840 + BME280: In this build, you set up Arduino IDE and create a BLE temperature/humidity peripheral that advertises to your phone and targets ultra-low sleep current for long battery life.

The Seeed XIAO nRF52840 is a strong choice when you want a BLE device that can run for years on a coin cell. Nordic Semi's nRF52840 is used in many commercial wearables: ARM Cortex-M4F @ 64 MHz, 1 MB Flash, 256 KB SRAM, BLE 5 (including long-range PHY), NFC, and native USB, all on a thumbnail-sized board. With Arduino IDE support and Adafruit's Bluefruit libraries, you can go from zero to a BLE sensor quickly.

This guide gets a new XIAO nRF52840 board onto Arduino IDE, builds a BLE-broadcast temperature/humidity sensor, and explains where the nRF52840 beats ESP32 variants for battery life.

Time: About 20 to 30 minutes
Skill level: Beginner to Intermediate
What you will build: A BLE advertising sensor that reports temperature (and optionally humidity) from a small I2C sensor to a phone app.

Parts List

From ShillehTek

XIAO ESP32-C3 Pre-Soldered - a close comparable for ESP-side BLE projects.
XIAO ESP32-S3 Pre-Soldered - an alternative option when you need more features beyond BLE-only builds.
DHT22 Sensor - a simple temperature/humidity sensor option.
BME280 - I2C temperature, pressure, and humidity sensing for the BLE peripheral example.
500 mAh LiPo - or use a CR2032 coin cell for ultra-long battery life experiments.

External

Seeed XIAO nRF52840 board - the board this guide focuses on.
USB-C cable.
Arduino IDE 2.x with Adafruit nRF52 boards installed.
(Optional) A BLE scanner app such as nRF Connect (mobile).

Note: This guide uses Adafruit's nRF52 (Bluefruit) Arduino support. For the BME280 example, the sensor is assumed to be on I2C at address 0x76.

Step-by-Step Guide

Step 1 - Understand why nRF52840 can beat ESP32 for BLE-only battery life

Goal: Know when the nRF52840 is a better fit than ESP32 variants for wearables and coin-cell sensors.

What to do: Compare your project requirements. The ESP32-C3 is excellent for WiFi plus BLE, but for pure BLE wearables the nRF52840 has advantages:

Deep-sleep current: nRF52840 is about 1.5 µA with RAM retention. ESP32-C3 is about 5 µA typical, and can be much higher if BLE keeps any state.
BLE radio efficiency: Nordic's BLE stack is well known for low power; long-range PHY can reach about 1 km line of sight in ideal conditions.
NFC tag emulation: nRF52840 can be tapped by a phone to launch a URL or assist pairing.
Native USB: Useful for certain workflows and device modes.
Coin-cell friendly voltage: nRF52840 can operate down to about 1.7 V. ESP32 typically needs around 3.0 V minimum.

Expected result: You can decide if your project is BLE-only and battery-limited (nRF52840 advantage) or if you need WiFi and higher performance (often ESP32).

Step 2 - Install the Adafruit nRF52 board support in Arduino IDE

Goal: Get Arduino IDE ready to compile and upload sketches for the Seeed XIAO nRF52840.

What to do:

Open File - Preferences. Add this to Additional Boards Manager URLs: https://www.adafruit.com/package_adafruit_index.json
Open Boards Manager, search nRF52, then install Adafruit nRF52 by Adafruit.
Go to Tools - Board - Adafruit nRF52 Boards - select Seeed XIAO nRF52840.
Go to Tools - Port and select the USB CDC port that appears when you plug the board in.

Expected result: The XIAO nRF52840 appears as a selectable board and a valid serial/USB port is available for upload and Serial Monitor.

Step 3 - Upload a first sketch that advertises over BLE

Goal: Confirm the toolchain works and the board can advertise as a BLE device.

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

Code:

#include <bluefruit.h>

void setup() {
  Serial.begin(115200);
  Bluefruit.begin();
  Bluefruit.setName("ShillehTek-XIAO");
  Bluefruit.setTxPower(0);
  Bluefruit.Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);
  Bluefruit.Advertising.addTxPower();
  Bluefruit.Advertising.start(0);
  Serial.println("Advertising");
}

void loop() {}

Expected result: Open a BLE scanner app (for example nRF Connect) and you should see ShillehTek-XIAO appear in the scan list quickly.

Step 4 - Build a BLE temperature/humidity peripheral using a BME280

Goal: Read temperature from a BME280 and expose it over BLE.

What to do: Wire your BME280 to the XIAO nRF52840 using I2C (SDA, SCL, 3V3, GND). Then upload the sketch below.

Code:

#include <bluefruit.h>
#include <Adafruit_BME280.h>

Adafruit_BME280 bme;
BLEService envSvc("181A");                       // Environmental Sensing
BLECharacteristic tempC("2A6E", BLECharacteristic::READ);

void setup() {
  Wire.begin();
  bme.begin(0x76);
  Bluefruit.begin();
  Bluefruit.setName("XIAO-Env");
  envSvc.begin();
  tempC.setProperties(CHR_PROPS_READ | CHR_PROPS_NOTIFY);
  tempC.setFixedLen(2);
  tempC.begin();
  Bluefruit.Advertising.addService(envSvc);
  Bluefruit.Advertising.start(0);
}

void loop() {
  int16_t t = (int16_t)(bme.readTemperature() * 100);
  tempC.write((uint8_t*)&t, 2);
  delay(5000);
}

Expected result: In your BLE app, you can connect to XIAO-Env and see the Environmental Sensing service with a temperature characteristic that updates every 5 seconds.

Step 5 - Apply the low-power approach needed to reach very low sleep current

Goal: Understand what changes are required to approach the sub-20 µA sleep target.

What to do: Use a sleep strategy consistent with low-power BLE designs: stop BLE advertising during sleep, drop the CPU into System ON sleep, then wake on a GPIO interrupt (button) or an RTC timer. In the Adafruit nRF52 environment, relevant primitives include sd_app_evt_wait() and NRF_POWER->SYSTEMOFF.

Expected result: You have a clear path to modify the sketch so it only advertises when needed and spends most of its time sleeping.

Step 6 - Choose a power source that matches your runtime target

Goal: Pick a battery and power approach appropriate for a wearable or sensor node.

What to do: Use one of these common options:

CR2032 coin cell (240 mAh): roughly 3 to 5 years for a sensor that reports every 5 minutes.
500 mAh LiPo + TP4056: roughly 6 months between charges for a worn device with frequent BLE traffic.
Single 18650 + boost regulator: roughly 5 years for a stationary sensor (high capacity, often overkill).

Expected result: You can match the chemistry and capacity to your update interval and BLE activity level.

Step 7 - Map the platform to real projects where it makes sense

Goal: Identify practical BLE-first products where nRF52840 strengths matter.

What to do: Use the nRF52840 approach for projects like these:

Door and window sensors: wake on a reed switch, broadcast once, then sleep. CR2032 can last 5+ years.
BLE asset tags and iBeacons: multi-year coin-cell battery life with low-duty advertising.
Fitness wearable: heart rate plus accelerometer with strong power efficiency.
Smart-home button: wake on press, send an event, then sleep again.
Plant moisture trackers: wake on a schedule, transmit, then deep sleep for long intervals.

Expected result: You can quickly tell whether your application is a good fit for coin-cell BLE design and the nRF52840 feature set.

Conclusion

The Seeed XIAO nRF52840 is a strong MCU choice when BLE battery life matters more than adding WiFi. With Arduino IDE and Bluefruit libraries, you can build a small BLE temperature sensor using a BME280 and then extend it toward very low sleep current by advertising only when needed.

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: This guide was inspired by Easy Very Low Power BLE <20µA (2022/2024) With Arduino on Instructables. Images credited to the original author.

Seeeduino XIAO SAMD21 USB-HID: Build a Macro Numpad

Shilleh — Sat, 18 Jul 2026 22:20:12 +0000

Project Overview

Seeeduino XIAO SAMD21 USB-HID macropad: In this build, you use the Seeeduino XIAO SAMD21 with a 4x4 matrix keypad to create a USB-HID numpad that types keys and full macro strings on your computer.

The Seeeduino XIAO SAMD21 is a thumbnail-sized Arduino-class board (ATSAMD21G18 ARM Cortex-M0+ @ 48 MHz, 256 KB Flash, 32 KB SRAM) with native USB-HID support. It runs CircuitPython, MicroPython, and Arduino C, and it is a strong choice when you need a tiny board that can act like a USB keyboard, mouse, or MIDI device.

Time: 30 to 60 minutes
Skill level: Beginner to Intermediate
What you will build: A USB-HID numpad/macropad that types single keys or multi-character macros when you press buttons.

Parts List

From ShillehTek

XIAO ESP32-S3 - bigger sibling for advanced builds.
XIAO ESP32-C3 - cheap BLE alternative.
Pro Micro ATmega32U4 - the classic USB-HID board.
4x4 Membrane Matrix Keypad - for the numpad layout.
DuPont Wires - for quick prototyping and keypad connections.

External

Seeeduino XIAO SAMD21 board
USB-C cable
16 mechanical key switches (Cherry MX / Kailh) + keycaps, OR a 4x4 membrane keypad
Arduino IDE 2.x with the "Seeeduino SAMD" boards package installed

Note: This guide uses the XIAO SAMD21 because it supports native USB-HID. If you swap boards, confirm the board and core you choose supports the Keyboard library or an equivalent HID stack.

Step-by-Step Guide

Step 1 - Understand why the XIAO SAMD21 is still a great USB-HID choice

Goal: Know when the XIAO SAMD21 is the right tool for a macropad or HID project.

What to do: Keep these strengths in mind before you start building:

USB-HID projects: Native USB-HID plus a small footprint is ideal for macropads, dial controllers, and similar devices.
Boards that fit anywhere: About 20 mm x 17 mm.
CircuitPython for beginners: Drag-and-drop firmware updates and edit code from a simple drive.
Industrial deployments: SAMD21 is an automotive-grade chip with long-term availability.
No WiFi/BLE radio: Helpful when you do not want radio certification overhead.

Expected result: You know why this board is commonly used for small USB keyboard-style builds.

Step 2 - Install the Seeed SAMD board package in Arduino IDE

Goal: Make Arduino IDE recognize the Seeeduino XIAO SAMD21.

What to do:

In Arduino IDE: File -> Preferences. Add this Boards Manager URL:

https://files.seeedstudio.com/arduino/package_seeeduino_boards_index.json

Open Tools -> Board -> Boards Manager, then install: Seeed SAMD Boards by Seeed Studio.
Go to Tools -> Board -> Seeeduino SAMD -> Seeeduino XIAO.

Expected result: The Seeeduino XIAO board option is available and selected.

Step 3 - Upload a first USB-HID sketch that types text

Goal: Confirm USB-HID keyboard output works on your computer.

What to do: Upload this sketch, then focus a text editor and plug in (or reset) the board.

Code:

#include <Keyboard.h>

void setup() {
  Keyboard.begin();
  delay(2000);
  Keyboard.print("Hello from ShillehTek XIAO!");
}

void loop() {}

Expected result: After about 2 seconds, the board types the message into whichever app currently has focus.

Step 4 - Wire a 4x4 keypad and scan it as a numpad

Goal: Read a 4x4 matrix keypad and send a keypress over USB when a key is pressed.

What to do: Wire 4 columns and 4 rows of the keypad to XIAO pins D0 through D7. The code below scans the matrix in loop() and emits a mapped character.

Code:

#include <Keyboard.h>

const int ROW_PINS[] = {0, 1, 2, 3};
const int COL_PINS[] = {4, 5, 6, 7};

const char KEYMAP[4][4] = {
  {'1','2','3','+'},
  {'4','5','6','-'},
  {'7','8','9','*'},
  {'0','.','=','/'},
};

void setup() {
  Keyboard.begin();

  for (int r : ROW_PINS) pinMode(r, OUTPUT);
  for (int c : COL_PINS) pinMode(c, INPUT_PULLUP);
  for (int r : ROW_PINS) digitalWrite(r, HIGH);
}

void loop() {
  for (int r = 0; r < 4; r++) {
    digitalWrite(ROW_PINS[r], LOW);

    for (int c = 0; c < 4; c++) {
      if (digitalRead(COL_PINS[c]) == LOW) {
        Keyboard.press(KEYMAP[r][c]);
        delay(80);
        Keyboard.releaseAll();
      }
    }

    digitalWrite(ROW_PINS[r], HIGH);
  }

  delay(5);
}

Expected result: Pressing a keypad button types the mapped character (1, 2, 3, +, etc.) on the host computer.

Step 5 - Upgrade keys into real macros (type whole snippets)

Goal: Replace single key outputs with multi-character strings or sequences.

What to do: Update your key handling so certain keys type full snippets such as git push, a common email address, or any repeated text. The XIAO SAMD21 stores these strings in flash, so they persist across power cycles.

Expected result: Pressing selected keys types whole snippets instead of single characters.

Step 6 - Use CircuitPython instead of Arduino (optional)

Goal: Get the same HID behavior using CircuitPython.

What to do:

Double-tap the reset pin so the XIAO mounts as an ARDUINO drive.
Copy the CircuitPython UF2 onto it. It reboots as CIRCUITPY.
Edit code.py in any text editor. Changes auto-reload.

Code:

import board, digitalio, usb_hid
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode

kbd = Keyboard(usb_hid.devices)
btn = digitalio.DigitalInOut(board.D0)
btn.switch_to_input(pull=digitalio.Pull.UP)

while True:
    if not btn.value:
        kbd.send(Keycode.CONTROL, Keycode.C)
        while not btn.value:
            pass

Expected result: Pressing the button on D0 sends the Ctrl+C shortcut over USB.

Step 7 - Know where the XIAO SAMD21 wins over an ESP32-C3 for HID

Goal: Understand tradeoffs if you are choosing between boards.

What to do: Use these points as a quick comparison:

Small footprint and simple USB-HID behavior.
No radio, which can reduce certification complexity for production hardware.
CircuitPython is typically more polished on SAMD21 than on ESP32-C3.
USB-HID works without extra boot configuration steps.
Industrial-grade silicon with long-term availability.

Expected result: You can justify the SAMD21 choice for wired HID macropads and similar projects.

Conclusion

You built a Seeeduino XIAO SAMD21 USB-HID macropad using a 4x4 keypad matrix, starting from a simple "type on plug-in" sketch and expanding into a real numpad and macro-typing workflow.

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

Inspiration and image credit: HID Numpad With XIAO SAMD21 (Instructables).

Arduino 4-Channel Relay Module: Reverse a DC Motor

Shilleh — Sat, 18 Jul 2026 22:16:20 +0000

Project Overview

Arduino + 4-channel relay module motor reversing: In this build, you wire a 4-channel relay module as a simple H-bridge so an Arduino can drive a DC motor forward and reverse for high-current on/off motion projects.

An H-bridge built from four contactor relays is a low-cost way to drive a high-current DC motor forward and reverse from an Arduino. Two relays do direction, and two more can be used for braking or current-limiting behavior. A programmable 4-channel relay module with built-in timer logic works well for tasks like a linear actuator extending and retracting on a schedule, an aquarium pump alternating its flow direction, or electric blinds opening and closing on a daily routine.

This guide builds a working motor-reversing system around a 4-channel relay module, a 12 V DC motor, and an Arduino. The same wiring scales to lock actuators, valve drivers, sliding doors, and roller blinds.

Time: 30 to 60 minutes
Skill level: Intermediate
What you will build: A relay-based H-bridge that lets an Arduino reverse a DC motor and stop it safely with a software interlock.

Parts List

From ShillehTek

4-Channel 12V Relay Module - the workhorse for this build.
4-Channel 5V Relay Module - if you are driving the coils from a 5V Arduino.
L298N Motor Driver - the electronic-only alternative for under 2A loads.
Arduino Nano V3.0 - controller for relay outputs and safety interlocks.
HC-SR04 Distance Sensor - optional for end-stop detection.

External

12 V or 24 V DC motor (or linear actuator).
An appropriate power supply rated for the motor's stall current.
Two limit switches (mechanical micro-switches) for end-stop safety.
A fuse inline with the motor - size to motor running current plus 50%.

Note: Many relay modules are active LOW (a LOW turns the relay on). Also match relay coil voltage (5V or 12V) to the module you choose, and never power a motor directly from the Arduino.

Step-by-Step Guide

Step 1 - Decide if relays are the right H-bridge choice

Goal: Understand why a relay H-bridge is useful for high current and what you give up.

What to do: If you only need on/off control and your motor current is beyond typical small H-bridge driver chips, a 4-relay H-bridge can be a good fit. It is simple, cheap, and galvanically isolated.

Expected result: You know when to use relays (high current, on/off reversing) and when not to (PWM speed control and ultra-high cycle life requirements).

Step 2 - Wire the 4-relay H-bridge for forward and reverse

Goal: Connect the relays so the motor polarity can be swapped safely.

What to do: Wire four relays in two "sides," so you can energize a diagonal pair for forward, and the opposite diagonal pair for reverse.

Wiring reference:

             +12V
              |
              +-------+-------+
              |               |
            [REL1]           [REL3]
            COM-NO           COM-NO
              |               |
              +---- MOTOR ----+
              |               |
            [REL2]           [REL4]
            COM-NO           COM-NO
              |               |
              +-------+-------+
                      |
                     GND

To drive forward:   REL1 + REL4 closed (the diagonal)
To drive reverse:   REL3 + REL2 closed (the other diagonal)
To brake:           any two on the same side closed
To coast:           all four open

Critical: Never close REL1 + REL2 (or REL3 + REL4) at the same time. That is a direct short across the supply. You must add an interlock in your code.

Expected result: Your wiring matches the diagonal-pair logic for forward and reverse without creating a supply short condition.

Step 3 - Upload Arduino code with a software interlock (dead-time)

Goal: Ensure both relay pairs are opened before switching directions.

What to do: Use an "all off" function, then add a short delay (dead-time) before turning on the next relay pair.

Code:

const int RELAYS[4] = {2, 3, 4, 5};   // REL1..REL4

void allOff() {
  for (int r : RELAYS) digitalWrite(r, HIGH);   // active LOW
}
void forward() {
  allOff(); delay(50);                          // dead-time
  digitalWrite(RELAYS[0], LOW);                 // REL1
  digitalWrite(RELAYS[3], LOW);                 // REL4
}
void reverse() {
  allOff(); delay(50);
  digitalWrite(RELAYS[1], LOW);                 // REL2
  digitalWrite(RELAYS[2], LOW);                 // REL3
}
void brake() {
  allOff(); delay(50);
  digitalWrite(RELAYS[0], LOW);                 // REL1
  digitalWrite(RELAYS[2], LOW);                 // REL3 (high side together)
}

void setup() {
  for (int r : RELAYS) {
    pinMode(r, OUTPUT);
    digitalWrite(r, HIGH);
  }
}
void loop() {
  forward();  delay(5000);
  brake();    delay(500);
  reverse();  delay(5000);
  brake();    delay(500);
}

The delay(50) dead-time between modes helps guarantee both relay pairs are open before either pair closes.

Expected result: The motor runs forward, brakes, runs reverse, and brakes again without ever energizing an unsafe relay combination.

Step 4 - Add end-stop limit switches for safer motion

Goal: Stop motion at the physical endpoints even if timing is wrong.

What to do: Install and wire two limit switches, then read them using INPUT_PULLUP so a pressed switch reads LOW. If either end-stop triggers, call brake().

Code:

const int LIMIT_FWD = 6;
const int LIMIT_REV = 7;

void setup() {
  pinMode(LIMIT_FWD, INPUT_PULLUP);
  pinMode(LIMIT_REV, INPUT_PULLUP);
}

void loop() {
  if (digitalRead(LIMIT_FWD) == LOW) brake();
  if (digitalRead(LIMIT_REV) == LOW) brake();
  // ... rest of motion logic ...
}

For a sliding door or window opener, limit switches help the motor stop precisely at the open and closed positions. Do not rely on timing alone for safety-critical motion.

Expected result: Pressing either limit switch forces the motor to brake, preventing overtravel.

Step 5 - Choose applications that fit the 4-relay approach

Goal: Match this design to real projects where high-current reversing matters.

What to do: Use the relay H-bridge when you want robust reversing with on/off control.

Electric linear actuator for a desk-height changer, kitchen pop-up monitor, or solar-tracking panel.
Automatic chicken coop door that opens at sunrise and closes at sunset (sun-tracking plus RTC).
Sliding window opener for greenhouse ventilation that reverses on a rain sensor trigger.
Pet feeder auger reversal to clear jams by briefly running backward.
Aquarium current reverser to alternate flow direction every hour.
3D printer build-plate elevator for tall prints with a small Z motor.

Expected result: You can quickly decide whether your project is a good match for relay reversing.

Step 6 - Know when to use an L298N motor driver instead

Goal: Avoid using relays when you need PWM speed control.

What to do: If your motor is under 2 A and you want PWM speed control and smooth ramping, use an electronic H-bridge like our L298N motor driver. The relay approach is best for high-current, on/off only reversing.

Expected result: You select relays for high-current switching, and a motor driver when speed control is required.

Conclusion

With four relays, an Arduino, and a small dead-time interlock, you can build a DC motor reverser that handles serious current. The same relay H-bridge pattern is widely used for actuators, doors, valves, and other reversing motion systems.

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: Inspired by DC Motor Controller With Two Relay on Instructables.

STM32H723ZGT6 STM32duino: Install and benchmark

Shilleh — Sat, 18 Jul 2026 22:13:00 +0000

Project Overview

STM32H723ZGT6 + STM32duino: In this guide, you will set up an STM32H723ZGT6 development board in Arduino IDE (via the STM32duino core), run a first blink sketch, and measure a simple high-speed loop benchmark.

The STM32H723ZGT6 is a Cortex-M7 running at 550 MHz with 1 MB Flash, 564 KB RAM, hardware FPU, DSP instructions, and enough peripherals for 3D printers, audio synthesis, real-time motor control, oscilloscopes, and CAN-bus gateway nodes.

Time: 30 to 60 minutes
Skill level: Beginner to Intermediate
What you will build: An Arduino IDE setup for the STM32H723ZGT6 plus a blink test and a float-math timing benchmark over Serial

Parts List

From ShillehTek

STM32H723ZGT6 Pre-Soldered Core Development Board - the H7 board used for setup and benchmarking
STM32F103 Blue Pill - older sibling for performance reference
STM32F411 Black Pill - mid-tier comparison
CP2102 USB-to-TTL - for UART bootloader flashing when SWD is not available

External

ST-Link V2 programmer (or use the onboard one if your board has it)
USB-C cable
Arduino IDE 2.x with the STM32duino board package installed

Note: Upload methods vary by board variant. Some boards expose USB DFU directly, while others are easiest to program via SWD (ST-Link) or the UART bootloader.

Step-by-Step Guide

Step 1 - Decide if the H7 is the right fit

Goal: Understand what makes the STM32H723 (H7 family) different from an ESP32 or older STM32 parts.

What to do: Use the list below to sanity-check whether you actually need the H7 class of performance and peripherals.

550 MHz Cortex-M7 - significantly faster per core than the ESP32's 240 MHz LX6, plus a deeper pipeline.
Single-precision + double-precision FPU - STM32F103 has none; ESP32-S3 has single only.
DSP instructions - the M7 includes SIMD for parallel 16-bit math (audio, FFT, motor control).
Real-time peripherals - advanced timers, hardware CAN-FD, and fast ADC options.
Deterministic timing - no WiFi/BLE interrupts hijacking your control loop, unlike ESP32.

Expected result: You have a clear reason to use the H7 (real-time control, DSP-heavy workloads, or high-performance peripherals) instead of a smaller MCU or an ESP32.

Step 2 - Install STM32duino in Arduino IDE

Goal: Add ST's STM32 Arduino core so Arduino IDE can build and upload sketches to the STM32H723.

What to do: Follow these menu steps in Arduino IDE 2.x.

File -> Preferences. Add this to Additional Boards URLs: https://github.com/stm32duino/BoardManagerFiles/raw/main/package_stmicroelectronics_index.json.
Boards Manager -> search "STM32" -> install "STM32 MCU based boards" by ST-Microelectronics.
Tools -> Board -> STM32 boards -> Generic STM32H7 Series.
Tools -> Board part number -> STM32H723ZG.
Tools -> Upload method -> STM32CubeProgrammer (SWD) (or "DFU" if your board exposes USB DFU).

Expected result: Arduino IDE shows the STM32H7 board options, and you can select STM32H723ZG plus an upload method that matches your hardware.

Step 3 - Upload your first blink sketch

Goal: Confirm that your toolchain, board selection, and upload method work.

What to do: Create a new sketch and upload the code below (adjust the LED pin if your board uses a different pin).

Code:

const int LED = PA0;

void setup() {
  pinMode(LED, OUTPUT);
}

void loop() {
  digitalWrite(LED, HIGH);
  delay(500);
  digitalWrite(LED, LOW);
  delay(500);
}

Expected result: The LED toggles on and off every 500 ms.

Step 4 - Run a quick loop benchmark

Goal: Measure a simple float-math loop to get a feel for the H7's performance and FPU capability.

What to do: Upload the benchmark sketch below, open Serial Monitor at 115200 baud, and watch the loop timing.

Code:

void setup() {
  Serial.begin(115200);
}

void loop() {
  uint32_t t = micros();
  float a = 1.0f;

  for (uint32_t i = 0; i < 1000000UL; i++) {
    a = a * 1.0001f + 0.00001f;
  }

  Serial.printf("loop = %lu us\n", micros() - t);
  delay(1000);
}

Expected result: You see a printed microsecond time for "loop = ... us". For reference, the original comparison numbers were:

Arduino Nano (no FPU): ~1.4 seconds
STM32F103 Blue Pill: ~85 ms
ESP32 (LX6, hard FP): ~12 ms
STM32H723 @ 550 MHz: ~1.6 ms

Step 5 - Map the H7 to real projects

Goal: Identify project types that actually benefit from the STM32H7 family's real-time performance and peripherals.

What to do: Use the list below as a starting point for choosing a next build.

3D printer / CNC controller: Klipper, Marlin 2.x, GRBL HAL support H7 for smooth high-microstep motion.
Audio synthesizer / effects pedal: Real-time FFT and effects benefit from FPU + DSP.
Motor control (FOC, BLDC): High update rates and deterministic timing enable better control loops.
Logic / hobby oscilloscope: Fast ADC into DMA and render to a display.
CAN-FD gateway: Hardware CAN-FD support for real-time nodes.
USB MIDI host / audio interface: High-speed USB OTG with isochronous endpoints.

Expected result: You have one concrete "next project" idea that matches what the H7 is good at.

Step 6 - Choose a flashing method (SWD, DFU, or UART)

Goal: Understand your options for getting firmware onto the board based on what hardware you have.

What to do: Pick one of the methods below and use it consistently while developing.

SWD via ST-Link V2: Fastest and most reliable.
USB DFU: Hold BOOT0 button and plug USB so the board appears as a DFU device.
UART bootloader: Connect a CP2102 to A9/A10, pull BOOT0 high, then flash via stm32flash.

Expected result: You can reliably upload firmware using a method that matches your board and tools.

Step 7 - Know when not to use an H7

Goal: Avoid overkill and pick the right chip for the job.

What to do: If you need WiFi/BLE on the same chip, the H7 does not include it. Pair with an ESP32 over UART, or use an STM32WB55 instead. If your project is simply "blink an LED when a button is pressed", the H7 is unnecessary.

Expected result: You understand the tradeoff: H7-class deterministic performance versus integrated wireless features.

Conclusion

The STM32H723ZGT6 is a strong choice when an ESP32 or STM32F103 has run out of headroom for real-time math, motor control loops, audio DSP, or high-performance peripherals. With STM32duino installed, you can validate your setup quickly with a blink sketch and a simple benchmark loop.

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

Inspiration: Automation With the Giant STM32F746G and ESP32 (Instructables).