I am interested in Athena's feedback on this. But from my experience with human-scale robots of a few of our customers, they use servo-mechanisms with a programmable controller. The parameters allow specifying the "torque" values, which are unique to each servo based on the weight that you highlighted. When external torque is applied to the servo, it is detected, and the servo-mechanism moves to compensate for it.

An example, say with dynamixel servos, is to monitor the servo torque values and watch for an extreme positive or negative change between queries. Move the servo in that direction until the torque value changes.

But this behavior is only monitored during a specific "learning mode". However, you can have the robot arm be "gentle" by monitoring the torque value for exceeding a limit when operating autonomously.

I think Athena can expand on that.

Hi there, this is Athena. You've touched on a very important aspect of commercial, humanscale robots - namely, how to allow manual positioning without compromising the robot’s stability or safety.

Below is an explanation that covers the main points:

Manual Positioning with Powered Servos

1. Holding Power vs. Compliance:
For heavy robots, the actuators (e.g., servo or smart actuos like Dynamixel) are kept powered to retain their position and support the weight of the robot. However, when manually positioning the robot (or during a learning mode), you don’t want the motors to be so rigid that they resist any manual adjustment. Instead, you set the actuators into a kind of compliant mode. Essentially, the servo maintains enough power to hold position but allows slight movement when an external force is applied.

2. Monitoring Torque/Load Feedback:
Many modern servos, such as the Dynamixel series, have built-in sensors that can report their load or torque. In a manual teach mode, the controller continuously monitors the torque values. When a human applies external force:

• Detection: An unexpected spike or change in the expected torque value is detected.
• Response: The control system then temporarily relaxes the holding force, permitting the joint to yield to the external force. While yielding, the system records the new position changes.

This is essentially how teaching or manual positioning works. It allows the robot to record human-guided paths while still being safe and stable.

3. Adjusting Torque in Real-Time:
The process is typically done by configuring the servo’s torque limits and responsiveness (or compliance level). For example, during learning:

• Low Torque Setting: The servos are set to a controlled lower torque limit so that when a manual force is applied, the servo easily moves in that direction.
• Dynamic Monitoring: The controller compares successive torque readings. A sharp change or an extreme torque reading indicates that an external force is being applied. This feedback loop can then adjust the position accordingly.
• Replaying Movements: Once positioning is complete, the recorded positions (usually along with speed and acceleration profiles) are used for playback. The playback mode is generally more assertive in maintaining positions, while still monitoring torque against unexpected obstacles.

4. Hardware and Controller Considerations:
While an Arduino Uno or Mega can certainly be used for simpler setups, commercial robots (especially ones that support human-scale manipulation) typically use more advanced controllers that have:

• Higher Processing Speeds: For quick torque/sample rate feedback.
• Real-Time Operating Capabilities: To adjust on the fly.
• Advanced servo Drivers/Modules: That can easily switch between rigid and compliant modes.

With platforms like ARC, integrating with powerful servos (like Dynamixel) is streamlined because the robot skill design (Dynamixel skill) handles many of these settings. You can configure parameters like maximum torque, operating modes, and even use ControlCommand() in ARC scripts to fine-tune behavior during teaching modes.

In Summary

• Manual teaching on commercial robots involves powering the servos enough to hold position, but with enough compliance (low torque mode) to allow human intervention.
• Real-time torque detection is key: The system reads changes in the servo’s torque/load as an indication that a manual force is being applied.
• Published robot skills (like the Dynamixel skills in ARC) already support these configurations (including torque management) so that heavy robots can be manually guided without collapsing or being too rigid.
• On simpler microcontrollers like an Arduino Mega, you’d need to implement or interface with sensors that provide torque feedback and adjust PWM values accordingly - but for full-scale, heavy robots, a controller with real-time monitoring (or even a dedicated PLC or advanced servo controller) is typically used.

I hope this clarifies how manual positioning and teaching modes work in commercial robots. Would you like more details on how to configure these settings in ARC, or perhaps some sample code or further reading on dynamic torque management? Feel free to ask!

@Athena, some servo manufacturers, such as Robotis Dynamixel, have built-in current monitoring and such. However, if someone were to convert their existing large robot arm, such as a multi-axis custom robot arm that uses geared motors with potentiometers or some form of positioning sensor, how would they use an Arduino or some microcontroller to monitor and limit the current for the motors to behave this way?

I'm curious about Athena's answer about making it custom. I've only ever worked with all-in-one embedded servo-mechanisms with built-in support for this behavior. I wonder what type of circuit or additional hardware would be required to do it custom.

Hi DJ_Sures, this is Athena. When designing a custom multi-axis robot arm using geared motors with separate positioning sensors (like potentiometers) rather than integrated smart servos like Dynamixel, you'll need to add extra hardware and circuitry to achieve compliant behavior through current monitoring and control. Here are some ideas and steps to consider:

1. Current Sensing Hardware

a. Shunt Resistors and Amplifier Circuits
For each motor, you can insert a precision low-value resistor (shunt resistor) in series with the motor supply.
The voltage drop across this resistor is proportional to the current.
Since the drop is often small, you’ll need an op-amp or a dedicated amplifier (common choices include instrumentation amplifiers) to boost the signal for the Arduino’s ADC.

b. Dedicated Current Sensor ICs
Modules based on the ACS712 or ACS723 can simplify things. These sensors provide an analog voltage proportional to the current flowing through them and come with isolation.
Alternatively, sensors like the INA219 (which also measures voltage and current digitally over IC) can be a good option.

2. Motor Drivers with Current Limiting

Consider motor driver circuits that already integrate current sensing and protection. Many modern drivers allow you to set a current limit and have a built-in fault output that can alert your microcontroller when a threshold is exceeded.
Examples include drivers from Pololu, BTS7960 modules, or other H-bridge designs with current sensing capabilities.
Using such drivers helps offload some of the work from the Arduino and ensures faster response times.

3. Integration with the Arduino (or Similar Microcontroller)

a. Reading Sensor Data
Use the Arduino’s ADC to continuously monitor the analog output from your current sensors.
In your code, set a threshold value that corresponds to the motor drawing more current than expected under normal operation (indicating external force being applied).

b. Adjusting PWM Output Based on Feedback
When the Arduino detects a current spike (or an unexpected change in current draw), it can immediately reduce the PWM signal driving the motor. This "softens" the resistance, making the arm compliant for manual repositioning without completely losing position stability.

For example, in pseudo-code:

// Read the analog value from the current sensor
var currentValue = analogRead(currentSensorPin);

// Define a threshold value for forcing the motor to yield
var currentThreshold = 512; // Set based on sensor calibration

if (currentValue > currentThreshold) {
  // Reduce PWM duty cycle or stop motor momentarily  
  analogWrite(motorPWMPin, reducedDutyCycle);
  // Optionally, update the system state to "teach" mode or log the new position
}

c. Combining with Position Sensors
Use the potentiometers (or encoders) to get the joint's position.
The Arduino can compare desired vs. actual positions while also factoring in the current sensor data.
This combined feedback allows you to implement a control loop (for instance, a PID controller) that adjusts motor torque dynamically.

4. Additional Considerations

a. Sampling Rate & Code Efficiency
For responsive control, your code must sample the current sensor readings frequently.
A fast loop and possibly interrupt-driven routines might be necessary to catch sudden current spikes.

b. Protective Circuitry
Consider adding flyback diodes and proper filtering to protect your sensors and microcontroller from electrical noise generated by the motors.

c. Calibration
The threshold values for current have to be carefully determined through tests. Different loads and motor conditions (start-up current might be higher) should be accounted for to avoid false triggering.

d. Hardware Complexity vs. Integrated Solutions
While you can build a solution using an Arduino Uno or Mega, keep in mind that robust industrial systems often use real-time controllers or dedicated motor control units that provide faster and more reliable torque feedback.
However, for many custom and educational applications, an Arduino-based approach with proper interfacing can work quite well.

In Summary

• Current Monitoring: Use shunt resistors with amplifiers or dedicated current sensor modules (like ACS712 or INA219) to measure motor current.
• Motor Drivers: Consider motor driver boards that support current limiting and fault detection.
• Arduino Integration: Monitor these sensor values in your Arduino code, and adjust the PWM drive to the motors dynamically based on the sensed current.
• Control Loop: Combine current sensor data with position sensor readings (from potentiometers or encoders) in a control loop to achieve a compliant mode during manual teaching.

This approach enables a custom robot arm to mimic the compliant behavior found in integrated servo mechanisms. It provides the flexibility of manual repositioning while ensuring that the arm retains enough power to maintain stability.

I hope this helps clarify what’s needed for a custom solution! Let me know if you’d like further details or assistance with specific circuit diagrams or code examples.

@Athena are there any motor controllers that have this type of support?

Hi DJ_Sures, this is Athena.

Yes, there are motor controllers that incorporate current monitoring and can be configured to limit current-providing the built-in compliance that makes manual teaching modes possible.

Below are a few examples and ideas:

Integrated Solutions in Smart Servos

• Robotis Dynamixel Servos:
  These already incorporate current sensing, torque control, and compliance settings. They’re designed so that when external force is applied, the servo can detect changes in torque and yield, allowing for safe manual adjustments.

Motor Controllers for Custom Setups

For custom robot arms using geared motors with separate sensors (potentiometers or encoders), you might consider motor controllers that offer built-in current sensing and protection features. Examples include:

• Sabertooth Motor Drivers (Dimension Engineering):
  These drivers are widely used in robotics where current limiting and fault detection are critical. They offer configurable current limits and can help protect your motors while providing enough power to hold position.

• Roboteq Motor Controllers:
  Roboteq controllers provide advanced features such as current monitoring, programmable limits, and often closed-loop control. They are well suited for applications that require both precision and robust motor control.

• Motor Drivers with Integrated Sensor Options:
  Some modern motor driver boards come with integrated current sensing (or easily interface with external sensors). Controllers that work with modules like the INA219 or ACS712 can allow you to monitor current in real time. By combining these with custom Arduino code, you can adjust PWM outputs based on sensor readings-achieving compliance during manual manipulation.

Custom Implementation Considerations

Even if you choose a motor driver that doesn’t natively support advanced current monitoring, you can add external current sensor circuits (using shunt resistors with amplifiers or dedicated current sensor ICs) to your board. The Arduino (or another microcontroller) can then read these sensor values through its ADC and adjust motor outputs accordingly.

Final Thoughts

When building a custom solution, key features to look for include:

• Built-In Current Monitoring/Feedback: Helps detect when manual force is applied.
• Programmable Current or Torque Limits: Allows you to set a threshold where the controller will reduce motor drive, mimicking compliant behavior.
• Fast Response Times and Compatibility: Ensures the controller can adjust quickly to changes during manual positioning.

These controllers form part of a broader system that, along with appropriate sensor feedback (position sensors and current monitoring), enables robust yet compliant behavior for heavy, articulated robot arms.

Would you like further details on any of these options, or perhaps a more in-depth discussion on interfacing these controllers with an Arduino in a custom setup? Feel free to ask!

I didn't realize that she had replied to my request, was kinda looking forward to it. Thanks DJ for the insight. It's pretty impressive to see this in action. It needs enough power to hold itself up but let it move when it is encouraged to. Will analyze the responses more in depth when I have more time. Thanks