RSIPI is a high-performance, Python-based communication and control system designed for real-time interfacing with KUKA robots using the Robot Sensor Interface (RSI) protocol. It provides both a robust API for developers and a powerful Command Line Interface (CLI) for researchers and engineers who need to monitor, control, and analyse robotic movements in real time.
🛡️ Safety Notice RSIPI is a powerful tool that directly interfaces with industrial robotic systems. Improper use can lead to dangerous movements, property damage, or personal injury.
- Test in Simulation First: Always verify your RSI communication and trajectories using simulation tools before deploying to a live robot.
- Enable Emergency Stops: Ensure all safety hardware (E-Stop, fencing, light curtains) is active and functioning correctly.
- Supervised Operation Only: Run RSIPI only in supervised environments with trained personnel present.
- Limit Movement Ranges: Use KUKA Workspaces or software limits to constrain movement, especially when testing new code.
- Use Logging for Debugging: Avoid debugging while RSI is active; instead, enable CSV logging and review logs post-run.
- Secure Network Configuration: Ensure your RSI network is on a closed, isolated interface to avoid external interference or spoofing.
- Never Rely on RSIPI for Safety: RSIPI is not a safety-rated system. Do not use it in applications where failure could result in harm.
RSIPI allows users to:
- Communicate with KUKA robots using the RSI XML-based protocol.
- Dynamically update control variables (TCP position, joint angles, I/O, external axes, etc.).
- Log and visualise robot movements with live graphs and static plots.
- Analyse motion data and compare planned vs actual trajectories.
- Parse and inject RSI into KRL programs.
- Simulate robot behaviour using a realistic Echo Server.
- Enforce safety limits and manage emergency stops.
- Researchers working on advanced robotic applications, control algorithms, and feedback systems.
- Engineers developing robotic workflows or automated processes.
- Educators using real robots in coursework or lab environments.
- Students learning about robot control systems and data-driven motion planning.
- Real-time network communication with KUKA RSI over UDP.
- Structured logging to CSV with British date formatting.
- Background execution and live variable updates.
- Fully-featured Python API for scripting or external integration.
- CLI for interactive control, trajectory planning, and live monitoring.
- Real-time and post-analysis graphing (live TCP, joints, force, acceleration).
- Safety management: emergency stop, limit enforcement, safety override.
- KUKA KRL
.src/.datparsing and RSI injection tools. - Echo Server and GUI for offline simulation and testing.
- Deviation and force spike alerts during live operation.
from src.RSIPI import rsi_api
api = rsi_api.RSIAPI(config_file='examples/RSI_EthernetConfig.xml')| Method | CLI | API | Description |
|---|---|---|---|
start_rsi() |
✅ | ✅ | Starts RSI communication (non-blocking). |
stop_rsi() |
✅ | ✅ | Stops RSI communication. |
update_variable(path, value) |
✅ | ✅ | Dynamically updates a send variable (e.g. RKorr.X). |
get_variable(path) |
✅ | ✅ | Retrieves the latest value of any variable. |
plan_linear_cartesian(start, end, steps) |
✅ | ✅ | Create Cartesian paths. |
plan_linear_joint(start, end, steps) |
✅ | ✅ | Create Joint-space paths. |
execute_trajectory(traj, rate) |
✅ | ✅ | Execute planned trajectory live. |
enable_alerts(True/False) |
✅ | ✅ | Enable or disable deviation/force alerts. |
start_live_plot(mode) |
✅ | ✅ | Live graph position, velocity, force, etc. |
generate_plot(csv, type) |
✅ | ✅ | Static graphing from CSV files. |
export_movement_data(filename) |
✅ | ✅ | Export recorded motion as CSV. |
parse_krl_to_csv(src, dat, output) |
✅ | ✅ | Extract TCP points from KRL programs. |
inject_rsi(input, output, config) |
✅ | ✅ | Add RSI startup code to a KRL file. |
(Full API details available in rsi_api.py.)
Start the CLI:
python main.py --cli| Command | Description |
|---|---|
start / stop |
Start or stop RSI client. |
set <var> <value> |
Update send variable. |
get <var> |
Get latest receive variable. |
move_cartesian, move_joint |
Move robot using planned trajectories. |
queue_cartesian, queue_joint |
Queue trajectory steps. |
execute_queue |
Run queued trajectories. |
alerts on/off |
Enable or disable alerts. |
graph show/compare |
Plot or compare test runs. |
log start/stop/status |
Manage CSV logging. |
plot <type> <csv> |
Static plotting (position, velocity, deviation, etc.). |
safety-stop, safety-reset, safety-status |
Emergency stop and limit management. |
krlparse <src> <dat> <out> |
Parse KRL to CSV. |
inject_rsi <src> [out] [config] |
Inject RSI code into KRL file. |
api.start_rsi()
api.update_variable('RKorr.X', 100.0)
api.update_variable('RKorr.Y', 50.0)start_pose = {'X': 0, 'Y': 0, 'Z': 500}
end_pose = {'X': 200, 'Y': 0, 'Z': 500}
traj = api.plan_linear_cartesian(start_pose, end_pose, steps=100)
api.execute_trajectory(traj, rate=0.012)> start
> set RKorr.X 150
> move_cartesian X=0,Y=0,Z=500 X=200,Y=0,Z=500 steps=100 rate=0.012
> graph show my_log.csv
> log start
> stop- CSV logs saved to
logs/folder. - Each log includes British timestamp, sent/received variables.
- Static plots exportable as PNG/PDF.
- Live plots include alert messages and deviation tracking.
- Connect robot and PC via Ethernet.
- Deploy KUKA RSI program with matching config.
- Install Python dependencies:
pip install -r requirements.txt- Run
main.pyor importRSIAPIin your Python scripts.
If you use RSIPI in your research, please cite:
@software{rsipi2025,
author = {RSIPI Development Team},
title = {RSIPI: Robot Sensor Interface - Python Integration},
year = {2025},
url = {https://github.com/your-org/rsipi},
note = {Accessed: [insert date]}
}RSIPI is licensed under the MIT License.
RSIPI is intended for research and experimental purposes only. Always ensure safe operation with appropriate safety measures in place.