You’re heading down a path that may lead to frustration. Working with proprietary hardware is incredibly challenging without knowledge of reverse engineering. Many automation manufacturers don’t want their hardware to be controlled by anything other than their own software, thereby locking customers into their ecosystem.

This is because it’s easier to copy hardware than to reproduce software. China can reproduce any hardware because, at the end of the day, they’re the manufacturers of it anyway. Or at least, they make the components.

So to protect themselves, big names in automation lock you in.

That doesn’t mean there isn’t information out there from others who have reverse-engineered your hardware.

This thread/question would benefit from including information about the products. Athena, I, or anyone can’t provide answers or direction because it’s a guessing game at this stage without knowing what products you're using. What hardware? What product model numbers? What protocols? What software is being replaced? Etc etc

I also didn’t understand the original question, so Athena took my guidance - interpreting that you wanted ARC instances to talk to each other. I’m going to remove the past comments because this has become a very confusing thread. What you’re asking is how to directly connect ARC to a proprietary robot hardware, correct? I edited the original question to make it easier to understand.

I’ll remove the questions about asking Athena to show you a communication example using Print() doesnt relate to each other. Print() is used to print out text to the console. To communicate with something other than a console, you’d use UDP, HTTP, com, uart, etc commands. But on top of that, you’d need to assemble the protocol packets for communication with those commands.

All the unknowns are

• product manufacturer
• product model number
• communication type
• software it is replacing

You might also find that their software has an api or SDK if you’re lucky! But it’s impossible to know without any information about what you’re working with.

Below is some guidance on how to approach integrating your heavyduty robots with Synthiam ARC:

1. Define the Communication Interfaces

Since your robot is built around an Arduino Leonardo with EZB Firmware, the default communication methods available in ARC are:

• USB (serial over USB):
  This is used by ARC to communicate with your EZB firmware. You can use the Serial Terminal (PC) robot skill to send and receive data or the TCP Script Server Raw if you prefer a network approach.

• Digital/Analog I/O:
  ARC controls servos and reads sensors via the digital ports (d0-d23) or ADC ports (ADC0-ADC7) on the EZB. For heavy-duty actuators or relays that handle higher power, you will likely need additional motor controllers or drivers with proper interfacing hardware.

Before you begin, consider questions such as:
What communication ports do your heavy-duty controllers offer? (USB, RS-232, RS-485, Ethernet, etc.)
What protocols are used by your proprietary hardware (if available)?
How does the manufacturer specify interfacing with their controllers?

Note: If these robots use proprietary protocols (or "closed" systems), you might need to reverse engineer the communication or make a custom robot skill. For more on creating the latter, see the Custom robot skill Tutorial.

2. Hardware Interfaces and Controllers

For a smooth integration with ARC, the following hardware components are generally required:

• EZ-B Controller or Compatible Microcontroller:
  Your Arduino Leonardo running EZB Firmware is one option. If you need more robust I/O or industrial-grade connections, you might consider using an EZ-B-compatible controller that is rated for heavier loads.

• Motor Drivers/Controllers:
  Heavy-duty robots typically require motor drivers that handle high current loads. These drivers must interface with your controller (Arduino/other microcontroller) via digital signals, PWM outputs, or even serial/ethernet commands.

• Communication Converters (if needed):
  If your heavy-duty robot controllers use another interface (e.g., RS-232 or RS-485), you might need USB-to-serial converters or dedicated interface boards. ARC’s Serial Terminal skill can then communicate via the appropriate COM port on your PC.

• Power and Signal Isolation:
  For robots carrying payloads around 50 pounds, ensuring the proper power supply, isolation of signals, and using industrial-grade connectors becomes crucial for reliability and safety.

3. Configuring ARC to Communicate with Your Robot

When integrating the hardware:

• Set Up the Connection in ARC:

  • If you’re using the USB connection (with the Arduino Leonardo), install the proper drivers and check that the COM port is configured correctly in ARC’s Serial Terminal skill.
  • For TCP/IP communication, use the TCP Script Server Raw skill. You can host a TCP server on ARC or on the Arduino (if supported via additional modules like an Ethernet or Wi-Fi shield) so that messages are exchanged directly.

• Utilize Synthiam’s Scripting Capabilities:

  • In ARC, you can create custom scripts in JavaScript or Python to send commands to your hardware. For example, using JavaScript you can print output with:

    print("Command Sent")
    

    However, for sending commands to your hardware, you will construct protocol packets and send them through the proper channels (serial, TCP, etc.).

• Develop a Custom robot skill (if required):
  If the robot’s interface isn’t fully supported by the existing skills, consider creating a custom robot skill. Use our step-by-step guide on creating custom robot skills here:
  Create a Custom Robot Skill.

4. Gathering Additional Information

Since heavy-duty and proprietary robots may have unique requirements, consider these questions:

• What are the specific product model numbers and documentation for the robot controllers?
• What communication protocols and ports do they provide?
• Is there any manufacturer API/SDK information available for interfacing?
• Are there any existing examples online of someone integrating similar hardware with third-party software like ARC?

The answers to these questions will help clarify whether you can directly interface ARC with the controllers or if you need a custom intermediary (or even reverse engineering of the protocol).

5. Next Steps

• Document Your Setup:
  Make a list of all interfaces, ports, and communication protocols available on your heavy-duty robots.
• Test Communication:
  Use the Serial Terminal or TCP Script Server skills to send simple commands to the robot’s interface and monitor the responses.
• Create Custom Logic:
  Once you have established basic communication, write custom scripts or robot skills to achieve the control you need.
• Explore ARC Tutorials:
  The DIY Robot Tutorial provides useful insights into connecting and controlling various custom robots with ARC.

In Summary

Integrating heavy-duty robots with ARC involves ensuring that your controller (Arduino Leonardo with EZB Firmware) can communicate with the robot’s actuators and sensors using a supported interface (USB/serial or TCP/IP). You’ll need to verify the communication hardware (motor drivers, interface converters, power supplies) and determine whether the proprietary system can be interfaced directly or whether customization (or reverse engineering) is necessary.

Could you provide more details on:

• The specific heavy-duty robot controllers or model numbers you’re working with?
• Which communication ports and protocols are available on that hardware?

This information will help narrow down the best integration approach using Synthiam ARC. If you have more questions or need further clarification about a particular step, feel free to ask!