reforge-core 0.0.20

Reforge Core SDK by Reforge Robotics.

Reforge SDK (reforge-core)

Reforge SDK is the independently built Python package that powers Reforge calibration and model-based vibration control.

This README is intended for PyPI distribution of reforge-core.

What This Package Provides

Calibration module (reforge_core.calibration)

The calibration module provides the cloud interface used after a robot calibration run:

• Uploads calibration data artifacts
• Triggers identification or fine-tuning jobs in Reforge Cloud API
• Polls job status and downloads generated model artifacts
• Extracts returned model files for control use

Primary entry point:

• reforge_core.calibration.api.ReforgeAPIManager

Control module (reforge_core.control)

The control module provides vibration-aware command shaping for robot trajectories:

• Loads per-axis model files generated by calibration/identification
• Computes shaping parameters from current robot state
• Shapes single commands or full trajectories
• Returns shaped positions, velocities, and accelerations for execution

Primary entry points:

• reforge_core.control.python.covalent_wrapper.ShaperInterface
• reforge_core.control.python.covalent_wrapper.RobotState

Interface with reforge-interface (src/robot)

Reforge SDK is designed to be consumed by the reforge-interface repository, where robot-specific integration lives.

Expected responsibilities in reforge-interface/src/robot:

• Robot transport and SDK communication loop
• Sensor acquisition (joint encoders, TCP accelerometer)
• Calibration routine execution and local data storage
• Invocation of Reforge SDK calibration + control APIs

Typical artifact flow:

1. src/robot/run.py runs calibration and stores local data (for example under src/robot/data/<date>).
2. ReforgeAPIManager uploads the data and requests model generation.
3. Returned model artifacts are saved for runtime control (commonly under src/robot/models/current).
4. ShaperInterface loads those models and the robot URDF to shape outgoing joint commands before they are sent through the robot driver in src/robot.

In this architecture, reforge-interface/src/robot owns robot I/O and execution, while reforge-core owns calibration-cloud orchestration and shaping logic. python_src_root should point at the reforge-interface/src directory so runtime dependencies (for example dynamics utilities and robot assets) can be resolved.

Usage

1. Ensure you have the requirements:

• An accelerometer/IMU located at the tool center point (TCP) that can measure data in the x-, y-, and z-coordinates of the end-effector’s inertial frame of reference (or the robot base’s inertial frame).
• Encoders in each joint that can accurately measure the current joint position of the robot at a rate of 200 Hz or higher.
• A real-time SDK to access data from IMU and encoders and to command the joint motors with time-domain angular motor positions.
• A Universal Robot Description File (URDF) that describes the robot’s kinematics and dynamics (dynamics optional but preferred).

2. Integrate the robot’s SDK/URDF and build the project.

• Pull the Reforge repository from Github and add your robot's SDK to requirements.txt

git clone https://github.com/reforge-robotics/reforge-interface.git
cd reforge-interface

• Add the robot's URDF to src/robot/urdf
• Build the project

python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
pip install --no-cache-dir .

3. Integrate your robot's SDK in src/robot/robot_interface.py

4. Test robot connection

python3 -m robot.run connect_test <robot_ip> --local_ip <local_ip> --sdk_token <robot_sdk_token> 

5. Run the calibration and identification of models

• Run with automatic identification

python3 -m robot.run calibrate <robot_ip> --local_ip <local_ip> --sdk_token <robot_sdk_token> --robot_id <reforge_robot_id> --freq 250 --identify <reforge_api_token>

• Run calibration first, then run identification

python3 -m robot.run calibrate <robot_ip> --local_ip <local_ip> --sdk_token <robot_sdk_token>
python3 -m robot.run identify <reforge_api_token> <reforge_robot_id> <local_data_location>

6. Run test to verify the calibration

python3 -m robot.run vibration_test <robot_ip> <local_data_location> --local_ip <local_ip> --sdk_token <robot_sdk_token>

The robot will go through a random series of motion pairs, one uncompensated and one compensated, store the accelerometer data from the motion tests, and print out a log with the test results.

Minimal Usage Sketch

from reforge_core.calibration.api import ReforgeAPIManager
from reforge_core.control.python.covalent_wrapper import ShaperInterface, RobotState

# Calibration/model generation
api = ReforgeAPIManager(reforge_api_token="<token>", robot_id="<robot_id>")
api.run_cloud_model_generation(data_folder="src/robot/data/<YYYY-MM-DD>")

# Runtime shaping
shaper = ShaperInterface(
    sample_time=0.005,
    model_directory="src/robot/models/current",
    python_src_root="src",
    urdf_filepath="src/robot/urdf/<robot>.urdf",
    num_axes=3,
    num_joints=6,
)

state = RobotState(joint_angles=...)  # numpy array
shaped = shaper.shape_sample(..., state)

Installation

pip install reforge-core