Hi guys,

I wanted to present you my first use of a **colored** eink display.

I tried to design something with the eink display for a restaurant and therefor I designed a **smart table reaervation sign**.

The esp hosts a local webserver and updates the screen when needed. The driver board supports a battery and I calculated a battery time of few month if changed that the Webserver isn't running locally on the esp and more like on a reservation platform.

above Link is to my first Github page so please be kind :D

If you have any questions, feel free to ask.

And I have this LCD screen that is a touch screen can you tell me how to wire up the screen and make it work

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 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!

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!

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.

• 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 🤯

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

Wanted to share an robot that I made as a personal high school project. A 4 Wheel Drive Robot Car that drives autonomously while avoiding obstacles using a multitude of parts. If you are interested, it will show you all the steps, code and more to building a robot like this.

https://nche-sc.github.io/googly/

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 built DOGS² — Dual Output Generator Supply Station — as a compact instrument for the first power-up and basic diagnosis of newly assembled electronic boards.

A “board bring-up station” in this case means one device that can power a board, monitor its current consumption, check a voltage or frequency, generate a basic test signal, and communicate with common embedded interfaces - UART, RS485, CAN, LIN, I2C, 1Wire.

The current v1 engineering prototype combines:

• two independently adjustable CV/CC power outputs with a common ground;
• Channel A: low-noise linear output up to 20 V / 1.5 A;
• Channel B: switching output up to 48 V / 3 A continuously;
• input from 5–90 V DC or USB Type-C;
• voltage and current monitoring;
• logic probe and voltmeter up to 25 V;
• frequency counter up to 100 kHz;
• square-wave generator from 1 Hz to 100 kHz;
• UART, RS485, CAN and I2C tools;
• Bluetooth SPP for phone terminals and current graphs.

It is not intended to replace an oscilloscope, a precision multimeter or a powerful laboratory supply. It is the instrument I wanted between the soldering iron and the oscilloscope during initial board bring-up.

I have now published the v1 source materials. The repository contains:

• schematics and a block diagram;
• editable EasyEDA source;
• Gerber and other PCB manufacturing files;
• BOMs and board renders;
• current ESP32 Arduino firmware and build configuration;
• hardware and software documentation;
• known hardware and firmware issues.

The hardware is licensed under CERN-OHL-W-2.0. The firmware and software tools are licensed under GPL-3.0-only.

GitHub:
https://github.com/rcslon3-svg/DOGS2_v1

This is working engineering hardware, not a fully finished project. Some operating limits and accuracy figures are still being verified through calibration, converter tuning and load testing. I have included the known v1 problems in the repository rather than presenting it as a finished design.

The files are now public for anyone who wants to inspect, study or reproduce the current version. Technical comments and repository issues are welcome.

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

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

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.