Workflow

Covalent modules follow the same workflow: collect calibration data, identify a robot model, and use that model inside a controller. The exact calibration routine and controller change by product, but the overall steps are the same for Covalent Shaper, Covalent KineCal, and Covalent Joint Tracker. Calibration and identification usually only need to be completed once for a robot type. After the model is identified and saved, the controller can be loaded and reused every time you run the robot.

Covalent Elements

Reforge SDK - a PyPI package containing the calibration, identification, and control modules. See the SDK documentation for usage.
Reforge Interface SDK - an open-source GitHub repository used to connect Reforge to your robot SDK, run calibration routines, and call the cloud API. See the Interface SDK documentation for usage.
Reforge Cloud API - Reforge's cloud API for turning calibration data into models used by the controllers. See the API reference for usage.

What To Expect

Set up the SDK and credentials. Install the Reforge tools, generate an API token, and register the robot so you have a robot ID. See First Steps.
Connect Reforge to your robot. The interface layer needs the robot SDK, robot connection settings, and the robot URDF. See Automatic Integration or Manual Integration.
Collect calibration data. Run the product-specific calibration command. The robot moves through a controlled routine and records the data required by the selected Covalent module.
Identify the model. Upload the calibration data to Reforge Cloud API, or run the identification step from the command line when the product supports it. The generated model is stored in src/robot/models/.
Run the controller. Load the identified model from src/robot/models/, pass the desired robot command into the Covalent controller, and send the modified command to the robot through the manufacturer's SDK.
Repeat control as needed. Once the model exists, you do not need to recalibrate before every run.

For the theoretical background behind the model-identification step, see System Identification and FEA.

Covalent Module Example

The example below shows controller use after calibration and identification are complete. The robot SDK provides the desired trajectory and sends the final command to the robot. The Reforge SDK loads the identified model and modifies the command before it is sent. For the workflow-level example here, assume the full trajectory is already known before motion starts.

python
import numpy as np
import robot_sdk  # Replace with the SDK package for the robot you are using.
from reforge_core.control.shaper import ShaperInterface

sample_time_s = 0.004

shaper = ShaperInterface(
    sample_time=sample_time_s,
    model_directory="src/robot/models/current/shaper",
    urdf_filepath="src/robot/urdf/<robot>.urdf",
    num_axes=3,
    num_joints=6,
)

# Desired joint trajectory from your planner or robot SDK: [N, num_joints].
desired_trajectory_rad = np.asarray(robot_sdk.get_planned_joint_trajectory())
time_vector_s = np.arange(len(desired_trajectory_rad)) * sample_time_s
velocity_rad_s = np.gradient(
    desired_trajectory_rad,
    sample_time_s,
    axis=0,
)
acceleration_rad_s2 = np.gradient(
    velocity_rad_s,
    sample_time_s,
    axis=0,
)

# Shape the full known trajectory with the identified Reforge model.
shaped_trajectory = shaper.process_trajectory(
    command=desired_trajectory_rad,
    command_dot=velocity_rad_s,
    command_ddot=acceleration_rad_s2,
    time_vector=list(time_vector_s),
    vibration_shaping_weight=1.0,
    vibration_weight_transition_s=0.0,
    residual_shaping_strategy=None,
    finalize_tail=False,
)

# Send the shaped command through the robot manufacturer's SDK.
robot_sdk.send_joint_trajectory(
    positions=shaped_trajectory.positions,
    velocities=shaped_trajectory.velocities,
    accelerations=shaped_trajectory.accelerations,
    sample_time=sample_time_s,
)

For complete Covalent Shaper examples, including online sample-by-sample control, see Control.