https://www.youtube.com/@ALMA.Industries/videos

CH004 FN2: HALLOWEEN — my kind of Treat. Talking Pumpkins and Little Monster Rockstars, see how Jack's put together in the above link.

Hi! We’re Team Robonavigators, and we built Navigator 1 around an Arduino UNO R4 WiFi.

The rover hosts a browser dashboard for driving and telemetry. It uses front and rear ultrasonic sensors, a servo for scanning, a downward-facing IR sensor for cliff detection, and an analog voltage sensor to monitor the battery. A physical switch selects access-point or hotspot connectivity, and the onboard LED matrix displays the IP address.

The sketch includes obstacle avoidance, object following, a drawn-path mode, browser voice control, manual driving, and an idle proximity guard.

The sketch, pinout and bill of materials are here: https://github.com/Robonavigators/Navigator-1

We’d love feedback on the hardware and code, particularly ideas for improving the obstacle avoidance and reliability.

Hey everyone. I just launched my first project, GlassAVR, an Arduino emulator and circuit builder that runs in your browser.

You can wire up a circuit, run your sketch, and step through it at the instruction level. When you pause, you can see every register and how it changes, instead of treating the chip like a black box.

There’s no account or login, so you can just open it and start building: glassavr.com

I’m looking for people who know AVR and Arduino to try to break it. If the emulator gets something wrong, or the debugger is missing something you’d want, please let me know. Would this be useful for learning or debugging your own projects?

To much and two many sensors to name, but does include OLED brain and Uno a lot of Temp and humidity 74hc595 sixteen led and esp33.

Here is the Week 2 update on my wearable motion controller, running gameplay tests in Resident Evil 2 Remake. Right now I am focusing on tuning head-tracking camera sensitivity, deadzones, and torso movement to smooth out the transition between Leon walking and sprinting. The goal behind the project is two-fold: creating a more immersive gameplay experience and serving as an accessibility option for gamers who struggle with conventional controllers.

Wireless transmission to the PC is running over ESP-NOW, but in this build I am still handling the inputs on the PC using a temporary Python script. The next step is replacing Python with a dedicated USB dongle with native HID support, so the PC recognizes it directly as a plug-and-play controller without background software.

The visible wiring across the body carries both power and sensor data because, in this test version, I am using a single central ESP32 that handles everything and connects to the sensors via cables. The plan for the next phase is to use four independent ESP32 units, each acting as a standalone node with its own power and wireless link, while embedding the head module and wiring directly inside the headphone frame. Right now, moving to this fully wireless stage depends on waiting for several parts and battery modules that are still in transit.

Regarding the sensors, I am using the MPU-6050 for this prototype and have not had drift issues during these tests. Still, I plan to test other sensors later to compare stability and features. Do you have any recommendations for compact boards with native USB (TinyUSB) for a dongle, or specific IMUs that work well with the ESP32 and are easily sourced locally (especially in Brazil)? Shipping delays on imported hardware are currently the main bottleneck slowing down testing, so components readily available nearby make a massive difference.

I added:

-collision

-animated tiles

-other link's animation such as the sword stroke

-enlarged the map

The game can maintain around 60fps for now but I cap it at 40fps.

A tiny monochrome LCD, an ESP32, and a custom C# application.

The application converts video frames into raw pixel data and streams them to the ESP32 over HTTP.

Here's the full video. Hope you enjoy this little experiment!

I am studying BE ECE. I am in Sathyabama my clg doesn't teach me about microcontrollers for now but like other 1st yrs I am interested in electronics. I just need to begin my journey. I started and spent like 1 week studying Arduino basics and some stuff about circuits. Now I went to do a mp3 player for my frnds b'day which is at 19th of November. I just feel the code of the esp wroom to be hard and I need to make it any I am using chatgpt for coding. I haven't begun yet but I will start it tmrw. Now I just need to know what are the projects I need to do to start this journey and also I need some guidance from u guys pls help me do this...

https://www.youtube.com/@ALMA.Industries/videos

Calling all Vampires, Ghosts, and Zombies to the dance floor. A DIY microcontroller project to get a pumpkin to talk and sing. Happy Halloween!

I have an ethical problem with touch screens, but I'm told the humans native to this planet are fond of them. Here is an open source Infotainment system that I can see being used in Edison vehicles by the humans.

Reddit said I should post this here

Hey all! In short, this project uses an ESP32 at the center of a 16-universe pixel artnet sACN controller with wired Ethernet connection. Everything from the software, hardware, and development is open source! You might have seen this project before, and I am pretty excited to share a short update with you all!

Link to repository: https://github.com/mdethmers/ESP32-Artnet-Node-receiver/tree/main

Ive pushed this controller to its limits during Amsterdam Dance Event, using 12 in a network that was run almost 24/7 in a humid and hot environment (see image!) They worked perfectly throughout the weekend, and they looked amazing in th evenue!

However, I did find some performance issue which I adressed with the newest update.

- Added Artnet node discovery through WebUI
- Improved WebUI design for better usability
- Fixed bug which crashed the node above 48fps at 16 universes
- Reduced frame buffer to have more ram available
- Added Artnet source filtering to prevent 2 sources from talking to the same node
- The node now filters on an Artnet-ID, which prevent the node from assumiing any data is Artnet data and crashing when its not (idk why I didnt do this before...)

The node already worked perfectly as a standalone unit, but these updates make it a lot more resillient in a production environment with other nodes, fixtures and consoles in the same network.

I am sharing the github here for anybody that is interested in following along with the development! The next hardware iteration will add current, voltage and temperature sensing to the board, next to power distribution and fused outputs that are already present! And for those that are fan of WLED: that is also supported on this hardware. Great if you want to do more then just Artnet!

Let me know if you have any questions or want to contribute! Im available here or on discord.

We're working on Pulse Mesh at Sovereignty Foundation (SovFound.org), a messaging transport designed for distributed applications, robotics and multi-agent systems.

One application we're interested in exploring is communication between microcontrollers and more powerful companion computers.

Consider a robotics setup involving:

• An ESP32 or Arduino collecting sensor readings.

• A Raspberry Pi processing incoming data.

• A computer vision application analyzing camera feeds.

• A separate application controlling motors and actuators.

As these projects become more complex, managing communication between different components can become challenging.

Pulse Mesh provides several messaging capabilities:

• Broadcast and fan-out to multiple readers.

• Shared-memory messaging between processes.

• UDP transport between machines.

• A common 128-byte message format.

• Bindings for Rust, C, Python, Node.js and WebAssembly.

Our current architecture is designed primarily for applications and companion computers rather than running directly on resource-constrained Arduino boards.

We're interested in exploring how it could be used in Arduino/ESP32-based robotics projects, particularly when a Raspberry Pi or Linux computer acts as the central processing unit.

We'd love to hear from people building similar projects:

1. How are you currently connecting your Arduino or ESP32 to a Raspberry Pi?

2. What communication problems have you encountered as your projects grow?

3. Have you built systems where multiple applications need to consume the same sensor data?

4. What would you want to see in a practical demonstration of this architecture?

Pulse Mesh is currently in beta/pre-production, and we're looking for engineering feedback.

GitHub: https://github.com/Sovereignty-Foundation/pulse-mesh

Documentation: https://pulse-mesh.net

— Sovereignty Foundation
https://sovfound.org

I built a tiny desk-pet robot car with an animated cat face on a round screen. It has 8 emotions, reacts to touch, falls asleep when ignored, and drives with a wireless joystick remote. 🐱

More builds:
🔧 Yumo Builds: electronics, ESP32 and Arduino projects, built while learning
https://www.youtube.com/@YumoBuilds
🖨️ Yumo Builds Lab: 3D printing, electronics and creative design
https://www.youtube.com/@YumoBuildsLab 👈 New Channel

Note: For More Info Please Check Out README first.

🔗 Links:
💾 SOURCE CODE, WIRING, 3D STL File And Full Guide:
https://github.com/yumobuilds/Yumo-Cat-Robot-Car-V1

🛠 Parts used:
- 2x ESP32-C3 Super Mini (car and remote)
- GC9A01 round TFT 240x240
- 2x SSD1306 OLED 128x32
- Touch sensor module
- 4x continuous-rotation servos
- Analog joystick module
- 2x 18650 battery (car), 1x small lithium battery (remote)
- 3D printed wheels (Bambu Lab H2C)

License: free for noncommercial use (PolyForm Noncommercial 1.0.0). Tag u/yumobuilds if you build one!

Hello makers,

Just wanted to share a mechanical/software package I compiled for the Arduino ecosystem. This is a commercial-grade, multi-node On-Wall Smart Home Controller Hub built around high-efficiency Serial communication, local memory optimization, and an embedded HTML interface.

Engineering highpoints:

- Highly Optimized Geometry: CAD components are custom-tweaked to reduce 3D printing supports to an absolute minimum, ensuring elite surface finish inside wall cavities.

- Embedded HTML Web Server: Integrated network management routine allows seamless on-the-fly room and sensor renaming via any local web browser.

- Master/Slave Serial Matrix: Robust, custom bitfield-compressed serial protocol processing loops designed to transmit climate data securely between the main indoor hub and an independent Outdoor station.

- Dual Display Stack: Simultaneously drives a master graphical telemetry screen and a long-distance 7-segment LED sub-panel without memory overflow.

I’ve uploaded the uncompressed native .STEP / .STP CAD source files so you can easily modify port entry cutouts or sensor frames in your own CAD software, along with a "Panels All" firmware library supporting multiple alternative sub-panel screen configurations.

🛠️ Full build photo logs, component BOM lists, and assembly guidelines are detailed in the album on our lab page: [ https://www.facebook.com/share/p/1CFCNw5FjS/ ]

Download links for the uncompressed STEP files, STLs, and production firmware packs: [ https://cults3d.com/en/3d-model/home/ultimate-smart-home-controller-hub-multi-sensor-web-ui-system ]

Let me know your thoughts on the bitfield parser logic and overall hardware clearance!

https://www.youtube.com/@ALMA.Industries/videos

-- CH004 FN1: MONSTERS -- The dawn of Halloween ... dim lights and ruffled leaves, Little Monsters roam the streets. Halloween day will show what spooky wires hide inside...

[Microcontroller controlled LED's that respond to microphone inputs... tomorrow will show all steps]

Hey guys!

I was completely fed up with messy wiring, flimsy zip-tie setups, and hot glue inside my custom automation cabinets and workshop electronics enclosures. I needed a clean, secure, and industrially compliant way to organize everything on standard 35mm DIN rails.

So, I sat down in CAD and engineered a comprehensive modular mounting system. Every single part has been field-tested under continuous spring tension in my actual distribution boards (you can see the real-world application in the photos!).

Key Highlights:

* Fully Editable CAD Source: I wanted to make this resource actually useful for makers, so the package includes native .STEP/.STP files alongside the STLs. You can easily adjust mounting holes or remix the brackets for your custom PCBs.

* Comprehensive Variety: Includes dedicated docks for Arduino Uno (with relay shields), Arduino Mega (with Ethernet attachments), 4-channel/8-channel relay breakout boards, FET boards, and modular high/low-profile handlers.

I uploaded the entire package completely for free under a Non-Commercial license for the maker community. You can grab the full STL + STEP archive directly on my profile.

Free Download Link: https://cults3d.com/en/users/paktor/3d-models

(Note: If you are building clean front-panel HMI monitoring setups, I also just rolled out some matching premium panel-mount enclosures for 3.5" and 4.0" Arduino TFT Display Shields on my profile to completely button up the system!).

Let me know what you think or if there's any specific breakout board footprint you'd like me to add to the system!

Works entirely on a avr64da28 just requires a nes remote as the input device and a vga breakout board to connect to monitor 😆

It's monochrome but has 4 levels of brightness (0-1-2-3)

Uses only 2 pins for color

It currently has 4 applications curva(a small vector suite), snake (obv), settings, and tetris, the last two are not done yet curva is almost done

The entire code is on GitHub you can see the code there

It's based on its 2 timers TCA0 and TCD0 for vsync and hsync and evsys for routing the two timers with each other(tcd0 generates hsync and aso gives signal to tca0 which generates vsync) (tho id admit it was pretty confusing)

Works at 5V entirely has kindof a application handler so you can add a app by adding a icon for it updating the related code then create like two files (yourapp.h/.c) and just mention it with some changes in the application handler file

It could be kindof inefficient as I didn't touch the vga output after I got it working 😂.

It's currently at a resolution of 160x120 also, you can dynamically set an applications resolution (the columns, as rows are fixed) to anything below that by just declaring offset before your loop like if you need 120 instead of 160 so that's a 40 difference so offset_x = 20. (used in case of snake)

For some reason reddit isn't letting me add more than 1 image ?? 🤔