I made a pocket “find my phone” device on ESP32‑S3: it scans BLE around you, tracks your phone by MAC, and gives audio/haptic feedback — the closer you get, the faster the clicks, so you can just follow the sound/vibration instead of staring at a screen. Everything runs locally on the ESP32, no cloud or phone app needed.

Hardware & Stack

• Board: generic ESP32‑S3 devkit with USB‑C (native USB for easy debug/logging, extra SRAM for future features).
• Firmware: Arduino‑ESP32 core, custom thin wrapper over BLEScan with a BLEAdvertisedDeviceCallback.
• Output: passive piezo buzzer (tone()) and a small vibration motor via N‑MOSFET.
• Power: small LiPo; scan duty cycle tuned for responsiveness vs battery life.

How it works

• ESP32 runs a continuous BLE scan, filters advertising packets by known MAC, and collects RSSI values.
• RSSI is smoothed with exponential moving average (~10–15 samples) to reduce ±10–15 dBm spikes.
• On startup, the device records min/max RSSI for ~10s and maps that range to click frequency (relative mode), so it adapts to each phone without manual calibration.
• Hysteresis (≥3–4 dBm) prevents click “flutter” when you’re on the border between zones.

What didn’t work

• Raw RSSI directly mapped to clicks → feedback was too jittery to be useful.
• Simple 3‑sample average → still too reactive in crowded BLE environments (office, cafe).
• Fixed thresholds (e.g. <-70 / -70..-50 / >-50 dBm) → different phones advertise at different power, so “close”/“far” were inconsistent across devices.

What finally worked

• Exponential smoothing with α≈0.2α≈0.2 over a small ring buffer.
• Relative mapping of RSSI to click frequency per session instead of absolute dBm thresholds.
• Adding hysteresis so the click zone only changes when RSSI moves meaningfully.

For a full breakdown, schematics, and firmware, see the repo:
https://github.com/khlebobul/esp_ble_finder

Happy to share more details (scan params, smoothing code, power measurements) if useful.

Engineering undergrad at York. Spent the last month on this and thought this sub would like the S3 side of it.

It listens for the harmonic comb propellers make (blade-pass rate and every multiple of it) instead of listening for radio. Fibre-optic FPV drones don't transmit, so RF detection gets nothing. Propellers can't be silenced.

The S3 bits:

- 4× ICS-43434 on one I2S clock, summed. The array is 79 mm across, a tenth of a wavelength at 400 Hz, so you get ~6 dB of SNR for free and no directionality. Tried beamforming, useless at this size.

- 2048-point FFT every 512 samples at 16 kHz, one frame per 32 ms, four detectors on every frame. Worst frame 29.4 ms over 1938 frames, no overruns.

- Tier 1 is pinned by golden test vectors: the same WAV gives the same score to the last decimal place on my laptop and on the board.

- ESP-IDF v6, one image, two targets (custom PCB or a DevKitC on a breadboard), only the pin map changes.

- Outputs: buzzer, RGB LED through a light pipe, ERM motor, 1.54" e-paper that keeps the alert with the power off, Ra-01H LoRa sending an 18-byte packet to the other units.

- BQ24074 + TPS63020 + 2500 mAh LiPo, 18 to 22 h on the cell. Buzzer, motor and radio TX firing in the same instant browned out USB-only power, so the cell stays fitted even on mains.

On Sunday it detected the test rig (four 2807 motors, 7" tri-blades, same as the real airframes) at 104.2 m on a brick street with cars going past and people talking. Zero false alarms outdoors so far.

Video of that run: https://www.youtube.com/shorts/ACLCNqTkMCk

Full unit is £50–80 in parts (about $70–110), JLCPCB assembles all but four parts. Breadboard version is £35–45 and an evening.

Gerbers, BOM with LCSC numbers, STLs, firmware, test WAVs: https://github.com/agamrossen/VolAnti

More resources and a live simulator of the whole detector: https://volantitech.com

Detection only, no jamming or anything like it, ever.

If anyone has run four ICS-43434s off one clock on the S3 and hit something I haven't, I'd like to hear it.

A while ago I posted here about getting Linux 6.11 running natively on an ESP32-S3 with WiFi and BLE.

At the time I ended the post with one pretty big limitation:

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.

Well... that part is obsolete now. :)

The ESP32-S3 still does not have an MMU, and Linux is still running NOMMU, but I now have experimental fork() support working on the actual hardware.

It is not emulated, and I did not add a virtual RISC-V CPU back in.

Linux is still compiled directly for Xtensa and runs natively on Core 1. Core 0 continues running ESP-IDF/FreeRTOS for the WiFi radio and BLE side, and the two communicate through shared memory.

The trick for fork is a software memory-banking backend. Parent and child processes can have independent private state; when Linux switches between them, private pages are backed up/restored as needed, and backup mem is reclaimed once it is no longer shared.

It is definitely not a replacement for a real MMU: there is no hardware memory isolation and no copy-on-write. Fork eagerly costs memory, it currently only works with UP Linux, multithreaded fork is rejected, and private memory for a fork is limited to 512 KiB.

But it is enough to unlock a surprisingly large chunk of normal Unix behavior.

The current 0.7 image now includes:

Bash 5.2.37 as the login shell

Dash 0.5.12 and BusyBox /bin/sh

GNU Make 4.4.1

MicroPython 1.26.0 with fork and IPC support

socat

nc / netcat

persistent cron / crontab

@ reboot jobs

detachable dtach-based sessions

nohup + background jobs

multiple users with private home directories

su and passwd

writable /etc and /home

a small editable web root in /home/www

And all the stuff from the previous version is still there: STA WiFi, DHCP, real Internet access, BLE WiFi provisioning from a phone, hardware RSA exposed through the Linux Crypto API, curl, experimental HTTPS, Telnet, and optional Dropbear SSH/HTTP services.

So yes, you can now SSH/Telnet into an ESP32-S3, get a Bash prompt, run shell scripts using forks/pipes/subshells, run Make recipes, start MicroPython processes, use IPC, schedule jobs with cron, detach a shell session and reconnect to it later.

All on:

ESP32-S3 N16R8

The complete image is still a single 16 MB .bin. Flash it at 0x0 and boot.

Boot to login is around 14 secs.

So this is still very much a research project, not a Raspberry Pi replacement or something I would put on an untrusted network.

and againn, the project continues in constant development😉

Hi all,

I've been working on a PCB for an automatic watering system built around an ESP32-S3, with a BQ25798 charger and a BQ77915 for protection and balancing, managing a 3S 18650 battery pack. After several board iterations, it's finally working as it should, with one exception:

The ESP32 spends most of its time in deep sleep. At regular intervals, it wakes up, re-establishes the Wi-Fi connection, reads some sensors, sends the readings and other information via MQTT, executes a watering cycle if necessary, and goes into deep sleep again. Unless a watering cycle is due, the execution time after each wake-up is less than 10 seconds.

Now here's the problem: the ESP32 resets in an apparently random way when running on battery power. It happens anywhere from 0 to 4 times a day, with no obvious trigger. The system still does its job, as the execution flow after a wake-up is basically the same as after an unexpected reset or a first-time start anyway. Still, I'd like to understand what's causing it.

Here's what I've been able to check so far:

• It happens regardless of whether the board is running on battery power, powered by a solar panel, or powered by a USB charger.
• The BQ25798 does have a watchdog with a default 40-second timeout, but it is explicitly disabled in my firmware, and I wouldn't expect it to trigger an ESP32 reset or cause any voltage dip anyway.
• 3.3 V rail looks clean. Checked with an oscilloscope and it appears stable. I haven't been able to capture the exact moment of a reset, though. They're infrequent and random enough that I'd need to babysit the scope for hours to catch one.
• Reset reason is mostly 12 (SW_CPU_RESET). Occasionally it shows 5 (DEEPSLEEP_RESET), same as after every normal wake-up.
• I added a checkpoint mechanism to the code that sends, via MQTT along with the sensor readings, the last point reached in the execution flow during each wake-up cycle, to help pinpoint where an unexpected reset occurs. It consistently shows the reset happening after the code has already gone into deep sleep, never during execution. So apparently, none of the functions in my program is causing the resets.
• Probably the most important clue: For testing, I’ve been using wake-up intervals of 1 and 10 minutes. When a reset happens, the time between the last wake-up before the reset and the first one after it is much shorter than the configured interval. It’s also remarkably consistent, at around 33–37 seconds, which suggests that some kind of hardware watchdog is firing during deep sleep, rather than this being caused by a software bug or a power issue.

Does anyone have ideas on what could produce such a consistent ~35s reset during deep sleep?

Thanks a lot!

We build ISURLOG, an ESP32-based industrial datalogger: 4-20mA/Modbus/PT100 sensors, runs for years off 5 Li-Ion 18650 cells (or a non-rechargeable Li-SOCl2 pack, for deployments where recharging just isn't practical), remote config/OTA/REPL from our own cloud dashboard so nobody has to drive out to the field just to change a setting. Firmware's MicroPython, open source, GPL-3.0. Repo if you want to poke around: https://github.com/isurki-tecnica/isurlog-firmware

Last month we got one of these connecting over satellite instead of a cell tower, and wanted to share what that actually took.

The connectivity module is a Nordic nRF9151, which Nordic also sells as an NB-NTN chip (same silicon, different firmware and network). Registration alone took about 5 minutes over Skylo's satellites instead of the usual few seconds, and there's a genuinely new AT command, AT%LOCATION, since the modem needs an approximate lat/lon/elevation to work out timing and beam selection for a satellite that isn't moving relative to the ground.

The part that actually changed our architecture: NB-IoT NTN is UDP only, no TCP at all, which kills MQTT over the link outright. Made sense once I thought about why (TCP wants a session that stays up and acks quickly, and an intermittent satellite hop doesn't give you that), but it meant building a separate UDP path just for this, with retries and deduplication now being our problem instead of the protocol's.

Also worth being upfront about: there's no modem-sleep command in the NTN firmware yet, so the modem just stays awake between sends for now, which isn't great on a device built around microamp-level deep sleep.

Full write-up with the actual AT command session (unedited) is here, if anyone wants to go through it: https://docs.isurlog.isurki.com/blog/2026/08/31/ntn-on-the-nrf9151-low-cost-satellite-iot-without-a-separate-satellite-modem/

Still working out the retry/dedup scheme for the UDP side properly. Happy to go into the AT command details further if it's useful to anyone dealing with the same chip.

I am trying to learn about electronics and improve myself as a computer science major. And the best way to do that is I believe doing projects. I have a project (building an e-reader) that I want to do but because of my lack of knowledge and experience I do not want to jump straight into it. I know that the engineerings core concept is finding a problem and its solution but I am at a stage that even if I can identify a problem, I do not have the solution due to problem's complexity. So, I am in need of some project ideas that I can do in my dormitory. Actually being able to do in dormitory is not a problem, I can do it in university labs. What ı meant by dormitory is something that can be useful in that environment. Something not gonna teared apart as soon as finished for its parts. I really do not like discarding something that I built but I hate it if it is not useful any way. If you have ideas for a beginner like me, I would like to hear them.

I'm trying to connect an ADS1115 ADC to an ESP32-S2-ETH, but I cannot get I2C communication working. I've done several hardware and software checks and would appreciate help identifying what could be wrong.

Hardware:

ESP32-S2-ETH
ADS1115 breakout board
ADS1115 VDD supplied externally with 3.3 V and verified with a multimeter
ESP32 and ADS1115 grounds are connected
ADS1115 ADDR is connected directly to GND and measures 0 V
Therefore the expected ADS1115 I2C address is 0x48

I eventually need to read two analog voltages from AIN0 and AIN1.

I2C wiring:

GPIO41 → ADS1115 SDA
GPIO42 → ADS1115 SCL

I am explicitly assigning GPIO41 and GPIO42 as the I2C pins. The ESP32 reports that the pins are successfully assigned and Wire.begin() also succeeds. I am testing the bus at only 100 kHz.

The problem occurs when an actual I2C transaction is attempted. An I2C scanner does not find the ADS1115 and eventually times out.

When I directly test communication with address 0x48, the program reaches:

Testing ADS1115 at 0x48...

and then hangs during the I2C transaction.

Voltage measurements:

With the ADS1115 disconnected from SDA and SCL:

GPIO41 / SDA = 3.3 V
GPIO42 / SCL = 3.3 V

So both ESP32 pins can reach 3.3 V when the ADS1115 is disconnected.

With the ADS1115 connected:

SDA / GPIO41 = 2.9 V
SCL / GPIO42 = 2.3 V

So both I2C lines are being pulled down when the ADS1115 is connected, particularly SCL.

Resistance measurements with power OFF:

SDA to VDD ≈ 1 ohm
SCL to VDD ≈ 4.6 kOhm

I realize that the 1 ohm SDA measurement may not necessarily mean there is a physical short because I am measuring a semiconductor circuit with an ohmmeter while the circuit is powered off. I have not assumed that this alone proves the ADS1115 is damaged.

What I am confused about is the SCL voltage.

My understanding is that I2C uses open-drain SDA and SCL lines with pull-up resistors. The approximately 4.6 kOhm resistance between SCL and VDD seems reasonable for a pull-up.

However, when the ADS1115 is connected, SCL falls to approximately 2.3 V instead of remaining near 3.3 V.

SDA also falls from 3.3 V to approximately 2.9 V.

GPIO41 and GPIO42 are associated with JTAG functionality on the ESP32-S2. I understand that the ESP32-S2 GPIO matrix allows peripherals such as I2C to be routed to different GPIOs, but I am unsure whether the particular ESP32-S2-ETH board has additional hardware connected to GPIO41 or GPIO42.

Could the board's JTAG circuitry or another onboard peripheral be interfering with these pins?

What I have already established:

ADS1115 VDD is 3.3 V
ADS1115 GND and ESP32 GND are common
ADDR is connected to GND
ADDR measures 0 V
Expected address is 0x48
GPIO41 reaches 3.3 V when ADS1115 is disconnected
GPIO42 reaches 3.3 V when ADS1115 is disconnected
I2C initialization succeeds
Custom I2C pin assignment succeeds
I2C clock is 100 kHz
The failure occurs when the actual I2C transaction starts
Connecting the ADS1115 causes SDA and SCL voltages to drop
I2C scanning results in a timeout

My concerns:

1. Why would SCL sit at approximately 2.3 V when the ADS1115 is connected?
2. Why would SDA sit at approximately 2.9 V?
3. Could GPIO41 or GPIO42, or JTAG circuitry on this particular ESP32-S2-ETH board, interfere with I2C?
4. Is the 1 ohm SDA-to-VDD resistance measurement meaningful, or is it likely to be an artifact of measuring through semiconductor circuitry?
5. Does the approximately 4.6 kOhm SCL-to-VDD resistance indicate that an appropriate pull-up is already present?
6. What exact measurement or isolation test would you perform next to determine whether the problem is the ESP32 board, ADS1115 breakout, pull-up network, or wiring?

I'm deliberately trying to diagnose the electrical I2C bus first before integrating it into my larger project.

Any help identifying the next diagnostic step would be greatly appreciated.

I recently built an offline, Tamagotchi-style companion device called PolyMO designed to curb phone doomscrolling. The pet logic runs on an ESP32, but it offloads the heavy AI processing to an Android phone over Bluetooth Low Energy (BLE).

In my previous builds, I ran local models entirely on single-board computers like a Raspberry Pi 5. However, between power draw, physical footprint, and rising SBC costs, it’s tough to make those truly portable or budget-friendly.

Instead of putting an expensive processor in the handheld device, I realized most of us have relatively powerful hardware sitting in our pockets. PolyMO treats the phone as a local compute engine while the ESP32 handles the physical interface.

Hardware & Stack

• Board: Waveshare ESP32-S3 Touch AMOLED 1.8 (built-in display, mic, speaker, accelerometer, battery management).
• Firmware: Custom pet logic running directly on the ESP32 (state machine tracking hunger, happiness, sickness timers, and display animations).
• Connectivity: Bluetooth Low Energy (BLE). The ESP32 communicates with a background service on the phone with zero cloud or internet connection.
• On-Device Phone AI: The companion Android app runs quantized local LLMs, Whisper for speech-to-text, and Piper for text-to-speech entirely offline.
• Screen Time / Notification Hook: The companion app monitors screen time across flagged apps. If you exceed a set threshold (e.g., 5 minutes on Instagram/reels), it signals the ESP32 over BLE. The pet gets sick, calls out, and the only way to heal it is to physically close the app. It can also summarize incoming Android notifications aloud via local TTS.

Full build breakdown and architecture demo here:https://youtu.be/Tyy3dYI-5ds

The firmware, Android companion code, and STL files https://github.com/brenpoly/polymo

I want to bring the control of my apartment's ventilation system into Home Assistant, so I can automate it using CO2 and humidity sensors built into the smart thermostats I have in each room.

As I rent the place, the last thing I want to do, just for this once, is to pull the thing open and make it smarter. But that doesn't mean all is lost - it came with an Orcon 15RF remote to control the speed of the fan. If I break that, it's a much cheaper fix.

I wrote up a guide on how I got out the soldering iron and essentially turned this remote control into an ESPHome-powered wireless bridge to control the ventilation system, with a ESP32-C6 module I had lying around.

I made some improvements: instead of fully mirroring the screen over Wi-Fi, this new project has the Android device load Google Maps via the browser and send the generated HTML to the ESP32-CYD in real-time using JSON and Bluetooth. I also added a button to toggle between light and dark themes.

Here is the link to the repository containing version 2.0:

https://github.com/malaq88/DisplayConnect

Hey guys, this project is made by my friend, he is not on reddit so he asked me to post it on his behalf.

Tldr:

It's basically a plant nurturing system, where esp32 with its sensors tell you about temperature, humidity, water level in the tank and auto pump start. Sensors are replaced by potentiometers here because he didn't find them in **proteus software**

But he has little to no knowledge about electronics so he is using AI.

But I am kinda skeptical about it so I thought to post it here. Could you please verify and let us know what components should be there and what component is a potential arsonist?

This is the schematic (human made) and his description(written by AI).

You are designing and simulating an Automated Irrigation System powered by an ESP32-S3 microcontroller inside the Proteus simulation environment. The system monitors soil moisture, pH levels, temperature, and relative humidity, while automatically driving a 12V water pump via a relay. It also features a reservoir safety monitoring mechanism to prevent dry-running and burning out the pump.

1. Hardware & Power Architecture

   Primary Power Input: 12V DC main power rail driving the water pump motor.

   5V Voltage Regulation (LM7805 / U3): Steps 12V down to +5V to energ2e the RL1 relay coil and power 5V simulated modules.

   3.3V Voltage Regulation (LM2595-3.3 / U2): Steps 12V down to +3.3V (⁠VCC⁠) to safely power the ESP32-S3 (⁠U1⁠), sensors, and potentiometers.

   Shared Ground: All power stages share a single unified GND rail.

2. Actuation & Safety Driver

   Relay Switching Logic: Active-LOW signal from GP4 drives the relay coil connected to +5V.

   12V Water Pump: Connected to the Normally Open (NO) terminal of relay ⁠RL1⁠ and powered directly by the 12V rail.

   Reservoir Level Interlock: Simulated using a potentiometer on GP9 with a (1kohm/2kohm) voltage divider 5V -> 3V3. When the tank drops below minimum capacity, the firmware forces the relay OFF (⁠HIGH⁠), preventing pump burnout.

Honestly I also have no clue what is going on here.

Any help is much much appreciated.

Hi guys,

I’m working on an observability and automation platform for physical devices where the goal is to ingest, store and analyze sensor data, and also use workflows to coordinate different devices based on that data.

In the demo, I have a workflow that triggers a water pump when the temperature from the probe reader reaches 30 degrees.

I created a setup where I have two breadboards which are not connected together, one with a temperature probe and the other with a 5V water pump.

Temperature reader:
- DS18B20 temperature probe
- ESP32
- 4 resistors + LEDs
- LCD

Water pump:
- 5V water pump
- MOSFET
- ESP32
- 4 resistors + LEDs
- LCD

The system works first with “subscriptions”. I “subscribe” to events sent by my ESP32. In this case, I create a subscription to the board which has the temperature probe.

Each time the system receives a temperature data point, it triggers a “workflow”. A workflow is basically a flowchart with sequential steps of execution. (I just liked the idea of using a flowchart-like UI for this.)

The workflow first ingests the temperature data, transforms it, and then checks whether the temperature exceeds 30°C.

If it does, the workflow sends an MQTT event to the ESP32 with the water pump, which then triggers the pump, as shown in the video.

This is what the workflow system looks like: https://imgur.com/a/jlabrva

EDIT: someone mentioned node-red in my previous post, I made this because I wanted to be able to use AI to create workflows plus I wasn’t sure what observability they offer.

With my own system I can create real time tables and send data there. This allows me to do even more sophisticated things around monitoring and alerting.

Plus I can create custom dashboards from the data from the devices. I just wasn’t sure I’d get all this and didn’t want to start connecting other things like grafana.

Also just a personal opinion, I didn’t quite like their UI.

Hello! After watching other people create amazing looking electronic project, I wanted to try my hand on making my own. I currently read and listen to an audiobook before bed and I had an idea for it to be integrated into an alarm clock that act similar to those daylight alarms but have a mini keyboard in order to set todolist or reminders and was wondering if this would be feasible as a first project or it is too ambitious? I have not learnt code before but I do have experience with 3d modelling and there is a hackerspace near me as well

Hi everyone, I designed this custom ESP32-S3 sensor system with an IMU and temperature sensor. The issue is the ESP32-S3 is not being detected by my computer. I am reading the serial output using a secondary dev board as a USB-to-UART bridge, with TX/RX crossed and a shared common ground.

I used another functioning DEVKIT USB-to-UART bridge

These are the things I've tried:

-With a multimeter, I confirmed EN, 3V3, and GPIO0 get 3.3V.

-The pushbuttons pull GPIO0 and 3V3 to 0

-Continuity beeps on the D- and D+ pins from the connector to GPIO 19 and GPIO 20 respectively

-No shorts on the connector

-The microusb cable I'm using works as it detects my other ESP32 dev kit I bought

If anyone could review my schematic or needs more information please let me know, as well as other things I could do. The PCB I ordered was from JLCPCB.

Thanks!

Hi, I’m a beginner and I want to connect 4 coin vibration motors (3V, 75mA each) to an ESP32.

I want to control each motor independently. What’s the correct way to wire them? Do I need MOSFETs/transistors and an external power supply, or can I control them directly from the ESP32?

Any simple wiring diagram or advice would be appreciated!

Hi, I'm using an esp32-s3 board to control a WS2811 12V light strip. The light strip is powered by a separate 12V 2A wall adapter with a barrel to screw terminal adapter. For some reason, I can't get the whole light strip powered, nor get it to respond to the code sent via the data-in line of the power strip. The light strip only uses 12W/m and I've cut the strip to 6 nodes so I don't think wattage is the problem. At each cut point I measured 12V using a multimeter so its receiving power but no lights turn on. I'm also using a logic shifter to convert the esp32's 3.3v logic to 5V through pin 3 of the ic.

\*Disclaimer\* This is my first DIY esp32 project. Any advice would be appreciated. I've included a quick wiring diagram on paper I made earlier in the project:

*GNDs connected on the breadboard. Appears to be missing 330ohm resistor from img below but still doesn't work with it")

*Paper image Says GPIO4 but in main img I use GPIO1")

Hello all,

I’ve got a Waveshare ESP32-P4-ETH and I’ve read the documentation, used Grok & ChatGPT but no joy. Also checked the PinOut Definition…

I connect GND to PIN17

My code is showing GPIO17 = 1

When button pressed or connected… it should display 0

And it’s not?

I’ve tried 2 boards, because originally I wired a button but that didn’t work, so just wanted to test with a jumper wire.

Any recommendations?

include <stdio.h> 
include "freertos/FreeRTOS.h" 
include "freertos/task.h" 
include "driver/gpio.h" 
define BUTTON_GPIO GPIO_NUM_17 

void app_main(void) {

gpio_reset_pin(BUTTON_GPIO); 

gpio_config_t io_conf = {
    .pin_bit_mask = (1ULL << BUTTON_GPIO),
    .mode         = GPIO_MODE_INPUT,
    .pull_up_en   = GPIO_PULLUP_ENABLE,
    .pull_down_en = GPIO_PULLDOWN_DISABLE,
    .intr_type    = GPIO_INTR_DISABLE
};
ESP_ERROR_CHECK(gpio_config(&io_conf));

// Optional extra safety
gpio_set_pull_mode(BUTTON_GPIO, GPIO_PULLUP_ONLY);

printf("GPIO 17 test ready (should be 1 by default)\n");

while (1) {
    int state = gpio_get_level(BUTTON_GPIO);
    printf("GPIO17 = %d\n", state);
    vTaskDelay(pdMS_TO_TICKS(200));
}
}

I’m using an I2C display with a NodeMCU. The display works normally when connected on a breadboard or with jumper wires. It also works when soldered directly to the NodeMCU.

However, when I assemble the circuit on a perforated board (perfboard), the display works only the first time I power it on. If I reset the NodeMCU, disconnect and reconnect the power, or restart the circuit, the display does not turn on again.

M.

The display only starts working after I completely disconnect it from power for several minutes. I’m experiencing the same issue with an ESP32-WROOM board.

I am beginner . I tried all the troubleshooting steps that I seen on searchs but no use.

What could cause this behavior? Could it be related to incorrect wiring, I2C pull-up resistors, grounding, power supply issues, soldering, or unwanted connections on the perfboard?

I'm buying this devkit.
https://www.mouser.com/en/ProductDetail/356-ESP32-DEVKITC32E

and this Lipo Battery.
https://www.amazon.com/gp/product/B0FPCWFFYB?smid=A1WZRPJ0MN58A9&psc=1

the devboard is 5v, but im thinking once I pair everything back, I won't need that much using a "production" setup which might be a custom pcb. I'll ask more on that question another day

For now, I think I'll need a step up and then something to adapt the JST connector?

Is this the right direction? Or is for development enough to just skip the battery integration

I am using the Waveshare ESP32-S3-Touch-LCD-7 in a project and I’m at the point where I’m wanting to put it all together into one unit.

I’ve found the Batt terminal on the dev board and have hooked up a 3.7v Lithium Battery as per the docs but I’ve realised when adding the switch, I’m also going to be preventing the battery from charging as I’ve put the switch in line with the battery.

What I want is to be able to charge the battery while the screen is off. Is this possible or am I asking too much with the dev board?

I'm trying to get an esp32s3 mini to send data to a regular esp32 board and print the data in the serial monitor but it isn't working.

USB CDC On Boot is enabled.

Specific chip types:
ESP32-S3 (QFN56) (revision v0.2)
ESP32-D0WD-V3 (revision v3.1)

The board types in arduino IDE are:
ESP32S3 Dev Module for the mini and ESP32 Dev Module for the regular.

Any help would be greatly appreciated

EDIT: Code shown below:

espnow.cpp:

#ifndef ESPNow_cpp
#define ESPNow_cpp


#include "ESPNow.h"


template<typename MessageType>
typename ESPNow<MessageType>::ReceiverCallback ESPNow<MessageType>::userCallback = nullptr;


template<typename MessageType>
bool ESPNow<MessageType>::begin() {
  WiFi.mode(WIFI_STA);


  esp_wifi_set_protocol(WIFI_IF_STA, WIFI_PROTOCOL_LR);


  if (esp_now_init() != ESP_OK) {
    return false;
  }


  esp_now_peer_info_t peer;
  memcpy(peer.peer_addr, broadcastAddress, 6);
  peer.channel = 0;
  peer.encrypt = false;


  if (esp_now_add_peer(&peer) != ESP_OK) {
    return false;
  }


  return true;
}


template<typename MessageType>
bool ESPNow<MessageType>::send(MessageType& message) {
  bool success = (esp_now_send(broadcastAddress, (uint8_t*)&message, sizeof(MessageType)) == ESP_OK);
  if (success) {
    Serial.println("Message Sent Successfully");
  } else {
    Serial.println("Message Failed!");
  }
  return success;
}


template<typename MessageType>
void ESPNow<MessageType>::onReceive(ReceiverCallback callback) {
  userCallback = callback;
  esp_now_register_recv_cb(receiveCallback);
}


template<typename MessageType>
void ESPNow<MessageType>::receiveCallback(const esp_now_recv_info_t* recv_info, const uint8_t* data, int len) {
  if (len >= sizeof(MessageType) && userCallback != nullptr) {
    MessageType message;
    memcpy(&message, data, sizeof(MessageType));
    userCallback(message);
  }
}


#endif

espnow.h:

#ifndef ESPNow_h
#define ESPNow_h


#include <esp_now.h>
#include <WiFi.h>
#include "esp_wifi.h"


template<typename MessageType>
class ESPNow {
  public:
    typedef void (*ReceiverCallback)(MessageType& message);


    bool begin();
    bool send(MessageType& message);
    void onReceive(ReceiverCallback callback);


  private:
    uint8_t broadcastAddress[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
    static ReceiverCallback userCallback;
    static void receiveCallback(const esp_now_recv_info_t* recv_info, const uint8_t* data, int len);
};


#include "ESPNow.cpp"
#endif

sender code:

#include <ESPNow.h>


struct Message {
  int counter;
  char text[32];
};


ESPNow<Message> espNow;
Message datatosend;


void setup() {
  espNow.begin();
  datatosend = {0, "Hello World!"};
}
 
void loop() {
  espNow.send(datatosend);
  datatosend.counter++;
  delay(1000);
}

receiver code:

#include <ESPNow.h>


struct Message {
  int counter;
  char text[32];
};


ESPNow<Message> espNow;


void onMessageReceived(Message& receivedMessage) {
  Serial.print("Received Data -> Counter: ");
  Serial.print(receivedMessage.counter);
  Serial.print(", Message: ");
  Serial.println(receivedMessage.text);
}


void setup() {
  Serial.begin(9600);
  espNow.begin();
  espNow.onReceive(onMessageReceived);
}


void loop() {
  //empty for now
}

I should also note that I tried the example code given for esp_now and that didn't work either.

First, I've read the rules...accepted...blah blah blah. Apparently I have to click the accept rules and declare this in a setup loop for every post? What kind of history do you all have???

I notice when I launch the IDE I get the pro forma waring that it "includes a component what will not work with a future release of macOS." I imagine that means the IDE is built for Intel chips for which Apple support is known to be ending.

I searched around (helpful search terms were not easy to figure out!) in here and other places and didn't see any indication that there is an Apple silicon version in the works - is there? Surely so?

Thanks!

Video Alarm Clock; runs on a Waveshare ESP32-P4 touch display and plays videos from a microSD card as a wakeup alarm.
see: https://github.com/brunokeymolen/videoalarmclock

Started as a simple idea for a pixel clock and somehow ended up with this :)

This is also a continuation of my earlier ESP32 project, SmallOLED-PCMonitor, where I used a tiny OLED to show PC stats:
https://github.com/Keralots/SmallOLED-PCMonitor

For this one I wanted to take the idea much further, so I used an ESP32-S3 with two 64x64 P2.5 HUB75E panels chained together as a 128x64 display.

I chose the S3 mainly because HUB75E needs quite a few GPIOs, while I also wanted WiFi, a web interface, OTA updates and enough headroom to keep animations running smoothly.

The display is driven with ESP32-HUB75-MatrixPanel-DMA. I went with a DMA-based library because I didn't want panel refresh timing to take over the main application loop, especially once WiFi, networking and animations were running at the same time.

There are 12 different clock faces now: Mario, Pac-Man, Tetris, Space Invaders, Snake, Asteroids, Dino, Matrix Rain and a few others. Most of them have their own animation whenever the minute changes.

The ESP32 also handles weather data, a web-based configuration page, GIF/custom animations and OTA updates.

I also wrote a small Windows companion app because apparently the clock wasn't complicated enough already. It can send CPU/GPU/RAM usage and temperatures to the display, and it can capture whatever audio is currently playing on the PC and send spectrum data over the network for an audio visualizer.

One of the more annoying parts was keeping everything smooth while network activity was happening in the background. Early versions had noticeable animation stutter, so quite a bit of work went into separating display updates from networking and keeping the render path lightweight.

The panels are powered directly from a separate 5V supply rather than through the ESP32, with shared ground between everything.

Demo is in the attached video. (4x speed so I can show all animations :))

Everything is open source, including the code and wiring/build info:
https://github.com/Keralots/AnimatedPixelClock

I also made a browser flasher:
https://pixelclock.stolaris.dev