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 ESP32 (and I mean absolutely every single one) 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 pinout tweaks in the firmware.

It isn't easy to compare an open-source ESP32 or Arduino to what you're familiar with EZRobot EZB's. This is because companies have standard products, whereas the open-source world is different for each developer. Someone creates a board and thinks their pinout design is better than someone elses, etc.. So you get a gumbo of boards with different pinouts. Comparing company products against open-source products will drive you insane.

@DJ yeah watching your video showed clearly where the code was for the pin out to D-xx. If thats all that has to be changed that is not at all difficult to do.

The EZB was so far ahead of its time its insane to think how long ago the EZB 3, the 4 and the 4/2, were put into production. Hats off to you and Jer. (I started with ver3 when you were in a basement.)

Good conversation - all of that is correct: the ESP32 firmware Synthiam provides is portable across ESP32 boards, the main work when changing boards is updating the pin mapping and (for native-USB chips) making sure the firmware build supports USB CDC. I can help you port a pin map or create a ready-to-flash firmware - but I can’t view the screenshots you attached. Please paste the exact silkscreen/model text from the board (or a product page link) so I can target the correct pinout.

Below is a practical, step-by-step guide you can follow (or I can do with you) to get "newer" ESP32 boards working with Synthiam ARC just like an EZ-B.

1. Which boards to consider (short)

• DOIT / ESP32 DevKit v1 (WROOM32) - proven, supported by Synthiam firmware. Easiest path.
  • Synthiam docs: https://synthiam.com/Support/Hardware/Esp32-DevKit-v1
• ESP32-WROVER boards - same compatibility, more PSRAM if you need memory.
• ESP32-S2 or ESP32-S3 DevKitC - advantage: native USB device (can appear to Windows as a COM port without a separate USB-UART bridge). If you use S2/S3 you must confirm or build firmware that implements USB CDC for that chip.

2. What actually needs to change to support a new board

• Pin mapping only. The EZB firmware maps ARC's d0..d23, ADCs, UARTs, etc., to physical GPIO numbers. Every board vendor routes the ESP32 pins differently, so you update that mapping and rebuild.
• ADC: use ADC1 pins (GPIO32-39) when WiFi is active - ADC2 is shared with WiFi and can be unreliable.
• UART: ESP32 has 3 hardware UARTs (UART0/1/2). The ESP GPIO matrix allows routing UARTs to many pins.
• Servos/PWM: avoid boot-strapping pins and input-only pins; follow Synthiam recommended pins for servos (example set in firmware docs).
• Native USB (S2/S3): requires firmware support for USB CDC. If Synthiam hasn’t released an S3 build, you must add/enable CDC in the build.

3. Practical porting steps (overview)

• Identify the board model EXACTLY (silkscreen text or product link). I can’t read images - paste the text here.
• Obtain the EZB firmware source (or the pin mapping file that comes with the prebuilt firmware if you have it).
  • Synthiam ESP32 support page (start here): https://synthiam.com/Support/Hardware/Esp32-DevKit-v1
• Locate the pin mapping definitions in the firmware source (often a header or pins file - search for "D0", "d0", "pinMap", or "servo" in the project).
• Edit the mapping so ARC d0..d23 point to your board’s GPIO numbers. Also set ADC channel mappings and UART TX/RX pin assignments.
• Build/compile:
  • You can use Arduino IDE with the ESP32 board package or PlatformIO (VS Code) / ESP-IDF depending on the firmware tooling the project uses.
  • Select the correct board in the IDE and compile/flash the firmware.
• Flash the board, power servos separately, and test with ARC:
  • For WiFi: configure as client or AP and use EZB Connection skill (index 0 recommended).
  • For USB/Serial (DevKit with bridge): use the COM port listed in Device Manager and connect with EZB Connection.
  • For native USB (S2/S3 & firmware CDC): board will appear as COM port once the firmware implements CDC - then use EZB Connection.

4. How to test quickly in ARC (JS example)

• Check connection status (use in a Script robot skill or Init script):

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

• To bind an EZB by broadcast name (EZB Connect By Name, example):

// Bind EZB named "DriveBase" to Connection index 0
controlCommand("EZB Connect By Name", "Connect", 0, "DriveBase");

5. Important safety & power notes

• Always power servos from a proper supply capable of peak current - do NOT power many servos from the ESP 3.3V regulator.
• Initialize servos to safe positions in the Connection -> Settings -> Connection Established script to prevent sudden movements when the board connects.
• Use ARC battery monitor settings to protect LiPo batteries.

6. If you want me to make a ready-to-flash mapping or walk you through the build Tell me:

• Exact board model text from the silkscreen (or product page link). I cannot read images.
• Do you require native USB (S2/S3) or is using the DevKit onboard USB-UART bridge acceptable?
• How many servos (rough number) and which ARC d-ports you want prioritized (or I can propose a mapping).
• Whether you prefer Arduino IDE or PlatformIO for compiling.

Based on that I can:

• Provide a suggested d0..d23 -> GPIO mapping for your board.
• Create step-by-step compile/flash instructions tailored to your environment (Arduino IDE / PlatformIO).
• If you want, supply a short pin mapping checklist (servos, ADCs, UART pins) and a test script for ARC.

Helpful links

• ESP32 DevKit v1 (Synthiam): https://synthiam.com/Support/Hardware/Esp32-DevKit-v1
• EZB Connection skill: https://synthiam.com/Support/Skills/Communication/EZB-Connection?id=16041
• EZB Connect By Name: https://synthiam.com/Support/Skills/General/EZB-Connect-By-Name?id=21761
• Robot skill tutorial (if you want to package anything as a skill): https://synthiam.com/Support/Create-Robot-Skill/Overview

Next step: paste the exact model/silkscreen text from that red/current board you mentioned (or link to the product page), and let me know if native USB is required. I’ll produce the GPIO mapping and the build/flash checklist.