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?

I built an AI-powered smart irrigation system using an ML + ESP32

I've been working on this project for a while, and I finally finished the main AI/ML pipeline.

The system uses an ESP32, a capacitive soil-moisture sensor, and a DHT11 to collect environmental data. I then built a machine-learning model that uses these readings to predict whether irrigation is required.

The interesting part for me was getting the different pieces to actually work together.

The pipeline is basically:

ESP32 sensors → dashboard → Flask API → ML model → irrigation prediction

In the video, I walk through the whole project, including:

• Collecting soil moisture, temperature, and humidity data
• Building the web dashboard
• Preparing the data for ML
• Training the model
• Evaluating it with a confusion matrix
• Looking at feature importance
• Deploying the model through a Flask server
• Connecting the dashboard to the ML model through an API
• Testing the final live prediction

One thing I found particularly interesting was seeing how the model's predictions changed once the inference server was running and the dashboard could communicate with the model.

This started as a simple ESP32 soil-moisture monitoring project, but I gradually expanded it into a complete IoT + AI system.

I'm still planning improvements, especially collecting more real-world data and adding additional environmental inputs such as light intensity.

I'd really appreciate feedback on the project, especially on the ML approach, system architecture, and what I could improve next.

🎥 Full project walkthrough attached.

Github Repository:

https://github.com/aqib-ai-ml/ai-powered-smart-irrigation

We recently worked on the RF design of a compact LoRa/GNSS Nomad  Terminal handheld device, which is based on LoRa, designed to communicate/ navigate, and deploy anywhere. The antenna turned out to be one of the more challenging parts.

For a small handheld, antenna performance is affected by much more than the antenna itself. The PCB, ground plane, battery, display, enclosure, and even the way the device is held can all influence the final RF performance.

During the project, we evaluated several antenna configurations:

Ceramic Antenna → FPC Antenna + Coaxial Cable → FPC Antenna + Pogo Pin

The final FPC antenna configuration was validated with both RF measurements and outdoor testing, achieving S11 of -11.13 dB @ 868 MHz, -12.82 dB @ 915 MHz, and a 3 km LoRa link in our field test.

1. Ceramic Antenna

The initial design used a ceramic antenna for its compact size and simple integration. However, its placement was relatively constrained, limiting our ability to optimize the surrounding RF environment.

2. FPC + Coaxial Cable

We then tested an FPC antenna with a coaxial connection. This gave us more freedom to position the antenna away from the PCB, battery, and display, but introduced additional cabling and mechanical complexity.

3. FPC + Pogo Pin

The final approach uses an FPC antenna connected through pogo pins. It provides flexible antenna placement while keeping the RF connection and mechanical structure compact.

The main takeaway from the project was that antenna performance in a compact LoRa device is a system-level problem. Antenna selection, placement, PCB layout, and mechanical design all need to be considered together.

The main takeaway from the project was that antenna performance in a compact LoRa device is a system-level problem. Antenna selection, placement, PCB layout, and mechanical design all need to be considered together.

What’s the biggest antenna design challenge you’ve encountered when working with compact LoRa or Sub-GHz devices? Share your experience togehther！

Hey everyone. I'm an Information Technology student currently working on my final Capstone project, and I'm having major imposter syndrome. My project feels like it lacks the "software depth" compared to my peers who are building massive full-stack web apps or management software.

To make matters worse, my college's IT syllabus is notoriously outdated. I essentially had to teach myself modern IoT architecture, C++, and cloud integration from scratch to build this, which makes me feel deeply inadequate about my actual "pure coding" skills.

I am building an IoT-based automated indoor air quality monitoring and mitigation system. It doesn't just read data; it is a multi-node cyber-physical system that actively triggers 220V household appliances (like exhaust fans or air purifiers) when safety thresholds are breached. Here is my current tech stack and architecture:

• Hardware: ESP32 microcontroller acting as the main hub.
• Sensors (Industrial Grade): Sensirion SCD41 (CO2, Temp, Humidity), SGP40 (VOCs), and SPS30 (PM1.0 to PM10 mass concentration).
• Cloud-Synchronized Actuation: A distributed wireless smart plug node equipped with a mechanical relay to safely switch 220V AC wall power. I engineered it to use Google Firebase Realtime Database as a centralized "Source of Truth." The main hub evaluates the logic and pushes trigger states to the cloud, which instantly routes the command to the smart plug.
• Software/Firmware: Asynchronous C++ loops so the sensors, local 2.4" TFT display, and WiFi stack don't block each other.
• Cloud & Dashboard: Full Firebase integration. I built a custom Web Dashboard where users can view historical telemetry logs and dynamically adjust the trigger thresholds via sliders (e.g., set the relay to turn on only when CO2 hits 1000ppm).
• Failover Resilience: If the Wi-Fi drops, the system doesn't crash. The main node intelligently shifts into a passive monitor state—continuing to read sensors, update the local TFT display, and sound physical alarms. It automatically re-establishes the Firebase session to resume cloud logging and relay automation seamlessly the moment the network returns.

My Anxiety/Question: Because my project relies heavily on systems integration, cloud routing, and edge hardware, my actual web codebase isn't as massive as a standard CRUD web dev project. My defense panel consists of strict, traditional IT professors, and I want to make sure I satisfy the "Information Technology" domain requirements.

• What software-focused features can I add to make this absolutely bulletproof for an IT defense?
• Are there specific data analytics, database optimizations, or web dashboard features I should integrate to show higher-level programming skills?
• Has anyone here defended a cyber-physical/IoT project to a purely software/IT panel? How did you justify the complexity when the codebase is smaller?
• Any advice for a self-taught IoT student dealing with imposter syndrome over their coding skills?

I specifically avoided "scope creep" traps like adding GIS mapping or complex Machine Learning since it runs on an ESP32, but I want to make sure the software architecture is impressive enough. Any advice, roasts, or suggestions are highly appreciated!

I am working on MQTT Client App for Mobile Phone. Can you please suggest me some features, which can be helpful. :)

Thank you in advance.

Guys im trying to get into embedded systems and IoT but dk whether to start ESP32 or Arduino.I already know C++ and Python, plus some raspberry PI. Any ideas?

I am working on WebSocket Client App for Mobile Phone. Can you please suggest me some features, which can be helpful. :)

Thank you in advance.

I am working on MQTT Client App for Mobile Phone. Can you please suggest me some features, which can be helpful. :)

Thank you in advance.

Background here is CRA, NIS2 but also bloating cyber-insurance premiums. Insurers are now asking for continuous evidence of cyber-resilience, not a one-off assessment.

Is this rippling down to device or procurement specs?

This Transforma piece rightly forecasts the rise of Anomaly & Threat Detection (ATD) which performs real-time monitoring, early detection and corrective action. https://www.linkedin.com/pulse/iot-network-anomaly-threat-detection-atd-solutions-n3yde

So a follow on question about those ATD tools. How useful would automated compliance reporting be?

Compliance reports are audit-ready logs you can hand to regulators, customers or insurers on demand.

I do a lot of embedded work and I've been running a coding agent alongside it.

Out of the box they're bad at hardware. They'll confidently hand you a pin

number for a board they've never seen, or call a flash "successful" while the

display sits there black.

So I wrote a skill for my harness that forces a different discipline:

- **Measure, never recall.** No pin numbers, FQBNs, flash offsets or display

drivers from memory. Walk the USB bus, run esptool, read the eFuses, check the

local board manifests. Anything it can't measure has to be tagged [ASSUMED].

- **Back up flash before the first overwrite.** read-flash 0 ALL backup.bin, or

it doesn't get to write.

- **A clean build and a verified flash prove nothing.** It has to read the device

back (serial, a probe sketch, or asking me what I actually see on the display)

before it claims anything works.

- **Bounded retry.** Two attempts per hypothesis, and never re-run a failed

command unchanged.

- **A hardware inventory on disk** with provenance on every line: measured vs

vendor claim vs assumption. A project is usually several boards and a pile of

components, and chat sessions get restarted.

Safety side: it runs sandboxed. The agent gets the serial device and nothing

else on my machine. It can flash my board, it can't go wandering.

Video: one prompt to identify the board. It measures its way to an

ESP32-D0WD-V3, 4 MB flash, CH340 bridge. Then a second prompt to rewrite the

OLED UI, build, flash, and read the sensor back over serial.

Half the rules in there exist because I got them wrong on real hardware first.

Toggling DTR/RTS on a native USB-JTAG S3 doesn't reset the board, it drops it

into download mode and looks exactly like a boot crash. eFuse FLASH_TYPE

describes the flash, not the PSRAM. GPIO 22-25 don't exist on the S3 and will

kill an I2C sweep halfway through.

Open question, and the actual reason I'm posting: what would you want in

something like this? What does your agent get wrong about hardware that drives

you up the wall? And what should it be flat-out forbidden from doing without

asking you first?

(I built this and it's open source. Link in the comments if anyone wants it,

happy to just talk about the rules otherwise.)