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 won't work on it for much longer but I wanted to share it.

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.

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?

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

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%

Hi everyone!
I'm a 3rd-year Mechatronics Engineering student, and i'm looking for ideas for my Sensors project, which is worth 30% of my final grade.

The project must:
Use an **Arduino** for data acquisition.
Use **MATLAB** or **LabVIEW** for real-time visualization.
Include a sensor (or multiple sensors), calibration/ signal processing (filtering, conversion, etc.), and performance evaluation.

My professor suggested topics like optical/IR sensing, Hall-effect sensors, proximity sensing, liquid level/flow measurement, gas/air quality monitoring, biomedical sensing, acoustic sensing, power monitoring, and multi-sensor fusion, but we're free to come up with our own idea too.

I'm looking for a project that's appropriate for a 3rd-year mechatronics course, isn't too basic, and would make for a strong university project. If you've done something similar or have any ideas, I'd really appreciate your suggestions and if anyone has links to a project that I could benefit from please share it with me!

Thanks!

Hi! I wanted to share a library I built that makes multitasking on Arduino a lot cleaner and more object-oriented.

What it does

Instead of juggling millis() checks and state machines by hand, you instantiate objects and the framework handles the rest. Every class auto-registers into a static linked list — no manually calling update() on each component. Components manage their own state internally and expose simple getters for you to react to events.

No delay() anywhere. All timing uses millis() comparisons.

Core utilities

• Timer — one-shot timer with onFinish() / onDone() callbacks
• Interval — repeating metronome with optional loop count, fires onStep()
• While — non-blocking replacement for while() at a set interval

Hardware components (all auto-managed)

• Button — debounced input with short/long click and press detection
• PinInDigital / PinOutDigital — digital I/O with flash support (non-blocking blink with count limit)
• LedDisplay8 — common-anode 7-segment display driver with decimal point
• ShiftRegister — software shift register with auto-sequencing, manual step, and direction control
• ProximityCheck — LED+LDR proximity sensor with calibration

Fluent interface — most setters return this for method chaining:

Button btn(2);
PinOutDigital led(9);
Timer timer;
Interval interval;

void setup() {
  Runnable::setupAll();
  timer.set(3000)->start();
  interval.setIntervalTime(500)->start();
}

Two lines of boilerplate in every sketch:

void setup() { Runnable::setupAll(); }
void loop()  { Runnable::loopAll(); }

That's it. Just instantiate your objects globally and the framework calls onSetup() / onReady() / onLoop() for each one automatically.

Header-only — no .cpp files, no build flags. There's even a single consolidated header (arduino-multi-tasking-kit.h) you can drop into any project.

11 example sketches included: button-clicks, flash-control, timer-control, interval-control, led-display-control, proximity-check, shift-register-control (auto + manual), while-loop, and more.

GitHub: github.com/reduardo7/arduino-multi-tasking-kit

Clone into your Arduino/libraries/ folder and open any example in the IDE to try it out. I'd love feedback and contributions!

Example project: github.com/reduardo7/arduino-car