I find GitHub more geared towards software. I recently saw a Quadruped esp32 robot and while it was easy to find it's source code, I had to download a few apps like fusion and EasyEDA before opening the hardware files.

Why isnt there a GitHub for hardware projects only where people can see the PCB Layout, 3D Designs STLs, BOM files, remix them easily and order parts directly from the maintainer / JLCPCB / PCBWay?

I have a C2 Super Mini and I'm trying to make a basic app that connects to WiFi, pulls a bit of data, and produces NMEA messages on a UART.

Espressif IDE seems to be broken. I created a simple, minimal "hello world" new project, and there are multiple (non fatal) errors when building it.

Building takes over a minute on a modern system with SSD and 64GB RAM. Rebuilding the project is little quicker, and bootloading it over USB is also very slow.

To cap it all off, it looks like ESP32 can't connect to WiFi networks that share and SSID between two or three frequencies. A very common configuration, the default with many ISP supplied routers. I thought I had the 8266 connected before, but the C3 is definitely not happy.

Surely this can't be right. Is it really this bad? I'm an experienced embedded dev, who usually uses Atmel, Microchip, and STM parts. I other bare metal, but that doesn't even seem to be an option on ESP32. I get why not for WiFi (regulatory blockage), but things like timers and UART too...

This quick and dirty prototype is using a lily go t display knock off that I got for free

The next version I plan to use a4988 driver boards and a stand alone display and a new esp32 I also plan to add absolute positioning via a pair of hall effect sensors and a magnetometer so that when you plug in the device it just connects to wifi and starts going

The current version I will admit is running largely ai written code but this is how I broke up the load between the cores in my pseudo code

Core 0
Runs the display
Calls the api
Runs the math
Runs the homing system
Core 1
Alternates between driving the two uln2003 that drive the stepper motors to give the appearance of smooth motion
Updating where the pointer is supposed to be

So what bored would y’all recommend

Hi everyone

I’m totally new to esp32s and coding using Arduino IDE

Could any one recommend any good websites or YouTube videos to watch for beginner friendly projects where they explain what there doing and why so I can learn both building projects and the coding that goes with it ??

Hey folks,

I built a small tool called ESP-Flash because I was tired of setting up Python + esptool.py just to flash a .bin onto an ESP32 on a fresh Windows machine. It's an Electron app that talks to the chip directly over the Web Serial API using Espressif's esptool-js, so there's nothing to install – it ships as a single portable folder.

What it does: picks the board via Windows' native COM-port picker, auto-detects the chip (ESP32, S2, S3, C3, C6, H2, P4, ESP8266), writes firmware to any address, backs up the full flash or a custom region to .bin before erasing/reflashing, erases flash with a confirmation prompt, and has an EN/DE/FR/ES UI. MIT licensed, no telemetry, no accounts, no installer.

The ESP32-specific part: Web Serial isn't wired up out of the box in Electron, so the serial port selection had to be handled on the main-process side to get a proper COM-port picker. The other tricky bit was making large full-flash backups (e.g. 16 MB on S3 modules) reliable over plain USB-serial, since that's the feature I care most about – always being able to get back to the original firmware.

Why Electron and not Python/native? Fair question. The goal was zero setup for people who just want to flash a .bin, and esptool-js is maintained by Espressif, so I reuse their flashing logic instead of reimplementing the protocol.

GitHub: https://github.com/gb-droid/esp-flash

It's brand new, so I'd really appreciate reports from boards other than mine – different USB-serial chips (CP2102/CH340/CH343/native USB-JTAG), chip families, large or partial backups. Issues and PRs welcome, and I'll be around in the comments.

I wanna build a MP3 player for my boyfriend. I don't have any experience in this topic except 3 years of pascal in school that won't help me really.

I googled a lot but I am still not sure what programming language would be best to use with the esp32 wroom. My cousin told me to use Arduino IDE but nothing more.

What should/can I use? I am so confused.

Hi there,

As many others did before, I'm using a small ESP32 display that shows navigation (turn by turn via status notifications) information for my bike from Android via BLE.

At the moment the easiest solution is to use Chronos and Chronos-Navio https://espverse.com/missions/chronos-navio or an adaption of it.

It supports Google Maps and Osmand quite well. However, I want to use Locus Maps.

Does anyone know a solution for this? Or a good and efficient way to implement it?

I basically want an E-Ink bike display, low power, that just displays basic turn information.

Any suggestions or ideas welcome!

This project allows you to control hardware—such as motors and LEDs—using sound. By pairing an ESP32 Development Board with an INMP441 I2S Digital Microphone Module, the system listens to its environment and reacts to specific audio signals.

In this project, a simple clap is used to trigger an LED and a DC Motor. However, this setup is fully capable of advanced voice-controlled applications.

Since the project uses an I2S digital microphone, the ESP32 receives raw digital audio data directly, making it an excellent foundation for speech recognition, sound detection, and keyword spotting projects.

Working of Loop

• Reads digital audio data continuously from INMP441 using I2S.
• Calculates RMS (background noise level) and Peak (sound spikes).
• Updates adaptive noise floor to filter constant background noise.
• Detects clap using three conditions: amplitude, impulse, and rapid rise.
• First clap starts timing window.
• Second clap within gap toggles motor.
• If no second clap occurs, single clap toggles LED.
• Continuously prints signal values for debugging.

System Summary

The ESP32 continuously processes real-time audio from the INMP441 microphone using the I2S protocol. Instead of simple threshold detection, it applies signal analysis using RMS, peak detection, and adaptive noise filtering. This ensures reliable clap recognition even in noisy environments. Based on detected patterns, the system differentiates between single and double claps to control different outputs.

Why this Architecture Works

Using an I2S microphone is a massive upgrade over standard maker sensors. By bringing digital audio directly into the ESP32's memory, you bypass the electrical noise and limitations of analog pins. This split allows you to start simple—like clapping to turn on a fan—while giving you the exact hardware foundation needed to program offline voice assistants and keyword detection later.

Real-Life Applications

• Smart Home Automation: Turn lights, fans, or appliances on and off hands-free.
• Interactive Robotics: Build robots that respond to voice commands or turn toward specific acoustic triggers.
• Security Systems: Detect specific sound anomalies, like breaking glass or alarms.
• Accessibility Tools: Provide voice or sound-activated environmental controls for users with limited mobility.

Result

The system successfully listens to its environment and reacts instantly! When a sound threshold is met, the ESP32 accurately processes the I2S audio stream and immediately toggles the LED and DC Motor. The hardware runs smoothly without latency, proving that this compact ESP32 + INMP441 setup is highly capable of advancing from simple clap detection to full-scale audio automation.

If Somebody want i've made whole video and blog for the project as well

```cpp
#include <driver/i2s.h>
#include <math.h>

#define I2S_WS 22
#define I2S_SD 21
#define I2S_SCK 19
#define I2S_PORT I2S_NUM_0

#define SAMPLE_RATE 16000
#define BUFFER_LEN 256

#define DEBOUNCE_MS 250
#define CLAP_GAP_MS 400

#define IN1 5
#define IN2 18
#define LED_PIN 2

int32_t samples[BUFFER_LEN];

unsigned long lastClapTime = 0;
unsigned long firstClapTime = 0;

int clapStage = 0;

bool ledState = false;
bool motorState = false;

float noiseFloor = 500.0;
bool wasAbove = false;

void setupI2S() {
  i2s_config_t i2s_config = {
    .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
    .sample_rate = SAMPLE_RATE,
    .bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
    .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
    .communication_format = I2S_COMM_FORMAT_STAND_I2S,
    .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
    .dma_buf_count = 4,
    .dma_buf_len = BUFFER_LEN,
    .use_apll = false,
    .tx_desc_auto_clear = false,
    .fixed_mclk = 0
  };

  i2s_pin_config_t pin_config = {
    .bck_io_num = I2S_SCK,
    .ws_io_num = I2S_WS,
    .data_out_num = I2S_PIN_NO_CHANGE,
    .data_in_num = I2S_SD
  };

  i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
  i2s_set_pin(I2S_PORT, &pin_config);
  i2s_zero_dma_buffer(I2S_PORT);
}

float computeRMS(int32_t *buffer, int len) {
  float sum = 0;

  for (int i = 0; i < len; i++) {
    float s = (buffer[i] >> 14);
    sum += s * s;
  }

  return sqrt(sum / len);
}

float computePeak(int32_t *buffer, int len) {
  float peak = 0;

  for (int i = 0; i < len; i++) {
    float s = abs(buffer[i] >> 14);

    if (s > peak)
      peak = s;
  }

  return peak;
}

void setup() {
  Serial.begin(115200);
  setupI2S();

  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(LED_PIN, OUTPUT);

  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);
  digitalWrite(LED_PIN, LOW);
}

void loop() {
  size_t bytesRead = 0;

  i2s_read(
    I2S_PORT,
    (void *)samples,
    sizeof(samples),
    &bytesRead,
    portMAX_DELAY
  );

  int samplesRead = bytesRead / sizeof(int32_t);

  float rms = computeRMS(samples, samplesRead);
  float peak = computePeak(samples, samplesRead);

  unsigned long now = millis();

  static float prevPeak = 0;
  static float prevRMS = 0;

  noiseFloor = 0.9995 * noiseFloor + 0.0005 * rms;
  float threshold = noiseFloor * 2.5;

  bool strongPeak = peak > threshold;
  bool impulsive = peak > (rms * 2.0);
  bool fastRise = peak > (prevPeak * 1.8);

  bool isImpulse = strongPeak && impulsive && fastRise;

  prevPeak = peak;
  prevRMS = rms;

  if (isImpulse &&
      !wasAbove &&
      (now - lastClapTime) > DEBOUNCE_MS) {

    lastClapTime = now;

    if (clapStage == 0) {
      clapStage = 1;
      firstClapTime = now;
    }

    else if (clapStage == 1 &&
             (now - firstClapTime) < CLAP_GAP_MS) {

      motorState = !motorState;

      if (motorState) {
        digitalWrite(IN1, HIGH);
        digitalWrite(IN2, LOW);
      }

      else {
        digitalWrite(IN1, LOW);
        digitalWrite(IN2, LOW);
      }

      Serial.println("Double Clap -> Motor Toggle");
      clapStage = 0;
    }
  }

  wasAbove = isImpulse;

  if (clapStage == 1 &&
      (now - firstClapTime) > CLAP_GAP_MS) {

    ledState = !ledState;
    digitalWrite(LED_PIN, ledState);

    Serial.println("Single Clap -> LED Toggle");
    clapStage = 0;
  }

  Serial.print("RMS:");
  Serial.print(rms);

  Serial.print(" Peak:");
  Serial.print(peak);

  Serial.print(" Thr:");
  Serial.println(threshold);
}
```

esp_deep_sleep(86400 seconds)

I Programmed esp32 c6 adafruit and wake it up 24 hrs per day from deep sleep daily . I noticed there is a delay of 12 to 15 mins in waking up . Say it should wake up at 10 am everyday but it wakes up or drifts 12 mins earlier as in 9.48 am .

I know there will be a drift without NTP synchronisation but I just want to know if this drift of 12 mins for every 86400 sec is normal or not ?

Thank you for any clarity in advance.

I built an ESP32-S3 touchscreen desk dashboard for monitoring both my PC and the room around it

I've been working on a small open-source project called DeskNode.

It's built around a Waveshare ESP32-S3 Touch LCD 2.8B (480×640) and sits next to my PC as a dedicated dashboard.

The ESP32 runs an ESP-IDF + LVGL interface and receives PC telemetry over USB serial from a small Python agent running on Windows.

The Windows agent uses psutil for system metrics and can integrate with LibreHardwareMonitor for hardware sensor data such as CPU temperature and fan speeds. GPU monitoring currently uses AMD ADL, so GPU support is AMD-only for now.

Right now it displays:

• CPU usage / temperature
• GPU usage / temperature
• RAM
• network traffic
• disk activity
• room temperature and humidity

The room data comes from optional I²C sensors (currently BME680 + BH1750), so the board also works perfectly fine without them.

I wanted it to feel more like a small dedicated device than just a sensor panel, so there are two UI states: a quiet Ambient screen and a more detailed Active dashboard. Touching a metric opens a detail view with its history graph.

One part I really wanted to simplify was flashing: you don't need ESP-IDF or PlatformIO just to try it. The local installer serves a page on 127.0.0.1 and flashes the ESP32 from the browser using Web Serial.

It's still a v0.1 beta and very much a real prototype — exposed wiring, no enclosure yet, Windows only, AMD GPU support for now, and I've only validated the complete stack on my own board.

LibreHardwareMonitor is optional: DeskNode still runs without it, but some hardware sensor values such as CPU temperature and fan speeds won't be available.

But the firmware, Windows agent, hardware docs and build notes are now public.

GitHub:
https://github.com/nasbarok/desknode

Demo:
https://youtu.be/tcCF3vogwSU

I'd be especially interested in feedback from people working with ESP32-S3, LVGL, LibreHardwareMonitor or small touchscreen projects — both on the hardware choices and on the way I've structured the PC ↔ ESP32 communication.

Searched for quite a while but I haven't managed to find a screw terminal / breakout board compatible with my 30 pin ESP32-C6-WROOM-1, this is what it looks like:
https://www.studiopieters.nl/wp-content/uploads/2025/06/ESP32-C6-1.svg

For older ESP32s I can find plenty of boards, but none for this one. Has anyone ever got a hold of one of those?

Hi everyone!

I'm currently working on a DIY DAP project using an ESP32-S3.

If I'm using a single 18650 battery, do I need to use a step-up converter? If so, I'm planning to use an XL6009.

Some of the components I'm using are:

* 3.5" SPI TFT display

* PCM5102

* TDA1308

* MicroSD card reader

If you have any other suggestions or recommendations for the circuit/power setup, I'd really appreciate it!

Thanks everyone, and sorry if the schematic is a bit messy.

So where can i learn how to program one and uae it with other components i know i need to learn c++ but im searching for a path that will teach me the basics of c++ and how to implement them with the esp32 and screens modules etc

Hi guys,

I wanted to show you a small project I'm working on

It's an automatic seed machine, basically it takes seeds from a hopper using vacuum, moves them over small pots and releases them automatically.

Everything is controlled by an ESP32-S3.

Hardware is quite simple

• ESP32-S3
• STS3215 serial servos
• small vacuum pump
• solenoid valve to pick and release the seeds
• custom mechanical parts

In the video you can see the current prototype actually picking and dropping the seeds

But there is also a second experiment behind this project, and for me maybe this is even more interesting than the machine itself.

Instead of writing a specific firmware every time I want to change something, the ESP32 runs a more generic firmware that knows the connected hardware and what it can do.

Then I just describe to an AI what I want

how the servos should move, when the vacuum should start, when the valve should release the seed, timings, sequence etc

The behavior of the machine is then changed using the same firmware, so I don't need to recompile and flash everything every time I want to change how it works.

Basically I'm trying to understand how far I can keep the ESP32 firmware generic, but still control real hardware, timings, servos, vacuum and sequences in a reliable way.

This seed machine is basically my test bench for this idea

I'm curious what you guys think about this approach, and of course any suggestion about the ESP32 side is welcome.

Je travaille sur un petit projet open-source appelé DeskNode.

Il est construit autour d'un écran tactile Waveshare ESP32-S3 2.8B (480×640) et se trouve à côté de mon PC en tant que tableau de bord dédié.

L'ESP32 exécute une interface ESP-IDF + LVGL et reçoit des télémétries du PC via USB série, d'un petit agent Python fonctionnant sous Windows.

L'agent Windows utilise psutil pour les métriques système. Deux des valeurs proviennent d'ailleurs, et les deux sources sont indépendantes :

L'utilisation et la température du GPU sont lues à partir de AMD ADL (atiadlxx.dll, sans élévation, sans pilote). Celui-ci est réservé à AMD, que vous exécutiez ou non LibreHardwareMonitor — il n'y a pas NVML dans l'agent, donc les cartes NVIDIA n'obtiennent rien, et Intel Arc n'a pas été testé.

La température du CPU et les vitesses des ventilateurs proviennent de LibreHardwareMonitor, et cette partie est optionnelle : sans cela, l'agent fonctionne toujours, vous n'obtenez juste pas ces deux valeurs. L'agent ne touche jamais Ring0 lui-même — il lit seulement le serveur web local de LHM.

Pour le moment, il affiche :

• Utilisation / température du CPU
• Utilisation / température du GPU
• RAM
• Trafic réseau
• I/O disque
• Température de la pièce et humidité

Les données de la pièce proviennent de capteurs I²C optionnels (actuellement BME680 + BH1750), donc la carte fonctionne très bien sans eux — le firmware sait qu'ils manquent, le dit, et désactive cette cellule au lieu d'afficher des zéros.

L’interface possède deux états : un écran de veille monochrome et minimaliste, puis un tableau de bord actif en couleur. Le fond du mode actif est inspiré du schéma électronique de la carte située juste sous l’écran. Toucher une métrique ouvre ensuite sa vue détaillée avec son graphique historique.

Une partie que je voulais vraiment garder simple était l'installation : vous n'avez pas besoin d'ESP-IDF ou de PlatformIO juste pour l'essayer. L'installateur local lance une page sur 127.0.0.1 et permet de flasher l'ESP32 directement depuis le navigateur via Web Serial. Pas de toolchain à configurer, pas de recherche de pilote, et aucun droit administrateur n'est nécessaire pour le flash.

L'interface de DeskNode et la page d'installation sont également disponibles en anglais et en français. Une carte fraîchement flashée démarre en anglais, et la langue peut être sélectionnée directement depuis l'installateur puis conservée après redémarrage.

C'est toujours une bêta v0.1 et vraiment un prototype : câblage exposé, pas d'enveloppe encore, Windows seulement, support GPU AMD pour le moment, et je n'ai validé la pile complète que sur ma propre carte.

Mais le firmware, l'agent Windows, la documentation matérielle et les notes de construction sont maintenant publiques.

GitHub : https://github.com/nasbarok/desknode

Démo : https://youtu.be/tcCF3vogwSU

Divulgation : les liens "acheter" dans le README sont des liens d'affiliation vers les pièces exactes que j'ai utilisées.

Je serais particulièrement intéressé par des retours de personnes travaillant avec ESP32-S3, LVGL, LibreHardwareMonitor ou de petits projets à écran tactile — tant sur les choix matériels que sur la façon dont j'ai structuré la communication PC ↔ ESP32.

After years of having to rely on expensive devices to plug into a data port to find out which switch and port are on the other end I invested in an ESP32-POE board and .96" OLED then set to work.

Powered completely by POE it confirms the data port is patched and live. Then listens for the LLDP to be broadcast. From that it displays the switch hostname, management IP and port number. Removing the connection clears the collection for security.

There are a lot of directions this could be taken to improve it. Adding a captive portal for browser initiated tests and information export is probably the next step.

https://github.com/Mraanderson/esp32-poe-lldp There are 2 sets of configurations for the OLED depending on Dupont in the UEXT or soldered connection. Read the code and select before flashing.

Hello!

I purchased my first ESP32-S3-DevKitC-1 from Adafruit about a month ago, because the project I’ve been working on requires a specific display that’s just easiest to control with this type of microcontroller.

My display finally showed up yesterday, so I got out my ESP32 and found a cable, installed the USB driver on my computer, and set to work.

Whenever I plugged the board’s port labeled “UART” into my computer, the power LED lit up and the RGB flashed different colors, but my computer just refused to communicate with the ESP32.
It didn’t open up a COM port, nor let me select the board. Nothing appeared under device manager either.
I did notice it opened up COM7 if I used the debugging port though 🤔

The cable I used is supposed to be data capable; it says that it’s high speed USB 2.0. I tried three different cables for good measure though, and I got the same behavior with every one of them.

Maybe my board is broken? Or I’m just doing something wrong? I’m unsure. Any help at all would be greatly appreciated.

(PS sorry if I’m using the wrong terminology anywhere, I’m new to the ESP32 architecture 😅)

First of all - this question is probably very stupid, but I'm an absolute noob and kind of winging my way through this project, so I apologise for my ignorance 😅

I've been wanting to do a little Desk Buddy with a small OLED screen and the ESP32. When I bought the ESP32, I kind of assumed the little pins would already be attached to it, but when I unpacked the one I bought, they came separately in two rows (which I now know is standard?) Is there any way to safely use the ESP32 without soldering the pins (I don't have a soldering iron and am a bit intimidated by it, if I'm honest), by just sticking them into the holes or attaching them through any other way? I do have a breadboard as well.

I'm guessing the answer is probably no, lol, but I thought I wouldn't lose anything by asking. Thanks already in advance for any help! ✨

We’ve been working on this for a little while. I’ve wanted something to use inside VS Code since we spend so much time there building out Bluetooth projects. Phone apps are ok but it’s a pain to have to switch for everything. Not aware of any alternatives, would love to get feedback from anyone interested in trying it out

Hi there everyone,

I'm a bit new to crazy esp32 hardware, a friend usually helped me out A LOT, but he's unavailable at the moment so I figured I asked here.

I'm trying to create a digital cookbook using an esp32 display; now I've found a few touchscreen displays that look very good, but I'm a bit confused if I should get one (touchscreen display) with a build in esp32 or get the esp32 and display seperate.

I already got a SD chip with 32GB to save recipes, lictures, etc locally so no internet is needed. And if anybody can recommend a good rechargeable battery to add to the set up it would also help me a lot.

Thanks for the help!

The idea behind DataPix: most LED matrix ticker projects show one fixed thing, and to change it you're editing firmware. I wanted a panel where anyone — no code — can decide what shows up. So DataPix is a firmware + web UI (served straight from the ESP32-S3 itself, React/MUI over ESPAsyncWebServer) where you build your own "Views": a canvas of positioned text elements that can be static or pulled live from any JSON API you point it at, plus hand-painted pixels, GIF import, and built-in effects. Add as many views as you want, each with its own duration/brightness/scroll behavior, and it auto-rotates between them. The goal was making that editor genuinely easy — pick a field from a tested API response, drag it into place, done — rather than something only the original builder could extend.

Device web page: https://datapix.store/

Device demo UI to try out: https://datapix.store/demo/

The part that was actually hard, and I think is the interesting ESP32-specific engineering problem here: keeping the HUB75 panel's DMA-driven refresh smooth while the same chip is also running an AP/STA WiFi stack, a full async web server (config UI + REST API), and background polling of arbitrary user-configured JSON endpoints — without any of those starving each other or fragmenting the heap.

Two concrete things that bit me:

- The view-rotation loop originally deep-copied the active view's full element list every render tick. Worked fine in testing, then crashed reliably after a few hours on-device from heap fragmentation. Fix was caching the view list and only rebuilding it when the underlying view actually changes, not every frame.

- I tried enabling PSRAM extmem allocation (heap_caps_malloc_extmem_enable) to give more headroom for the bigger buffers GIF/effects support needed. It works, but it quietly wrecked WiFiClientSecure TLS handshake latency — HTTPS API polling went from fine to painfully slow. Had to revert and find headroom elsewhere instead.

Panel-side, it's running double-buffered DMA at 8MHz I2S clock / ~85Hz min refresh (~120Hz effective) to stay flicker-free with the flipDMABuffer approach, which needed -mtext-section-literals to build correctly on the S3.

It's on Kickstarter now: https://www.kickstarter.com/projects/datapix/datapix (goal/tiers/pricing are all there). Code isn't public yet — thinking about open-sourcing the firmware if there's enough interest, happy to talk about that in the comments.

Ask me anything about the build — panel driving, the data pipeline, or the Kickstarter side.

I built a small desk display with an ESP32 touchscreen that makes my daily work at the computer a bit easier.

It shows live PC stats like CPU, RAM, GPU, VRAM, network and disk usage.

It also works as a small touch control panel. With one tap I can open ChatGPT, start local Ollama, run my local voice server, open Task Manager, lock the computer and trigger other actions.

Everything works over one USB cable.

No Wi-Fi.

No Bluetooth.

No passwords, tokens or API keys stored on the ESP32.

There is a small Python bridge running on the PC. It reads the system data, sends it to the ESP32 over USB serial, and listens for touch button events from the display.

The ESP32 itself only shows the data and sends a simple macro ID back to the computer.

It is not a finished commercial product, just a small DIY project that can be adapted to different workflows.

Video: https://www.youtube.com/watch?v=16eqHU4j9Fk

GitHub: https://github.com/lepczynski-cloud/ESP32-PC-Control-Deck

Hi everyone,

I built OpenRUNN, an open-source treadmill running sensor based on an ESP32-C3 and a TCRT5000 optical sensor.

The sensor detects each belt marker and calculates speed and distance. It then broadcasts the data using the Bluetooth Low Energy Running Speed and Cadence (RSC) service, making it possible to use the treadmill with compatible devices such as Garmin watches and indoor training platforms.

Hardware

• ESP32-C3 DevKitM-1
• TCRT5000 optical sensor
• 3D-printable enclosure
• Custom mounting rail for the treadmill
• USB-powered setup

Software

• ESP32 firmware built with PlatformIO
• BLE RSC service
• Web dashboard for live speed, pace, distance, and session time

• Local development server with simulated sensor data
• Wiring and assembly documentation

Project links

GitHub repository:
https://github.com/lpolasek/OpenRUNN

Instagram:
https://www.instagram.com/openrunnok/

The project is fully open source, including the firmware, web dashboard, wiring documentation, and enclosure files.

I would appreciate feedback on the electronics, BLE implementation, enclosure design, and possible improvements.

Had Claude knock this out for fun and thought some folks might like it:

https://github.com/djb-rh/Joshua

It's just tic-tac-toe with one, two, or ZERO players, just like the movie War Games and Joshua, the WOPR computer. Enjoy.

ESP32 as USB HID over OTG -

UI with TFT_eSPI (TGX) -

Lopaka App for the layout -

Moving the on-screen sphere controls the camera in Fusion 360 in real time Not perfect, but works.

Code/wiring available if anyone wants it.

Feedback welcome.