What Is MIMEX Helrit_bot?
This is the world of MIMEX Helrit_bot v2.5, an open-source robotic ecosystem designed to make advanced robot teleoperation, virtual simulation, and AI data collection accessible to anyone with a Wi-Fi router and a handful of cheap microcontrollers.
Whether you are a hobbyist building your first arm, a student studying control systems, a researcher collecting behavioral cloning datasets, or simply curious about the mechanics of modern automation, MIMEX offers a rare combination: production-grade architecture at hobbyist cost.
This guide covers every layer — the communication backbone, the hardware physics, the mathematical engines that translate angles to positions, the noise suppression strategies that prevent motor chatter, the recording and AI export pipeline, the built-in scripting language, and the multi-layer safety framework. We also include a full specification table, a competitive comparison, a development roadmap, and a complete glossary of terms.
System Architecture: How Three Subsystems Talk
The MIMEX system is best understood as a three-party conversation. A Leader Arm captures your physical intent. A central Flask Broker Server routes, processes, and rebroadcasts that data. A Follower Arm and a live browser dashboard simultaneously consume the stream — one translating it into physical servo motion, the other rendering it in 3D space.
Unlike traditional industrial robots that hardwire a single controller to a single arm through proprietary protocols, MIMEX uses a Publish/Subscribe (Pub/Sub) architecture inspired by the Robot Operating System (ROS). The design principle is elegant: the Leader publishes its state once, and anything that needs it — a physical follower arm, a digital twin, a data recorder, a second follower — subscribes independently. Add a new device and it simply joins the conversation.
┌──────────────────────────────────────────────────────────────────┐ │ MIMEX HELRIT_BOT v2.5 SYSTEM │ ├─────────────────┬───────────────────────────┬────────────────────┤ │ LEADER ARM │ COMMUNICATION LAYER │ FOLLOWER ARM │ │ ESP32 │ │ ESP8266/NodeMCU │ │ │ ┌─────────────────────┐ │ │ │ Sensors: │ │ Binary WebSocket │ │ Actuators: │ │ · Pot ×4 ─────│──│ 10-byte frames │──│── Servo Motor ×5 │ │ · Encoder ×1 │ │ ~20 Hz update rate │ │ │ │ │ └──────────┬──────────┘ │ Feedback: │ │ │ │ │ · Rotary Encoder │ │ │ ┌──────────▼──────────┐ │ │ │ │ │ Flask Server │ │ │ │ │ │ + VLA Engine │ │ │ │ │ │ (PyTorch) │ │ │ │ │ └──────────┬──────────┘ │ │ ├─────────────────┴─────────────▼─────────────┴────────────────────┤ │ BROWSER DASHBOARD │ │ Three.js 3D Twin │ Telemetry │ Sequence Editor │ Data Recorder │ └──────────────────────────────────────────────────────────────────┘
The Four Core Software Subsystems
The Leader Firmware (ESP32) — this tiny chip monitors an array of sensors attached to a passive input arm. It samples every joint 20 times per second and broadcasts the readings as compact binary packets over the local Wi-Fi network. It requires no display, no keyboard — it is purely a sensor-to-network bridge.
The Web Dashboard Portal — the visually rich interface running in your browser. Built on Three.js, it renders a fully responsive, interactive 3D model of the robot arm — the Digital Twin — that updates in real time as sensor data arrives. The dashboard also hosts the sequence recorder, the scripting terminal, telemetry graphs, and all control toggles.
The Follower Firmware (ESP8266 / NodeMCU) — this microchip subscribes to the joint data broadcast, applies noise filtering and PID smoothing, and commands five servo motors to mirror the leader arm's position. It also provides feedback through a rotary encoder on the base joint, giving the software a ground-truth reference to verify physical mirroring accuracy.
The Flask Server and VLA Engine — the Python backbone running on a host computer. It brokers all WebSocket traffic, runs the kinematics computations, handles session recording, processes AI dataset export, and hosts the web dashboard files. The PyTorch-based VLA engine sits ready for future model inference integration.
Three Ways to Control the Robot
You physically move the leader arm. The ESP32 publishes joint angles, the server brokers them, the follower arm subscribes and mirrors in real time, and the digital twin animates simultaneously. The purest form of teleoperation.
No physical leader arm required. Toggle the dashboard into Web Control to drive the robot via on-screen sliders, direct numeric coordinate input, or keyboard hotkeys (W/A/S/D). Full joint-level and Cartesian-level control from a browser tab.
Record motion sequences by clicking Record and physically demonstrating a task. Or write plain-text scripts using commands like MOVEJ, MOVEL, GRIP, and WAIT. The robot executes the sequence autonomously, no human input required.
Why Binary Frames Beat JSON
Most networked applications exchange data as JSON — human-readable text that is easy to debug but expensive for a microcontroller to parse. Every JSON packet wraps numbers in quotation marks, commas, and key names, inflating a handful of angle values into dozens of bytes. For a system firing 20 updates per second, that overhead accumulates fast.
MIMEX strips text out entirely. All five joint angles are packed into a tight 10-byte binary frame — numbers expressed as raw bytes, with no decorative syntax. The result is dramatic: latency falls from a sluggish 200 ms to a near-imperceptible 20 ms. The operator experiences the illusion of direct physical connection.
JSON format (heavy): {"j1":90,"j2":45,"j3":30,"j4":0,"j5":0} → ~40 bytes Binary format (lean): [0x5A 0x2D 0x1E 0x00 0x00 ...] → 10 bytes Latency with JSON: ~200ms Latency with Binary: ~20ms (10× improvement)
Hardware Architecture: Sensing & Actuation
MIMEX uses an intentionally asymmetric hardware strategy. The leader arm is built around affordable analog sensing; the follower arm is built around precise servo actuation with output-side verification. This balance keeps total build cost a fraction of commercial alternatives while maintaining professional-grade responsiveness.
The Leader Arm — ESP32 Sensor Array
The leader arm acts as a passive, human-guided input device. It has no motors and no powered actuation — it is simply a frame that maps your hand's movements to electrical signals. The ESP32 microcontroller reads those signals and broadcasts them over Wi-Fi.
Used on the Base (J1), Elbow (J3), Wrist (J4), and Gripper (J5) joints. A potentiometer behaves like a volume knob — it outputs a smooth, unbroken stream of analog resistance values that map linearly to joint angle. No steps, no quantization artifacts, no minimum increment. As you bend the joint, the voltage shifts proportionally.
Used exclusively on the critical Shoulder joint (J2). Unlike a potentiometer which has physical end-stops, a rotary encoder can rotate infinitely without damage. It works by emitting distinct electrical pulses — one per mechanical step — as the shaft turns. The ESP32 catches each pulse through a hardware interrupt, accumulating a precise count that translates to angle. This gives zero-drift, high-resolution shoulder tracking regardless of rotation speed.
The Follower Arm — ESP8266 / NodeMCU
The follower is the physical output device — the arm that actually moves objects in the real world. It is driven by five servo motors mapped to each of the five degrees of freedom: base rotation, shoulder elevation, elbow flexion, wrist pitch, and gripper open/close.
A distinguishing feature is the orange rotary encoder integrated into the follower's base joint. This sensor provides output-side position tracking. The control software continuously compares commanded position against measured position, verifying that the physical arm is faithfully executing every instruction — not merely accepting commands blindly.
Under load, servo motors draw substantial current — far more than a microcontroller's USB power rail can safely supply. Attempting to power servos from the microcontroller's 5V pin will cause voltage drops that crash the firmware mid-operation. The MIMEX build requires a dedicated external 5V switching power supply with sufficient current rating, with power rails kept completely isolated from the microcontroller logic circuits. Neglecting this causes unpredictable behavior and can permanently damage both the MCU and the servos.
Full Bill of Materials
LEADER ARM (Input) FOLLOWER ARM (Output) ───────────────────────────── ────────────────────────────────── ESP32 microcontroller ESP8266 / NodeMCU microcontroller 4× Rotary potentiometer 5× SG90 / MG996R servo motor 1× Rotary encoder (shoulder) 1× Rotary encoder (base feedback) Passive structural frame Dedicated 5V switching PSU (PLA / PETG / aluminum) Gripper claw mechanism SHARED INFRASTRUCTURE ───────────────────────────────────────── Flask server (Python 3.x host computer) Wi-Fi router (shared local network) Web browser (Three.js dashboard)
Mechanical Design Parameters
The arm follows a 5-DOF articulated configuration: a rotating base, an elevated shoulder, a folding elbow, a rotating wrist, and a two-finger gripper. Link lengths, payload capacity, and maximum reach depend on the specific servo motors and frame materials selected during the build. The software's IK solver is parameterized against the user-configured DH table, making it adaptable to custom arm dimensions.
Kinematics: The Mathematical Brain
Kinematics is the geometry of movement. When you bend your shoulder, elbow, and wrist, your brain instantly calculates exactly where your hand is in three-dimensional space — and can even solve the inverse: if you want to reach a glass on a shelf, your brain computes exactly how much to bend each joint to get your hand there. MIMEX replicates both of these calculations in software, running them 20 times per second.
Kinematics is the math that connects joint angles to real-world 3D positions. Forward kinematics asks: "Given these angles, where is the gripper?" Inverse kinematics asks the reverse: "Given this target position, what angles do I need?"
Denavit-Hartenberg Parameters
The arm's geometry is formally described using the Denavit-Hartenberg (DH) convention — an industry-standard mathematical framework for representing robot arm structures. Each joint is described by four parameters: link length (a), link twist (α), joint offset (d), and joint angle (θ). By specifying these four numbers for each of the five joints, the entire 3D geometry of the arm is precisely encoded. The kinematics engine uses this table as its reference model for all position calculations.
Forward Kinematics: Angles → Position
When the leader arm moves, the server receives a fresh set of five joint angles. The Forward Kinematics engine walks the arm's chain joint by joint, computing a 4×4 transformation matrix at each step. Each matrix encodes both the rotation and translation introduced by that joint. Multiplying all matrices in sequence yields a single matrix that describes the complete 3D pose of the gripper tip relative to the base.
The extracted X, Y, Z coordinates are transmitted to the Three.js renderer, which applies them to the digital twin model — updating the virtual arm's pose frame-by-frame in sync with the physical hardware.
Inverse Kinematics: Position → Angles
Forward kinematics is straightforward: given angles, compute position. Inverse kinematics is the much harder reverse problem: given a desired 3D position, compute the joint angles that will put the gripper there. There is no single formula — it requires solving a system of geometric equations.
The MIMEX IK solver uses a geometric closed-form approach, applying the Law of Cosines and trigonometric identities to analytically compute each joint angle in sequence. This is faster and more predictable than iterative numerical solvers, giving near-instant results that can be applied to servo commands without delay.
Before executing any IK result, the solver checks whether the requested coordinate falls within the arm's physical reach envelope. If the target is outside the workspace — either too far, too close, or in a physically impossible configuration — the solver raises a workspace violation warning on the dashboard and halts execution before any motor command is sent. This prevents mechanical over-extension and frame stress.
Digital Twin Synchronization Pipeline
Sensor Data (ESP32, 20Hz) │ ▼ Binary WebSocket Frame (10 bytes) │ ▼ Flask Server ├── FK computation → [X, Y, Z] + [Roll, Pitch, Yaw] ├── Broadcast to follower ESP8266 └── Broadcast to browser dashboard │ ▼ Three.js Renderer ├── Apply FK result to 3D joint transforms ├── Update mesh positions each animation frame └── Digital Twin synchronized ✓
PID Smoothing & Noise Suppression
Raw potentiometer readings are never perfectly stable. Even when the operator holds the arm completely still, microscopic fluctuations in electrical current cause the output voltage — and therefore the computed joint angle — to bounce around by tiny amounts. This is electrical noise, and it is unavoidable in analog sensor circuits.
If these noisy readings are fed directly to a fast servo motor, the result is constant, rapid micro-movements — the servo oscillates between adjacent positions thousands of times per second. This phenomenon, called chatter, rapidly wears out servo gears, overheats motor windings, shakes the arm frame apart, and looks alarming. The MIMEX firmware addresses this with a two-layer defense.
Layer 1 — Deadband Noise Gate
Before any angle value is acted upon, the firmware applies a deadband check: has the joint angle actually changed, or is this just electrical jitter? If the difference between the new reading and the last commanded position is smaller than ±1.5°, the reading is silently discarded. The motor holds its current position without issuing any new command. This eliminates the constant microscopic servo hunting that would otherwise occur at rest.
Layer 2 — PID Dampening
For changes that clear the deadband — genuine human-initiated movements — a PID (Proportional-Integral-Derivative) controller shapes the motion profile. Rather than commanding the servo to jump instantly to the new angle, the PID controller calculates a smooth trajectory: accelerating at the start of the movement, decelerating as the arm approaches the target, and gently settling rather than snapping. The result is fluid, stable, lifelike arm motion.
The proportional term (Kp=0.8) drives the servo toward its target with force proportional to the remaining error. The integral term (Ki=0.02) accumulates residual error over time and corrects for steady-state offsets — ensuring the arm actually reaches its commanded position rather than stopping just short. The derivative term (Kd=0.15) measures the rate of change and applies braking to prevent overshoot and ringing.
The PID constants shipped with MIMEX are tuned for typical servo motors and the standard arm geometry. If you substitute heavier servos or lengthen the link arms, the arm may feel sluggish (reduce Kp) or oscillate (reduce Kd). The dashboard includes a calibration mode where you can interactively adjust these values while watching the physical arm respond in real time.
Recording, Playback & AI Dataset Export
One of MIMEX's most strategically significant capabilities is its ability to transform ordinary human demonstrations into structured machine learning training data. Every motion you make while in recording mode becomes a potential training example for a future autonomous robot brain.
How to Record a Demonstration
The dashboard injects a session-start flag into the live WebSocket data stream. The Flask server begins high-fidelity state capture at 20 frames per second. A session metadata form prompts for a task label and description.
Move the arm through the intended behavior — picking up a block, sorting objects, drawing a path. Every 50 ms, the server snapshots the complete system state: all five joint angles, computed end-effector XYZ coordinates, joint velocities, and gripper state.
Clicking Stop packages the sequence as an ordered chain of waypoints with full timing information. The session is immediately available for playback — the physical arm re-executes your exact trajectory, while the digital twin animates it simultaneously on screen.
The Sequence Editor lets you scrub through the timeline, delete noisy waypoints, trim the start/end, and adjust timing between steps — just like editing a video clip. Multiple demonstrations of the same task can be merged into a single session.
What Gets Recorded: Dataset Schema
- Timestamp in milliseconds
- Joint angles J1–J5 in degrees
- End-effector X, Y, Z in meters
- End-effector Roll, Pitch, Yaw
- Joint angular velocities °/s
- Gripper state (open / closed / partial)
- Control mode (leader / web / script)
- Task label and description
- Total duration in milliseconds
- Total frame count
- Operator ID / session ID
- Export timestamp (UTC)
- Hardware configuration snapshot
- DH parameter table at capture time
Three Export Formats
CSV ──── Spreadsheet-friendly tabular format. Every frame is a row. Ideal for quick analysis in Excel, Google Sheets, or pandas. Compatible with any ML framework that reads tabular data. JSON ──── Structured hierarchical format. Session metadata wraps the frame array. Best for custom Python pipelines and web APIs. Human-readable and easily debugged. LeRobot (Hugging Face) ────────────────────── Industry-standard format for behavioral cloning and VLA model training. Includes full episode structure, action and observation tensors, and task language annotation. Drop into any HuggingFace-compatible training pipeline.
The Vision-Language-Action (VLA) Pipeline
The LeRobot export is not a cosmetic feature — it is the foundation of MIMEX's long-term AI vision. Hugging Face's LeRobot is an open-source framework used by robotics researchers worldwide to train Vision-Language-Action models: neural networks that perceive camera input, understand natural language instructions, and output joint-level robot actions.
The training pipeline works through behavioral cloning: the model observes thousands of recorded demonstrations across many task types, and learns to reproduce those behaviors when presented with similar visual scenes and language prompts. The more high-quality demonstrations recorded via MIMEX, the richer the training dataset, and the more capable the resulting model.
Full VLA inference (where a trained model actually drives the physical arm in real time) remains in the experimental development phase. The current MIMEX codebase is architecturally prepared for this integration: the Flask server has placeholder hooks for model inference calls, the WebSocket protocol includes a field for AI-generated joint commands, and the safety system treats AI-sourced commands identically to human-sourced ones. The camera pipeline and object detection layer (YOLO integration) are the primary remaining development items.
Once fully realized, the complete loop looks like this: a camera observes the workspace, a language model parses an instruction like "pick up the yellow cube and place it in the red bin," the VLA model predicts the joint trajectory frame by frame, and the follower arm executes it — entirely without human input.
Built-in Scripting Engine: Automation Without Code
For operators who want the robot to execute pre-planned sequences autonomously — without writing Python or configuring ROS — MIMEX includes a plain-text scripting language accessible directly from the dashboard terminal. No development environment, no compiler, no external tools required.
Command Reference
Move to a configuration defined by explicit joint angles. Each joint can be specified independently. The fastest way to reach a known pose.
Move the gripper in a perfectly straight Cartesian line to a target XYZ coordinate. Uses the IK solver internally. Essential for precision approach paths.
Open or close the gripper claw. Accepts OPEN, CLOSE, or a percentage value for partial closure on compliant objects.
Pause execution for a specified number of milliseconds. Used to allow objects to settle after gripping, or to synchronize with external events.
Example: Full Pick-and-Place Script
# ───────────────────────────────────────────────────────── # MIMEX Automation Script: pick block from A, place at B # ───────────────────────────────────────────────────────── # 1. Move to safe home position MOVEJ J1=90 J2=90 J3=90 J4=0 J5=0 WAIT 300 # 2. Open gripper before approach GRIP OPEN WAIT 200 # 3. Move above target block (approach height) MOVEL X=0.18 Y=0.12 Z=0.15 # 4. Descend to pick height MOVEL X=0.18 Y=0.12 Z=0.04 WAIT 200 # 5. Close gripper to grasp block GRIP CLOSE WAIT 400 # 6. Lift clear MOVEL X=0.18 Y=0.12 Z=0.20 # 7. Swing to drop zone MOVEJ J1=0 J2=75 J3=45 J4=0 J5=0 # 8. Lower to place height MOVEL X=-0.15 Y=0.10 Z=0.05 WAIT 200 # 9. Release block GRIP OPEN WAIT 300 # 10. Return home MOVEJ J1=90 J2=90 J3=90 J4=0 J5=0
The scripting engine validates each command before execution, catching syntax errors, out-of-range joint angles, and unreachable Cartesian coordinates. Errors are highlighted in the terminal with descriptive messages. A dry-run mode lets you simulate the full script on the digital twin before committing to physical execution.
Safety Architecture: E-STOP & Fault Handling
Robotic arms operating near humans, experimenting with new scripts, or running during software development can behave unpredictably. A complete safety framework is not optional — it is a first-class design requirement. MIMEX implements safety at multiple independent layers, so that no single failure point can cause uncontrolled motion.
The Three-Layer E-STOP Framework
A prominent red E-STOP banner is always visible in the dashboard, regardless of which tab or panel is active. Clicking it immediately injects a halt bit into the next outbound WebSocket frame. The message reaches the follower arm within the next 20 ms network cycle.
On receiving the halt bit, the ESP8266 firmware immediately calls the servo library's detach() function on all five motor channels simultaneously. This cuts the PWM control signal to every servo instantly, causing the arm to go mechanically limp and cease all motion. No gradual deceleration — immediate power-off behavior.
The inverse kinematics solver independently validates every commanded coordinate against the arm's physical workspace envelope before issuing any servo command. Requests outside the safe boundary are blocked at the computation layer — the motion is never even attempted.
Failure Handling
The safety architecture also addresses network-level and hardware-level failure scenarios:
If the WebSocket connection between the Flask server and the follower drops, the ESP8266 detects the connection loss event and automatically calls detach() on all servos after a configurable timeout (default: 500 ms). The arm goes limp rather than holding its last commanded position indefinitely.
In the absence of incoming frames beyond a defined threshold, the follower firmware treats the situation as a connection loss and executes the same safe detach sequence. Partial frames (truncated binary packets) are discarded and a frame counter increments to trigger the timeout if consecutive losses occur.
The output-side rotary encoder on the follower base provides position feedback. If a commanded joint angle is not reached within a timeout window — indicating a physical obstruction or motor stall — the firmware can flag the condition and halt further motion on that joint channel, preventing motor burn-out from sustained stall current.
Full System Specifications
The MIMEX Advantage: Why This Architecture Wins
To appreciate what MIMEX achieves, it helps to compare it against the traditional approach to robot control — both industrial and hobbyist — across the dimensions that matter most for modern robotics development.
| Feature | Traditional Industrial | Basic Hobbyist | MIMEX Advantage |
|---|---|---|---|
| Connectivity | Rigid proprietary cables. Locked to a single teaching pendant. | USB serial or Bluetooth. Short range, platform-specific. | Fully wireless over standard Wi-Fi. Any device on the network can participate. |
| Scalability | One controller operates exactly one arm. | One controller, one arm. Adding a second requires separate hardware. | One leader publishes. N followers subscribe simultaneously. True one-to-many replication. |
| Data Access | Data trapped behind closed manufacturer software. No export. | Raw sensor data only. No structure, no ML compatibility. | AI-ready LeRobot export in one click. Full episode structure with metadata. |
| Simulation | Proprietary offline simulation software. Expensive licenses. | None. What you see is what the physical arm does. | Live browser-based 3D digital twin. No software installation. Zero latency to simulation. |
| Cost | Thousands of dollars for the teaching pendant alone. | Cheap hardware, but limited capability and no ecosystem. | Full capability stack on ~$15–30 in microcontrollers. Fully open source. |
| Automation | Proprietary G-code variants. Requires specialist training. | None, or requires writing custom firmware from scratch. | Built-in scripting engine with MOVEJ/MOVEL/GRIP/WAIT. No prior coding experience needed. |
Development Roadmap
MIMEX v2.5 is a working platform, not a prototype. But the development roadmap is ambitious, with several high-impact integrations on the horizon that will transform it from an excellent teleoperation tool into a fully autonomous manipulation system.
Binary WebSocket teleoperation · Digital twin (Three.js) · Publish/Subscribe architecture · PID smoothing & noise gate · Forward and inverse kinematics engine · Sequence recorder and waypoint editor · Dashboard scripting terminal (MOVEJ/MOVEL/GRIP/WAIT) · Multi-layer E-STOP safety framework · CSV / JSON / LeRobot export
Camera feed integration · Object detection pipeline (YOLO v8) · End-to-end VLA inference loop — trained model driving the physical arm in real time · Workspace reachability visualization (heatmap of reachable zones)
ROS 2 bridge for compatibility with RViz, Gazebo, and MoveIt 2 · Reinforcement learning training pipeline integration · Servo stall detection and auto-halt · Wi-Fi reconnect logic with graceful hold-last-position fallback
Multi-robot coordination — one leader commanding multiple follower arms simultaneously · Cloud dashboard streaming for remote operation · Mobile app controller · Battery / portable power management mode · ROS 2 Control hardware interface
The pub/sub architecture of MIMEX is philosophically aligned with ROS 2's topic-based communication model. A planned ROS 2 bridge will expose /joints/leader as a native ROS 2 topic, making MIMEX data accessible to the full ROS 2 ecosystem — RViz for visualization, Gazebo for physics simulation, and MoveIt 2 for advanced motion planning.
Glossary of Key Terms
A real-time virtual 3D replica of a physical machine, synchronized frame-by-frame via live sensor data through the WebSocket stream and rendered in Three.js.
The math that computes where the gripper tip is in 3D space given the current set of joint angles. Runs 20× per second to keep the digital twin synchronized.
The reverse of FK: given a desired 3D target coordinate, compute the joint angles needed to reach it. Solved geometrically using the Law of Cosines.
An industry-standard convention for describing robot arm geometry using four parameters per joint. Forms the basis of MIMEX's kinematics model.
A network architecture where a producer broadcasts data to a topic channel and any interested device subscribes to receive it — enabling one-to-many data distribution.
A persistent, low-latency internet connection that transmits raw binary data (numbers as bytes, not text). Reduces MIMEX's frame size from ~40 bytes (JSON) to 10 bytes.
A Proportional-Integral-Derivative feedback algorithm that shapes motor motion profiles — preventing jitter at rest and overshoot during movement for smooth, stable actuation.
A threshold filter that discards sensor changes smaller than ±1.5°, preventing electrical noise from causing constant micro-movements in the servo motors.
An AI training method where a model learns to perform tasks by imitating recorded human demonstrations — the primary use of MIMEX's LeRobot-format dataset export.
A neural network architecture that perceives camera input, understands natural language instructions, and outputs robot joint-level action sequences autonomously.
Hugging Face's open standard for robot learning datasets. Includes episode structure, action/observation tensors, and task annotations — directly supported by MIMEX export.
Emergency Stop. A multi-layer safety system that instantly cuts all servo control signals (via firmware detach()) when activated, causing the arm to go mechanically limp.