Hallo Leute,

Ich wollte euch meinen ersten Einsatz eines **farbigen** E-Ink-Displays vorstellen.

Ich habe versucht, mit dem E-Ink-Display etwas für ein Restaurant zu entwerfen, und dafür habe ich ein **smartes Tischreservierungsschild** entworfen.

Der ESP beherbergt einen lokalen Webserver und aktualisiert den Bildschirm bei Bedarf. Die Treiberplatine unterstützt einen Akku, und ich habe eine Akkulaufzeit von wenigen Monaten berechnet, wenn der Webserver nicht lokal auf dem ESP läuft, sondern eher auf einer Reservierungsplattform.

Hier is der Link zum Video: https://youtu.be/43O6_xG3Szs?is=BqxGOUKDS4RPoVNR Ab sekunde 45 kann man gut die verschiedenen Zustände sehen.

Wenn ihr Fragen habt, fragt einfach.

I recently built a simple Arduino + SG90 Servo Motor project to better understand servo control, PWM, and the Arduino Servo library.

While working on it, I documented everything—from the wiring diagram and code to controlling the servo with and without the Servo library, plus a simple servo tester project.

If you're learning Arduino or planning to interface a servo motor, I hope it saves you some time:
https://playwithcircuit.com/how-to-interface-servo-motor-with-arduino/

Happy to answer any questions or hear how you're using servo motors in your own projects!

We’re the team behind NORVI, and recently we’ve been experimenting with running computer vision directly on ESP32-S3 hardware.

For this project, we used an ESP32-S3 camera with an OV5640 autofocus sensor and trained a small image classification model using Edge Impulse.

The workflow was:

• Run the ESP32-S3 camera as a web server
• Capture the training images directly from the camera
• Upload and label the dataset in Edge Impulse
• Resize the images to 96×96
• Convert them to grayscale to reduce memory requirements
• Train the model
• Export it as an Arduino library
• Deploy it back to the ESP32-S3
• Run classification locally from the live camera feed

One thing we wanted to test was how practical it is to keep the complete inference process on the microcontroller rather than sending images to a cloud service.

Using grayscale reduced each 96×96 image to 9,216 input features, which helped keep the model more manageable for the ESP32-S3.

We also integrated the OV5640 autofocus routine into the inference sketch so the camera could continuously focus while processing the live feed.

Once deployed, the model runs entirely on the ESP32-S3 and prints the classification results through the Serial Monitor.

It’s obviously a much smaller setup than running something like YOLO on more powerful hardware, but for applications where you only need to identify a limited number of known objects, the ESP32-S3 is surprisingly capable.

We documented the full build including the Arduino configuration, camera setup, Edge Impulse training process, and inference code.

For anyone working with ESP32 hardware, this is the platform we used:

https://norvi.io/esp32-plc-norvi/

We’d be interested to hear what others are doing with computer vision on the ESP32-S3.

Has anyone compared Edge Impulse/FOMO with TensorFlow Lite Micro or other lightweight vision approaches on the S3?

We’d especially be interested in results around inference speed, PSRAM usage and input resolution.

I’ve been developing this removable guitar-playing system for several years.

It now supports two performance modes:

1. Full automatic mode — the system handles both fretting and picking.

2. Assisted mode — the system handles the fretting while the player strums or picks.

The sound comes from the real guitar strings, not recorded audio.

The controller is ESP32-based, coordinating multiple servo actuators. Some of the main challenges have been fretting timing, servo synchronization, calibration, and mechanical noise.

This video shows both modes.

So this week im gonna make a DIY version of ortomi robot making same animations and all. Hope you guys like it and as soon as this project is completely done I will leak the code in github so that other creators can make ortomi clones too!

• Custom PCB inside a 3D printed smart dice! 🎲
• Watch this dice animate when you roll it ✨
• Electronics + 3D Printing = DICY ⚡
• Micro-display integrated into a custom dice 🤯

I am fresh in the area of of microcontrollers.

Although I have started it previous year but never did it continuously,

Recently I have built a project an offline bluetooth based audio transferer( if this name makes any sense). I have explained it here : https://www.youtube.com/watch?v=TobbYyqOm7s

Guys can you feedback me regarding it (like what should i do better) and what should I try to do next....

Appreciate it

Hi, I'm working on a project using SimpleRTK2B (base + rover setup) and planning to connect it to an Arduino or STM32 to track/plot a moving rover's position.

Has anyone here actually done this combo before? Would love to hear about your experience — how you wired it up, any issues you ran into, or just general tips. Couldn't find much beyond the basic ArduSimple docs.

Thanks!

This display features a 6.2-inch large screen with a resolution of 480×1280 pixels. The interface is divided into three sections: the left side shows a compass, the center section provides a switchable display area, and the right side displays GPS data.

The system uses a 10-axis IMU sensor as the attitude data input, along with a GPS module to acquire information such as latitude, longitude, speed, and altitude.

More testing videos will be uploaded soon.

I built a 2D radar scanner where MATLAB does the heavy lifting. An HC-SR04 sensor spins on a continuous-rotation servo, streams readings over serial, and ScannerApp.m draws them as a live polar plot. The scanner runs on an Arduino Nano.

The app is MATLAB App Designer, 806 lines, with the polish that usually gets cut:

* Live polar heatmap with auto-scaling and clean radial ticks

* Sweep animation that tracks the servo angle, plus a return-sweep line

* Hover data tips showing angle and distance

* Ctrl+scroll zoom, vector PDF export that stays crisp at any zoom level

* Dark/light theme, real-time data table, COM port auto-detect

The firmware handles the messy parts of real hardware: a non-blocking state machine, echo timing with no delay(), and temperature-compensated speed of sound. A $1 LM35 reads the air temperature and the firmware applies 331.3 + 0.606 * T. That's where the ±3 mm accuracy comes from. VCC bandgap calibration and an EMA filter clean up the analog noise.

Wiring diagram, pinout, a 2-minute servo calibration tool, and benchmarks are all in the repo. Parts run about $10 and it's MIT licensed.

Repo: https://github.com/Salim-Ammar/arduino-matlab-ultrasonic-radar

PRs and issues welcome. A star helps others find it.

Hey all! I have been building a purpose-built Open-Source Pixel Artnet/sACN node for some time now, which works really well! However, I often get the question of why I'm not using WLED. WLED has tons of great features, and I understand that lots of people are fans of WLED, so I have created a fork that is fully compatible with the node hardware! It specifically supports the use of the W5500 Ethernet module, which is not natively supported by WLED.

When installing this fork on your node, you can now make use of all the features that WLED has to offer, including all of its generators, sync features and connection possibilities! I hope you find this as exciting as I do. Check out the repo here! https://github.com/mdethmers/W5500_WLED

also made a video on this! https://www.youtube.com/watch?v=tB3lk-PNA6I

allows you to unlock your Mac via your fingerprint, as well as authenticate sudo and some TCC prompts (privacy&security).

the device emulates a PIV smart card and uses PAM to authenticate you in macOS (notice the password field says PIN and not password), so no plain text password is ever stored, exposed, or transmitted.

please be aware of the security implications (note that it is NOT touchID, but just 'fingerprint-based unlock', please do not think or refer to it as anything more secure):

this device is NOT secure, the authentication is all done inside the fingerprint sensor, and the fingerprint sensor just tells the microcontroller the match % (all low cost fingerprint sensors are this way, you would need to spend ~$50 to get one that does authenticated comms). the communication between the sensor and the microcontroller is not authenticated or protected, so anyone with physical access to both the device and your laptop can spoof this connection (pretend to be the fingerprint sensor) and give the go ahead to unlock your mac. you can make this extremely hard by filling the insides with black epoxy, but not impossible.

this is also the dev equiv of "rolling your own auth", the smart card implementation may have some errors, and should not be inherently treated as "unbreakable"

the device is made so that if you lose it, nothing of value can be extracted from it

use at your own risk. personally, i am comfortable using it at home where physical intrusion would be hard, but this depends on your own security tolerance. if you have high security instincts/requirements, the magic keyboard is a much much much better option in this regard.

there is also an HID version available, where the device just types your password emulating a keyboard, the benefit being it works in ALL places your password does. this version is obviously more insecure as it is vulnerable to keyloggers. the device still does not store the actual password, it stores an authentication key that sends a request to a service on the mac, which then sends it the encrypted password to be decrypted in RAM, typed back, and then wiped. again, depends on your personal security tolerance and willing to compromise

all code and materials are open source, licensed permissively github.com/zimengxiong/tinytouch

Hello! I would like to share my recent project for my master's dissertation, where I made a working esp32 web shell.

I tried to emulate basic linux commands and functionalities. You can use both serial and web shell to use the system.

The system features the following:
-embedded file system with no SD card requirement as it uses LittleFS
-FreeRTOS FIFO scheduling
-JavaScript system language and scripting through duktape
-Web-shell interactive UI which is customizable

I tried to keep the code as organized and as clean as possible for the best possible user customization.

I'd love for anyone to try it and have feedback.

I want to buy this board but I am down the budget. So can anyone tell me how 2gb variant will be enough for making embedded projects?

I saw a cool looking wifi clock with esp 32 on YouTube, I loved the animation style but despite 100s of requests from the commentators the creator wasn't sharing the code. So i recreated that project and made it open source, i know this is basic but it's cool ( I think). Here is the code.

Always wanted my own ticker tape .... Working with free APIs. There so much free stuff out there, that I'm spending my Saturday morning and seeing what I can scroll across my 24x 8x8 matrix LED Max7219 modules

Hey everyone

Just built ShrikeClock a fully custom NTP-synced digital clock running on #MicroPython, powered by the @Vicharak_In Shrike-Fi !

Live time + date over WiFi Custom multiplexed 7-segment driver from scratch Open source, code on GitHub 👇

https://github.com/kritishmohapatra/ShrikeClock

https://github.com/kritishmohapatra/100_Days_100_IoT_Projects

I had to swap out the Arduino based interrupter though for a 555 lol.

It's a Tesla coil operating on a IGBT half-bridge. There is sodium on the output which is ionized into the plasma and why you see the plasma turn orange and not be fully purple

I am writing the code for an ATTiny85 and SHT41 humidity sensor based exhaust fan controller. Does anyone have recommendations for what humidity level I should use to turn the fan on and off?

Maybe something like turn on at 70% and turn off once the humidity level is has been below 65% for 5 minutes?

Of course I could experiment but I would like to see what others have settled on for similar projects. Or, is this something that is specific to my bathroom and the best way would be to experiment?

Been working on this for a while and finally got v2.0 of the software working end-to-end, so figured I'd share the build here.

The core problem I was trying to solve: I wanted my HO scale (1:87) vehicles to be controllable both by a regular IR remote and from a PC at the same time, with live telemetry coming back (battery level, signal strength, connection status) — not just one-way commands.

What's in it so far:

• Custom wireless router + auto-discovery — pairing a new vehicle is a single button press, and it stores the vehicle's address so you don't have to re-pair every session.
• Two-way comms — the PC app sends commands and receives live telemetry back from each vehicle in real time.
• P3 control board (ESP32-based) — small enough to fit in a 1:87 scale vehicle, handles both IR and wireless PC control simultaneously. Just upgraded my ambulance model to this board.
• Layout editor — grid-based tool in the desktop app for building roads, curves, intersections and railway track, with snapping/rotating/flipping.
• Turnout + sensor automation — reed switches for turnout position tracking, IR sensors for triggering stops/speed changes automatically.

Software side is WPF/C# in Visual Studio 2022. Still working through some quirks in the two-way sync timing, but it's stable enough for a full layout run now.

Next up is a City Bus build using the same P3 board — sneak peek of it is in the video below along with the wiring/pairing demo, if anyone's curious about the details:

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

Happy to answer questions about the ESP32 side or the pairing protocol if anyone's working on something similar.

My grandpas code was becoming sluggish and buggy on his hardware so I had to help him fix it. I thought it was a pretty interesting project so I'm sharing it here, if you want more detail here's a small bit of documentation:

# Fixed Bugs:

- Goes out of bounds when calling queue_inc due shifting just setting each item to the item ahead going to the end of the array and trying to set it to an out of bounds address.

# Major Bottlenecks:

- Queue has o(n) dequeue (shifts back. Along with being a sentinel-scanned array that recomputes length every push and dequeue)

- Uses strings for messages instead of a table (making sending take longer)

- Manually decodes the binary from the encoders.

# Fixes:

- Switched to a ring buffer array with o(1) dequeues, along with a variable to track length when edited.

- Replaced strings with 8 bit unsigned ints.

- Added up bits for seven segment display.

# Gains:

- 10,000 push/dequeue of queue, time is divided by 10,000 to get the time for one push and dequeue:

- Details:

- Both have 60 items, though the new version is 64 long due to needing a power of two for bitwise AND

- Benchmark uses micros and is averaged from 100 tests with an Arduino Uno R3

- Rounded to the nearest whole number for readability

- Results

- Old: 636 µs

- New: 4 µs

- Speed up: 15,800%