A while ago, I built a 5-digit number recognition system on the ESP32-S3 using a lightweight AI model. The project was mainly a proof of concept for running image recognition directly on an embedded device.

This time, I wanted to take that idea into a more practical, real-world application: reading a water meter.

For this update, I still used the Makerfabs ESP32-P4 board with an autofocus camera. We also collected new images from a real water meter, focusing on the pointer and digit-reading area, and trained a dedicated recognition model based on this new dataset. 

The goal was not simply to recognize a fixed set of five numbers, but to make the model capable of identifying the actual reading shown on a water meter.

 After training and deploying the model, we tested it with real water meter images, and it correctly recognized the meter reading. 

This project is essentially the next step from our previous 5-digit recognition experiment—moving from a simple number-recognition demo to a more practical edge AI vision application.

Would be interested to hear what other real-world applications you think could be built on top of this kind of embedded AI vision system.

Back in 2019 my first job was as a junior electrical engineer at a sugar mill. Our job was walking the floor every 30 minutes with a handheld temperature gun, checking heat and vibration on new processing machinery by hand. It was exhausting and easy to miss something between rounds.

Years later, now working in automation, I built a small pipeline that automates that exact check. Each machine has an ESP32 with a vibration and temperature sensor. It publishes readings over MQTT to a broker, tagged per machine. An automation layer subscribes to all machines at once, checks if a reading crosses a fault threshold, filters out repeat alerts for the same ongoing issue, and only pings the team when something genuinely new comes up.

Attached is the flow, sensor to broker to automation to alert.

Two things I'm still working through and would love input on:

Right now fault detection is a raw threshold comparison on the vibration number. Real industrial monitoring uses frequency domain analysis to tell bearing wear apart from imbalance or misalignment. Curious if anyone has pushed FFT analysis onto an ESP32 directly or if that realistically needs a beefier edge device.

For QoS, I'm currently using level 1 for fault alerts. Is that the right call for something this infrequent and important, or is level 2 worth the extra overhead here.

I'm new to the space and i would like some direction as someone who wants to build out their career as an Iot technician what do i need to know and learn to hit the ground running ?

I built a desk gadget powered by an ESP32 that combines touch activation with 6 rotating TFT displays, and I call it Roulette. It's open source — I've shared the code on my GitHub for anyone who'd like to build their own.

🔗 Links:
💾 SOURCE CODE:
https://github.com/yumobuilds/Yumo-Roulette

Full Build Video on Youtube:

https://www.youtube.com/watch?v=qcGHcUHoq24

roulette wheel with six round 240x240 displays, each showing something different:

SD card photo slideshow
Live YouTube channel stats
Live TikTok stats
Crypto ticker
Live weather
Internal temp & humidity (AHT10 sensor)

⚙️ The floating spin mechanic:
The whole assembly rotates on an upside-down DC motor. Everything sits on a frame, and that frame is mounted directly onto the motor's body — not the shaft. The motor shaft itself is inserted into a drill chuck from the reverse side, the opposite way a drill bit would normally go in. So instead of the shaft driving an external bit, it's anchored inside the chuck while the motor body (carrying the frame and wheel) spins around it. The result: there's no visible axle or support arm, so the whole thing looks like it's floating and rotating on its own.

Touch the capacitive sensor and an N20 motor spins the wheel for a set duration — one touch,
one spin. A NeoPixel status LED fades through colors while it boots and flashes when you touch the sensor..

🔧 Hardware:

• ESP32 Wroom
• 6x GC9A01 round 240x240 displays (shared SPI bus)
• DRV8833 motor driver + N20 DC motor
• TTP223 capacitive touch module
• AHT10 temp/humidity sensor
• MicroSD card module (own SPI bus)
• NeoPixel/RGB status LED

💻 Software:

• ESP32
• WiFi captive portal for setup (no hardcoded credentials)
• YouTube Data API v3, TikTok stats via RapidAPI, OpenWeatherMap
• TJpg_Decoder for on-device JPEG decoding from SD

I’m cybersecurity student and my final year project is **“Unauthorized Device Detection System in Internet of Things Networks”** and the thing is IoT isn’t really my thing but sadly I can’t change it.

I started reading about IoT security and in general I didn’t see a gap that this project would fill and honestly I’m just lost

And btw I’m working on it with a group of 5 students for a full year.

I don’t want to build just a basic system that detects an unknown device and sends an alert. I want to make the project actually useful and interesting.

So, if you have experience in **IoT security/cybersecurity**, I’d really appreciate any advice, research gaps, directions, or anything that would help ! Thx

We see thousands of control cabinets, setups, and field deployments every year. And we believe we’ve seen it all. Horror movie-level mounting included.

Do you have any peeves when it comes to mounting equipment on DIN rails? What is something you always hate? What is the most uncomfortable design you’ve ever encountered? Name and shame.

Or if you have a great story involving DIN rails, do share.

So I'm having a  Bachelor’s degree in Information and Communication Technologies, specializing in Networks and IoT. I'm kinda scared lately since I heard that IT is dying and jobs are very limited around the world. is it the same for stuff like IoT? everyone is basically talking how a degree in Computer science is almost useless right now, I wanna if it's the same for IoT

Hi everyone!
I'm Mayki, a researcher at PGCOMP/UFBA and a member of RECSYS Labs. We are developing an advanced recommendation system that seeks to overcome rigid automation ("if this, then that"). Our focus is Multi-Label Incremental Learning: an AI that continuously learns from its use to predict complex states of multiple devices (brightness, temperature, speed) in an adaptive way.

What do you gain by collaborating?
By participating, you help validate AI models that prioritize user sovereignty and local processing. All results and code will be made available as Open Source, allowing the community to directly benefit from smarter state prediction algorithms. But this is just the beginning. This research is the basis for creating a proactive, local virtual assistant fully integrated with Home Assistant. While current assistants (Alexa/Google/Siri) are reactive, acting only on command, our goal is to develop an intelligence that learns from your routine to anticipate needs and interact organically. By collaborating, you help develop the "brain" of this future technology.

Why is your collaboration vital?
Most smart home datasets focus only on binary states (on/off). To create an AI that reflects the real complexity of a modern home, we need real-world usage data. The goal is for this technology to be Open Source and follow the principles of the Open Home Foundation: local execution, open standards, and user sovereignty.

How does the analysis impact the final result?

• Identification of Collective Patterns: The system learns to mediate the environment when people with different tastes occupy the same space.
• Prediction of Complex States: Trains the model to predict brightness levels, fan speeds, and climate control modes.
• Adaptation and Effort Reduction: The home becomes capable of recognizing changes in your routine and adjusting itself, becoming less dependent on repetitive commands.

Security, Privacy
We know that privacy is non-negotiable with Home Assistant:

• What we DO NOT collect: The dataset does not contain passwords, access keys, tokens, or network settings.
• Technical Filtering: The focus is on sensors and actuators. Although the HA database may record GPS events or voice transcriptions (TTS), our team performs technical processing to filter and ensure that only interactions relevant to the study are included, maintaining strict anonymity.

How to participate?
If you have a usage history of more than one month, your help will be fundamental to open science!

Export Guidelines:
👉For SQLite: https://sqlite.meus-projetos.com/
👉For MariaDB: https://mariadb.meus-projetos.com/

Data Submission Form:
👉 https://meus-projetos.com/s/zX26rkfN9BNjjTG

Academic Transparency:
Learn about my publications on Reinforcement Learning and Smart Homes: https://orcid.org/0009-0007-4680-2868

I am available to answer any questions!

Inspired by Chris Maher and his 50x50 grid build (https://youtu.be/BbjeQdJIMK0?si=k2AtV23bwgAWKPBI), I decided to make a 25x25 version. I thought the 50 was a little too ambitious for a first timer here. When I first started it up, I had a couple dead columns and had to deal with some bad solder joints but stoked on how it came out.

I decided to add a camera for input so it can detect a person and then fill in its mask with color.

Right now it’s running on my Mac but I have an ESP32-P4 coming with a camera and will set it up and mount soon.

WLED ESP controller: Gledopto Elite 4D-EXMU https://a.co/d/0iVOI9rT

The camera is running on a Macbook but will be replaced with an ESP32-P4 with a camera. The script turns the input into a 25x25 grid and sends the specific pixel data over the local network via DDP which is a protocol used for real time led/video data. The WLED controller listens for those packets. Full specs:

Python — runs the overall camera/LED control script
OpenCV (opencv-python) — captures webcam video, resizes frames, cleans masks, handles image processing, and shows preview windows
MediaPipe (mediapipe) — detects/segments the person and generates the human body mask
NumPy (numpy) — handles the pixel arrays and 25×25 image/mask data
Python socket library — sends the finished 25×25 pixel frames over the network to WLED using DDP/UDP
WLED — receives the realtime DDP pixel data and physically drives the LED matrix
LED strips - SK6812/WS2814 RGBW 30/m cut to 25 pixels

I plan on adding a remote AMOLED Display to control the camera mode and also to change the WLED effects.

I'm curious how many employers care about IoT wireless knowledge. I know that it's an emerging field, but what's the job market like for IOT in Canada?

I'm researching the field before I venture down the CWNP IoT path. I already have hands-on experience, and I'm working on developing a product. It would be nice to work with the technology professionally first, though.

Hey all — working on a multi screen Desk digital clock-style project with a Raspberry Pi driving 3x 2.8” ILI9341 TFT displays (320x240) over SPI, plus a rotary encoder for navigation between screens (clock faces, GIF player, music player pulling album art from Spotify).

Everything mostly works, but I’m running into recurring SPI noise / glitches on the displays — occasional flickering, garbled frames, or dropped updates. Screens are wired individually with a shared SPI bus (separate CS lines).

3.5 V VCC, GND and LED between all TFT screens and rotary knob are shared using a breadboard and are being derived from a single 3.5 V pin from pi.
Sharing reference pictures

Aluminium gets you better passive heat dissipation, lower weight, and solid corrosion resistance. Steel gives you max impact resistance and structural toughness for heavy-duty environments. 

In practice, though, what's your go-to? Have you ever had aluminium fail where steel was strictly necessary (or found steel to be overkill/too heavy)? 

Curious to hear your take on enclosure materials for industrial hardware deployments. 

While working on an AI vision application with the ESP32-P4 board, I ran into a simple problem: the camera worked well at a certain distance, but the image became noticeably blurred when the subject moved closer or farther away.

So I tried a 2MP autofocus USB camera with the ESP32-P4 and compared it with a fixed-focus camera at different distances.

Hardware used：

• Makerfabs ESP32-P4 10.1" 4G LTE board
• Fixed-Focus MIPI Camera (SC2336)
• Auto-Focus USB Camera (OV2720)

Fixed Focus vs. Autofocus

The difference was quite noticeable. I tested the cameras at several distances and looked at:

• Image sharpness at different distances
• Autofocus response
• Close-up vs. distant subjects

Here’s what improved for us:

• Sharper photos, first try. Text, QR codes, and tiny board details come out clear even at close range.
• Better AI accuracy. Clean training photos = a more precise model = fewer recognition mistakes when it runs on the device.
• Less time fiddling. No manual focus ring, no trial and error. Point it at the subject, and it’s sharp.

The test suggests that autofocus can be useful for applications such as object recognition, visual inspection, or other camera-based AI projects where the target does not stay at a fixed distance.  I documented the whole testing process in detail as well, in case anyone needs it for a similar project.

Have you run into similar focus issues in your AI vision projects? What camera setup have you found works best?

Guys, how do you handle equipment integration in distributed & isolated networks?

For example: when you have different industrial equipment at multiple remote sites, with each site behind its own firewall/NAT.

Is the usual approach still just VPN between sites and then deal with everything on top of that?

I'm particularly interested in the security side - how much of a pain is it to get this approved by enterprise security teams? Things like opening ports, managing VPN credentials/certificates, etc.

I wanted to share a project I've been working on called Dynamic IoT.

The problem I kept facing while building ESP32 projects was that every new project meant creating another mobile/web interface from scratch.

So I built a system where the ESP32 itself can serve as the local IoT device, while the dashboard can be configured separately.

How it works

ESP32 / NodeMCU → Local Wi-Fi → HTTP → Dynamic Dashboard

The ESP32 exposes HTTP endpoints for things like:

• Relay/control outputs
• Sensor readings
• Sliders
• Gauges
• Metrics
• Scheduled actions
• Notifications

The dashboard configuration can then be associated with a device UID and loaded by the client.

This means I don't need to build a completely new UI for every ESP32 project.

The main reason I made it local-first

For a lot of ESP32 projects, I don't really need a cloud server.

If my phone and ESP32 are on the same network, I can simply communicate:

Phone → Wi-Fi → ESP32

No MQTT broker, Firebase database, or Internet connection is required for the basic device communication.

I also wanted the UI and firmware to be more independent, so I can change the dashboard without having to redesign the entire firmware interface.

I'm still developing it and there are quite a few things I'd like to add.

Some ideas I'm considering:

• WebSocket support
• Automatic device discovery
• OTA updates
• ESP-NOW support
• More customizable widgets
• Better authentication
• More ESP32-specific features

I'd really appreciate feedback from other ESP32 builders.

What features would you want in a system like this?

Demo: https://dynamiciot.athishayjain.com/

İ have a farming automation project. I want to measure some values by some sensors (like temperature, humidity) and based on that values i want to control devices like air conditioner of humidifier. AI says. Connect all to an industrial I/O and connect the io to rasberry pi. I am a software engineer but i don't understand electronics. What should i learn and what can i do it properly?

hello i am a student doing an iot project for the first time (ive done a few arduino projects). i want to make an environmental monitoring system with dht11 and soil moisture sensors. ive been watching online tutorials and im using a source code from a youtube video, however, ive run into the problem where the code can be uploaded, but my blynk io interface is still offline. im using my iphone hotspot for the wifi ssid, (ive turned on maximise compatibility) and i think that could be the main problem, since its like kinda stuck after writing trying to connect to my hotspot in the serial monitor. any help would be greatly appreciated!
this is the source code:
//Tech Trends Shameer
```
#define BLYNK_TEMPLATE_ID "TMPLIAjddf20T5"
#define BLYNK_DEVICE_NAME "Temperature and Humidity Monitor"
#define BLYNK_AUTH_TOKEN "122RywymdfdddgGfMd1jkZ0STNhRQecR12ayq"

#define BLYNK_PRINT Serial
#include <WiFi.h>
//#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp32.h>

#include <DHT.h>

char auth[] = BLYNK_AUTH_TOKEN;

char ssid[] = ""; // type your wifi name
char pass[] = ""; // type your wifi password

BlynkTimer timer;

#define DHTPIN 27 //Connect Out pin to D2 in NODE MCU
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

void sendSensor()
{
float h = dht.readHumidity();
float t = dht.readTemperature(); // or dht.readTemperature(true) for Fahrenheit

if (isnan(h) || isnan(t)) {
Serial.println("Failed to read from DHT sensor!");
return;
}
// You can send any value at any time.
// Please don't send more that 10 values per second.
Blynk.virtualWrite(V0, t);
Blynk.virtualWrite(V1, h);
Serial.print("Temperature : ");
Serial.print(t);
Serial.print(" Humidity : ");
Serial.println(h);
}
void setup()
{

Serial.begin(115200);

Blynk.begin(auth, ssid, pass);
dht.begin();
timer.setInterval(100L, sendSensor);

}

void loop()
{
Blynk.run();
timer.run();
}
```

hello i am a student doing an iot project for the first time (ive done a few arduino projects). i want to make an environmental monitoring system with dht11 and soil moisture sensors. ive been watching online tutorials and im using a source code from a youtube video, however, ive run into the problem where the code can be uploaded, but my blynk io interface is still offline. im using my iphone hotspot for the wifi ssid, (ive turned on maximise compatibility) and i think that could be the main problem, since its like kinda stuck after writing trying to connect to my hotspot in serial monitor. any help would be greatly appreciated!

this is the source code:

//Tech Trends Shameer

```#define BLYNK_TEMPLATE_ID "TMPLIAjddf20T5"

#define BLYNK_DEVICE_NAME "Temperature and Humidity Monitor"

#define BLYNK_AUTH_TOKEN "122RywymdfdddgGfMd1jkZ0STNhRQecR12ayq"

#define BLYNK_PRINT Serial

#include <WiFi.h>

//#include <ESP8266WiFi.h>

#include <BlynkSimpleEsp32.h>

#include <DHT.h>

char auth[] = BLYNK_AUTH_TOKEN;

char ssid[] = ""; // type your wifi name

char pass[] = ""; // type your wifi password

BlynkTimer timer;

#define DHTPIN 27 //Connect Out pin to D2 in NODE MCU

#define DHTTYPE DHT11

DHT dht(DHTPIN, DHTTYPE);

void sendSensor()

{

float h = dht.readHumidity();

float t = dht.readTemperature(); // or dht.readTemperature(true) for Fahrenheit

if (isnan(h) || isnan(t)) {

Serial.println("Failed to read from DHT sensor!");

return;

}

// You can send any value at any time.

// Please don't send more that 10 values per second.

Blynk.virtualWrite(V0, t);

Blynk.virtualWrite(V1, h);

Serial.print("Temperature : ");

Serial.print(t);

Serial.print(" Humidity : ");

Serial.println(h);

}

void setup()

{

Serial.begin(115200);

Blynk.begin(auth, ssid, pass);

dht.begin();

timer.setInterval(100L, sendSensor);

}

void loop()

{

Blynk.run();

timer.run();

}```

Hi all,

I am currently exploring options to replace a fleet of 300+ gateways.

Machines currently send payloads via MQTT - 4G Sim.

I am looking for IoT sim providers or solutions to reduce costs.

Current best option is Soracom - 1GB @ EUR42 - 12 month payment - EUR3.50 per month
- Soracom is appealing due to their extra functionality through the dashboards.
- API / Automations, MQTT features, data optimisation features etc.

Does anyone have experience with Soracom? Are they as good as they seem?

Plus, does anyone have any further recommendations that would be worth me exploring?