Alternative To Ezrobot Ezb For Robot Head Project

Fantastic - glad it settled down and is working reliably! A ghost in the machine is the best kind of mystery when it disappears. A few quick suggestions and checks you can keep for Mecha Morphix release and to avoid future hiccups:

Recommended stability checklist

• Keep using the buck that worked (7.5V5V @ 3A) or the USB-C feed that proved stable. Low-quality bucks often inject noise or suffer transients.
• Ensure a solid common ground between the ESP32 and servo power supply.
• Add a bulk electrolytic at the PCA9685 V+ to GND (470-2200 F) and a 0.1 F ceramic close to the board for decoupling.
• Verify PCA9685 jumper/logic VCC settings so logic is 3.3V for the ESP32 and servo V+ is 5V.
• Use short servo power wires where possible; if long runs are needed, increase conductor gauge or place local caps near servos.
• If you see intermittent socket drops again, run continuous ping + serial monitor to capture the moment (helpful for debugging).

How to tune the robot skill settings (kebab menu) - useful for TCP & camera skills

1. Open your ARC project and the robot skill window (Single Camera servo Server or TCP Script Server Raw).
2. Click the three-line kebab/hamburger in the top-right of the robot skill window to open Settings.
3. Things to look for and change:
   • Enable any Debug/Logging options to capture server-side errors.
   • Increase TX/RX buffer sizes and timeouts (TCP Script Server Raw) if you send larger payloads.
   • Check "Allow multiple connections" or equivalent - disable if you want a single ARC client.
   • Enable keepalive/heartbeat options if available (helps TCP survive transient WiFi drops).
4. Save and restart the skill after changes.

Useful links (for docs and tutorials)

• ARC Downloads: https://synthiam.com/Products/ARC
• ESP32-CAM firmware / overview: https://synthiam.com/Support/Hardware/ESP32-Cam
• Single Camera servo Server skill doc: https://synthiam.com/Support/Skills/Virtual-Reality/Single-Camera-Servo-Server?id=17663
• TCP Script Server Raw skill doc: https://synthiam.com/Support/Skills/Communication/TCP-Script-Server-Raw?id=15953
• Robot Skill tutorial (create a skill for Mecha Morphix): https://synthiam.com/Support/Create-Robot-Skill/Overview

Want help with any of the following?

• I can draft a short "wiring & power" page you can include with Mecha Morphix (recommended for beta / release).
• Walk through skill settings to optimize buffer/timeouts/keepalive for your final setup.
• Convert any control scripts for Mecha Morphix into ARC JavaScript (I prefer JS over EZ-Script).

Anything you want me to prepare first - wiring doc, skill settings checklist, or a simple control script for the five servos?

@Athena There is a robot skill that uses with the SSC-32, Would it be possible to connect a ESP32 wrover to the Ssc-32 via uart?  The one pictured below is $14 on eBay..looks like a Chinese knock off. But can’t the servos on the SSC-32 be controlled via Vxx ( virtual ports) in ARC? 

Short answer: Yes - you can connect an ESP32 WROVER to an SSC-32 over UART and have ARC control the SSC-32 servos as virtual ports, but you need the right wiring, levelshift or voltage checks, and a bridge/firmware so ARC can talk to the SSC-32 over your chosen transport (USB serial, direct UART via a controller, or TCP over WiFi).

Below I’ll give:

• Two practical options (wired and wireless)
• Wiring & power cautions (most important)
• How to make the ESP32 act as a simple TCP UART bridge (example firmware)
• How to expose SSC-32 servos to ARC as Vx (skill setup / kebab menu)
• What I need from you if you want me to make a tailored firmware or skill configuration

1. Two practical ways to make this work

• Option A - Easiest / most robust (wired)

  • Connect the SSC-32 to the PC (USB/serial) or connect SSC-32 to an Arduino/EZB that’s connected to ARC. ARC’s SSC-32 skill can then connect directly to the COM port. No extra firmware needed.
  • Use this method for development and verification.

• Option B - Wireless via ESP32 (what you asked about)

  • Use the ESP32 as a serial bridge (WiFi UART). ARC connects (TCP) to the ESP32, ESP32 forwards bytes to/from the SSC32 UART.
  • Two ways to do the bridge:
    1. Flash the ESP32 with Synthiam-compatible firmware (if you implement the exact protocol expected by the ARC robot skill - more work).
    2. Use a raw TCP UART forwarder on the ESP32 (much simpler). ARC must be configured to talk raw to that TCP socket (or you use a robot skill that supports raw TCP to the servo controller). This is a practical wireless approach.

2. Wiring, signal levels, and power (critical)

• SSC-32 serial lines are TTL-level serial. Check your exact SSC-32 board manual for the UART voltage (many are 5V TTL). The ESP32 is 3.3V logic - don’t assume 5V-tolerant inputs.
  • If SSC-32 TX is 5V and ESP32 RX is not 5V tolerant, use a logic-level shifter (bidirectional or unidirectional) between them.
  • If SSC-32 TX is 3.3V tolerant, you can connect directly (TXRX cross) but verify in the SSC-32 docs.
• Cross the UART lines:
  • ESP32 TX -> SSC-32 RX
  • ESP32 RX <- SSC-32 TX
  • Connect common GND between ESP32 and SSC-32 and servo supply.
• Servos power:
  • Power servos from a proper 5V servo supply sized for stall currents.
  • Do NOT power servos from the ESP32 3.3V regulator. Keep the ESP32 and servo power rails separate, but share ground.
  • Add bulk capacitance (470-2200 F electrolytic) at the PCA or SSC-32 V+ for transient current spikes.
• Baud rate:
  • Confirm SSC-32 baud rate (configure ESP32 Serial1 with that same baud).

3. Example: ESP32 TCP UART bridge (Arduino-style sketch) This sketch runs the ESP32 in station mode (or AP if you prefer), opens a TCP server (port 23), accepts one client, and forwards everything between the TCP socket and Serial1 (UART to SSC-32). Use a level shifter on RX/TX if required.

// ESP32 TCP <-> UART bridge (Arduino IDE)
// - Adjust AP or WiFi credentials as needed.
// - Set UART pins and baud to match SSC-32.
// - Use appropriate level shifting for signal safety.

#include <WiFi.h>

const char* ssid = "YourSSID";        // or create AP mode
const char* password = "YourPass";   // set empty "" for open AP

WiFiServer server(23);

HardwareSerial &sscSerial = Serial1; // Serial1 on many ESP32 modules

const int uartRX = 16; // ESP32 RX1 (change if needed)
const int uartTX = 17; // ESP32 TX1 (change if needed)
const int sscBaud = 115200; // set to your SSC-32 baud

WiFiClient client;

void setup() {
  Serial.begin(115200);
  delay(1000);
  // Init UART to SSC-32
  sscSerial.begin(sscBaud, SERIAL_8N1, uartRX, uartTX);

  // Connect to WiFi (station mode)
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi");
  int tries = 0;
  while (WiFi.status() != WL_CONNECTED && tries++ < 30) {
    delay(500);
    Serial.print(".");
  }
  if (WiFi.status() == WL_CONNECTED) {
    Serial.println();
    Serial.print("IP: ");
    Serial.println(WiFi.localIP());
  } else {
    Serial.println();
    Serial.println("WiFi failed - starting AP mode");
    WiFi.mode(WIFI_AP);
    WiFi.softAP("ESP32-SSC", "12345678");
    Serial.print("AP IP: ");
    Serial.println(WiFi.softAPIP());
  }

  server.begin();
  Serial.println("TCP Server started on port 23");
}

void loop() {
  // Accept only one client. If new connects, close existing.
  if (!client || !client.connected()) {
    client = server.available();
    if (client && client.connected()) {
      Serial.println("Client connected");
    }
  }

  // Forward from TCP client to UART
  if (client && client.connected() && client.available()) {
    int c = client.read();
    if (c >= 0) sscSerial.write((uint8_t)c);
  }

  // Forward from UART to TCP client
  while (sscSerial.available()) {
    uint8_t b = sscSerial.read();
    if (client && client.connected()) {
      client.write(b);
    }
  }

  // tiny delay to yield
  delay(2);
}

Notes on that sketch:

• Change ssid/password or switch to AP mode as you prefer.
• Change uartRX/uartTX pins to ones that work for your board.
• Set sscBaud to the SSC-32 baud (confirm settings on your board).
• This is a raw bridge. ARC must open a TCP socket to the ESP32 IP:23 and send SSC-32 command strings. If your SSC-32 ARC skill expects a COM port, ARC may not support connecting to a raw TCP socket for SSC-32 - read next section.

4. How ARC expects to talk to the SSC-32 and how to expose servos as Vx

• ARC SSC-32 skill supports:
  • Direct COM/USB serial connection on the PC (recommended, simplest).
  • Connection via a controller with UART (EZ-B / Arduino) if you route serial through that controller.
• Virtual Ports:
  • Once the SSC-32 skill is configured and connected, ARC exposes the SSC-32 channels as V0..V31 (virtual ports). Other ARC robot skills can then move Vx servos just like normal servos.
• If you use the ESP32 TCP bridge above:
  • ARC’s SSC-32 skill may not have a built-in option to open a TCP socket. If it doesn’t, ARC won’t talk directly to the ESP32 TCP server unless you:
    • Expose the ESP32 bridge as a COM port on the PC (use a TCP->Serial driver on PC like com0com + com2tcp or socat on Linux to create a virtual COM linked to TCP), or
    • Modify/extend ARC skill to support TCP targets, or
    • Use a custom robot skill that speaks raw TCP to the ESP32 and forwards SSC-32 commands - then map Vx inside that skill.
• Recommended approach for wireless with ARC:
  • Option 1 (less work): Connect SSC-32 to an Arduino/EZB that implements the custom servo controller firmware ARC expects. The Arduino/EZB handles UART to SSC-32 and ARC connects to that controller (wired or wireless).
  • Option 2 (intermediate): Run the ESP32 TCP bridge, then on the PC create a virtual COM port bound to that TCP server. ARC’s SSC-32 skill can connect to the virtual COM port. (Search for "COM over TCP" tools for your OS.)
  • Option 3 (best integration): Port the "Custom servo Controller" firmware used by ARC to run on the ESP32 (modify the example Arduino firmware provided in the Custom servo Controller docs). That firmware implements the protocol expected by the ARC skill so ARC will connect to the ESP32 as if it were the controller. The Custom servo Controller docs include example firmware you can adapt. Link: https://synthiam.com/Support/Skills/Servo/Custom-Servo-Controller?id=22238

5. How to configure the SS C-32 or Custom servo Controller skill (kebab menu steps)

• Open your ARC project.
• Add the SSC-32 servo Controller skill (Project Add robot skill SSC-32 servo Controller) or Custom servo Controller skill.
• Open the skill window, click the kebab/hamburger (three lines) in the top-right Settings.
• Configure:
  • Connection Type: Direct COM (if using USB-to-SSC on PC) OR "UART through controller" (if going through EZ-B/Arduino).
  • COM Port / Baud Rate: match your SSC-32 settings (if direct COM).
  • If using Custom servo Controller: select the Vx mapping (which servo channels map to V0..Vn).
  • Enable debug logging to see the raw commands.
• Save, Connect. The skill should report connection and expose virtual ports V0..Vn for use by other ARC skills.

6. Troubleshooting checklist (if things misbehave)

• Confirm common ground between ESP32 and SSC-32.
• Confirm UART baud & parity match.
• Use a logic level shifter if levels are mismatched.
• Keep servo power separate and sized for stall current. Add bulk caps.
• If ARC can’t connect to TCP directly, use a TCPCOM bridge on the PC or port ARC firmware protocol to ESP32.
• Use the Serial Monitor on the ESP32 to watch incoming/outgoing bytes while you move a slider in ARC.
• If you want me to adapt the Custom servo Controller firmware to run on your ESP32 WROVER, tell me:
  • Desired max servos count (e.g., 16, 32)
  • SSC-32 serial baud
  • Whether you want the ESP32 to be AP or STA (connect to router)
  • Whether you want the ESP32 to implement EZB / Synthiam capability (more work) or just a raw TCPUART forwarder

Follow-up questions for you

1. Do you want wired (COM) or wireless (WiFi) control for SSC-32 from ARC?
2. Is the SSC-32 UART 5V TTL or 3.3V TTL on your board? (Check the board or post the exact model text - I cannot see images.)
3. Do you want me to prepare a ready-to-flash ESP32 sketch that implements:
   • a raw TCP UART bridge (quick), OR
   • a port of the Custom servo Controller firmware for ESP32 so ARC can connect directly over TCP (more integrated)?
4. Which baud rate is your SSC-32 set to?

If you want the quick wireless route, I’ll finalize the ESP32 bridging sketch with AP mode and an example of how to create a virtual COM on Windows to let ARC use the SSC32 skill straight away.

If its within the guard rails of TCP then I would prefer it to be wireless. Can The ESP32 handle 32 servos via wifi?

i am pretty sure athena is super confused with all the topics of this thread. whlie some of what she's saying is ok, it's not accurate.  a new thread would be useful becuase it's an entirely new topic. llm's are fancy auto-complete. and they gravitate toward a common subject/topic. humans have alot more ADHD than llm's haha. llm's benefit from single topic with single defined outcome. llm's work toward an outcome that's pre-defined. so this conversation has many outcomes and she's gonna give weird feedback.

new threads are useful for situations like this. more threads is better than cluttered threads if u know what i mean

so to answer what she kind of got right... the esp32 has a uart and it's exposed in the firmware as UART 0 in ARC. so YES you can use the ssc-32 manual and connect it to the uart pins of the esp32.

verify with the firmware that your uart pins are exposed and usable

It makes since now to do these new threads for Athena. I can see some drifting. LOL. I often find it hard to come back to all these threads to find what I am looking for especially when many months go by. So like the old days I try and keep all the content for what I am asking or trying to do into one thread, but can see how its confusing for Athena.

haha ya... llm's are sooooooo powerful when you wrap your head around how to use them. they speak so well that it's easy to take for granted that they're not humans. although, with llm's we learn to manage our projects and outcomes a lot clearer for other humans. i've noticed a benefit within synthiam's organization on how we clearly define outcomes rather than mushing them all together.

it doesn't hurt to have lots of threads. honestly, there's nothing wrong with that. the forum is a place for discovery and problem solving. i learn a lot by reading the threads haha

Quote:

Beginner note: ARC does not generate servo signals directly. ARC sends serial commands through a connection (USB/COM port or via UART from an EZB or Arduino), and the SSC-32 generates the servo PWM signals that actually move the servos.

ARC over wifi ----> ESP32 with camera-----> SSC32.

(And by the way, all these similar controllers with their E's and 32's is making my dyslexic brain work hard )