For the past days I have been building esp32flight: a desk flight radar that runs entirely on a Waveshare ESP32-S3 Touch LCD 7 (800x480, about $35). You plug in USB power, flash it from a browser tab, connect it to Wi-Fi on the touchscreen, and it shows every aircraft around you. No Raspberry Pi, no dongle, no accounts, no API keys required. MIT licensed.

What it shows

- Live aircraft within a configurable radius (10 to 250 NM), refreshed every 8 s, up to 80 aircraft with the nearest kept first

- Airline logos (1300+ bundled), aircraft type, registration with country flag, squawk, ADS-B category

- Routes: origin and destination with city, country flag and local airport times, progress bar, ETA and estimated local arrival time

- A spotter line: where to look in the sky (compass + elevation angle) and a flyover prediction ("passes you in ~3 min at 1.2 km")

- Aircraft photos (planespotters.net), commercial flight numbers (FR4238 instead of RYR638T) with an optional free FlightAware key

- Weather in the header plus the raw METAR from the nearest station

Views

- Flight list + detail panel, ambient auto-cycling mode with a mini map, radar view with a real map background, and a session stats view (hourly chart, top airlines, daily records)

- Full-screen route map with great-circle arc, swipe pan and zoom, flight trails

- Map screensaver after idle: full-screen map of your area with every aircraft, your observation circle, clock and weather; tap a plane to see where it is heading

- Night mode (backlight off during quiet hours), 7 color themes, English and Polish UI

Data

- Free community ADS-B APIs (airplanes.live, adsb.lol) with automatic failover, or your own dump1090/readsb receiver as a source with internet fallback

- Routes are cross-checked against the aircraft's actual position, so stale database entries get rejected instead of displayed

- Bundled OurAirports database (8000+ airports), map tiles with an on-device cache

Alerts and integrations

- Push notifications to your phone via ntfy.sh (free, no account): emergency squawks, watchlist aircraft, predicted flyovers

- Watchlist with gold highlighting; military and notable heavies (A380, AN-124, C-17...) are always highlighted

- MQTT with Home Assistant auto-discovery, generic JSON webhooks (Node-RED, n8n)

- Alert history stored on flash and browsable in the web panel

Web panel

- Live Leaflet map with trails and country flags, flight table, session and 30-day stats, spotting history with CSV export

- Full device configuration with per-field help, OTA firmware updates from the browser (locked by default, armed from the device)

- Documented HTTP API: live state JSON, config, logs, Prometheus /metrics, even a /screen.bmp live screenshot endpoint

- Optional password protecting the panel and the whole API

Install

Browser installer (Chrome/Edge): https://theqkash.github.io/esp32flight/

Source: https://github.com/theqkash/esp32flight

Happy to answer questions. If you have your own RTL-SDR receiver, this thing turns it into a proper desk display in about five minutes.

Hi everyone, I'm completely new to ESP boards and electronics in general, so I’ve been trying to figure out how to get everything connected. I couldn't find any helpful videos on YouTube, so I turned to Gemini and ChatGPT. Even though they guided me through the wiring and I got it connected, my screen is just showing a solid white backlight. I'm completely stuck and can't seem to get any of the example codes to run. Any advice?

I'm trying to read the interior CAN bus (CAN-B, 83.3 kbps) on a Mercedes C-Class W203 using an ESP32 (built in TWAI controller) and an SN65HVD230 transceiver module (the WCMCU-230 board, VP230 chip). I tap the CAN pair at the radio connector.

The problem: I get absolutely nothing. Zero frames and zero bus errors, at both 83.3k and 500k, and with either wire polarity.

What I already verified. I ran a TWAI loopback self test (NO_ACK mode, self reception through the board's onboard 120 ohm) and it received its own frames perfectly, 39 in a row, no errors. So the ESP, the TWAI controller, the transceiver TX and RX, and the wiring between ESP and transceiver are all proven good. A raw digital read of the RX pin on a live bus shows it sitting almost always high with only tiny noise blips, so no framed traffic is reaching the pin.

Then I measured the actual CAN wires at the radio. There is no continuity between them (no 60 ohm termination), and the idle levels are about 0.5V and 4.5V, not 2.5V and 2.5V. That looks like low-speed fault-tolerant CAN (ISO 11898-3), not high-speed.

Here is where I'm stuck. The author of a well known W203 CAN project told me high-speed transceivers read fault-tolerant CAN-B just fine in normal operation and that he used a TJA1050 without issues. So the transceiver type may not be the blocker. My board has a 120 ohm termination resistor (R2) permanently between CANH and CANL. Low-speed fault-tolerant CAN is supposed to be terminated with 500 ohm to 6k per node, never 120 ohm, so I suspect that 120 ohm is overloading the weakly driven low-speed bus and collapsing the signal. The SN65HVD230 datasheet also rates the bus pins for only -2V to +7.5V, which matters if CANL actually sits near 11V when dormant.

My questions. Has anyone read Mercedes interior CAN-B with an ESP32 plus a plain high-speed transceiver like the SN65HVD230 or TJA1050? Is the onboard 120 ohm the likely culprit here, and should I just remove it for a mid-bus tap? Or is there something about reading low-speed fault-tolerant CAN with a high-speed transceiver that I'm missing? Any help appreciated, I've been going in circles for days.

Hi everyone,

Funny confession for this group: I’ve been soldering since I was six. This project was about doing the opposite. Zero soldering, zero jumper wires - you buy a ready all-in-one cube (M5Stack Core2) and software does the rest of the job I wanted done: a standalone internet radio.

The idea went a bit further though. I wanted anyone in the world to be able to buy the cube and install the whole system straight from the browser - a few minutes, one button, no toolchain, no specialist knowledge. That part works today: Chrome or Edge, a USB-C cable, done. It plays through its own speaker or a Bluetooth one, keeps a local white/pink/brown noise generator for when the network dies, and there are no accounts, no cloud, nothing phones home.

One honest disclaimer: the firmware and the site are in English, but the station catalogue is Polish for now (218 stations, each one verified with a real connection, not a scraped list), so for most of you this is more a curiosity than a daily driver. The sources are landing on GitHub soon, GPL. The plan from there: ports to other M5Stack cubes first, then other vendors’ hardware if it works out - and I figure “only Polish stations” is exactly the kind of problem a community fixes in a weekend.

If you want to look at it: https://fiedoruk.pl/open-radio-en.html

*AI trigger warning* I've not done any coding since i finished university many many years ago (we're talking PIC chips and 555's)

But I had an idea for a project and thought I'd give this "vibe coding" a shot... It's not perfect and i understand the hate but hell I'm impressed with how much ai has come on in such a short space of time.

Anyway...to the problem in hand: I have project that requires an esp32 with a i2s dac & amp to play files from an SD card selected by an rfid reader and tags. I can get each individual part to work on its own but when assembled as a whole the rfid reader stops working. The all powerful Claude seems to think there's not enough power to go round causing the card reader to brown out? The card reader is the only thing drawing power from the 3v3 line everything else is directly from the 5v line.

How do I get more power through the esp? I thought about running the chip from 5v 3 amp psu directly through the vin...but I'm reading that if I do that I shouldn't then connect it to a computer/psu via usb...but that means I then lose access to the serial monitor for reading the rfid tag data?

The only other way I can think to do it is to give the rfid reader a separate 3.3v voltage regulator? But I'd much prefer to just increase to power available to the esp as a whole?

Thanks for reading and any help appreciated :)

We've been working on Atome LM for embedded machine learning, and instead of showing a handful of cherry-picked examples, we wanted to evaluate it across a broader set of MCU workloads.

So we built a benchmark comparing Atome LM against deployable TensorFlow Lite Micro baselines.

Results

• 18 datasets

• 4 statistically significant wins

• 13 statistical ties

• 1 loss

Accuracy was evaluated with 95% confidence intervals, so we only count a win when the difference is statistically meaningful.

The part we found most interesting wasn't actually the accuracy—it was the model size.

Across many tasks, Atome LM achieved comparable accuracy while producing artifacts that were anywhere from about 5× to over 70× smaller than the best deployable TensorFlow Lite Micro model.

\*This is the benchmark of Atome LM V3, scheduled to be released next month.

Meanwhile if you find this interesting, V2(SuperESP edition) is open source and available in GitHub. It's a LM that runs in a $5 chip. Comes with 12 ai apps. Tested and verified in real hardware, a $5 ESP32.

See for yourself :

https://github.com/TilelliLab/atome-lm

So im buliding a GPS collar using a NEO-6M , im using a SIM800L for connection so its functional in rural areas as well where there is no wifi. im running on a 3.7v lip battery, my sim800l needs 5v sl im running it through a mt3608 stepup converter. But when i power it on the SIM800L fast blinks. And it says “NO SIM DETECTED “ Through ardiuno IDE can someone help?

So I was recently gifted a fireplace and entertainment center from family. As I was sitting on the couch too far away from the remote, I got the idea "Hey wouldn't it be cool to control this with Alexa?"

Since this was a project that built on other things that I've done in the past, (namely coralling a Roomba vacuum cleaner with an IR "wall" and using the ESPAlexa library to control a smart relay with voice commands) I figured I'd build on those.

I got a chance to learn about and work with transistors and sniffing IR remote codes, as well as using the Fauxmo library to create multiple "devices" for Alexa to recognize and control. I had some trouble building on ESPAlexa to recognize multiple devices, thus learning about Fauxmo.

Right now the logic is a little janky for some of the functionality but thought it'd be cool to show as a stepping stone for me and future projects. But as is, I can turn it on and off, control heat with a slider, cycle through flame intensity, and power the sound.

I won't be building a custom pcb or thinking about long-term use, just thought it'd be a fun & fast way of keeping up on some dusty skills and to show someone

Hi all,
I am going to use this kind of sensor on a ESP32 LoRaWan board.
Got everything working for now, but I'm going to use it in the garden outside. I can put the esp in a casing, but the sensor is going to be put in the soil.
So how do I protect the electronics on the sensor from the weather? I've been searching on the web, but until now with no useful results.
Anyone ideas?

I’ve been building my own C-like compiler in Python for a while now. Eventually, I thought to myself, "Why don't I use it to compile to my own custom instruction set?" I had an unused ESP32 lying around from an old project and figured it would be fun to make it run on the hardware and build some games.

Well, things escalated quickly. With the help of Claude to speed up the architecture design and documentation, it evolved into a complete, cross-platform 16-bit fantasy console ecosystem.

Currently, the hardware version runs on two ESP32-S3-N16R8 chips: one handles the CPU emulator and audio, and the other is a dedicated PPU emulator.

Here are the technical specs of what I ended up building:

CPU: A custom 16-bit CPU (8 registers, 64 KB space), emulated entirely in C++.

Toolchain: A complete C-like compiler (Lexer, Parser, IR, Register Allocator, .rom).

PPU: Strongly inspired by the NES-2C02. It features tile, sprite, and text layers, hardware scrolling, and its own dedicated VRAM.

APU: A 4-voice chiptune synth (2 pulse + triangle + noise). It supports instrument macros, vibrato/slides, a song sequencer, and comes with an MML (text-to-song) compiler.

One of the things I'm most proud of is the zero source drift. There are three ways to run the engine (Native CLI, WebAssembly for the browser, and ESP32 hardware). A single game ROM runs bit-identical across all three of them.

I also put together a chapter-by-chapter walkthrough that teaches you how to build a complete side-scrolling mining game from a completely blank screen, just to show how the whole pipeline works.

On the hardware side, as you can see it's all still on a breadboard right now. I'm pretty green with the electronics side of things, so I haven't locked in a final build yet  at some point I'd like to move it onto perfboard or a proper PCB, but I'm genuinely not sure what makes the most sense. I also want to add more modules as I go (an SD card for ROM/save storage is next on the list, probably more after that). Very open to suggestions if anyone's walked this path before.

The whole project is 100% open-source with zero dependencies. You can check it out here: https://github.com/hamxxaa/toy-compiler-custom-emu16

This is a voxel-space renderer running on an ESP32-C3/S3 Supermini with an ST7789V display, controlled by a BLE Bluetooth keyboard (a classic bluetooth keyboard cannot be used due to ESP32-C3/S3 limitations).

https://github.com/juanmpd/ESP32C3-Supermini_VoxelSpaceWKeyboard

As usually, I'm using a pin assignment that allows me to plug-and-play the display directly over the microcontroller on a protoboard without any cables at all, or to solder it directly on its belly without any wiring (except for the BackLight control if supported by the TFT display).

It's been compiled with VisualStudio Code with the PioArduino extension, using the Lovyan display and NimBLE-Arduino libraries.

The project demonstrates the use of a BLE keyboard to control the device, and the rendering of a terrain with shadows using the Voxel Space technique.

Using a BLE keyboard to control a device such the ESP32-C3 or ESP32-S3 is probably a completely useless thing to do, but I'm a bit stubborn and I didn't stop until achieving it... It was quite difficult to get to work, and it may even still have some flaws... But it is more than enough for me in its actual state.

About the Voxel engine, I previously adapted a simpler pascal demo (see PoC: Retro voxel landscape render with ESP32-C3 Supermini : r/esp32), but later I stumbled upon great Sebastian Macke's VoxelSpace project (see s-macke/VoxelSpace: Terrain rendering algorithm in less than 20 lines of code) where he shares some javascript code to run a demo very like the original Comanche 1992 Novalogic game. So, I couldn’t resist attempting an adaptation for the ESP32-C3 / ESP32-S3.

Compared to my previous pascal-derived version, it looks far more realistic, as it is four times larger and wider, and shows shadows. But it so requires far more memory, which did not fit in the scarce ESP32 main memory, so I ended up storing 2Mb of data in flash, and that makes it run slower than my previous demo.

Key points:

• As previously, the adaptation of the code includes using fixed point arithmetic instead of float.
• Computations using parallelization in case of ESP32-S3
• 2Mb of Terrain and color data stored in flash memory (requires board_build.partitions = huge_app.csv)

This a video of me blinking my first led on esp32!!!

Unfortunately my laptop was my brothers so I had to use Arduino droid because there was no driver in laptop. Could you believe it?

And I didn't have administrator permission so I couldn't install😭

Hey everyone,

I’ve officially made my ESP32-C3 environmental monitoring project fully Open Source on GitHub!

It's built entirely on native ESP-IDF v5.x and PlatformIO (no Arduino framework) to keep it lightweight, fast, and optimized for Deep Sleep.

Since I'm still polishing the codebase and testing real-world edge cases, I’d love to invite anyone interested to join in, test the firmware, or contribute code!

What's already in the repo:

• Pure ESP-IDF C: Built without Arduino wrappers.
• Deep Sleep Architecture: RTC timer and RTC GPIO button wakeups.
• SoftAP Web Portal: On-demand configuration for Wi-Fi, thresholds, and calibration without serial re-flashing.
• Multi-Channel Alerts: Independent dispatch to Telegram, Discord Webhooks, and Custom JSON Webhooks.
• NVS Storage: Persistent flash memory for Wi-Fi credentials and soil calibration (v_dry / v_wet).
• Sensors Integrated: Capacitive Soil Moisture, DHT22, and BMP280.

Whether you want to flash it on your board, suggest architectural improvements, open a Pull Request, or just report a bug — all contributions and testing feedback are super welcome!

GitHub Repo:d7main/ESP32_EnvironmentalNode: ESP32-C3 low-power node in pure ESP-IDF & PlatformIO with Web Config

Feel free to star the repo, clone it, or drop your thoughts in the comments or GitHub Issues. Let’s build something great together!

Cheers!

So, I've been working on this diy toy camera project and this noise/pattern persisting in my image captures has had me scratching my head.

It is a OV5640 sensor paired with Seeed XIAO ESP32S3 Sense. Powered by a 2000mah LiPo wired to the board. Did not experience the issue with the OV3660 the board came with by default

The problem is in darker scenes: noisy, consistent lines. The lines sit in the same place shot to shot. Dark frame attached to see the extreme of what I mean. The other shot is a relatively dim lit desk space, but you can see the lines and noise more prominent along the left side.

Couldn't find a definitive solution from my online research. One common theme I found though is it could be either power or heat related.

What I've done to try mitigate:

• reduce / cap the gain ceiling
• reduce sensor XCLK below 20mhz
• reduce the capture resolution (to QXGA max)
• reseating the ribbon cable, to not much improvement

Is this just a limitation with the sensor and board? Any insights appreciated.

Hey everyone!

We've been building Ditto based on ESP-CLAW, and just added a feature we've been wanting for a while: desktop music controls.

Now Ditto can sync with the music playing on your computer, so instead of reaching for your keyboard or switching windows, you can just interact with Ditto.

So far it can:

• Show the current album artwork
• Tap the screen to play/pauseac
• Touch the side to skip tracks

It's a pretty simple feature, but it's made Ditto feel a lot more useful on our desks while we're working or studying.

We're still playing around with new ideas, so if there's anything you'd like to see on a little desktop companion like this, we'd love to hear it. Feedback and feature suggestions are always welcome! 🐾

Source code, pcb gerbers, schematics, and setup instructions are up:

code: https://github.com/espressif/esp-claw/tree/master

hardware: https://oshwhub.com/esp-college/project_cnyfhxqz

Im making a graphing calculator for a project. I'm using an esp32 s3 board (16mb flash, 8mb psram) with an ILI9341 3.2 inch screen and card KB v1.1 for the keyboard. The screen takes 2 3.3v (one for screen, one for backlight). The cardKB also takes a 3.3v. One more 3.3v pin than the board has. So I'm wondering if I'm able to solder 2 things to one 3.3v pin and it'll be fine

gfx is my cross platform hardware agnostic graphics library for embedded.

it is typically used with uix to do demand draws similarly to how LVGL does.

Note that like LVGL, and unlike many other graphics libraries, this does not manipulate display hardware. You must use something like the ESP LCD Panel API or another library if you want to send bitmaps to a display. htcw_uix can do this for you by allowing you to lay out controls that are then demand drawn as necessary, again similar to LVGL.

This library primarily deals in creating bitmaps. The bitmaps can be in most any format you need.

The flexible bitmap format includes paletted color matching, for loading for example, jpgs onto color e-ink displays. This library has best in class e-ink and monochrome or grayscale support as well.

It can rasterize vector graphics, and even a sizeable SVG subset, plus full TinyVG support

It supports TTF/OTF vector fonts, VLW raster fonts, and Win 3.1 raster fonts

It can load JPGs and PNGs.

It supports alpha blending

It supports anti-aliased raster draws (new!)

The anti-aliased raster draws are what I'm really excited about, as they are a fixed point and integer rasterization mechanism that allows for full antialiasing with transparency. See the attached images.

What I did was pour over LVGL's drawing code until I got the hang of it. Then I reimplemented it on my own in my graphics lib from first principles. The result is a fast pretty raster for a limited number of shapes.

PlatformIO and esp-idf: codewitch-honey-crisis/htcw_gfx (htcw_uix available as well, which includes it)

Ardiuno: htcw_gfx (htcw_uix is also available and includes it)

It also builds with cmake on PCs with major compilers.

I'm a software dev, and I'm quadriplegic. Years of writing code — but I'd never touched hardware in my life. Breadboards, GPIO, flashing a board... I honestly figured an ESP32 project just wasn't a thing I could do.

So I gave Claude Code a goal and my wifi, and I watched. It wrote the firmware, flashed the board, and — the part that got me — when the little display showed the wrong text, it *looked at the screen through an old phone's camera*, saw the bug, and fixed it. I sat there watching my first real, physical thing come to life. One I could never have built with my own hands.

It's a small bedside display (a LilyGO T-Display / ESP32) for a health routine I have to stay on: a glanceable countdown + a status light, and a button I tap when I feel a symptom — so I never have to reach for my phone. It quietly feeds my own health setup (a little agent I run).

I know it's tiny. But it's my first, it does something real for me every day, and watching it happen honestly moved me. Had to share it with people who'd get it.

(Video's above. Repo if you're curious: github.com/fcavalcantirj/claude-code-eyes — happy to get into the T-Display / firmware details in the comments.)

Has anyone bought an esp32-s3 cam from temu? I bought 2 and a couple of others from temu and I've search for the "Goouuu" stamp and been able to find a tiny bit of info but it seems like I'll have to learn how to set each pin... Does anyone else have experience with this board? It uses a different configuration than other more popular boards and I've been fooling with this for days and am frustrated. Thankfully I did buy the Seeed Sense (with camera) so I can mess around with it while I try and think what I can do with the Goouuu boards other than a simple blink program. microSD card, camera, network connection... nothing else but the blink example works. Any help would be greatly appreciated. PS: I've used Arduino IDE, Espressif IDE, VS Code and online coders and compilers that seem great once I get to my other boards and over this frustration. I did buy these 2 before I knew there were different boards and to pay attention there... oops.

Wanted to share my first big ESP32 build. I replaced my old Rain Bird irrigation panel with a custom setup integrated directly into Home Assistant.

The main goal is to run smart automation logic based on local weather data, sun position, etc rather than relying on a basic timer.

Parts List:

• ESP32
• 10-channel relay board
• AC/DC buck converter
• WAGO lever connectors
• 22 AWG hookup wire
• Custom 3D-printed mounting plate

(Yes... I know the wiring is crazy right now. I'm printing the case on an Ender 3, so I ran into some bed size limitations. I'm actively iterating on designs to clean up cable management.)

Would love any feedback, constructive criticism, or ideas for improving the layout/case :)

Maybe im adjusting the parameters too quickly? handleModesetSerial() its just a state machine that calls modeSet() when i recieve a header followed by the modetype and its value. I use this to send camera frames through serial for a cardputer ADV (ESP32S3/StampS3A) when i swap the resolution, i do this

// cardputer's side void apply_modeset(){ // discard old camera data while (Serial2.available()) {Serial2.read();} rx_state = WAIT_SYNC_1; modeSetSend(FR_SIZE,current_settings->FR_SIZE); modeSetSend(JPEG_QUALITY,current_settings->JPEG_QUALITY); modeSetSend(BRIGHTNESS,global_settings.BRIGHTNESS); modeSetSend(CONTRAST,global_settings.CONTRAST); modeSetSend(CONTRAST,global_settings.CONTRAST); modeSetSend(SHARPNESS,global_settings.SHARPNESS); modeSetSend(WB,global_settings.WB); modeSetSend(WB_MODE,global_settings.WB_MODE); modeSetSend(AWB_GAIN,global_settings.AWB_GAIN); modeSetSend(EXP_CTRL,global_settings.EXP_CTRL); modeSetSend(AE_LEVEL,global_settings.AE_LEVEL); modeSetSend(AEC_VALUE,static_cast<int8_t>(aec_map[global_settings.AEC_VALUE])); modeSetSend(AEC2,global_settings.AEC2); modeSetSend(GAIN_CTRL,global_settings.GAIN_CTRL); modeSetSend(GAIN_CEILING,global_settings.GAIN_CEILING); modeSetSend(LENS_CORR,global_settings.LENS_CORR); modeSetSend(MIRROR,global_settings.MIRROR); modeSetSend(FLIP,global_settings.FLIP); modeSetSend(SPECIAL,global_settings.SPECIAL); modeSetSend(REQUEST_FRAME); }

``` void initialModeSet(){ current_config.pin_d0 = 5;   current_config.pin_d1 = 18;   current_config.pin_d2 = 19;   current_config.pin_d3 = 21;   current_config.pin_d4 = 36;   current_config.pin_d5 = 39;   current_config.pin_d6 = 34;   current_config.pin_d7 = 35;   current_config.pin_xclk = 0;   current_config.pin_pclk = 22;   current_config.pin_vsync = 25;   current_config.pin_href = 23;   current_config.pin_sccb_sda = 26;   current_config.pin_sccb_scl = 27;   current_config.pin_pwdn = 32;   current_config.pin_reset = -1; // Not used   current_config.xclk_freq_hz = 20000000;   current_config.ledc_channel = LEDC_CHANNEL_0;   current_config.ledc_timer = LEDC_TIMER_0;   current_config.grab_mode = CAMERA_GRAB_WHEN_EMPTY;   current_config.fb_location = CAMERA_FB_IN_PSRAM;   current_config.jpeg_quality = 12;   current_config.pixel_format = PIXFORMAT_JPEG;   current_config.frame_size = FRAMESIZE_QXGA; // Allocate max size in ram   current_config.fb_count = 1;   previous_fr = FRAMESIZE_QXGA;   esp_camera_init(&current_config);   modeSet(FR_SIZE,FRAMESIZE_QQVGA); // step down size }

void modeSet(modetype mode,int8_t value = 0){
  sensor_t *s = esp_camera_sensor_get();
  switch (mode)
  {
  case FLASH: set_flash(value); break;
  case FR_SIZE:{
    unsigned long start_time = millis();
    camera_fb_t *fb = NULL;
    if (previous_fr == (framesize_t)value) break;
    previous_fr = (framesize_t)value;
    s->set_framesize(s,(framesize_t)value);
      while (millis() - start_time < 500) {
        fb = esp_camera_fb_get();
        if (fb) {
          esp_camera_fb_return(fb);
          break;
        }
        delay(10);
      }
    break;}
  case JPEG_QUALITY: s->set_quality(s,value); break;
  case BRIGHTNESS: s->set_brightness(s,value); break;
  case CONTRAST: s->set_contrast(s,value); break;
  case SATURATION: s->set_saturation(s,value); break;
  case SHARPNESS: s->set_sharpness(s,value); break;
  case WB: s->set_whitebal(s,value); break;
  case WB_MODE: s->set_wb_mode(s,value); break;
  case AWB_GAIN: s->set_awb_gain(s,value); break;
  case EXP_CTRL: s->set_exposure_ctrl(s,value); break;
  case AE_LEVEL: s->set_ae_level(s,value); break;
  case AEC_VALUE: s->set_aec_value(s,(uint16_t)static_cast<uint8_t>(value) * 1200 / 255); break;
  case AEC2: s->set_aec2(s,value); break;
  case GAIN_CTRL: s->set_gain_ctrl(s,value); break;
  case GAIN_CEILING: s->set_gainceiling(s,(gainceiling_t)value); break;
  case LENS_CORR: s->set_lenc(s,value); break;
  case MIRROR: s->set_hmirror(s,value); break;
  case FLIP: s->set_vflip(s,value); break;
  case SPECIAL: s->set_special_effect(s,value); break;


  case REQUEST_FRAME:
  frame_requested = true;
  break;


  default:
    break;
  }
}

void loop() {
  while (Serial.available()){handleModesetSerial(Serial.read());}
  if (frame_requested){
    frame_requested = false;
    camera_fb_t *fb = esp_camera_fb_get();
    if(!fb) return;
    Serial.write(0xAA); // Sync byte 1
    Serial.write(0xBB); // Sync byte 2
    Serial.write((uint8_t*)&fb->len, 4); // length of JPEG
    Serial.write(fb->buf, fb->len);      // JPEG data
    
    esp_camera_fb_return(fb);
  }

```

Hey everyone. This is my first time using an Esp32 (I have only interacted with Arduino and STM32 boards before) and I'm having some trouble with finding the right kicad symbol/footprint for my board.

I got it bare (no package, no nothing) with not much info from a professor for a uni project, so with research I came to believe it is an ESP32-C6-DevKitM-1. I saw it's footprint was supported by this github community library and downloaded it. But, when attatching it to Kicad i noticed the pins on my devboard do not align with the pins on the footprint nor the layout listed on ESPRESSIF's website.

I'm a bit confused, I tried to image search but couldn't find a board with my layout... So before trying to edit the footprint I want help on knowing if I even am searching for the right devboard? (It would be better for me a ready to go footprint rather than trying to make my own because it's not the focus of the project, sadly.)

Making a wall map where spots light up. This is the back. Want to have people who have more experience with wiring and esp32s give feedback.

- ESP32 on screw terminal board
- WS2812 5V LEDs
- 5V 3A wall plug, powered from one end
- FastLED

I have the ESP32-CAM and daughter board and am finding it really unreliable. It only connects to WiFi after 3-4 minutes. I have only been able to connect and stream video from it once. More often I can connect to the web interface but not stream video.

Anyone experienced these issues and can offer tips? Thanks.

Project overview This DIY project uses a Seeed Studio XIAO ESP32S3, which I chose mainly because it already has native USB support built in (important for USB audio) and a very compact form factor. That made it perfect for directly interfacing with a USB speaker without needing extra USB host shields or converters.

For the physical connection, I used a USB-C to USB-C cable/adapter to plug the ESP32S3 straight into the JBL speaker's USB port. Since the ESP32S3 can act as a USB device, it's able to present itself as a USB audio source over this connection.

How the software works For the software side, I built this project on top of rbouteiller's "airplay-esp32" firmware.

GitHub repository: https://github.com/rbouteiller/airplay-esp32

I chose this because it already implements the full AirPlay protocol stack, which is non-trivial (network discovery, buffering, synchronization, etc.). Rewriting that from scratch on an ESP32 would be a huge effort, so using a proven base let me focus on modifying the audio path instead.

By default, this firmware outputs audio using I2S, which is the standard digital audio interface on the ESP32. In a typical setup, I2S sends audio data to an external DAC (for example, a PCM5102). That's the expected hardware path the original project is designed around.

However, my hardware setup is different — I'm not using an external DAC. Instead, I wanted the ESP32 to send audio over USB directly into a JBL Charge 6 speaker that accepts USB audio input. Because of this, the original I2S output path wasn't usable.

• Original path: AirPlay → decode → I2S → DAC → speaker
• Modified path: AirPlay → decode → TinyUSB → USB → speaker

To solve this, I modified the firmware at the point where the audio stream is already decoded (PCM data). Instead of passing that data to the I2S driver, I redirected it into a USB Audio Class (UAC) stream using the TinyUSB library.

Additional info to make it as a USB Host: GitHub repository: https://github.com/wasdwasd0105/airplay-esp32-usb

One of the main challenges here was configuring the ESP32 to behave as a proper USB audio device. The USB "handshake" matters — a lot.

To enable USB audio on your JBL Charge 6, you need to use a wired connection trick:

1. Power on your JBL Charge 6.
2. Press and hold the Play button on the speaker, and while continuing to hold it, plug the USB-C cable into the speaker and connect the other end to your source device (like a Mac or PC).
3. Listen for an audible confirmation sound.

The Bluetooth indicator light will turn off, indicating that the speaker has switched to a direct, lossless digital audio stream.

Once configured correctly, the JBL Charge 6 recognizes the ESP32 just like a standard USB audio source (similar to plugging in a laptop or phone). No additional drivers or special handling were needed on the speaker side.

For connectivity, I kept the built-in captive portal from the original firmware. This is very convenient for ESP32 projects:

• On first boot, the ESP32 creates its own WiFi access point
• You connect to it with a phone and enter your WiFi credentials
• The credentials are stored in flash and reused on future boots

This meant I didn't have to implement any custom WiFi provisioning.

Challenges / notes:

• The biggest challenge was replacing the I2S output with USB while keeping the audio stream stable.
• USB descriptor configuration (sample rate, bit depth, channels) had to exactly match what the speaker expects.
• Power and USB stability matter — using a proper USB-C cable helped avoid connection issues.
• Audio hiccups sometimes happen because of my WiFi speed.
• Watching YouTube on my iPhone is great, and the latency is good.
• The XIAO ESP32S3 gets hot, so it will need a heatsink.

Overall, most of the heavy lifting (AirPlay handling) comes from the original project. It works well for my usage, and I'm planning to build and test a multi-room setup.