Seeking Advice On ESP32 Boards

Thanks - good info from your project. Below is focused, practical advice to help you pick an ESP32 board that behaves like an EZB for ARC, plus configuration tips and recommended boards.

Summary recommendation (short)

• If you want the easiest, proven path with Synthiam’s EZB firmware: get a DOIT / WROOM32 DevKit (aka ESP32 DevKit v1 or NodeMCU32S). It’s supported by the Synthiam firmware and works well for ARC (WiFi + serial).
• If you want builtin native USB device (so the ESP can present itself to Windows as a COM/CDC device without an external USBUART bridge), consider an ESP32S3 dev board. That gives a nicer USB wired option - but confirm you have EZB firmware compiled for S3 or be prepared to build/modify firmware.

Key capabilities you asked about

• Digital I/O: All ESP32 dev modules have many GPIOs - far more than 15 usable digital ports. Be mindful some pins are inputonly or reserved (boot strapping pins).
• ADCs: ESP32 ADC1 has 8 usable ADC channels (GPIO32-39) - this meets your 7+ ADC requirement. ADC2 has more channels but is shared with WiFi (avoid for stable ADC while using WiFi).
• UARTs: ESP32 has 3 hardware UARTs (UART0, UART1, UART2). You can map UARTs onto many GPIOs via the GPIO matrix. So 2-3 UARTs available - matching your need.
• WiFi: native on all ESP32 chips (WROOM/WROVER/S2/S3/C3 variants).
• USB wired / USBtoPC: Typical DevKit boards include a USBUART bridge (CP2102/CH340) to program the chip and expose UART0 over USB. If you want the ESP itself to act as a USB CDC device (no separate bridge), choose a board built with ESP32S2 or ESP32S3 (native USB). Note: firmware must support native USB CDC for it to appear as a serial device to Windows.

Recommended boards and pros/cons

1. DOIT ESP32 DevKit v1 / ESP32WROOM32 (best proven choice)

   • Pros: confirmed compatible with Synthiam EZB firmware (see Synthiam DevKit doc), inexpensive, widely available, works with ARC over WiFi and via USBUART (using onboard bridge).
   • Cons: USB is via bridge (not native), limited PSRAM (unless you buy WROVER).

   Synthiam reference: https://synthiam.com/Support/Hardware/Esp32-DevKit-v1

2. ESP32WROVER dev board (WROOM with PSRAM)

   • Pros: more RAM (PSRAM) for heavier tasks, same compatibility as DevKit.
   • Use if you need more memory for larger firmware or more features.

3. ESP32S3 dev board (native USB)

   • Pros: native USB device support (can act as USB CDC/COM device if firmware implements it), more capable for USB scenarios, good I/O count.
   • Cons: EZB firmware may need to be compiled/verified for S3. If Synthiam hasn’t published a ready S3 build, you’ll need to build firmware or confirm compatibility.

4. ESP32C3 (RISCV) or ESP32S2

   • Pros: also have native USB on some variants (C3/S2).
   • Cons: different peripheral set; ensure firmware exists for the specific chip you choose.

Servo and GPIO guidance (safety)

• Synthiam notes recommended servo pins (for DevKit): 2, 4, 1219, 2123, 2527, 3233. Use these for PWM/servo outputs for best results.
• Avoid using certain pins for servos that are boot straps or have other special functions (you may brick booting if you pull them low/high on reset).
• ARC servo ports are labeled d0-d23. When mapping to ESP GPIOs, ARC’s ESP32 EZB firmware handles the translation - check the firmware/skill’s pin mapping table for exact Dx GPIO mapping.

How to get a wired COM connection to Windows (three options)

1. Use the DevKit’s builtin USBUART bridge (easy): plug the board’s USB to your PC - it will expose a COM port (UART0). ARC can connect over that COM port via the EZB Connection skill.
2. Wire an external USBtoUART cable to the ESP TX/RX header pins: connect TX/RX/GND to the cable. If using this, unplug the board’s USB bridge or make sure you aren’t shorting two USBUART bridges.
3. Use a board with native USB (ESP32S2/S3) and an EZB firmware that implements USB CDC: the board will appear as a COM port directly without an external bridge. This is the most integrated wired solution if supported.

ARC configuration tips (quick steps)

• Add EZB Connection skill (Project Add robot skill Communication EZB Connection).
• For WiFi: enter the IP address of your ESP32 (when it’s a client) and click Connect in the connection index you use (index 0 recommended for a single controller).
• For USB/Serial: pick the COM port and baud rate (match firmware baud). Use the Port Refresh button if COM not shown.
• In the Connection skill Settings Scripts, add a Connection Established script to initialize servos to safe positions (recommended for safety).
• Battery monitor settings: set appropriate minimum voltages if you power servos from the same supply (important for LiPo safety).

Example: Check connection status from an ARC JavaScript script

// Get EZB #0 status (true = connected)
var online = controlCommand("Connection", "GetStatus", 0);
print("EZB #0 online: " + online);

Things to confirm before buying

• Which ESP32 chip revision (WROOM vs WROVER vs S2 vs S3) does the Synthiam EZB firmware support? The DOIT WROOM DevKit is documented and known to work (safest choice).
• Do you need native USB (S3) or is USBbridge (DevKit) acceptable?
• How many servos and total current draw? Make sure your power supply and the board’s servo power wiring can handle it.
• Do you need PSRAM (WROVER) for heavier firmware?

Follow-ups I recommend

1. Do you absolutely need native USB (so the ESP appears as a COM device without the bridge), or is using the dev board’s builtin USBUART bridge acceptable?
2. Roughly how many servos (and peak current) do you plan to run from this ESP?
3. Will you run WiFi only, wired USB only, or both?
4. Do you want me to list a short parts shopping list (links to specific dev boards) or a pin mapping table for ARC d0-d23 to ESP GPIO for the DOIT DevKit v1?

Useful links

• ESP32 DevKit v1 EZB firmware page: https://synthiam.com/Support/Hardware/Esp32-DevKit-v1
• EZB Connection skill: https://synthiam.com/Support/Skills/Communication/EZB-Connection?id=16041
• How to make a robot / EZB microcontroller info: https://synthiam.com/Support/Get-Started/how-to-make-a-robot/EZB

If you tell me whether you prefer native USB or proven compatibility first, I’ll give a concrete board model recommendation and a wiring/pin mapping checklist you can use with ARC.

@dave I just started a discussion about this yesterday @ https://synthiam.com/Community/Questions/Alternative-to-ezrobot-ezb-for-robot-head-project-23103

You can see in my last image an esp 32 with a break out board with accessible ports. There are links to the ESP32 firmware, but as DJ notes there is not a standard and each board manufacture changes the pin outs and part of the ARC firmware reroutes those pins to match D-ports in ARC, so each board might need to be changed in the firmware.

Also I found a esp 32 that matches the powerhouse that the is the EZB. Its the red board I screen grabbed in that thread. So all in all the firmware is there just would have to rewritten to reroute the IO ports to match. The firmware DJ has on the support page, is for a specific esp32 from 2021. This is an older board:

Good notes from fxrtst - you’re on the right track. A few clarifications, practical steps, and options below to move this forward.

First: I can’t view images you attach here. Please paste the exact text from any screenshot (or the board model printed on the silkscreen) so I can identify the exact board. The red board you mentioned - tell me the board model or the silkscreen text (for example "ESP32-S3-DevKitC" or "WROOM32" etc.).

Quick summary of fxrtst’s points and concrete guidance

• Yes - many ESP32 boards share the same chip name but have different pin breakouts and features. That means the Synthiam EZB firmware pin mapping must match the board’s GPIO layout (Dx GPIO translation).
• The Synthiam ESP32 firmware on the support page is published for the DOIT / WROOM DevKit (ESP32 DevKit v1). That is the proven, easiest option for ARC because the published firmware already maps ARC d0-d23 to the DevKit’s pins.
• If you pick a different board (especially S2/S3/C3 or vendor breakout variants), you’ll likely need to change the firmware pin mapping and rebuild the firmware so ARC’s d-ports map to the correct GPIOs.
• If you want a native USB/CDC device (so the ESP itself presents a COM port to Windows without a separate USB-UART bridge), choose ESP32-S2 or S3 boards - but confirm or build firmware that supports native USB CDC.

Options and tradeoffs

1. Easiest, fastest (recommended for most users)

   • Buy the DOIT / WROOM32 DevKit (ESP32 DevKit v1). Use the Synthiam-provided firmware and ARC will work over WiFi and via the onboard USB-UART COM port.
   • Synthiam support page: https://synthiam.com/Support/Hardware/Esp32-DevKit-v1

2. If you need native USB (no separate USB-UART chip)

   • Use a board based on ESP32-S2 or ESP32-S3 (they support native USB). You’ll get a better wired experience (ESP appears directly as a Windows COM device) - but you must ensure the Synthiam EZB firmware is available for that chip or be prepared to modify/build the firmware for that variant.

3. If you want a high-performance board or more RAM/PSRAM

   • Look at WROVER (with PSRAM). Works similarly to the DevKit but gives more RAM for complex firmware.

What needs changing when you pick a different board

• Identify every GPIO you want to use for ARC d0-d23, ADCs, UART TX/RX, etc.
• Update the firmware’s pin map (the code that maps ARC d-ports to ESP GPIO numbers).
• Rebuild the firmware with the new mapping and flash the board.
• Test: ARC Connection skill (or direct COM/serial) - verify GetStatus/GetAddress and the IO/servo behavior.

Important practical notes / tips

• ADC: Use ADC1 (GPIO32-39) for stable ADC while using WiFi. ADC2 shares WiFi and can be unreliable while WiFi is active.
• UARTs: ESP32 has 3 hardware UARTs (UART0/1/2). The GPIO matrix allows assigning UARTs to many pins - handy for peripherals.
• Servos / PWM: Some pins are not recommended for PWM/servo (boot strapping pins, input-only pins, pins with special functions). Follow Synthiam recommended pins for the DevKit: 2, 4, 12-19, 21-23, 25-27, 32-33.
• Power: plan servo power (voltage/current) separately from the ESP 3.3V regulator. High servo counts require a beefy separate battery and proper wiring.
• If you wire an external USB-UART adapter to TX/RX, be careful not to have two USB-UART bridges driving the same pins at once.

If you want help doing a firmware pin remap / build I can guide you step-by-step. Tell me:

• Which exact board/model is the red board (paste the silkscreen text or model link).
• Do you want native USB (S2/S3) or is the DevKit USB-UART bridge acceptable?
• Which ARC d-ports (d0-d23) do you want assigned to which GPIOs (or do you want me to propose a mapping based on the board)?

If you prefer to stick with the known-working option, I’ll list the exact DOIT / WROOM DevKit v1 product links and a d0GPIO mapping table you can use with ARC.

How I can help next (pick one)

• I’ll create a ready-to-flash firmware mapping for your named board (if you give me the exact board model).
• Or I’ll provide a DOIT DevKit v1 d0-d23 GPIO mapping table plus wiring checklist for servos, ADCs, UARTs, and how to set up ARC’s Connection / Connection Established script.
• Or walk you through building the firmware (what tools, where to change pin defines, flash steps).

Example: quick ARC check script to verify a connection (JavaScript)

// Check if EZB on index 0 is connected
var online = controlCommand("Connection", "GetStatus", 0);
print("EZB #0 online: " + online);

Next step for me: paste the exact board model text from the image (or a link to the product page) and tell me whether you want native USB or proven DevKit compatibility - and I’ll produce a concrete mapping and next steps.

@dave DJ has a great video step by step (Ez-builder so its an oldie but goodie:):

Would love to see support for a more current board like :

Just add the firmware to that "more current board," and it'll work. It's pretty much the same code base. "Maybe" there are a few pinout changes, but that's to be expected across all esp32s.

You see, the esp32 is an open-source board that anyone can make. The DOIT was supported because it was the most popular. The firmware will work for ANY esp32, it's just the pinouts. Every single (and I mean absolutely every single) ESP32 has a different pinout. All that means is pin 1 might be pin 15 or pin 18 in software. The only way to know is compare the schematics or try it

Either way, it'll work with minor firmware tweaks for pinouts