Controller Options for Rover Upgrade

Question

Hi @Athena,

I'm rebuilding my rover to improve mission capability and would appreciate advice on controller hardware.

Current setup (ARC project with an EZBv4 controller):

Four stepper motors running at 12 VDC, ~1 A each. An Arduino Mega generates the PWM for the stepper drivers and handles some wheel-rotation logic for the mecanum wheels. The Arduino is separate from the EZBv4.
In my ARC project I have about three concurrent scripts that interact with the EZBv4. Those scripts primarily pulse a single IR distance sensor and drive a single servo. The sensor and servo are connected through the EZBv4.
The rover requires the servo movement and IR pulsing to be as fast as possible. When I increase the update/pulse rate, I seem to be reaching the EZBv4’s limits (the EZB is currently handling the sensor/servo tasks in this architecture).
I will be changing the rover DC bus to 24 V.

Question: Do you have any recommendations for a microcontroller or controller board that would be an improvement over the EZBv4 for this use case? I need something robust enough to handle tight loops and precise signal conditioning for high-rate servo and sensor tasks, while keeping the Arduino Mega (or a similar MCU) for motor PWM if needed.

Thanks, Jack

Athena · Answer

For this use case, I’d keep ARC on the PC for orchestration and move the tight loop work off the EZBv4 onto a microcontroller that’s better suited for deterministic timing. ## Best direction Since your rover needs: - fast servo updates - high-rate IR sensor sampling - precise signal conditioning - tight loop behavior - while ARC still manages higher-level behavior the best upgrade is usually a microcontroller dedicated to the real-time tasks, not a second "general control PC-style" board. ## Good hardware options ### 1. Teensy 4.1 A very strong choice for this kind of job. Why it fits: - Extremely fast MCU - Great for deterministic timing - Plenty of PWM, timers, ADC performance - Good choice for high-rate control loops - Works well for custom firmware If you’re really trying to squeeze performance out of servo timing and sensor sampling, this is one of the best off-the-shelf options. ### 2. ESP32 A solid option if you want: - WiFi capability - lower cost - good performance for control tasks It can work well, but for very tight real-time behavior, I’d still lean toward Teensy over ESP32. ### 3. STM32-based board Also a great fit if you’re comfortable with embedded development. Pros: - Strong timers/PWM - Good ADC capability - Deterministic behavior - Very capable for control/conditioning tasks ### 4. Arduino Mega You already know this one, but for your requirements it’s usually not a meaningful upgrade from an EZBv4 in terms of performance for fast control loops. It’s fine for basic logic, but if you’re hitting timing limits now, I would not pick the Mega as the final solution for the high-rate side. --- ## ARC-specific recommendation If the board is going to be doing custom control and sending data to ARC, a good path is to create a custom robot skill and have the MCU communicate with ARC over serial or network. This is the right model when the controller needs to handle: - sensor polling - filtering - servo timing - local loop control ARC then handles: - navigation logic - state machines - vision - user interface - mission behavior You can build that integration using a custom skill here: https://synthiam.com/Support/Create-Robot-Skill/Overview And if you end up using serial/UART between ARC and the microcontroller, ARC handles that well with the built-in UART/COM functions and scripts. --- ## My practical recommendation for your build If I were choosing for your rover, I’d suggest: - Teensy 4.1 for the high-speed sensor/servo controller - keep the Arduino Mega only if it already does motor PWM reliably - use ARC for high-level behavior - communicate between ARC and the MCU over serial/UART That gives you a clean split: - MCU = real-time - ARC = decision-making --- ## About the 24 V bus Going to 24 V for the drive bus is fine, but keep the control electronics on appropriate regulated rails: - 24 V for motors / motor drivers - regulated 5 V or 3.3 V for logic - don’t power the MCU or sensors directly from the 24 V bus unless the board explicitly supports it --- ## One thing to consider If your IR sensor is the limiting factor, the board upgrade may help, but sensor choice and sampling method matter too. Some analog IR sensors are noisy or nonlinear, and you may get better results by doing: - oversampling - filtering on the MCU - fixed-rate timing using a hardware timer --- ## ARC note Questions like this are often a good fit for the ARC AI Assistant built into ARC, since it can help rewrite scripts or sketch out the integration logic right inside the editor: https://synthiam.com/Products/AI-Assistant ## A couple of questions so I can recommend more precisely: 1. Which IR distance sensor are you using? 2. Is the servo a standard PWM servo or a smart servo? 3. Do you want the new controller to talk to ARC by USB serial, WiFi, or UART into the EZB ecosystem? 4. Are you trying to replace the EZB entirely, or just offload the real-time loop and keep it in the project? If you want, I can also suggest a specific ARC architecture for this rover and show how to structure the MCU/ARC split.

Robojack · Answer

@Athena, so help me understand what you are saying. Keep the EZBv4 as the overall controller (interfacing via Wi-Fi) with my computer running ARC. Connected to the EZBv4 on the rover is the Arduino (controlling the stepper motors) and a Teensy controlling the servo motor and the IR sensor. My EZBv4 scripts are simply to activate certain features on the Arduino and the Teensy as necessary. The Teensy handling the heavy servo/IR sensor work and leaving the EZBv4 as the overall controller, not bogged down with high CPU demands. Do I understand? Jack

Athena · Answer

Yes - that’s basically the right architecture. ## What I meant Think of it like this: - ARC on your PC = mission logic / UI / orchestration - EZBv4 = networked I/O bridge for ARC - Arduino Mega = stepper motor control / wheel logic - Teensy = fast real-time servo + IR sensor processing So the EZBv4 does not need to be the "brains" doing the fast control loops. Instead, ARC talks to the EZBv4 over Wi-Fi, and ARC can then command the Arduino and Teensy as needed. ## Important clarification The EZBv4 should not be doing the heavy lifting for the servo and IR sensor if the Teensy is taking over those tasks. That means: - Servo pulses / timing-sensitive servo logic Teensy - IR sensor sampling / filtering / conditioning Teensy - Stepper PWM / wheel logic Arduino - High-level behavior / mission decisions ARC ## One key point If the Teensy is controlling the servo and IR sensor, then those devices should be wired to the Teensy, not to the EZBv4. The EZBv4 would then mainly be used for: - Wi-Fi connection to ARC - sending commands to the Arduino and Teensy - possibly monitoring status or passing messages between them ## A more accurate version of your setup Your revised stack would look like: - PC running ARC - EZBv4 connected to ARC via Wi-Fi - EZBv4 communicates with Arduino and Teensy - Arduino drives the stepper/motor side - Teensy handles servo + IR sensor real-time work That is a good split if your goal is to reduce timing pressure on the EZBv4. ## One caution The only thing to verify is how you want the EZBv4 to communicate with the Arduino and Teensy: - serial/UART - I2C - UDP/TCP over Wi-Fi - USB serial through the PC For the cleanest design, I’d usually suggest: - ARC EZBv4 over Wi-Fi - EZBv4 or PC Arduino/Teensy over serial, depending on your physical layout But if the Teensy and Arduino are doing the real-time work, you may not even need to force the EZBv4 into the middle of everything unless you specifically want it as a bridge. ## Bottom line Yes, your understanding is close: the Teensy handles the fast servo + IR work, the Arduino handles motor control, and the EZBv4 is no longer burdened with those timing-critical jobs. The only nuance is that the EZBv4 is not necessarily the "overall controller" in the real-time sense - ARC on the PC is. The EZBv4 is more of a connected I/O endpoint for ARC. If you want, I can draw you a simple block diagram of the ideal wiring/communication paths for this rover.

Robojack · Answer

@Athena. Thank you. I would like a simple block diagram to help me understand the wiring / comms paths for the rover. Jack

Athena · Answer

Absolutely - here’s a simple high-level block diagram for the architecture you described. ## Recommended control layout text +----------------------+ | PC running ARC | | (mission logic UI) | +----------+-----------+ | | Wi-Fi | +----------v-----------+ | EZBv4 | | (ARC connection) | +----+-----------+-----+ | | | Serial / | Serial / UART / logic commands | comms | | | +----v----+ +--v----------------+ | Arduino | | Teensy | | Mega | | (servo + IR loop) | | motors | | | +----+----+ +--+----------------+ | | | | | +--> Servo motor | +--> IR distance sensor | +--> Stepper drivers +--> 4 stepper motors  ## What each part does - PC running ARC - Runs the project - Makes higher-level decisions - Sends commands to the robot - EZBv4 - Provides the Wi-Fi bridge to ARC - Can remain in the system as the main ARC-connected controller - Sends commands onward to the Arduino and Teensy - Arduino Mega - Handles stepper motor logic - Generates motor PWM / step timing - Controls the mecanum wheel motion side - Teensy - Handles fast servo updates - Samples the IR sensor - Does filtering / tight timing loops ## Wiring concept The important part is this: - Servo and IR sensor should be physically wired to the Teensy - Stepper drivers should be physically wired to the Arduino - EZBv4 should only be used for control/comms - ARC remains the project’s main brain ## If you want it even simpler You can think of it as: text ARC (PC) -> EZBv4 -> Arduino (motors) -> Teensy (servo + sensor)  ## One design note If the Arduino and Teensy are both on the rover, you may eventually decide to let ARC talk directly to them instead of routing everything through the EZBv4. That can simplify things if the EZBv4 is not actually needed for I/O. But for now, your diagram is a good way to visualize the split. ## Helpful ARC resources - Create a custom robot skill if you want the Teensy or Arduino to behave like a first-class ARC device: https://synthiam.com/Support/Create-Robot-Skill/Overview - Roli Rover hardware info: https://synthiam.com/Support/Hardware/Roli-Rover If you want, I can also make you a more detailed wiring diagram showing: - power rails - logic voltage levels - serial connections - where grounds must be tied together

Robojack · Answer

@Athena. Please make more detailed wiring diagram showing: * power rails * logic voltage levels * serial connections * where grounds must be tied together Thanks. Jack

Athena · Answer

Absolutely - here’s a more detailed rover wiring / comms diagram you can use as a design guide. ## Detailed block diagram text PC Synthiam ARC (mission logic / scripts) Wi-Fi EZBv4 ARC network controller Serial Serial link link Arduino Mega Teensy stepper/motion servo + IR sensor control layer real-time loop Servo signal IR sensor input Step/Dir/Enable signals to stepper drivers Power system: 24 VDC bus > motor power side > stepper drivers (motor supply) > DC-DC buck regulators 5 V rail 3.3 V rail Ground: All grounds must be tied together (24V supply GND, EZBv4 GND, Arduino GND, Teensy GND, driver GND, sensor GND, servo GND)  --- ## Power rails ### 1) 24 V bus Use this for: - stepper motor drivers - any motor power input that specifically requires 24 V Do not connect 24 V directly to: - EZBv4 logic inputs - Teensy - Arduino Mega I/O - servo power - IR sensor power ### 2) 5 V rail Typically used for: - Arduino Mega logic power - some IR sensors - some stepper driver logic inputs, depending on the driver - servo power if your servo is a 5 V servo ### 3) 3.3 V rail Typically used for: - Teensy logic I/O - some sensors/modules that require 3.3 V only > Important: many Teensy boards are 3.3 V logic, even if they can be powered from 5 V/USB. > Always confirm the exact Teensy model and pin tolerance before wiring 5 V signals into it. --- ## Logic voltage levels ### EZBv4 - EZBv4 ports are generally treated as 5 V logic domain for many robot use cases - If you connect its ports to other controllers, confirm the receiving board can accept that level ### Arduino Mega - 5 V logic - Good match for many step/dir drivers, provided the driver supports 5 V input logic ### Teensy - Usually 3.3 V logic - This is the main caution point If the Arduino or EZBv4 sends a 5 V TX signal into a Teensy RX pin, you may need: - a level shifter - or a resistor divider - or a UART/serial interface that is explicitly 3.3 V compatible --- ## Serial / comms connections ### Recommended serial paths You have a few clean options: #### Option A: ARC EZBv4 Arduino / Teensy - ARC talks to EZBv4 over Wi-Fi - EZBv4 talks to Arduino and Teensy over serial/UART This keeps your current architecture closer to what you already have. #### Option B: ARC EZBv4, and ARC also talks directly to Arduino/Teensy via USB serial - EZBv4 stays in the project for ARC connection / existing skills - Arduino and Teensy appear as separate serial devices to the PC This can be simpler if you don’t actually need EZBv4 to bridge everything. #### Option C: ARC Teensy / Arduino directly, EZBv4 removed from the loop - cleanest for real-time controller roles - best if EZBv4 is no longer needed for hardware I/O --- ## Suggested wiring diagram by function text 24V SUPPLY +24V > Stepper drivers VMOT / motor power GND > Stepper drivers GND > Buck converter(s) +5V > Arduino Mega 5V input (if using regulated 5V) +5V > Servo power (if 5V servo) +5V > IR sensor (if 5V sensor) +3.3V > Teensy power / peripherals if needed EZBv4 Wi-Fi to ARC UART/serial TX/RX > Arduino Mega RX/TX UART/serial TX/RX > Teensy RX/TX Arduino Mega STEP/DIR/EN > Stepper driver inputs Serial > EZBv4 or PC USB serial Teensy Servo signal > Servo control pin IR sensor input > sensor output pin Serial > EZBv4 or PC USB serial  --- ## Grounding rules This is the part that causes the most issues if missed. ### Tie all grounds together: - 24 V supply negative - buck converter ground - EZBv4 ground - Arduino Mega ground - Teensy ground - stepper driver ground - servo ground - sensor ground ### Why: Serial signals only work reliably when both devices share a common reference voltage. Without shared ground, you can get: - erratic serial communication - missed pulses - noisy sensor readings - servo jitter --- ## A practical wiring example If I were wiring this rover, I’d do: - 24 V bus stepper driver motor power - 5 V buck Arduino Mega + servo + 5 V IR sensor - 3.3 V rail Teensy logic/peripherals if required - EZBv4 ARC Wi-Fi link and command bridge - Shared ground between everything - Serial level checking between Arduino/EZBv4 and Teensy --- ## One caution about the servo If the servo is a standard hobby servo: - power it from the proper supply rail - do not power it from a weak logic regulator - make sure the servo current does not brown out the Teensy or Arduino A servo can create power dips when it starts moving, so it’s often good to: - use a separate regulator rail - add bulk capacitance near the servo power input --- ## Best next step If you want, I can turn this into a cleaner ASCII wiring schematic with: - labeled pins - TX/RX direction arrows - 24 V / 5 V / 3.3 V rails - example resistor divider for Teensy-safe serial If you tell me the exact Teensy model and the stepper driver model, I can make it much more precise.

Robojack · Answer

@Athena.

Here are some questions you asked previously and my answers.

Which IR distance sensor are you using? I am using a Sharp Corporation IR distance measuring sensor GP2Y0A02YK0F.
Is the servo a standard PWM servo or a smart servo? I am using a DS servo- RDS3225. DC volts, 4.8-6.8. 25Kg torque.
Do you want the new controller to talk to ARC by USB serial, WiFi, or UART into the EZB ecosystem? ARC to EZBv4 via Wi-Fi, Arduino Mega to EZBv4 via UART and Teensy 4.1 to EZBv4 via UART.
Are you trying to replace the EZB entirely, or just off load the real-time loop and keep it in the project? Just off loading the EZB and keep it in the project.

Can you provide a cleaner ASCII wiring schematic with:

labeled pins
TX/RX direction arrows
24 V / 5 V / 3.3 V rails
example resistor divider for Teensy-safe serial

If you tell me the exact Teensy model and the stepper driver model, I can make it much more precise. I am using a Teensy model 4.1. I am using a Version 3.0 of the CNC Shield for an Arduino Mega. It uses four DRV8825 Drivers.

Thank you for your help. Jack

Athena · Answer

Yes - with those parts, I can make this much more concrete. ## What your updated architecture looks like - ARC on PC connects to EZBv4 via Wi-Fi - EZBv4 stays in the project as the ARC-connected controller - Arduino Mega + CNC Shield v3.0 + DRV8825s handle the 4 stepper motors - Teensy 4.1 handles the Sharp GP2Y0A02YK0F IR sensor and the DS RDS3225 servo That is a solid split for a rover that needs better real-time performance. --- ## Cleaner ASCII wiring schematic text +----------------------+ | PC / ARC | | mission logic, UI | +----------+-----------+ | | Wi-Fi | +----------v-----------+ | EZBv4 | | ARC-connected I/O | +----+-----------+-----+ | | | UART | UART | | +-------------v--+ +--v----------------+ | Arduino Mega | | Teensy 4.1 | | + CNC Shield V3 | | servo + IR task | +----+--------+----+ +----+--------+----+ | | | | | | | | STEP/DIR/EN | Servo PWM IR Analog | | | | +-------------v--+ +--v-------------+ | +--v------------------+ | DRV8825 #1 | | DRV8825 #2 | | | Sharp GP2Y0A02YK0F | | motor A | | motor B | | | VCC / GND / VO | +------+------+---+ +---+------+----+ | +---------------------+ | | | | | | | | | | Stepper Stepper Stepper Stepper | motor 1 motor 2 motor 3 motor 4 | | v +---------------+ | DS RDS3225 | | Servo signal | +---------------+  --- ## Power rails ### 24 V rail Use this for: - DRV8825 motor power input through the CNC shield motor supply - stepper motor power Do not feed 24 V directly to: - Teensy 4.1 - Arduino Mega logic - Sharp sensor - servo - EZBv4 I/O pins --- ### 5 V rail Use this for: - Arduino Mega logic power - DRV8825 logic side if your shield routes it that way - Sharp GP2Y0A02YK0F sensor power - servo power, since your DS RDS3225 is rated 4.8-6.8 V A good rule here is to use a separate high-current 5-6 V regulator for the servo, not the MCU’s 5 V pin. --- ### 3.3 V rail Use this for: - Teensy 4.1 logic domain where needed The Teensy 4.1 is a 3.3 V logic board. Its pins are not 5 V tolerant in general, so this matters a lot for serial. --- ## Logic voltage levels ### Arduino Mega - 5 V logic - Safe to drive CNC shield step/dir/enable inputs - Good match for the DRV8825 logic pins ### Teensy 4.1 - 3.3 V logic - Do not feed 5 V directly into Teensy RX pins - If the EZBv4 or Arduino TX is 5 V, level shift it before going into Teensy RX ### EZBv4 - Treat as a 5 V-class controller for typical ARC I/O use - If you wire UART to other boards, verify voltage compatibility first --- ## UART / serial wiring You said: - ARC EZBv4 via Wi-Fi - Arduino Mega EZBv4 via UART - Teensy 4.1 EZBv4 via UART That can work, but here’s the key constraint: > Any 5 V TX signal going into the Teensy 4.1 must be level shifted to 3.3 V. --- ## Example serial wiring for Teensy-safe UART ### Option A: EZBv4 TX to Teensy RX through a resistor divider text EZBv4 TX ----[ 1k ]----+-----> Teensy RX | [ 2k ] | GND  That drops a 5 V-ish signal down to around 3.3 V. A common equivalent pair is: - 1 k top - 2 k bottom If you want, I can also give you a more conservative divider like 10k / 20k, which is often easier on signal loading. --- ### UART direction arrows text EZBv4 TX -----> Arduino Mega RX EZBv4 RX  Teensy RX [through level shift / divider] EZBv4 RX  5 V - GND -> common ground - VO -> Teensy analog input  ### Important note This sensor outputs an analog voltage, so it is not a UART device. It should go straight into the Teensy’s analog input, assuming you keep the output within the Teensy’s input range. Since the sensor is powered at 5 V, check the output voltage range before connecting it directly to the Teensy analog pin. If needed, add a divider or conditioning network. --- ## Servo wiring: DS RDS3225 For the servo: text Servo power: - +V -> regulated 5 to 6 V supply - GND -> common ground Servo signal: - PWM signal from Teensy  ### Important Do not power that servo from the Teensy or EZBv4 logic supply unless the regulator can handle the current. A 25 kg-class servo can pull large current spikes. --- ## Grounds that must be tied together This is critical. All of these should share a common ground: - 24 V supply negative - 5 V regulator ground - Teensy ground - Arduino Mega ground - EZBv4 ground - CNC shield ground - DRV8825 ground - servo ground - Sharp sensor ground If you do not share ground, UART and PWM signals can behave unpredictably. --- ## Cleaner wiring summary text 24 V SUPPLY +24V -> DRV8825 motor power input GND -> common ground bus 5 V REGULATOR +5V -> Arduino Mega / Sharp sensor / servo power rail GND -> common ground bus 3.3 V DOMAIN Teensy 4.1 logic GND -> common ground bus ARC PC Wi-Fi -> EZBv4 EZBv4 UART -> Arduino Mega UART -> Teensy 4.1 (with level shifting into Teensy RX if needed) Arduino Mega CNC Shield -> DRV8825 drivers -> stepper motors Teensy 4.1 PWM -> servo signal Analog input -> Sharp VO UART -> EZBv4  --- ## Two practical cautions ### 1) Servo power and noise Put bulk capacitance near the servo supply if you can. High-torque servos can inject noise into the rail and cause resets or sensor jitter. ### 2) DRV8825 current setting Make sure each DRV8825 current limit is properly adjusted for your stepper motors. That matters a lot once you move to 24 V. --- ## ARC side note If you want ARC to manage the communications cleanly, a custom robot skill can help you build a better interface between ARC and the Teensy/Arduino. That’s the right path if you want more than simple scripts: https://synthiam.com/Support/Create-Robot-Skill/Overview --- ## Final recommendation Your current plan is workable, but I would slightly refine it like this: - ARC EZBv4 over Wi-Fi - Arduino Mega handles only the steppers - Teensy 4.1 handles only the servo + Sharp sensor - Avoid routing 5 V UART directly into Teensy RX - Tie all grounds together If you want, I can make the next version into a pin-by-pin table like: - EZBv4 pin Arduino pin - EZBv4 pin Teensy pin - Teensy pin servo/sensor pin - power rail assignments That would be the most useful next step for actual wiring.

Robojack

Upgrade to ARC Pro

Best direction

Good hardware options

1. Teensy 4.1

2. ESP32

3. STM32-based board

4. Arduino Mega

ARC-specific recommendation

My practical recommendation for your build

About the 24 V bus

One thing to consider

ARC note

A couple of questions so I can recommend more precisely:

What I meant

Important clarification

One key point

A more accurate version of your setup

One caution

Bottom line

Recommended control layout

What each part does

Wiring concept

If you want it even simpler

One design note

Helpful ARC resources

Detailed block diagram

Power rails

1) 24 V bus

2) 5 V rail

3) 3.3 V rail

Logic voltage levels

EZBv4

Arduino Mega

Teensy

Serial / comms connections

Recommended serial paths

Option A: ARC EZBv4 Arduino / Teensy

Option B: ARC EZBv4, and ARC also talks directly to Arduino/Teensy via USB serial

Option C: ARC Teensy / Arduino directly, EZBv4 removed from the loop

Suggested wiring diagram by function

Grounding rules

Tie all grounds together:

Why:

A practical wiring example

One caution about the servo

Best next step