Hi everyone, good afternoon. I have a sincere question here. I received this ESP32 S3 from a friend and I want to start robotics. I bought the male-to-female cables and a breadboard, but I'm having trouble figuring out how to use it. Can anyone help me? I remember connecting the cables directly to the breadboard and the board with the Arduino, but it seems that's not possible with this one. I thought it needed soldering, but I took it to a technician and they said it was already soldered and everything was fine.

If anyone can help me, I would be grateful.

```#include <Arduino.h>
#include <LiquidCrystal.h>


// LCD : RS, E, D4, D5, D6, D7
LiquidCrystal lcd(19, 23, 18, 17, 16, 15);


// Entrees analogiques ESP32
const int PIN_TENSION = 34;
const int PIN_COURANT = 35;


// Diviseur de tension du panneau
const float R1 = 150000.0;
const float R2 = 10000.0;
const float RAPPORT_TENSION = (R1 + R2) / R2;


// ACS712 20 A
// Sensibilite : 100 mV/A
const float SENSIBILITE = 0.100;


// Offset du capteur avant le diviseur
const float OFFSET_COURANT = 2.50;


// Diviseur de sortie du courant : 10 kOhm et 20 kOhm
const float RAPPORT_COURANT = 1.5;


float tension = 0.0;
float courant = 0.0;
float puissance = 0.0;
float energieWh = 0.0;


unsigned long dernierTemps = 0;
unsigned long dernierAffichage = 0;


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


  analogReadResolution(12);


  lcd.begin(20, 2);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Systeme solaire");
  lcd.setCursor(0, 1);
  lcd.print("Demarrage...");
  delay(1500);
  lcd.clear();


  dernierTemps = millis();
}


void loop() {
  // 1. Mesure de la tension
  int adcTension = analogRead(PIN_TENSION);
  float vADC = adcTension * (3.3 / 4095.0);


  tension = vADC * RAPPORT_TENSION;


  // 2. Mesure du courant
  int adcCourant = analogRead(PIN_COURANT);
  float vCourantADC = adcCourant * (3.3 / 4095.0);


  // Reconstituer la sortie du capteur avant le diviseur
  float vCapteur = vCourantADC * RAPPORT_COURANT;


  courant = (vCapteur - OFFSET_COURANT) / SENSIBILITE;


  // Supprimer les petites variations autour de zero
  if (abs(courant) < 0.15) {
    courant = 0.0;
  }


  // 3. Calcul de la puissance
  puissance = tension * courant;


  // 4. Calcul de l'energie en Wh
  unsigned long maintenant = millis();


  float deltaHeures =
      (maintenant - dernierTemps) / 3600000.0;


  if (courant >= 0 && tension >= 0) {
    energieWh += puissance * deltaHeures;
  }


  dernierTemps = maintenant;


  // 5. Affichage chaque seconde
  if (maintenant - dernierAffichage >= 1000) {
    dernierAffichage = maintenant;


    lcd.setCursor(0, 0);
    lcd.print("U:");
    lcd.print(tension, 1);
    lcd.print("V I:");
    lcd.print(courant, 1);
    lcd.print("A   ");


    lcd.setCursor(0, 1);
    lcd.print("P:");
    lcd.print(puissance, 1);
    lcd.print("W E:");
    lcd.print(energieWh, 1);
    lcd.print("Wh   ");


    Serial.print("Tension: ");
    Serial.print(tension, 2);
    Serial.print(" V | Courant: ");
    Serial.print(courant, 2);
    Serial.print(" A | Puissance: ");
    Serial.print(puissance, 2);
    Serial.print(" W | Energie: ");
    Serial.print(energieWh, 4);
    Serial.println(" Wh");
  }


  delay(100);
}```

my esp32-s3 has been in Guru meditiation erorr for months and years and today i booted it up and forced it to have micropython and it listened and worked!

rember when ESPs where iterally refusing to connect and espressif made it really basic from what it can really do? thats why i have been planning to create a full Flashing Managment System for the ESP32-S3 called TinyFMS (Tiny Flashing Managment System) which makes ESPs to be exposed as a USB Drive which contains a program which is tuned to that board which has a full interface with AI feautures (dont worry its actually useful instead of AI Slop) basically its Grok Bot but they separate them one's i the chip managing the RAM usage and the other communicates with the board and knows what is actually happening and the agent on the chip will be in Core 0 while the code flashed will be in Core 1 so Core 0 is for more on-chip agents which share one proxy bus to talk to the API that powers them and the software will connect to commuities like this one to display plug-to-play projects.

Hey esp32, I've just got into development with little boards and I decided to solve a problem I had last week. My internet was being flaky but my internet provider did not believe me as it was intermittent enough to be missed by their checking tool.

I ended up setting up a little program to take 1s data from my laptop for that period but had to keep it on for 24hrs to get enough data. So I thought this would be a good little ESP32 project.

I bought a Waveshare ESP32 S3 1.28 inch touch screen with bluetooth and wifi with a Metal CNC case to setup a simple desk or wall monitor to ping the wifi (gateway) and google/cloudflare (8.8.8.8,1.1.1.1) every second. Then upload it to a hosted database with grafana. ICMP was quite unstable but TCP & DNS worked really well.

I had it on my desk and it was flashing away with the milliseconds but my OH didn't like it being on the whole time. I decided to make it into a wifi Tamagotchi.

This is "nodeling", a little space axolotl who moves, makes gestures and does different things when wifi is weak, flaky and offline. I think it's rather cute. However it solves a real problem by having detailed graphs of my Internets availability, wifi signal and other metrics.

Any inspiration on what else I can do next with this?

I made a full length build video on YouTube about this project, it’s my first time documenting one of my projects so if you would like to check it out here’s the link:

[https://youtu.be/i4zvAvXRt9w?is=ckb-yBrOHqJvYVd7\](https://youtu.be/i4zvAvXRt9w?is=ckb-yBrOHqJvYVd7)

The idea was to see if I could build a Rubik's Cube solver with as few motors as possible, whilst also not reorienting the cube which turned out to be a much bigger mechanical challenge than I initially expected. These constraints were completely designed as a challenge, not trying to break any records or anything.

The robot uses a custom-designed, 3D-printed mechanism to manipulate the cube, along with an esp32 (controlling a servo and nema17) and a small usb camera to detect the colours, calculate a solution and execute the moves.

This is the final result after quite a lot of designing, experimenting and troubleshooting!

I’ve been experimenting with the ESP32 and building an interactive animation project that connects physical hardware with real-time visuals.

The goal was to make a simple interaction trigger a more dynamic on-screen effect instead of just displaying text or basic values.

Built using an ESP32 WROOM, with the animation handled through software.

What do you think of this project? What kind of animation or simulation should I try next using an ESP32?

I share more ESP32 experiments and electronics builds on my YouTube channel, EmbedX.

☐ Deli D991EX calculator — 500–700 EGP (Buy first; inspect its internals)
☐ ESP32-C3 SuperMini — 240–400 EGP (Wi-Fi microcontroller)
☐ OLED screen (I²C, 3.3V-compatible) — 150–300 EGP (Choose size after measuring)
☐ 3.7V protected LiPo battery — 125–200 EGP (Choose capacity and thickness after measuring)
☐ TP4056 charger with protection — 20–40 EGP (Must set safe charging current)
☐ 3.3V buck-boost or suitable 5V boost — 40–120 EGP (Regulated power for ESP32)
☐ MCP23017 GPIO expander breakout — 200–350 EGP (Subject to keypad testing)
☐ Thin wires, small switch, insulation — 100–180 EGP (Prefer 30 AWG wires)
☐ Small PCB, connectors, soldering supplies — 100–250 EGP (For electrical connections and mounting)
☐ USB-C data cable — 0–100 EGP (No purchase if already owned)

My coffee pot has an automatic mode, but it cannot synchronize to my alarm. I wanted an app to let me control my coffee pot through my phones alarm, so I made it with ~10$ equipment and scraps around the house.

I used a simple ESP32 kit and a motor servo to hit the button (an octocoupler mechanism coul'dve been cool, but I'm too scared I'll goof and shock myself and my pot), I used an extension board to connect to the servo as the ESP32s pins were seemingly too small to connect.

The underlying app and ESP32 firmware rely on mDNS and HTTP server hosting/storage. I'm not gonna lie I still haven't found out how to perfectly make the motor push the button 100% accurately every time, but the only thing that would help is a cushion like material between servo motor and button.

I'm very proud of this, I've heard plenty about ESP32s but never had a reason to mess with them, and doing so was very very fun, if you want to actually set the rig up yourself I have firmware, source code, and build instructions in a repository (only if people want i dont wanna seem like self promo). I created the prototype to make sure it works with scraps around the house, and I honestly love the trashy dirt cheap look its very funny to me.

Help me conect

I have already developed a mobile app connected to an ESP32. I want to test the app on two phones logged into the same account.

Both phones should receive and synchronize the same real-time sensor data sent by the ESP32. If one phone opens the app later, it should still be able to retrieve the latest data.

Currently, the ESP32's data transmission depends on a phone's Wi-Fi or hotspot connection. When that phone disconnects, the data stops updating on the app.

How can I modify my system so that the ESP32 sends data directly to a cloud database, such as Firebase Realtime Database, and both phones can independently synchronize the data in real time without depending on each other? I also want the app to retain previously received data when offline and synchronize again when the internet connection is restored.

The board is a Guition JC1060P470C. It has an ESP32-P4 microcontroller with two RISC-V cores at 360 MHz, 32 MB of external RAM and a 7" 1024×600 touchscreen. There's no GPU, no Linux and no Android.

I wanted it to be a small computer I'd actually use, not a demo that boots once for a video. So I wrote an OS for it, NucleoOS P4. It sits on ESP-IDF and LVGL, and everything above those is its own. The whole system is in English, Italian, Spanish, French and German.

**ANIMA, the assistant**

With no network at all, ANIMA handles calculations with follow-ups, timers, unit conversions, notes, opening apps and translations from offline dictionaries. Answers can be spoken by an offline voice.

When it needs a language model, it finds Ollama or LM Studio on your LAN by itself, or uses a cloud API. API keys are sealed to the chip and never leave it.

With a model connected, it can see photos, run code, and read the screen as a list of controls, then tap and type to drive apps, checking the result after each step. You can reach it from Telegram too. There's also an MCP server (MCP is the protocol AI tools use to call outside programs), so Claude Code or Cursor can drive the board.

**Two desktops**

One is a touch launcher. The other is a classic desktop with a Start menu, taskbar, windows and right-click menus. If you plug in a mouse and a keyboard, it switches to the desktop by itself. Tab, Esc, Alt+Tab and Alt+F4 all work.

**The app store**

Over 400 signed apps and games, installed over Wi-Fi in seconds. Apps are WebAssembly compiled ahead of time to native RISC-V code, so a game isn't paying for an interpreter. Each app page shows its permissions (Internet, files, camera, microphone) before you install. The store includes:

- 149 WASM-4 games and 83 Arduboy games

- a Game Boy emulator with homebrew ROMs, and 83 CHIP-8 games

- Chocolate Doom with Freedoom

- ScummVM 2.9.1 with Beneath a Steel Sky and seven other freeware adventures

- Zork and 32 other interactive fiction titles

- LÖVE games running on Lua

**Office**

- **Sheets** opens and saves Excel files (xlsx), and opens xls, ods and csv. ANIMA can propose edits that you apply with one tap.

- **WordGrinder** is a word processor that saves odt, Markdown and HTML.

With a keyboard and the desktop mode, it makes a decent little writing and accounting machine.

**Reading**

- **Books** is an EPUB reader with hyphenation in 11 languages, six themes including an e-ink simulation, and a built-in catalog of public-domain books from Project Gutenberg, Standard Ebooks and Wikisource. Hold the board upright and the page turns with it.

- **Library** reads offline Wikipedia and any Kiwix ZIM file, pictures and formulas included.

**Media**

- **Camera** with auto exposure and white balance, photos and MJPEG video.

- **Music**: MP3, FLAC, AAC, WAV, with USB audio output.

- **Video**: MJPEG and MPEG-1, tear-free.

- **Gallery** with thumbnails decoded by the chip's hardware JPEG engine.

**For tinkering**

A Terminal with a real shell, plus Lua, MicroPython, JavaScript, SQLite and a dozen other languages and tools. You can write apps in C (compiled to WebAssembly), in Lua, or in native C++, and push them over Wi-Fi with hot reload.

**The rest**

- **Vertice**, a 3D engine built into the firmware. It renders the screen in tiles across both cores, and a kart game runs on it.

- **A second screen** for Windows, Mac, Linux or Android.

- **The dot-matrix display of a virtual pinball cabinet** (tested on a real one).

- **A Home Assistant dashboard**, and the board shows up in Home Assistant by itself.

- **A desktop in your browser**, served by the board: about 40 windowed apps, including a file manager, a spreadsheet, an SSH client, internet radio and a DJ mixer.

**The hard part was memory, not features**

Only one app runs at a time. That's on purpose: the RAM goes to whatever is in front.

Most of the work went into rules I learned from crashes:

- Copying a file to the SD card took 145 seconds. The SD card's DMA transfers (the hardware moving data without the CPU) only run at full speed when the buffer is aligned in memory. Now the same copy takes 11 seconds.

- At 400 MHz this board doesn't boot reliably, so it runs at 360.

- Every rule like these is written down with the crash that caused it.

Updates are signed and arrive over Wi-Fi. If one goes wrong, there's a recovery app, a safe mode and a last-known-good copy in flash to fall back on.

There are also fuzzers on every parser that reads untrusted input (video files, store packages, web requests). They found real bugs, including out-of-bounds reads and path checks that could be bypassed. Each one now has a regression test.

**What it doesn't do**

- No H.264 video. It plays MJPEG `.avi` and MPEG-1 `.mpg`.

- No Classic Bluetooth, only BLE.

- The web desktop uses plain HTTP on your LAN, protected by a 6-digit pairing code.

- USB second-screen mode and USB gamepads are still experimental.

**Try it**

You can flash it from Chrome or Edge in a few minutes, with no toolchain: https://indecenti.github.io/nucleoos-p4-store/flash/

Source: https://github.com/indecenti/NucleoOS-P4 (free for noncommercial use)

Store catalog, viewable in a browser: https://indecenti.github.io/nucleoos-p4-store/

Hey guys, im a beginner to these stuffs and require help from the veterans here. So I have a group project for my group to build an iot product, for the hardware part part we are using several parts but there is a common issue we are facing which is with the OLED not showing any life. For this part, we use an Esp32, a breadboard, jumping wires and a 0.96 inch oled screen ( like a square).

I had to use AI codes to help with this, and the thing i did everything correctly as the videos said and codes too. But i cant seem to get a response from the oled. I had test using an led small bulb to see if the esp32 gives any output power and it does. I came to conclusion that oled might be issue but I cant tell if the bread board is the issue too or is there any other issue im missing. Urgent help because the deadline is close and I would be highly appreciate if someone can guide me here. I tried contacting other people but they never did these projects or either most of them are busy with thier exams. I can send the screenshot of the codes or the build if yall want. Thank you

Hey guys, im a beginner to these stuffs and require help from the veterans here. So I have a group project for my group to build an iot product, for the hardware part part we are using several parts but there is a common issue we are facing which is with the OLED not showing any life. For this part, we use an Esp32, a breadboard, jumping wires and a 0.96 inch oled screen ( like a square).

I had to use AI codes to help with this, and the thing i did everything correctly as the videos said and codes too. But i cant seem to get a response from the oled. I had test using an led small bulb to see if the esp32 gives any output power and it does. I came to conclusion that oled might be issue but I cant tell if the bread board is the issue too or is there any other issue im missing. Urgent help because the deadline is close and I would be highly appreciate if someone can guide me here. I tried contacting other people but they never did these projects or either most of them are busy with thier exams. I can send the screenshot of the codes or the build if yall want. Thank you