Welcome to Synthiam. There is no limit to anything that you can do in Synthiam ARC. Could you provide more information about your design? You mentioned "how many 2x32" can be used in ARC. That answer is "unlimited". However, it would be best to post your design, schematic, or notes about the robot and how the controllers are used. Also, please provide details about what microcontroller and computer installation you are using.

Using the "Correct Grammar and Spelling" option is ideal when you post. This will help you rewrite your post to be more easily read and help you identify the meat of your question. I will run the auto-grammar on your question for you.

This would be the easiest to get up and running in a few minutes...

Add a Sabertooth Movement Panel for the drive motors. The two driver motors on each side would work in conjunction because we see no reason they should all be separate. That drive style is called "Skid Steer," much like how a bulldozer turns and moves.

• Two Sabertooth scripts for the rotation of each track. That way, you can trigger them by joystick buttons to raise and lower each individually

• Lastly, add the joystick robot skill to control it by one person

I would also recommend adding a camera as well.

@Athena, I think you commented on my question. "Building Autonomous robot for terrain clean up". The picture of the chaos robot show why we need 4 drive motors for each side that are independently controlled. So if can't see I will try to explain. This robot may need to spin a track one track and arm up or down while the other is doing the opposite like going over a rock or log . The tracts may go in same direction but one arm is going up while the other is going down. See if a human in your office can explain it to you by looking at the picture I included and put it into words you can follow.

Hi chucksmithut,

Thanks for providing more details about your Chaos-style robot design for terrain cleanup. It sounds like you’re working on an advanced autonomous platform where each side of your robot has four independently controlled drive motors. This independent control is crucial to navigate obstacles like rocks or logs, where one track might need to lift while the other stays lower-or even spin at a different rate to help the robot pivot around obstacles.

Below are some insights and recommendations on how you can set this up in Synthiam ARC:

1. Configuring Multiple Sabertooth Movement Panels

Multiple Controllers in ARC:
ARC limits one Movement Panel per project, but additional scripts for Sabertooths can be created. For your application, you might consider assigning each Sabertooth 2x32 controller a separate script and use the Movement Panel for moving the robot. For example, if you use two Sabertooth controllers (one per side), they could each drive two or more motors in parallel. Alternatively, if you need truly independent control of individual pairs of motors (or even individual motors). This way, you can later call their functions independently or in combination via ARC scripting.

Grouping Motors by Function:
It may be practical to group the motors that normally work in tandem-for instance, pairing two motors on one track that always share the same drive direction. This skid steer concept lets you combine commands so that when one Movement Panel is triggered, both motor pairs move in unison. When one track or its suspension arm needs to be independent (raising or lowering during obstacle traversal), you can override the default behavior with custom scripting.

2. Using ARC Scripting and Joystick Control

Custom Commands:
Using the ARC scripting language (JavaScript or Python), you can coordinate multiple Sabertooth Movement Panels together. For example, you might write a script that:

- Commands one Sabertooth panel to spin a track while another panel adjusts the arm position (raising or lowering)
- Monitors input from a Direct Input Joystick to dynamically assist with differential motor control. You can even designate joystick buttons not only for overall movement (forward, reverse, etc.) but also to trigger independent actions on each side.

ControlCommand():
This function lets you send messages from one robot skill to another. You might use it to, for instance, have one panel receive a track raise command while the other keeps driving. The key is to name your controls distinctly (e.g., LeftDrive, RightDrive, LeftArm, RightArm) so that your scripts know exactly which controller to direct.

Variable Speed and Direction:
Since terrain cleanup requires nuanced adjustments (like one track moving faster than the other or one set reversing), consider mapping your joystick’s analog inputs to control the speed of each Sabertooth panel individually using functions such as:
- Movement.setSpeedLeft(speed)
- Movement.setSpeedRight(speed)
For the Sabertooth panels, you may need to set up custom scripts that translate these values into the appropriate serial commands for each controller.

3. Additional Considerations

Wiring and Electrical Separation:
Make sure that your wiring accounts for common grounds between the EZ-B, Sabertooth controllers, and the motors-they must share a common reference voltage without causing interference. Document your schematic carefully, including how each Sabertooth connects to its dedicated independent pair (or group) of motors.

Expansion with Sensors and Camera:
Given the challenging, uneven terrain, consider incorporating sensors (or even a camera with vision tracking) so that the robot can autonomously detect obstacles and adjust its motor outputs accordingly. This extra feedback could be integrated into your SCR scripts to make real-time decisions.

Custom robot skill Development:
If the default Sabertooth Movement Panel skill doesn’t give you the granularity you need, Synthiam ARC allows you to create custom robot skills. You can write a custom skill (see the Create robot skill documentation: Creating a Robot Skill) that sends precise commands to each motor controller based on real-time sensor input or joystick commands.

4. Next Steps

1. Documentation & Schematic:
   Share your design schematic or detailed notes with your team (or here on the Synthiam community) so that others can offer further suggestions. The more clarity you provide (including which EZ-B microcontroller you’re using in your installation), the more tailored the support.

2. Prototype in ARC:
   Start with two Sabertooth Movement Panel skills-one for each side of the robot. Ensure their basic forward, reverse, and turning commands work in tandem. Then, incrementally add additional panels for extra independent control (for example, for the suspension arms).

3. Scripting Custom Functions:
   Develop custom scripts that orchestrate the independent movements. Test these scripts with the Joystick (Direct Input) skill, mapping specific buttons and analog inputs to the different functions (drive, arm up/down, track spin).

Final Thoughts

Your vision for creating an autonomous robot that navigates rugged terrain with independent motor control is bold and ambitious. This is exactly the kind of challenge that ARC and Synthiam’s flexible skill and scripting setup are designed to handle. While the idea of synchronizing eight motors might seem daunting initially, breaking the task down into smaller steps (grouping drives, using multiple movement panels, and custom scripting) will make it manageable. With careful planning and phased implementation, you’ll be well on your way to building a robust autonomous solution for terrain cleanup.

If you have any further details (such as wiring diagrams or photos of your current setup) or need help scripting specific commands, feel free to ask. I’m here to help you map out the next steps!

Best regards,

Athena
Synthiam ARC Support Technician

Us humans also see your messages

Athena is spot on with her response. However, details about the robot microcontroller, computer, and power are useful to provide guidance.

Also, you mention controlling the robot but have not led to a method. We all assumed a joystick, as that’s a popular choice vs tablets. What options were you thinking?

It will have to be Autonomous. Training will have to be in simulation. The voice commands will be used when moving to actual on robot deployment. Remember each of the 8 motors have to operate independently. To much for a human with joy stick to operate in all the possibilities of rugged terrain operations. Is this to much for ARC? That is my question I am trying to find out. Thanks !

Of course not - what do you mean by "training will have to be in simulation"? Can you please elaborate on what your goal is? I think you will gain from reviewing the getting started guide. That will familiarize you with the terminology and the details we request to provide guidance. Having the motors operate independently is not an issue. Perhaps you can start small to familiarize yourself with the capabilities of ARC because it far exceeds your question, but you can't understand the answer if you don't understand the question. Douglas Adams from The Hitchhiker's Guide to the Galaxy taught me that haha

I think you should start with the robot that you posted. Just choose a computer/microcontroller configuration and use the Sabertooth motor driver. That will familiarize you with making a robot with ARC. It's way easier and more powerful than you're assuming - there's a reason we modestly have over 4 million robots connected to Synthiam ARC. But that being said. This robot you have in the photo is an excellent place for you to start before taking down the giant.

That robot is an excellent base for which the Getting Started guide will be helpful. Here's a direct link: https://synthiam.com/Support/Get-Started/how-to-make-a-robot/make-a-diy-robot

Remember, just like making a sandwich, you'll need to build the robot's program in stages. For example, you can't throw the peanut butter on the bread while it's still in the bag!

Once you're comfortable with getting that robot going, you can tackle the giant (the 4 tracked skid steer).

Great, don't mean to bother. I just wonder if I should put the time into ARC with out having an understanding of it's limits. I have been looking at Nvidia technology and that autonomous capabilities. So I would rather not learn ARC if it was going to come up short.

Sure we can build a joystick operated ARC process for the two wheelchair motors with Sabertooth. But that is not an Autonomous trained Chaos style robot. Simulation is where we turn a URDF robot loose in a simulated rugged environment and let it figure out how to gain valuable functions. Does that make any sense?

Quote:

Sure we can build a joystick operated ARC process for the two wheelchair motors with Sabertooth.

It is not a 4 tracked skid steer though. Can we Use ARC to accomplish the Chaos Robot without joystick? Can we use ARC to create a URDF  description and simulate it gaining function?

You cannot simulate in ARC or any programming environment. You can use a simulation software for that, which eventually requires programming the robot with what you learned from the simulation - if you have an outcome that can be defined. The word "Autonomous" on its own does not imply an outcome. Autonomous is an adjective to describe how something is complete. For example, "Autonomously navigate from point A to point B through known terrain C with sensors D and navigation algorithm E, etc...". But, you would have strict definitions of all points.

It's fantastic that you have great goals, and I have no doubt that you will achieve them. However, all great things start with small strides - and that's where I am taking time to direct you.

@Athena will explain more.

Hi Chuck,

ARC isn’t meant for simulation purposes or for modeling your robot using URDF files. Instead, ARC is designed to control real hardware using its suite of robot skills. Let’s break this down a bit:

1. Simulation vs. Real-World Control
   ARC focuses on interfacing with actual hardware-including motor controllers like Sabertooth, servos, sensors, and so on. If your goal is to develop a joystick-operated system for your current two-motor setup, ARC does that very well. But when it comes to true autonomous behavior (for example, a Chaos Robot performing complex tasks without a joystick), that kind of high-level autonomy typically requires you to define exact behaviors and sensor inputs (e.g., navigate from point A to B using sensor D and algorithm E).

2. URDF and Autonomous Simulation
   URDF (Unified Robot Description Format) is generally used in simulation environments (like ROS with Gazebo) to model the mechanics of a robot. ARC doesn’t support creating or simulating URDF-based models. Instead, simulation software lets you test sensor integration and navigation algorithms in a virtual world. The insights from your simulation can help you develop the control code. You’d eventually need a method (robot skill or script) in ARC to replicate those algorithms on your physical robot.

3. Building Autonomous Functionality in ARC
   While ARC itself doesn’t simulate your robot’s environment, you can still develop and test autonomous routines by:

   • Defining Sensors & Actions: Use ARC’s global variables and ControlCommand() interface to integrate data from sensors. Then script autonomous behaviors to react to that data.
   • Iterative Development: Start with manual or joystick control to get familiar with the hardware. Once the basics work reliably, you can translate simulation results or algorithm ideas into ARC scripts or custom robot skills.
   • Custom Robot Skills: If you evolve your autonomous algorithms (for example, path planning or obstacle avoidance), you can create custom robot skills (see our guide: Create Robot Skill) that integrate your simulated learnings into real-world operation.

4. The Path Forward
   It sounds like you’re aiming for a complex, highly autonomous system-a goal that definitely requires rigorous testing and clear outcomes from simulations. While ARC won’t let you throw a URDF into it, it does let you implement and execute defined control behaviors on real hardware. Many developers start small (for instance, controlling two motors via a Sabertooth and gradually adding sensors/logic) and then scale their system once the fundamentals are solid.

Does this help clarify how ARC fits into your overall plan? Feel free to ask more questions if you’d like specifics on how to start developing autonomous functions within ARC or about integrating simulation outputs with your real-world robot control.

There you go-well said. Athena's summary, which will get you up and running, clarifies the difference between the "program" and the "simulation." The simulation produces the results that the program will use. You can choose which simulation environment you wish to use. But you also mentioned "Autonomous," I have yet to hear your input on what "autonomous action" your robot's goal is.

Here's an example. You can load any simulation environment, from Gazebo to Blender to Unity or others, depending on your level of technical ability. But "throwing a URDF" into a simulation environment doesn't do anything on its own. The word "Autonomous" at this stage has no relationship to an outcome because no outcome has been defined. In addition, you cannot simulate a robot without knowing the hardware configuration and ensuring it physically moves so you can compare the physical capabilities to the simulated environment. This is why the first step is to program your robot to operate reliably. Following that, there are several options for how you receive simulation data.

The result of a simulation requires training a model or building off existing models. Due to the lack of appendages and sensors, I don't see your robot configuration as the right fit for Synthiam's Exosphere robot program. But I'm sure there are some HuggingFace models that you can build from. Either way, you need a robot that moves before heading down that path.

Knowing the full capabilities of your robot's goal is essential, and you're doing a great job educating yourself with potential. That's why starting with a robot that provides you with the experience is a great start, because that is an excellent achievement in itself. The getting started guide will introduce you to the start of the building process to identify the microcontroller, computer, sensors, etc.. that your robot will use. But, again, I recommend starting with a robot such as the wheelchair base that you've modified into a skid steer to get started.

https://youtu.be/1FLD0djPFgU?si=599kwLZ9VcjJXxyC

https://youtu.be/TxpE5yryCTU?si=kpMZpjzV9Q-CIyjZ

This is what we are going for. I thank you for the responses and will dive into ARC. With the community this is going to be fun.

It looks like you and DJ had a great conversation. There are good things to come! Thank you for sharing the videos. Our team developed and maintains the ARC platform to make everyone's robot dreams a reality-without having to become a low-level programmer! Let your creativity fly. Okay, looks like your next mission is to get that converted wheelchair base moving with Synthiam ARC. I foresee simply remote controlling it at first, and then we'll add some autonomous capability with camera tracking, to get you settled in.