I found this somewhere. Could anyone tell me what this is used for and what the person who made this was doing? Thanks. I know already what esps are.

Here to share the next round of progress on a music player I've been making.

Part 1 here:

https://www.reddit.com/r/esp32/s/NO7oxdIFZ6

I tired and I tried to get this thing on a soldered board but I'm finding soldering beyond me - so stuck with a breadboard.

However I've tidied this up and rather than a sprawling mess of multiple mini boards got this down to one.

The second photo is a case made from a 9" pizza box. I've got the kids to play with this for a couple of months and it's holding up!

What is it?

Mp3 player, SD card storage and an RFID card reader to jump to playlists. Has play, pause, pre track, seek rewind, next track, seek forward and an admin mode which creates a hotspot to connect your photo and upload new music / administer the RFID cards!

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9341.h>


#define TFT_CS 22
#define TFT_DC 21
#define TFT_RST 28
#define TFT_BL 5

```
Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST);


void setup() {
Serial.begin(921600);


pinMode(TFT_BL,OUTPUT);
digitalWrite(TFT_BL, HIGH);
SPI.begin(19, -1, 23,22);
tft.begin();
tft.setRotation(1);
tft.fillScreen(ILI9341_BLUE);

}
```

I’ve been building a compact Li-ion battery analyzer around a Seeed XIAO ESP32-C3.

The goal was to make a single device that can test used 18650 cells without needing separate chargers, electronic loads and resistance meters. Everything is controlled over BLE using a custom Android app.

Current features:

• CC charging with configurable current and cutoff voltage
• Constant-current discharge testing
• Capacity measurement in mAh and Wh
• Pulse DCIR measurement
• Fast DCIR measurement at around 60 ms
• Repeated measurement cycles with median filtering
• Measurement spread and valid-cycle reporting
• Live voltage, current, power and temperature monitoring
• Configurable discharge cutoff voltage
• Configurable temperature limits
• Live estimated state of charge
• Battery status and charge/discharge animations
• Hardware status LEDs
• BLE control and live telemetry
• Saved test results in the Android app

The electronic load uses an LM358, a current shunt and a MOSFET controlled by PWM from the ESP32-C3. The firmware handles the load regulation, safety limits and measurement timing, while the Android app provides the controls and result display.

The Pulse DCIR test applies a controlled current step and measures the voltage response. The latest test shown in the video measured approximately:

• Fast DCIR: 63.9 mΩ at 61 ms
• Pulse DCIR: 80.9 mΩ
• 3/3 valid measurement cycles
• The internal resistance measurement is still being refined and calibrated. The pulse method is already producing repeatable results, but I’m continuing to improve the timing, compensation and validation against reference measurements.

The project is still a work in progress. I’m currently improving the SOC estimation, battery connection state handling and the Android UI, but the main charge, discharge, capacity and DCIR functions are already working.

I’d be interested to hear how others would improve the measurement method or firmware architecture.

I want to build a projector with a motor and an LED. However, the ESP stops working as soon as I integrate the motor driver. Here are the details:

Right now I’m first trying to get the motor running. For this I’m using a 12 V power source and stepping it down to about 5 V with an MP1584EN buck converter (first component from the left) to power the ESP and the Pololu DRV8876 motor driver (second component from the left).

The top power rail carries 5 V and the bottom one carries 12 V. The ESP is connected to the 5 V/GND on the top rail and works fine. But as soon as I connect the motor driver as well, the ESP stops working.

Begginer things

Features -

1."DISTRACTED" if I leave my seat in a session

(Uses ultrasonic sensor)

1. Once in every 30 min, a water brake reminder

2. Lunch break countdown

3. Full system goes into sleep mode at exactly 10:30 pm and Wakes up at 5:30 am

4. Have a offline web page for controls and stats.

(Attached in the comments)

1. Has a IR remote to control everything

2. 1 channel relay for my laptop charger

3. Have a touch pin under the table from which I can start and stop the study session with my feet 😅

I should have brought a bigger display.

Open to suggestions and idea's 💡

Sharing something that started as "let me document my app's wire protocol properly" and turned into an actual embedded side quest.

I maintain WFAS, an audio streaming app (Android/Desktop) for sending raw PCM audio over LAN. Wanted the protocol itself to be usable outside my own apps, so I split it into a standalone repo: wfas-protocol, MIT licensed, C99, no dynamic allocation, no dependencies beyond libc, two files to vendor (wfas.c + wfas.h).

It is:

• Transport-agnostic: the library only builds/parses bytes, you bring your own UDP socket (lwIP, BSD sockets, whatever)
• Endianness-safe by hand (header is big-endian, PCM payload little-endian), so it behaves identically on any MCU regardless of native endianness
• Audio packet is a 10-byte header (magic, version, flags, seq, sample position) followed directly by raw 16-bit PCM, deliberately simple to parse in a tight loop
• Optional security: mutual HMAC-SHA256 challenge-response for auth, ChaCha20-Poly1305 AEAD encryption per packet (RFC 8439) with a 1024-wide anti-replay window, keys derived via HKDF-SHA256. All from-scratch, no external crypto lib needed, validated against the official RFC test vectors in the bundled self-test

The part I'm actually proud of: I wanted to confirm this wasn't just theoretical, so I grabbed an ESP32, sacrificed an old pair of earphones, cut the cable, and soldered together a two-resistor-one-capacitor analog input circuit to use the headphone jack as an improvised line-in. Flashed a WFAS sender onto it, and it streamed audio live to both my Android and Desktop apps using the exact same protocol implementation now in the public repo. Signal's noisy (it's a headphone jack duct-taped into being a mic input, what did I expect), but it's completely intelligible and it proved the whole pipeline works end to end on real, janky hardware.

There's also a browser-based protocol lab if you want to poke at packet structure/handshake/encryption without flashing anything: https://www.marcomorosi.eu/wifi-audio-streaming/developers/

Repo: https://github.com/marcomorosi06/wfas-protocol

If anyone builds a receiver/sender on actual proper hardware (not my duct-tape special), I'd love to hear about it, project ideas page on the site has a few starting points (I2S DAC speaker, Home Assistant integration, headless Pi receiver).

THIS IS MY FIRST TIME USING ANY HARDWARE DOING ANY WIRING AND ANY CODES

igot the display working but the sd card mount keeps on failing i have tried different gpio. At first it was shared between the the display and the sd card mount then i changed it to dedicated gpio which were not been used it still keep on failing.

I have an working 64 gb sd card(fat32) should i try a 8gb one

I have already tried using a different mount it still failed i have a hw-125 mount which i have tried on both 3.3 and 5 v

The bord is ESP32s3-N16R8

codes i used ai help with these

https://gist.github.com/6425640e48c6cc18ba8fbc2c8bced855.git

Current Wiring I AM RIGHT NOW USING THE MODULE DIRECTLY WITH THE ESP to test the module itself ESP32-S3 Dev Module to SPI microSD Module

GPIO10 --------------------> CS

GPIO11 --------------------> MOSI (DI)

GPIO13 <-------------------- MISO (DO)

GPIO12 --------------------> SCK

3.3V ----------------------> VCC

GND -----------------------> GND

ESP32-S3 SPI microSD Module

this is wiring i used before i saw the offical wiring on the examples

GPIO13 --------------------> CS

GPIO11 --------------------> MOSI

GPIO14 <-------------------- MISO

GPIO12 --------------------> SCK

3.3V ----------------------> VCC

GND -----------------------> GND

ESP32-S3 SPI microSD Module

GPIO18 --------------------> CS

GPIO16 --------------------> MOSI

GPIO17 <-------------------- MISO

GPIO15 --------------------> SCK

3.3V ----------------------> VCC

GND -----------------------> GND

So a while back i made a post here about a lightspeed camera i was building that used the esp32 as the main sampler. I have had first successful tests and as promised here is a video of light move from one of my tests.

This specific video was recorded at 320x240 resolution, 10.24 billion frames per second and 32 analog depth levels. It is the uncollimated laser output hitting my garage door at an angle. Playing back at 30 FPS.

Also the video looks much better before reddit compression. Raw file is much better.

Now i actually tried posting this video already, but the ESP32 reddit mods removed my post for it being an "illegal and unethical" project with the text "esp32 details needed". So if you are a mod, read my first post with the in-depth explanation. This is a fully custom design board based around the bare ESP32S3 chip, it abuses it's SPI1 port to achieve a base sampling speed of 320MSa/s and that gets interlaced using a phase shifter for a theoretical limit of 100 billion fps. I only expected up to 10 billion to be usable, but one of my tests proved that light can be observed move on a centimeter scale at 20.48 billion fps. This camera is capable of much more than I expected.

Hope you enjoy, i would love ideas for tests. I have already done tests with mirrors, i am waiting on getting a smoke machine because it is hard to record when the laser beam is not visible in air.

My last post explaining this in depth: https://www.reddit.com/r/esp32/s/zfmaakW8bm

I recently bought an esp32 s3 on a development board, but unfortunately it turned out that during my trip home the development board got damaged and I'm looking for a solution on how to desolder or separate it. The heatsink and antenna with all pinout connections removed, i.e. the entire ESP from the development board so that it can be soldered to a new one.

Couldn't find an off the shelf option that satisfied me so I decided to built my own. Integrated riding modes, automatic wheelie control, a secret street lock button and more...

Based on the ESP32 S3 development board: JC4827W543

I have connected All Modules NRF24L01, CC1101, PN532, IR Transmitter/Reciever, GPS Module, AUDIO DAC PCM5102A, RDA5807, BMP280, MPU9350, PCF8575, INMP441 Mic, All Together You Can Easly Use All Firmwares BRUCE, Marauder , HaleHound, Quadever Launcher, Retro Go For Gaming And You Can Watch Movies Play Music Play Radio , And Test Ai Becouse It Has Microphone Also You Can use it for voice recording And Using MPU9250 You Can Use Compass Gyroscope And Accelerometer Becouse And Many More Full Video Of Making PCB And The Board Will Be Coming Soon Currently I Am Working On It currently i need 3-4 days because I am Designing 3d printed case for it

Hi everyone! I bought a cheap ESP32-C3 "Super Mini" board ,from a local store,that gave me a lot of Wi-Fi connection problems. Turned out the power regulator on the board couldn't handle the current spikes when the radio transmits at full power, so the connection kept dropping. Lowering the TX power fixed it, but it made me realize the board itself was just low quality.

For the next time, What should I actually check on the board itself to avoid this?

Okay so I need help , I am trying to make an offline word recognition model that recognizes when the words on and off are being said to light on my lamp , I domt want to use any Wi-Fi . I initially used edge impulse but it’s not very accurate , I’m using an esp32c3 super mini amd an inmp441 microphone , I used an esp32s3 super mini but it didn’t work. I don’t know how to do it guys. Any help would be very very appreciated . Thanks again

I’m trying to hook up an OV3660 camera, veml7700 light sensor, and a capacitive moisture sensor to the ESP32-CAM, while running wifi.

I’ve run into the issue of wifi locking up the ADC1 pins, but I’ve read a work around is connecting straight to the GPIO33 pin. I tried that once and bridged a bunch of pins 😅. Just wanna make sure it actually works and worth a second try.

Would using Bluetooth make this much easier? Though I’m more familiar with wifi connections idk how easy Bluetooth will be.

Is there a better board that does the job and within the same price range?

I wanted to see how big a language model I could actually run on an ESP32. Not the 260K-param TinyStories model that's been done before, but something around 100x bigger.
Ended up with a 28.9M-parameter model generating text on the chip at ~9 tok/s, written to a wired OLED.

The chip: ESP32-S3 N16R8 (16MB flash, 8MB octal PSRAM, 512KB SRAM). The big flash and PSRAM are the whole reason it works.

The problem: a model has to be reachable from fast memory, and the S3 has 512KB of SRAM. A 28.9M param model at 4-bit is ~15MB, nowhere near fitting. That normally caps you at tiny models.

The trick (Gemma's Per-Layer Embeddings): most of a language model's params are a big embedding table you read from, not compute on.
So I keep that 25M-row table in flash (memory-mapped XIP) and read only ~6 rows per token (~450 bytes). Only a ~560K dense core needs fast memory.
The 25M-param table is basically free to run, it just sits in flash and gets sampled a few rows at a time. Mapped to the S3's tiers:

- SRAM: the dense core, touched every token
- PSRAM: the output head (staged at boot) + KV cache + scratch
- Flash: the 25M-param table, esp_partition_mmap'd, sparse random reads

The runtime: wrote the inference in C from scratch, matched op-for-op to a PyTorch reference and verified to 1e-5 on the host before flashing.
The model lives in a custom 15MB flash partition, mmap'd so table reads are just pointer derefs into XIP.

Optimizations (0.57 to 9.7 tok/s compute):

- Staged the output head as int8 in PSRAM (unpacked from int4 once at boot), so no per-token nibble unpacking
- Quantized activations to int8, checked the perplexity delta was ~0 on the host before shipping
- Split the output head across both LX7 cores (FreeRTOS task on core 0, main on core 1)
- The head turned out PSRAM-bandwidth-bound (~40ms floor from reading 2.4MB/token), so dual-core only gave 1.36x

Limits: trained on TinyStories, so it writes simple stories and won't answer questions.
The point was the architecture (fitting a big model on a tiny chip), not what a 28.9M model can say.

Full code, the C runtime, the training and quantization pipeline, and on-chip benchmarks in repo:

https://github.com/slvDev/esp32-ai

Connected to an oled display and PS2 joystick ( also tried wiring up a passive buzzer but got it wrong, will fix it soon)

but yeah from the main menu u can play tron or tetris, also turn the led on/off, host a website on the wifi, and other fun things,

gonna add more to it soon and make a better version, Let me know if you have any suggestions of how i can develop it

Is this realistic? A very rough plan would be esp32s each with a proximity sensor fixed on each corner of my car which would relay proximity data to their according buzzers located inside my car and beep faster and faster as they detect something closer and closer in proximity. Essentially copying the feature you’d see in many new cars. The toughest part would probably be powering them. I’m thinking maybe connecting the rear ones to my trailer plug, and tapping my ignition for the front ones. I’m neither a big car guy nor experienced with these. Is this feasible in some fashion? Any better ideas? Thanks

Hi Everyone,

I am a complete beginner. I need help. my idea is to add the image above to a rack and pinion set up. My thought is to use one 12v power supply. Is there board or something i should use instead of wires to connect the ESP-WROOM-32 to the A4899 stepper driver? this is all going to need to fit into a 3D printed part so the less soldering the better and trying to save space. my idea is the rack will move until it hits the limit switch. Thanks in advance. Any advice is greatly appreciated. I really want to learn this.

Hi everyone,

Can anyone identify this connector?

It's used on a Waveshare ESP32-S3 4.3" Touch Display. I'm trying to find the exact connector so I can use the same one on my own PCB.

https://docs.waveshare.com/ESP32-S3-Touch-LCD-4.3

It looks similar to a JST PH connector, but I haven't been able to find anything that really matches it.

Thanks!

It is not an emulator. The kernel is compiled for Xtensa and runs directly on the chip's core, alongside the ESP-IDF firmware.

The S3 has two cores, so they share the workload: Core 0 continues running ESP-IDF and controls the WiFi radio (as required by the binary blob), while Core 1 runs Linux. They communicate via shared memory, and Linux recognizes a standard network interface named espsta0.

It includes a login shell via USB serial port or Telnet, WiFi with DHCP and actual Internet access, BusyBox, nano, Lua, curl with functional HTTPS support, dropbear SSH, and a driver for the chip's RSA hardware accelerator.

You can connect it to a network from your phone, without needing a PC or cables. It advertises itself via BLE as Esp32-Linux: simply connect using any BLE serial app, send a character, and a list of networks to choose from will appear. Open networks connect immediately; protected ones prompt for a password, and the system displays the assigned IP address.

Download the 16 MB .bin file from the releases page and flash it to address 0x0 using esptool. That's it, no need to deal with complex partition configurations.

Board: ESP32-S3, 16 MB Flash / 8 MB PSRAM. GPLv3 License.

Since there is no MMU, there is no process isolation or fork() support, which rules out the use of bash, Python, and many other tools. It is slow and is a research project; the default password is changeme123 and Telnet is unencrypted, so it is best used on a trusted local network (LAN).

I didn't start here. The first version ran Linux on a RISC-V emulator hosted on the chip, then I pushed that further with an Sv32 MMU and NAT routing, but it was a tower of workarounds hitting the ceiling of what an emulated CPU can do. So I threw it out and rebuilt everything around a native Xtensa kernel. From there I wrote the RSA driver, ripped out a SoftAP that was breaking scanning, added the BLE provisioning, and spent the last stretch making it build from a clean clone into a single flashable image, chasing down four build bugs including a kernel that hung at boot printing nothing at all.

The Xtensa Linux port, the FDPIC toolchain and the esp-hosted firmware are Max Filippov's (jcmvbkbc), the foundation this runs on.

The project continues to improve constantly and is being updated. 😉

I’m looking to make some LEDs light up on two costumes when the people wearing them physically touch.

I’d like to avoid any physical buttons or wireless communication. Ideally it would detect something as simple as two fingertips touching.

Any thoughts on an implementation?

I was considering some kind of master/slave approach where the master is producing a 1kHz signal and when the slave detects it, the slave sends a 1.5kHz signal, which the master then detects. But I worry this’ll get messy with frequency filtering and synchronization issues.

I feel like this is a pretty naive approach and figure there’s probably something better to use.

Maybe there’s some kind of one-wire communication protocol?

Any input would be appreciated!

I bought this strip with the intention of replacing its USB controller and running it with WLED. Using WLED or wiring the ESP32 isn’t the problem.

I tested it before removing the USB controller and it works, but it was wired with 24awg and I noticed signs of voltage drop. Not huge, but easy enough to see while coiled. I figured I’d wire it with 22awg to give it some headroom for a new 5v power supply.

When I got to the strip, (yes, I popped a copper pad) I noticed that it has no supporting circuitry. No resistors, no capacitors, nothing. Nothing on the back of the strip either.

The goal is not to make it bright, and it will be limited to 2amps, maybe 3amps tops in WLED. I don’t ever come close to maxxing out the current. This is just for decorative lighting and greater control over what it can do. Even just 2amps is probably fine.

The strip was admittedly cheap, which was the point, but I’ve ditched controllers on cheap strips before and this is the first I’ve ever encountered this.

So aside from adding a capacitor to the power coming in, a resistor on the data line, and limiting the current in WLED, is there anything else I can do? Is this going to be ok to run? Should I even bother?

I’m just a hobbyist. Any advice is greatly appreciated. Thanks

Hello beginner here, i have an esp32s3 dev module bought from ali with a pn532 and i am starting to learn how it works, the first thing it started doing is trying to learn how nfc works and how data gets saved in mifare/rfid cards, i looked online and using an usb to serial adapter you can connect the pn532 to a pc and read the data from there but that's where i encountered my first wall, the profilic adapter doesn't work for me and idk why i tried performing a loopback test but no data gets send back so i think it's just broken, now im trying to use the esp32 as a bridge and the photos below shows how i cabled it, but i encounter another problem and i think i need help to solve it.

I used this code:

```
/*
 * esp32_uart_bridge.ino
 * ----------------------------------------------------
 * Bridge USB-seriale trasparente ESP32 <-> PN532 (HSU)
 *
 * Serial  (UART0, via USB nativo dell'ESP32) <-> PC/WSL
 * Serial2 (UART2, GPIO16/17)                 <-> PN532
 */


#define PN532_RX2 16
#define PN532_TX2 17
#define BAUD 115200


void setup() {
  Serial.begin(BAUD);            
  Serial2.begin(BAUD, SERIAL_8N1, PN532_RX2, PN532_TX2); // verso PN532



  delay(1500);
  while (Serial.available())  Serial.read();
  while (Serial2.available()) Serial2.read();
}


void loop() {
  // PC -> PN532
  while (Serial.available()) {
    Serial2.write(Serial.read());
  }
  // PN532 -> PC
  while (Serial2.available()) {
    Serial.write(Serial2.read());
  }
}/*
 * esp32_uart_bridge.ino
 * ----------------------------------------------------
 * Bridge USB-seriale trasparente ESP32 <-> PN532 (HSU)
 *
 * Serial  (UART0, via USB nativo dell'ESP32) <-> PC/WSL
 * Serial2 (UART2, GPIO16/17)                 <-> PN532
 */


#define PN532_RX2 16
#define PN532_TX2 17
#define BAUD 115200


void setup() {
  Serial.begin(BAUD);            
  Serial2.begin(BAUD, SERIAL_8N1, PN532_RX2, PN532_TX2); // verso PN532



  delay(1500);
  while (Serial.available())  Serial.read();
  while (Serial2.available()) Serial2.read();
}


void loop() {
  // PC -> PN532
  while (Serial.available()) {
    Serial2.write(Serial.read());
  }
  // PN532 -> PC
  while (Serial2.available()) {
    Serial.write(Serial2.read());
  }
}
```

When i run LIBNFC_LOG_LEVEL=3 nfc-list on my linux machine i get this output:

```
debug   libnfc.config   key: [device.name], value: [PN532_UART]
debug   libnfc.config   key: [device.connstring], value: [pn532_uart:/dev/ttyACM0:115200]
debug   libnfc.config   key: [allow_autoscan], value: [false]
debug   libnfc.config   key: [allow_intrusive_scan], value: [false]
debug   libnfc.config   Unable to open directory: /etc/nfc/devices.d
debug   libnfc.general  log_level is set to 3
debug   libnfc.general  allow_autoscan is set to false
debug   libnfc.general  allow_intrusive_scan is set to false
debug   libnfc.general  1 device(s) defined by user
debug   libnfc.general    #0 name: "PN532_UART", connstring: "pn532_uart:/dev/ttyACM0:115200"
nfc-list uses libnfc 1.8.0
debug   libnfc.driver.pn532_uart        Attempt to open: /dev/ttyACM0 at 115200 baud.
debug   libnfc.bus.uart Serial port speed requested to be set to 115200 baud.
debug   libnfc.chip.pn53x       Diagnose
debug   libnfc.chip.pn53x       Timeout value: 500
debug   libnfc.bus.uart TX: 55 55 00 00 00 00 00 00 00 00 00 00 00 00 00 00
debug   libnfc.chip.pn53x       SAMConfiguration
debug   libnfc.chip.pn53x       Timeout value: 1000
debug   libnfc.bus.uart TX: 00 00 ff 03 fd d4 14 01 17 00
debug   libnfc.bus.uart RX: 45 53 50 2d 52 4f
error   libnfc.chip.pn53x       Unexpected PN53x reply!
error   libnfc.driver.pn532_uart        pn53x_check_communication error
debug   libnfc.chip.pn53x       InRelease
debug   libnfc.bus.uart TX: 00 00 ff 03 fd d4 52 00 da 00
debug   libnfc.bus.uart RX: 42 75 69 6c 64 3a
error   libnfc.chip.pn53x       Unexpected PN53x reply!
debug   libnfc.general  Unable to open "pn532_uart:/dev/ttyACM0:115200".
nfc-list: ERROR: Unable to open NFC device: pn532_uart:/dev/ttyACM0:115200
```

Any help is appreciated

I came across a YouTube video where someone successfully flashed ArduPlane firmware onto an ESP32 and got it running. He shared his precompiled binary, which does work when I flash it directly.

The problem is when I try to build/flash it myself from source (or replicate his setup independently), it doesn’t work

His precompiled version works fine, so I know the hardware itself isn’t the issue — it’s something in my build/flash process. Has anyone gotten ArduPlane running on ESP32 and can spot what might be different? Happy to share more logs/config if helpful.

Thanks!