Skip to main content

Changelog

v0.11.1​

Latest

Improved1

  • Install & update: Remote support (plem remote) now connects through Depot's WebSocket (wss) address when Depot provides one, so it keeps working when Depot's network falls back to its backup route. If Depot does not provide one, it connects as before.

Fixed1

  • Pendant: Simulation runs failed to start on installed devices (the server answered with an internal error) in 0.11.0. They start again.

v0.11.0​

Show 289 changes

Breaking changes44

  • Pendant: ▶ Run is now refused for a program that has a link drawn straight from outside a loop to a node inside it, or whose two parallel lanes use the same gripper while running (the server checks this too). Reconnect the nodes shown in the problem list to the loop entry, or move the gripper nodes into one lane.
  • Server API: PUT /api/workflows/{id} now requires expected, the version the edit is based on (0 for a new document); scripts and agents that save without it get 400. Send the version returned by GET as expected. If a save from another device makes the expected version stale, you get 409 with the server's version. Refresh any Pendant tabs that were open during the upgrade.
  • Server API: The reset_error response on /plem now returns success and message, like set_mode, instead of a sentence (text). If the controller rejects the reset, you get success: false with the reason. Update clients to read success and message instead of text.
  • Server API: /health no longer returns robotId (cell robots are in robots of session_meta). /api/system/restart and /api/gripper/initialize require the robot_id query parameter, and restart is refused while any robot in the cell is in motion.
  • Server API: A Job now runs only on the target robot in its Job document (metadata.robot_id) and resumes only in the same cell. Jobs without a target get the first robot in the cell during the update. If a Job is refused because its target robot is outside the cell, start a cell that contains that robot or add the robot to the cell.
  • Server API: Cell objects (/api/cell-objects) are now part of the scene of every robot in the cell, and each robot has one pedestal, keyed by robot_id. Existing pedestals go to the first robot in the cell during the update, and pedestals of robots not in the cell are dropped from the scene. Overlap rejections now include robot.
  • Server API: All HTTP errors and /plem errors now share one shape, {"error": {"code", "message", "params"}}, with a distinct code for each rejection reason. A Job's node_error also carries code and params. Waypoint save, rename and delete refusals and measure_tool_load failures now arrive as these errors too, and a rename result gives old_name. Scripts should branch on error.code instead of the old detail or error strings.
  • Server API: session_meta on /plem now gives the running cell and its robot list (robots) instead of a single robot. Robot-scoped actions (set_mode, move_to_joints, calibration and others) and /api/calibration/camera/* require robot_id, and robot_state arrives per robot with robotId.
  • Calibration: A hand-eye calibration record belongs to the robot it was measured on and can only be used with that robot; it stays valid across cell changes for the same robot. The first startup after the update assigns a robot to old records (when only one robot has that serial or uses that record). Records whose robot cannot be determined are unusable; calibrate again.
  • Robot: Waypoints now remember the robot that taught them, and Jobs that use Waypoints taught by another robot are refused on deploy, start and resume. Old Waypoints go to the first robot of the last startup during the update. On devices whose data folder was moved with PLEM_DATA_DIR or PLEM_DEVICE_ID they are left unassigned; move to each point and save over it (re-teach) on the target robot.
  • Robot: The protective floor (workspace_min_z) now watches the lowest point of the robot and tool collision shapes instead of two points (tool tip and elbow). It is on whenever a value is set, and 0 or negative values are heights too. workspace_elbow_link is rejected; remove it. If the robot stops below the floor, raise it with Freedrive, then reset.
  • ROS 2: RtEvent 0x47 now means a protective floor violation (joint_id = floor segment number, value = lowest vertex height in the detecting cycle minus the margin, in m). 0x48 is no longer sent. The driver log names the link involved.
  • Developer SDK: EtherCATBus::get_status() and ControlStatus are merged into motion_possible(), the two SDO list types into SlaveSdos, and has_injected_config(), ControllerConfig::watchdog, describe_* and set_brake_engage_sequence() are removed.
  • Developer SDK: The tool link contract (four channels plus ToolTxCommand, ToolRxResponse, ToolAutoQuery) moved to <plem/driver_interface/tool_link.hpp> (plem::robot), SerialToolBridge moved to plem_gripper_nodes, and SharedMemoryRegistry is removed.
  • Developer SDK: plem_ipc now ships in plem-core instead of plem-drive (systems with only the drive layer installed no longer have it).
  • Servo drive: Leaving a with Bus(...) block normally now also stops the axes and engages the brakes (previously only when it exited with an exception). To keep the axes released after the block, create Bus(...) without with and finish with close().
  • Servo drive: Drive model file keys were renamed: control_word→controlword, mode_display→mode_display_timing, serial→serial_number, pdo_mapping: standard→generated, sync_mode: sm→drive_default. Old names are rejected; fixing them keeps the existing approval.
  • ROS 2: Drive message names changed: actual_position, command_torque, statusword and others in RtRawBatch, RAMP_STOP_TIMEOUT and others in RtEvent, and DriveStatus.brake_operation_pending. RtEvent.extra is removed. Update subscriber code, and analyze bags recorded with earlier versions using those versions.
  • ROS 2: The drive packages are now plem_drive, plem_drive_msgs and plem_rt_msgs (plem_drive_nodes is merged in). Import RtEvent, RtRawBatch and SetControlCommand from plem_rt_msgs. The plugin is plem_drive/DriveSystemInterface and C++ headers are under <plem/drive/…>.
  • ROS 2: The drive bus control service moved to /<bus>/plem_drive/control_command (previously /<bus>/plem/control_command). The robot's /<robot_id>/plem/control_command is unchanged.
  • Servo drive: plem drive check now prints a human-readable summary (bus, axes, approval status, warnings, next steps). Scripts that read the JSON (plem-drive-check/1) should switch to plem drive check --json <file>. Exit codes are unchanged.
  • Developer SDK: Python plem.drive Bus.status.statusword (previously status_word) and several C++ names changed: JointTarget, JointActual, plem/fieldbus/cia402_types.hpp, ramp_stop(), Approval, ModeDisplayTiming. The full mapping is in the migration guide in the public repository.
  • Developer SDK: The C++ bus initialize() (ICiA402Bus, EtherCATBus), IO device register_PDOs() and configure_after_domain(), and the validate_* functions in the installed headers now return plem::core::Result<void>. If you implemented a bus or device yourself, update your overrides; check success with is_ok() and read the reason with message().
  • Developer SDK: The IO device brake-state hook DeviceBase::set_brakes_released() is removed. If you overrode it, delete the override. If you need the brake state, read the controller's brake_engaged().
  • Developer SDK: Monitoring is_initialized() (the global function and the MonitoringContext method) is removed. To check initialization, test whether queue<T>() of a stream with a nonzero queue size is non-null.
  • Developer SDK: Discarding a plem::core::Result now triggers a compiler warning. value() on an error result throws std::logic_error (previously it read a default value), and error() with an empty message still reports failure, with "(no reason given)".
  • Developer SDK: C++ names changed: SharedJointData (previously SharedRobotData, header shared_joint_data.hpp), Logger::instance() (previously EcatLogger::Instance()), and tool channel names plem::core::kTool* (previously plem::ipc::paths). Types used only by the robot stack were removed from the public core.
  • Developer SDK: Shared memory connect() now rejects an already connected channel and a negative retry interval, with a reason (previously an OWNER reconnect recreated the segment zeroed, and a negative interval retried without waiting). A negative retry count also gets a reason. shared_memory.hpp no longer includes <fcntl.h>, <sys/mman.h> or <unistd.h>.
  • Developer SDK: PLEM package headers are now installed per package under include/<package>/ (the layout ROS 2 recommends). #include lines and CMake target linking are unchanged; builds that used -I/opt/plem/include directly must switch to -I/opt/plem/include/<package>.
  • Developer SDK: Building plem_fieldbus from source now requires the IgH EtherCAT master. The serial-only build (-DPLEM_ENABLE_ETHERCAT=OFF) and the PLEM_HAS_ETHERCAT define are removed, and plem_drive/specs/drive_model_spec.hpp moved to models/.
  • Developer SDK: Bench loading is now load_drive_model_file(path, ApprovalRecord::IGNORE) (previously a bool argument). The RtEvent constants that are no longer sent (REFERENCE_CHAIN_STATS, BRAKE_RELEASE_HANDSHAKE_FAILED, BRAKE_ENGAGE_HANDSHAKE_FAILED) and pointer_free_field.hpp are removed.
  • Developer SDK: EtherCATController::start() now refuses to start when the bus cycle (set_cycle_time_ns, 1 ms if unset) differs from the loop cycle (cycle_time_us). enter_quiesce_mode() is now close_brake_release_admission(). The list of removed APIs is in the migration guide.
  • Developer SDK: Shared memory connect() no longer has a default mode. Pass ConnectMode::OWNER in the one process that creates the segment and CLIENT everywhere else (a connect() without arguments used to delete the owner's segment).
  • Developer SDK: MonitoringContext::initialize() and plem::core::monitoring::initialize() now return plem::core::Result<void> (calling again with a different configuration fails with the reason). PLEM_EMIT is an expression without a value; use emit() when you need the result.
  • Developer SDK: Header locations changed: <plem/core/monitoring.hpp> (plem::core::monitoring, previously <plem/monitoring.hpp>), SeqlockData and seqlock:: are in plem::core::threading (threading/seqlock.hpp), and rt_memory.hpp is under threading/. The mapping is in the migration guide.
  • Developer SDK: plem/core/monitoring/queues.hpp is renamed monitoring/rt_queue.hpp, the internal Protective Stop decision (internal_pstop_decision.hpp) is merged into types/control_mode_flags.hpp, and MotionLimit::dump() is removed. Rebuild code that uses PeriodicTimerRT.
  • Developer SDK: RtSample::controlword (always 0), cycle_period_us and monitor_stats_decimation in the monitoring Config, MonitoringContext(MetricQueues&) and detail::g_metric_queues are removed, and RtEventEmitter is no longer in the public headers.
  • Developer SDK: TriState::TRUE and FALSE are now YES and NO (they clashed with glib macros). The plem_fieldbus test kit now lives in the single namespace plem::fieldbus::test, and MockBus and the test-only constructors DeviceServo(const ServoInfo&) and DeviceBase() are removed.
  • Developer SDK: EtherCATController now rejects NaN or inverted limits, velocity and torque limits ≤ 0, and negative or non-finite stop deceleration, and refuses start() when a csp or csv axis with declared limits has no stop deceleration (> 0). ServoInfo rejects torque ranges that exclude 0, SerialToolBridge::start() rejects poll_period ≤ 0, and EtherCATBus can no longer be copied or moved.
  • Developer SDK: A shared memory OWNER now fails to connect, instead of sharing it, when a segment with the same name exists that it cannot delete (owned by another user). The unused DeviceServo::position_actual_value_word() and WatchdogResult::should_protective_stop are removed.
  • Developer SDK: EtherCATController now rejects start() for csp or csv axes without declared limits (call set_drive_limits() and set_drive_stop() first), infinite velocity limits, and set_brake_setup() masks outside the partition rules, and rejects calling EtherCATBus::initialize() again after it succeeded. ServoInfo::slave_position goes up to 65535.
  • Developer SDK: IO device DeviceBase::read() and write() are noexcept, so overrides must declare it too. build_pdo_mappings() returns plem::core::Result, enumerators (RampStop*, Approval, ApprovalRecord, Partition) are uppercase like IDLE, and RtQueue rejects a capacity of 0 or above 2^24.
  • ROS 2: teleop_controller is replaced, with no alias, by joint_target_stream_controller (type plem_controllers/JointTargetStreamController), which follows the points on ~/target (position, velocity, stamp). If the stream stops it holds the last target, an empty message stops it until reactivation, and state is published on ~/controller_state (100 Hz). Update the config section, type and topics.
  • Robot: The robot mounting position is now stored in the cell (~/.plem/cell-state/default/) instead of the robot profile, and a robot must be in that cell to start. The first startup after the update moves the last started robots and the mounting positions from their profiles into the cell and removes them from the profiles. If you then roll back to an older version, the mounting position resets to the origin.

Security4

  • Server API: Cell IO Modbus TCP has no authentication, so anyone who can reach the port of a connection where the PLC connects to plem can write input signals. Restrict the listen address to the cell's dedicated network interface and keep only cell equipment on that network.
  • plem code: The robot stack, rosbridge and configuration-query processes that plem code starts no longer inherit the device key through environment variables.
  • Install & update: Installation and device registration, version reporting in plem update, remote support, telemetry upload and plem code key renewal no longer send Depot tokens (user and device tokens) unless the Depot address is https (only http://127.0.0.1 for local development is exempt). Version reporting is skipped, telemetry keeps its records and postpones the upload, and the others stop and explain why.
  • Install & update: The cuMotion install now verifies the SHA-256 of the PyTorch wheel and does not install a downloaded file that does not match.

New41

  • Servo drive: The setup wizard now asks once whether to share device data with WIM: hardware, software versions, device health and EtherCAT session statistics. Nothing is sent unless you answer Yes, and sudo plem-fleet off turns it off at any time. What is sent and kept is listed in docs/telemetry.md of the public repository.
  • Pendant: The screen is available in English and Korean. The left-rail language button switches it in place and the tablet keeps the choice; a first visit follows the browser's language, otherwise English. Server refusals and reasons (refused deploys, starts or resumes, calibration progress, failures and records, unreachable Cartesian targets), stop, zeroing and input error notifications, and node library names and descriptions use the chosen language. Server or robot detail text stays as sent.
  • Server API: A refused deploy (WORKFLOW_VALIDATION_FAILED) and a refused start or resume (JOB_REVALIDATION_FAILED) list each problem in params.issues, with a check code and its parameters. Wait for Signal and Write Signal nodes refused for a cell IO reason get a check code per reason (io_wait_*, io_write_*). Clients can localize refusals by these codes.
  • Pendant: "N problems" at the top right of the program canvas lists the nodes to fix before running. Clicking a row opens that node's value panel at the field with the problem, and when ▶ is refused the list opens on its own and shows, per node, why the server refused.
  • Pendant: A command bar above the program canvas always shows Undo, Redo, the selection count, Group into loop, Duplicate, ⋯ and Delete, and folds into ⋯ when narrow. Nodes and links are deleted without confirmation and come back with one Undo (after 6 s the offer folds into the header until the next edit). The list ⋯ menu now has Duplicate.
  • Pendant: The save state (Saved, Waiting to save, Saving, Not saved) is always shown next to the program name, and when a lost connection returns the program is saved again without user action. If another device saved first, the Pendant does not overwrite it and lets you choose: reload, overwrite with yours, or save a copy.
  • Pendant: The Jog tool tab has [Buttons | 3D handle]. Drag the TCP cube to move freely, a tool-axis arrow to move along that axis, or a ring to rotate; the robot follows and distance and angle are shown. On release the robot goes there (up to 0.25 m and 0.6 rad from the TCP) and stops, or stops after 1 s if it cannot get closer, and the cube returns to the TCP. Shift moves at 1/10. The handle scales with the robot; from afar only the cube shows.
  • Pendant: The cell 3D view draws every robot in the cell with a name tag; switch focus with the top switcher or by clicking a robot in 3D. The focused robot is outlined, and Jog, move-to-target, Payload and calibration act on it (locked while pressing or measuring). Other robots' Protective Stops and faults stay as named alerts. Plan view edits any robot's mounting and pedestal. The focused robot stays operable while another runs a Job.
  • Pendant: When the cell has two or more robots, you pick the robot that runs the program next to the program name, and the Job screen shows that robot. Gripper node ranges, via points added to a failed move, and via-point, simulation and collision ghosts use that robot, not the focused one.
  • ROS 2: The jog node now accepts an absolute TCP target pose on /<robot_id>/jog/pose_target_cmd (geometry_msgs/PoseStamped). Use it for input in the robot's own coordinates, such as a simulator; send input that moves the target by as much as the input device moved to jog/pose_cmd. Both topics resolve frame_id through TF.
  • ROS 2: The new service /<robot_id>/plem/request_lane (plem_msgs/srv/RequestLane) switches between the jog lane and the trajectory lane within TRAJECTORY. It stops the current lane and confirms the arm is stationary before switching. set_mode while the jog lane is active is no longer refused and is handed over in the same order.
  • TUI: Choosing a cell (workspace) at the top of Start session starts all robots in that cell, and PREFLIGHT shows the cell name. This screen also creates, renames and deletes cells, adds and removes robots, and edits robot position and protective floor. Robots outside the cell are listed under ROBOTS; press enter to add one. The space selection of individual robots is removed; to start one robot, create a cell with only that robot.
  • Gripper: Supports the DH-Robotics AG-95 (RS-485 on the Neuromeka robot flange). Select it in robot editing, enter the device ID (Modbus address 1–247) in the gripper settings and restart the stack; it then applies to 3D, MoveIt planning collision checks, collision avoidance (cuMotion) and Payload. Collision avoidance is not yet available together with a ZED X Mini. The new deb is plem-gripper-dh.
  • Gripper: Robot editing shows the gripper's communication path and offers "Shape and weight only (communication off)". "Restart pending" appears when the saved gripper differs from the running one. Turning on flange RS-485 communication on a non-Neuromeka robot is refused at save and startup with the reason; with communication off it saves. The AG-95 status query interval (default 1000 ms) is set under Advanced.
  • Gripper: The gripper node has a third outcome, "Object dropped". If the gripper reports a drop while the node runs, execution takes that branch; if it is not connected, the path ends there (as in older programs). A drop at any other time does not stop the Job, and a top banner shows the node and how many seconds after the grasp it happened.
  • Pendant: Cell IO device signals now include "Gripper dropped" (device.<robot id>.gripper.dropped). It turns on only for grippers that report drops and turns off on the next gripper command, so processes that must stop should check this signal with a condition node.
  • Gripper: Grippers that need initialization (AG-95) are initialized with the [Initialize] button on the gripper status card and a confirmation dialog. Restarting the driver does not move the fingers. It is blocked while a Job is running or paused, and starting or resuming a Job during initialization is refused at once with "Gripper is initializing". If it does not finish within 10 s, the reason is shown (POST /api/gripper/initialize).
  • Pendant: Robot › Settings has a new gripper status card. It shows moving, at target (empty), object grasped or object dropped, and the current width with the maximum, as in "42.5 mm / 95 mm"; if the gripper does not respond it shows "Disconnected" instead of the last width. The gripper list in robot editing now shows product names (OnRobot RG6) instead of model IDs.
  • ROS 2: plem_msgs/GripperStatus adds needs_initialization (not yet initialized, so position commands are ignored) and object_dropped (a grasped object was dropped; cleared on the next gripper command). Both are always false for the RG6. Rebuild nodes that use this message.
  • Pendant: Modbus TCP connections (plem connects to the PLC, or the PLC connects to plem) and signals created under the cell tab [Cell IO] apply without a restart, with live connection status and current signal values. Each robot's gripper grasp, connection and width also appear as read-only device signals (device.<robot id>.gripper.*; user signals cannot start with device.). The same settings are available through /api/cell-io.
  • Pendant: The "Wait for signal" node waits up to a maximum number of seconds for a condition on an input or device signal and branches on met or timed out, and the "Write signal" node writes a value to an output signal. If the timeout branch is not connected or a write fails, the program ends with an error and the reason; simulation neither waits nor writes.
  • Pendant: In the Cell IO signal table you can switch output signals on and off or write values directly (forced output). This needs confirmation, is blocked while a Job is running or paused, and every write and refusal is recorded in the audit log (~/.plem/audit/cell-io.jsonl). Output values written by plem stay as they are when a Job is stopped or ends.
  • Pendant: Simulation, next to ▶ on the bottom bar, shows plan results and branches on the Job screen without moving the robot or gripper, and replays the path as a 3D ghost. The first move starts at the current pose; refused moves are skipped and counted on the bottom bar, and a silent planner ends it with an error. Grippers reach target width, conditions use current values, loops run once, waits are skipped. Success does not guarantee the run.
  • Servo drive: plem drive check now warns, with the representable range, when an axis's limits.position exceeds what the drive's 32-bit position can represent given zero_offset_count and flip. It also warns about files that still have the example vendor_id (0x00c0ffee), and before approval its next step tells you to change the example values instead of running plem drive run.
  • Servo drive: plem drive run with an approved file now checks the bus drives against the approval record before starting. If a drive was swapped for another unit of the same model, it offers a bench run in the terminal and, if it passes, updates the approval and starts. A different model, missing drive or reordered wiring is refused. --unapproved runs even an approved file in bench mode without recording, shown as bench mode on the start line.
  • Servo drive: If the drive model file maps the error code (0x603F) to a PDO, plem drive run --monitor shows that code for an axis stopped by an alarm (axis0 fault (statusword 0x0238, error 0xff50)), and Bus.reset() logs the axis and code as a warning before clearing the alarm. This tells the communication alarm left when the bus stops (0xFF50 on the A6B) apart from a real drive alarm.
  • Install & update: Install and update now set the system log to be kept on disk, so logs from the previous boot (journalctl -b -1) are available after the device hangs or reboots. Logs use up to 2% of the root file system (at most 2 GiB). After a kernel panic the device reboots itself after 10 s instead of staying hung.
  • Pendant: Cell objects (plane, box, sphere, cylinder, cone, mesh) are added by numbers, 3D placement, points picked with the robot, or MoveIt .scene import/export, then moved, rotated and resized with 3D handles, duplicated, undone or deleted. Dragging snaps to the floor or a face within 20 mm, in 10 mm and 15° steps; overlaps turn red. Meshes (STL, OBJ, GLB, DAE, up to 64 MB and 1M triangles) use a slightly larger collision shape.
  • Pendant: "Select multiple" for cell objects aligns several objects on the X, Y or Z axis by min face, center or max face to the first selected object, or spaces three or more evenly between the two outer ones. It is saved in one step and undone with one Undo, and nothing moves if any object would overlap the robot.
  • Pendant: Cell objects selected for collision checking take effect without a restart: planning rejects paths that hit them, and Jog stops as the robot approaches them. Objects cannot be placed where they overlap the robot's current pose (they turn red and the touching link is reported). Objects saved while the planner is off are saved unchecked, and the screen says so. The floor starts disabled; check the mounting height before enabling it.
  • License: plem-server now includes /usr/share/doc/plem-server/BUNDLED-NATIVE-NOTICES, the notices for third-party native code in coacd, which is used for meshes. coacd ships as a wheel built from a modified CoACD (MIT), with the Sobol generator replaced by our own implementation.
  • Pendant: The cell 3D view has top, front and side view buttons and a fit-all button, and while a Job runs the current node name appears over the 3D view. When only the program tab is shown, click the robot preview at the bottom right to go to the cell. The 3D view is not redrawn while the robot pose and F/T values barely change and the camera is still, and hidden 3D views and previews are not drawn.
  • Pendant: When a move fails to plan because of a path collision, the message names the object hit (or link, for self-collision) and where, as in "Path hits 'Supply box' at 42%, wrist (link 5)". The node gets [View in 3D] (object, contact point, pose at that moment) and [Add via point] (inserts a via-point move at that pose before it, opened in the target tool). Simulation failures work the same. Other failures keep the old message.
  • Pendant: Joint targets and cell Waypoints are previewed in 3D as a translucent ghost. Picking a point in the cell Waypoints section shows its pose and makes it the named Jog "Target", sent with Jog's "Move while pressed". Edited joint values become the target; clearing the selection targets the current pose. This move uses the Jog speed, not the server default. A chip at the top left of the 3D view tells what the ghost is and whether it moves.
  • Pendant: In the cell's "Robot mounting", base X, Y, height and orientation and the protective floor height are previewed as a 3D ghost and saved to the cell for the next startup (no tilt yet). The robot stops when the lowest point of its collision shape goes below the floor, so leave a margin; a floor above the mounting height is rejected. Pedestals (box, mesh) attach under the base, follow the mounting, and are dragged and rotated with handles.
  • Pendant: "Restart robot stack", next to the "Restart required" notice, engages the brakes on every robot in the session, stops them and starts them again, like pressing S twice in the plem screen. It is refused while a Job, Jog or calibration motion is running (Freedrive cannot be blocked; stopping engages the brakes first), and it is disabled for stacks not started from the plem screen.
  • Pendant: The Jog "Joint target" tab is now "Target" and adds a Cartesian (TCP) target. Drag the 3D handle (move or rotate; move arrows follow the tool axes) or type X, Y, Z, Rx, Ry, Rz, and a ghost follows the joint pose solved by the server, showing reachable, unreachable, near singularity or moving with color, icon and text. When unreachable, the reason is shown and the move is locked.
  • Server API: GET /api/jobs and GET /api/jobs/{id} again include started_at (start of the last run, epoch ms, null if never run). It is updated on start and on resume from a checkpoint after a Protective Stop or restart; resuming after a pause does not change it.
  • Server API: The solve_tcp_target action returns the joint solution for a TCP pose and its status (reachable, unreachable with a reason, or near singularity, which is a heuristic). The robot does not move.
  • Lab: When Run & capture is saved, the Simulation tab shows a "Run saved" notice. If an earlier run with the same stimulus exists, "Compare with previous" compares the two runs right away; otherwise "Open in Runs" opens the new run.
  • Install & update: The RT setup wizard (setup/rt/setup.sh) has a new menu 5. It builds the USB-CAN (gs_usb compatible) and USB-serial (CH340/CH341, PL2303) adapter drivers that the kernel leaves disabled, on the device from the original source of the running kernel version (RT or standard), and installs them to load automatically by the adapter's USB ID. Menu 2 checks whether the drivers are present.

Improved89

  • Pendant: Names that the Pendant and server make for you are in English on both screen languages: new nodes ("Start", "Move Gripper"), copies ("<name> copy"), via-point moves ("<node> via"), a new cell's floor ("Floor"), gripper device signals in Cell IO ("arm1 gripper holding") and the AG-95 settings fields ("Device ID"). Names you already have are not changed.
  • Pendant: Dragging, double-tapping and moving a line end follow the same connection rules. Dropping on a card body connects, an invalid target shows why above your finger, and dropping an empty slot's line on blank canvas opens the add dialog. Retargeting or moving a line's start undoes in one step, and moving nodes into or out of a loop or parallel previews lines that will break. Inner nodes end a loop only via its bottom "Exit loop" slot.
  • Pendant: Tapping a node once opens its value panel, with fields grouped as Basic, Advanced (collapsed) and Value binding (collapsed). Number fields commit with −/+, Enter or tapping elsewhere, and only input that cannot be committed remains when you reopen the same node. Invalid values show one line below the field, long field descriptions fold under "More", and every skill node uses the same layout.
  • Pendant: Gripper node outcomes are shortened to "Gripped · Position reached · Missed", and the "Manual trigger" node is called "Start" in the node panel and for new nodes. Saved connections and execution are unchanged.
  • Pendant: The "Program" screen has a new layout. The left bar is a single level (List, Nodes, Structure, Variables, Robot, Calibration), and tapping an entry opens its panel over the canvas. Drag the divider line itself to resize; node details open on the right of the canvas and shrink the cell pane. "Stop" stays usable while a confirmation dialog is open.
  • Pendant: Canvas cards have a new design. Each shows a node-type icon tile (category color) and up to two key-value chips with icons, and states such as running, done and error appear as both border and badge. Cards on a disconnected work screen are grayed out, and condition-node exits and comparisons read "Yes · No". Cards are larger, so if nodes you placed tightly in an earlier version overlap, drag them apart.
  • Pendant: Loop boxes on the program canvas are redrawn. Edit the count (− 3 +) and type (Count · Forever · Condition) directly at the left of the header, and connect lines to the "↻ Back to loop start" and "⇥ Exit loop" slots at the bottom. The loop-condition picker shows only variables, and expressions outside the list are left unchanged.
  • Pendant: Canvas lines are drawn as rounded right angles; tap a line and use the 🗑 above it to delete it (undoable). Loop count, condition expression, lane name and case name fields save once on Enter or when you leave the field, and undo in one step. Canvas editing works only at zoom 1 or higher.
  • Pendant: Nodes are added from one popup with search at the top; items that cannot go there are hidden. A node from an empty exit's + lands at the exit's height with its value panel open; a line's + inserts into that line. The node panel places a tapped node at screen center, unconnected; Loop, Condition and Parallel are under "Logic". The popup opens where the list fits, and "Arrange" (bottom-left view buttons) lines nodes up left to right.
  • Pendant: The screen of a running Job follows the running node. It moves only when the node changes and does not follow loop or parallel frames, and the screen-lock pin is gone. The Job strip above the canvas shows the result, where it stopped and the elapsed time in one line; tap it to go to that node or to the error list.
  • Pendant: Loop headers show progress ("2/5 ●●○○○" or "2nd"), and inner node indicators reset to waiting on each new iteration. Edit in the Job strip opens the source program with the node you tapped in the Job selected. The word "Deploy" is gone from the screen: buttons read "Run" and "Stop run", and the state reads "Not run".
  • Pendant: While waiting for Protective Stop recovery, the ⓘ next to the difference from the resume pose in the bottom bar is always visible regardless of screen width. Tap ⓘ to expand truncated text and the move result. The Pendant is landscape only (minimum width 1024).
  • Pendant: "Manual control" and "Release session" in the Jog panel are merged into one button. When on, it reads "Turn off manual control", and pressing it when the release was not confirmed retries the release. The robot name is removed from the Jog panel; the robot selector in the header shows the target robot.
  • Sensor: ZED camera setup (zed-setup) uses ZED SDK 5.5, ZED ROS 2 node v5.5.0 and GMSL2 driver 1.4.4. Camera IMU topic latency is much lower. Re-running leaves an installed driver in place if its kernel type (generic/RT) matches; get a new version with "Reinstall" (--force-reinstall). Setup stops before installing if you set the wrapper build location to the PLEM workspace.
  • Robot: Jog now runs on the new Jog engine for every robot regardless of vendor (including Huayan Elfin). You can Jog without MoveIt, but then cell objects are not avoided. Rotational Jog rotates about the TCP, and tool-axis Jog moves straight along that axis.
  • Robot: To Jog in configurations without gripper state reporting (for example Elfin + RG6), set gripper_state_source: full_range in the robot profile. Without it, only Jog is disabled and the robot starts normally.
  • Robot: Jog now slows down in front of the cell's protective floor as it does for other objects.
  • Pendant: Releasing a Jog button or the 3D handle keeps manual control active, so pressing again moves immediately. A single Jog status line shows why motion stopped or slowed (near collision, singularity, joint limit, stop reason) and what to do next, and the first press after an abnormal stop (grab, for the handle) moves after "Restarting". The servo reset button is removed.
  • ROS 2: joint_target_stream_controller loads inactive on every built-in robot model. Without measured values it uses max_acceleration from joint_limits.yaml (jerk = acceleration ÷ 0.05 s) and warns once; if the value is missing or invalid, startup is refused. Your controller_config_file must contain this section (including limits).
  • Pendant: The Stop button stops every robot in the cell. Other robots stop immediately even if one robot does not respond, and robots whose brakes could not be confirmed are reported per robot.
  • Install & update: Programs, Jobs, Waypoints and variables now belong to the cell. On first startup after the update, data in ~/.plem/<first robot>/ is moved to ~/.plem/cell-state/default/. PLEM_DEVICE_ID no longer changes the data location.
  • Gripper: Gripper nodes in programs are merged into a single "Gripper control" node. Programs made with the old OnRobot RG6 gripper node are converted to Gripper control nodes when opened or run, keeping width, force and outcome connections, and are saved in the new format on the next save.
  • Pendant: Width and force slider ranges of the gripper node follow the mounted gripper's specification (RG6: 160 mm, 25–120 N), and force is shown as the actual grip force (0 means maximum force). Deploying is refused, naming the node, if width or force is out of range or the robot has no gripper. Simulation works without a gripper.
  • Pendant: In "Move while pressed", releasing the button no longer stops abruptly; the robot decelerates smoothly along its path and stops. The button is locked as "Stopping" until it stops. If a smooth stop is not possible, it stops immediately as before, and if the soft stop state cannot be confirmed, the brakes are engaged.
  • Pendant: Waypoints are saved, renamed, updated to the current position, deleted and searched in one place, the cell's Waypoint section. The sidebar Waypoint list is removed; instead of a row's "Move to this position", select the point and use Jog's "Move while pressed". Waypoint JSON export is removed. Sidebar Robot › Settings now shows directly, without the tab row and "Robots (n)" header.
  • Pendant: "Save current position" saves immediately with a short name such as P1, P2 … without asking, and opens that row for renaming (Enter for a new name, Esc to keep it). Auto names from "Save position" in the bottom bar also use P numbers instead of wp_date_time. Existing names are not changed.
  • Pendant: Results of "Move while pressed" read "Reached", "Canceled — server message", "Not moved — reason" or "Failed — reason". If the robot arrived even though you released, it reads "Reached — server message". If another motion holds the robot, it shows "Another motion is using the robot" and the holder, and if the robot becomes BRAKED while decelerating after release, it shows "Stopped".
  • Pendant: "Design" and "Run" under Jobs are now a single "Programs" list. Running Jobs are at the top, finished Jobs under their program (latest 3, collapsible with the arrow), and Jobs without a source program at the bottom; programs are ordered by most recent run (re-running an old Job also moves its program up). Date grouping and the program filter ("Show N deployed Jobs") in the Job list are removed.
  • Pendant: On a Job screen that is not running, you can simulate that Job's content ("Simulate again" after a finished simulation), and the pencil in the strip above the canvas opens the source program. Pressing ▶ no longer opens the left panel or switches to the run list.
  • Pendant: The Job screen strip now shows a lock and "Read-only", and screen lock and follow use a pin icon. The run list header reads "Running n", Jobs whose source was deleted show "No source", and the slot name in the done badge and the extra text in the panel are removed. The reason a button is locked is shown as text in the bottom bar.
  • Pendant: Until you lock it, the Jog target follows the robot's current pose (the current TCP in Cartesian), and the "Read current pose" button is removed. Changing a value or picking a Waypoint locks it. Pressing "To current pose" or a move ending as reached or failed makes it follow again; a move ending in cancel (such as releasing) keeps the target, so pressing again continues to it.
  • Pendant: Joint target input ranges follow the joint limits of the robot model (URDF) instead of −180° to 180° for every joint. Out-of-limit values are rejected with the range shown.
  • Pendant: The [Program | Cell] tabs at the top switch between program editing and the 3D view, and the split button shows both side by side. Pushing the divider to the end collapses that pane; double-tapping it splits evenly. The last view is kept when you reopen the Pendant, and the header's 3D expand button is removed. On the Cell tab the left panel briefly collapses to widen 3D and reopens on return to Program (unless opened on Cell).
  • Robot: If the robot does not start because an EtherCAT device has not mapped a required PDO entry, the log now names the device and the missing entry and gives the command to check the device firmware version. Previously it only listed possible causes.
  • Robot: The link displacement tolerance for indy7_v3 measured kinematics is widened from 12 mm to 13 mm. Accordingly, the link collision margin in path planning grows by 1 mm per link.
  • Robot: The Indy7 tool flange LED shows robot state by color: white when idle (brakes engaged), green while running a trajectory, blue in hand guiding, red in Protective Stop. Previously it turned off when brakes were released and blinked red when they engaged. If PLEM is not running or communication is lost, it shows the board default, a blinking dim red.
  • Servo drive: Host warnings in plem drive run (not an RT kernel, no isolated CPU, nvpps TSC lock) now include how to fix them (menu 1 of the setup wizard setup/rt/setup.sh in the PLEM public repository, sudo plem-nvpps-tsc-unlock).
  • Servo drive: Guidance text in the drive bench, plem drive run and the RT setup wizard is refined. When the bench aborts it shows the pass condition as expected:, the wizard refers to steps as "menu N" as on screen, and RT permission and EtherCAT activation failure messages include how to fix them.
  • Servo drive: If mode_display_timing is omitted from a drive model file, it is read as pre_enable. Approvals of existing files stay valid. For drives that display the mode only after enabling, release is refused and the message tells you to use post_enable for that axis.
  • Lab: rt_raw signal labels follow the renamed fields (actual_position, command_torque, etc.). Saved dashboards, runs and exports open as before.
  • Servo drive: The bench writes CiA 402 states by full name (SWITCH_ON_DISABLED, READY_TO_SWITCH_ON, OPERATION_ENABLED, etc.).
  • Servo drive: When the bench approval step refuses, the message starts with drive_model_tool approve: (the previous plem-drive approve: was not an existing command).
  • Servo drive: plem drive run --plot builds a PlotJuggler layout from the axes of the bus being run (position per axis, velocity and torque of all axes, loop timing, bus state). The sync tab for a two-axis mirror pair is in plotjuggler.xml of the a6b_pair example; load it in PlotJuggler.
  • Servo drive: Guidance and error text writes commands as plem drive run and plem drive check. Without the plem command, the name is plem-drive <verb>.
  • Servo drive: An unknown value in PLEM_LOG_LEVEL (for example verbose) is no longer silently treated as info; it is reported with the allowed names. plem drive run reports it before startup and ignores the value.
  • TUI: If log_level in settings.yaml is not one of the four values selectable in the settings screen (err, warn, info, debug), the TUI logs it once and uses info. Previously other values were read differently by the screen and the ROS log level.
  • Developer SDK: When the output queue is full, PLEM logging drops the oldest unwritten line instead of waiting, and on exit writes the number of dropped lines to standard error. Other spdlog loggers and settings in a process that loads the PLEM library are left untouched.
  • TUI: The robot control screen now has three panes (Robot · Joint move | Log | SYSTEM). The bottom status bar shows running (the selected robot's mode as text), Protective Stop, EtherCAT disconnect and stop progress, and [ and ] show or hide the left column and the SYSTEM pane. The web UI address is under WEB in SYSTEM, joints are J0, J1…, and the move button is Move.
  • TUI: The start screen (Start session) now has three panes (Robot | Session setup | Preflight). Components are named Motion planning, Camera and Collision avoidance, and the robot you last started is preselected (the first robot if it was deleted). Camera quality presets have readable names such as Balanced, with a one-line description like Sees up to 3 m · 5 cm detail.
  • TUI: Focus moved with Tab is clearly shown with a cyan background on every screen, and checkboxes are drawn square.
  • TUI: The settings screen (,) now has three panes (SETTINGS | Robot list | Configuration). e edit and n new robot open a form in the right pane (ctrl+s save, esc cancel), and ● Unsaved changes appears in the status bar until you save. Form fields are named Model, Controller and F/T sensor. Below 100 columns the SETTINGS pane collapses and g switches between Robots and General.
  • TUI: Enter the camera serial in CAMERA › Serial of the robot form; it also appears as Serial in the robot details.
  • TUI: Colors use a new palette (dark slate background, green success, yellow warning, red error) with a single cyan accent; the meaning of safety and mode colors is unchanged. Keys are marked by coloring a letter in the label (release brake, end freedrive, stop, and a red Recover for recovery).
  • TUI: When starting a robot, the TUI cleans up only processes it previously launched and left behind. Processes launched elsewhere, whether ROS nodes or ones holding a port or EtherCAT bus, are not force-killed; the TUI shows their name and PID and points you to plem kill.
  • TUI: The run screen log shows only launch warnings and errors and failure lines (traceback, Failed to reserve master). INFO lines go only to the TUI log file, whose path is shown in one line at startup. Lag where a noisy launch held up screen input is also reduced.
  • TUI: When a process dies during a run, its last lines without a log level (up to 5) are shown before the death line so the cause stays visible.
  • TUI: A warning repeated within 30 seconds is shown once; after 30 seconds the line is shown again with "(xN more in 30s)" giving the repeat count (the count appears even if repeats stop). Repeated robot RT events ([RT]) are counted the same way with a 5-second window.
  • TUI: Log warnings are orange and errors red, and process death, traceback and Failed to reserve master lines are bold red with ✖ so they stand out among routine error lines.
  • TUI: RViz and PlotJuggler output is filtered by the same rules, showing only warnings, errors and abnormal-exit lines. If a process inside RViz dies, its last lines without a level are shown before the death line, and PlotJuggler output without a level goes only to the TUI log file unless it directly follows a warning.
  • TUI: The plem command now speaks English: the update notice and workspace question when you run plem, the messages and errors of plem workspace, plem init and plem kill, and the README that plem init generates.
  • Docs: The F/T sensor guide is rewritten as step-by-step procedures and now includes the Pendant's F/T chip, detail card, zeroing and Payload measurement screens.
  • Docs: The ROS 2 integration, stop, safety and servo drive pages are reorganized into procedures and tables, and brake manual release conditions, per-model trajectory goal tolerances, drive preparation steps and which devices can receive packages (Jetsons registered with a token) now match current behavior. The menu names are "Connect a servo drive" and "Servo drive hardware verification".
  • Docs: The Teaching Pendant guide now correctly states that Job stop halts without deceleration and does not engage the brakes, and the run, moving the robot, program and calibration sections are rewritten as step-by-step procedures and tables. New content covers saving positions, renaming Waypoints and deleting ones in use, loop and parallel boxes, and the robot edit screen.
  • Docs: The license lock page is renamed to match the current screen (PLEM is locked), and new content covers recovery after losing the license file or device key, plem uninstall options, perception profile preview and choosing a plugin .so path. Troubleshooting, TUI and Lab guides are organized into step-by-step procedures and tables.
  • Docs: The public docs site is written in English and has a Korean edition under /ko/; switch with the language menu at the top. Teaching Pendant screenshots show the screen in the language of the page, and the agent index (llms.txt) is in English.
  • License: The drive layer plem-drive (six packages and their install files) and plem-cli for the plem command change to Apache License 2.0. /usr/share/doc/<package>/ contains an Apache-2.0 summary and NOTICE instead of the full agreement text. Other PLEM packages are unchanged.
  • License: The license agreement is updated to version 1.2: public components that the company marks as provided under an open-source license are governed by that license instead of the agreement (Article 1, item 10 and Article 8-2).
  • Lab: Auto run names show gains changed since the previous run of the same controller, as kp[0] 200→400 (up to 2, the rest as +N). If there is no previous run or no gain changed, gains are omitted. Names of already saved runs do not change.
  • Lab: Gain names on screen use the single form kp[0] (tuning panel, convergence report, Runs gain table, gain sweep). Hovering a name shows the ROS parameter name (kp.j0), and export files (CSV, JSON) keep using ROS parameter names.
  • Lab: Number display follows one rule: measurements use 3 significant digits, gains and velocity limits 6, and time, playback position, trajectory length and joint angles two decimal places.
  • Lab: The tuning panel's Apply button is filled only when there are values to send, and dims together with the input fields when tuning is locked.
  • Lab: Ramp is removed from the Experiment Shape list. Ramp is the same stimulus as a Step with Rise set to the move time and Hold set to 0. Previously saved Ramp runs are shown as that Step and compared as the same stimulus as matching Step runs.
  • Lab: The Immediate checkbox is removed from the threshold band form. Setting Dwell to 0 judges on the first matching sample. Saved bands and templates work as before.
  • Lab: The UI style is refined. The accent color is the company brand blue, and plot line colors are chosen per dark and light theme to be easy to tell apart. Section titles and tabs use sentence case instead of uppercase, and monospace is used only for numbers and signal names. The recording indicator and convergence bands are no longer drawn in the warning color (red): recording shows only a red dot, and only violation-watch bands are red.
  • Lab: The Runs Inspect and Compare screens are decluttered. The gain table shows only gains that differ between runs (changed cells highlighted, "Show all gains" for all), and a stimulus mismatch is flagged with a single badge. The "Remove start offset" checkbox is now a "Zero start" toggle.
  • Lab: The Runs metrics table first shows Rise, Overshoot, Settle, Steady state and Chatter for step, Amp, Phase and RMS for sine, and Mean and RMS otherwise; the rest are under "More". Values use 3 significant digits (up to 6 decimal places), and Δ for metrics with a defined direction reads like (-40%).
  • Lab: The Runs result line and Gain sweep follow the first plotted signal. Gain sweep appears only when you select 3 or more runs that differ in exactly one gain (excluding runs with tuning locked).
  • Lab: The "Send to robot" button on the Simulation tab is now a small "Move without recording" button under Run & capture. It still moves without recording.
  • Lab: Font sizes are unified into three steps: data 12px, UI elements 13px, titles 15px (10 and 11px removed). Plot axes and band labels are also 12px. Buttons and tabs show a solid accent-color focus outline only when navigating with the keyboard.
  • Install & update: The RT setup wizard no longer changes the Wi-Fi country code based on a guess from the time zone (a configured value is kept). Run logs with content are kept after exit with their path shown, and the previous DTB is saved to /boot/dtb/.plem-bak-<name> before it is modified.
  • Install & update: EtherCAT master installation in the RT setup wizard (menu 3) makes /dev/EtherCAT* accessible only to the realtime group (0660) instead of all users. It first creates the group and adds the user running it; if you were newly added, log in again. Menu 2 checks device permissions and group membership.
  • Install & update: Verdict messages of the RT setup wizard (setup/rt/setup.sh) state only what was measured (the "fully isolated" claim on passing the isolation test and the asserted cause of EtherCAT state changes during the load test are removed).
  • Servo drive: The bench's list of startup failure causes and the unapproved-model message in plem drive run are reworded (behavior unchanged).
  • Servo drive: Some error and warning messages in the EtherCAT and drive layers (CiA 402 transition table check, stored_sdo mismatch guidance, model file size exceeded, brake not confirmed after stop, major page fault report) are shorter and more accurate. Update scripts that match the exact text to the new messages.
  • Servo drive: A user profile for move_to(profile=) must now hold per-axis position and velocity at each point with increasing time, and is refused before sending if it contains NaN. Position-only trajectories are no longer accepted.
  • Servo drive: Buses that include a cst axis skip the bench's stop-decel (NA). Stopping such a bus is an immediate disable rather than a ramp, so it is not approved as ramp deceleration. Earlier approvals that include this item stay valid.
  • Install & update: RT setup wizard menu 4 (jitter measurement) refuses to measure while a user RT thread such as a control loop runs on an isolated CPU, because the priority-99 measurement would preempt that loop and end up measuring it. Run it before starting your application.
  • plem code: The robot stack launch approval dialog shows options set differently from the defaults (MoveIt, camera stack and perception profile, collision avoidance, Pendant, Lab) with their values. With the default setup it shows only the robot and master, as before.
  • Calibration: The analysis that computes suggested joint corrections (Δq) after calibration finishes faster. The computation is the same, so analyses that finish within the internal time limit give the same results as before.

Fixed103

  • Pendant: A node interrupted by stopping the Job now says it was stopped by the operator. Previously it reported a protective stop or a generic node failure.
  • Server API: GET /api/jobs/{id} no longer always reports completed for a temporary Job (such as a simulation). It now gives how the run ended (success, failure, stopped, error or waiting_for_operator), saved before the run starts, and error if a server restart lost the run.
  • Install & update: EtherCAT installation in the RT setup wizard (menu 3) now stops before building when the C compiler (cc) or make is actually missing, and shows the recovery command. Previously it only checked that the packages were installed, then failed during the build with an error that did not reveal the cause.
  • Pendant: Fixed the run status in the bottom bar reverting from "Completed" to "Running" right after a short Job finished, showing Pause and Stop buttons instead of Rerun. If another device restarts the same Job, the status changes to "Running" as expected.
  • Install & update: Remote support (plem remote) can now be open on several devices at the same time. Previously, while one device was in a remote support session, connections from other devices were rejected. Only the devices that will open remote support need to be updated.
  • Pendant: Even when another robot has focus, once the Job details arrive, Run, Rerun, Simulation and Resume on the Job screen are locked by a Protective Stop on the Job's robot (including one the Job reports), and the Resume start position is checked against that robot's pose. Until then, or if the details never arrive, the focused robot is used. A Protective Stop the Job reports also shows in the robot switcher and 3D name tags.
  • Pendant: When a mode change or error reset is rejected, a notification now shows the full rejection reason instead of the fixed text "Server not connected". An error reset that cannot reach the server is also shown as a notification, and Jog (manual operation) does not start if the mode change is rejected.
  • Robot: Fixed the target joint's torque dropping to 0 Nm after b0 tuning finished and until a stop command arrived, which could let the arm sag in a brake-released pose. The joint now returns to normal control as soon as tuning ends and holds its pose.
  • Developer SDK: Torque control plugin parameters that are NaN or infinity, outside the declared range, or not representable by the parameter type (float or integer) are now rejected instead of applied. Previously such values were applied as is, which could drive all joints to 0 Nm and cause a Protective Stop. Plugins that declare a range with NaN or infinity, or with min > max, are not loaded.
  • TUI: plem kill no longer terminates ROS launches started directly from a shell (such as the MoveIt demo) and leaves other jobs in the same terminal alone. It still cleans up launches whose file name matches a PLEM one (such as robot.launch.py), launches wrapped in bash -c, and anything started in the same command as the PLEM stack.
  • Pendant: "Save current position" now rejects Waypoint names starting with @ (a node using such a name moved to a different Waypoint without the @). Waypoints already saved that way are renamed without the @ on update, and nodes using them follow the new name. If that name was taken and a suffix such as _2 was added, nodes using it are rejected at run time; select the Waypoint again.
  • Sensor: zed-setup now also installs the ROS dependency step on JetPack 7 (Ubuntu 24.04, Jazzy) devices, and finds the right GMSL2 driver files for the device on both the standard and PREEMPT_RT kernels (it stopped when it could not find the driver on the JetPack 7.2 standard kernel).
  • Robot: Cartesian and joint Jog starting from standstill now ramps up speed over 0.1 s. This reduces how far the TCP speed overshoots the limit right after start, mostly at high Jog speeds. At low speeds it can still exceed the limit somewhat.
  • Robot: Removed wrist jitter in single-joint Jog (such as tool rotation Jog), where wrist joints that should stay still periodically jumped by about 1 mrad.
  • Pendant: Pressing manual operation on a robot whose Jog node failed to start now immediately shows "The Jog node is not running". "Manual operation off" in the status bar now uses a neutral indicator instead of green.
  • Pendant: The second robot in a cell now also shows its own gripper and F/T sensor, so deploying a gripper node for that robot and initializing its gripper are no longer rejected with "No gripper".
  • Robot: Autonomous calibration, plem code moves and Plem Lab trajectories right after Jog no longer go to a deactivated trajectory controller. Releasing the target move button while the control lane is switching no longer moves the robot.
  • Pendant: A Jog now stops if you switch to another window or the screen is covered while holding a Jog button (previously a release during that time was not delivered and the robot could keep moving). Jog notifications start with a message in the screen language followed by the server's reason unchanged.
  • Gripper: Until the gripper driver first responds, the 3D view and MoveIt planning show the fingers fully open instead of closed (the actual width is not yet known, and collision checking uses the largest shape).
  • Pendant: Reopening the page or reconnecting no longer brings back Protective Stops that were already acknowledged or have ended. An unacknowledged Protective Stop stays until recovered with ↻, even if you switch focus to another robot and back, and a late recovery response no longer clears another robot's Protective Stop or a newer one.
  • Gripper: Commanding the RG6 to its maximum width (160 mm) no longer fails with a timeout; it stops at 155 mm and succeeds. In the gripper node, a force of 0 N is treated as the maximum force (120 N), and anything below 25 N as 25 N.
  • Robot: Fixed cuMotion planning on JetPack 6 where, after a start pose was rejected once for colliding with surrounding objects, start poses with the arm colliding with itself were not filtered and planning failed with an unrelated reason. These cases now report a start pose collision immediately.
  • Lab: If loading the robot model (joint limits) fails right after connecting, Lab retries at intervals starting at 2 s and doubling (up to 1 min), and Generate is enabled once it succeeds. Switching controllers (ADRC↔PID, etc.) no longer leaves frozen graphs for signals the new controller does not have.
  • Lab: Entering an invalid robot namespace such as /indy7 or indy-7 on the connect screen is now rejected immediately with the reason (previously it hung at "Waiting for manifest…"). Rejected names are not kept in the recent list.
  • plem code: When you use plem code in several terminals, each uses its own robot connection process, so closing one does not drop the others' connections. The connection process is also cleaned up if plem code is force-killed. Connection processes left by earlier versions that remain after their session ends are cleaned up by a reboot or plem kill.
  • plem code: Exiting plem code during a robot move or gripper action cancels the action and requests the brake (BRAKED) once before exiting. If the brake cannot be confirmed, it prints a notice to check the physical E-Stop after the screen returns to the original terminal.
  • Lab: Phase @freq for sine runs is now the phase difference from the commanded target of the same joint. A run that follows the command exactly comes out near 0° regardless of amplitude and period (previously off by 15° to 72°). If the target signal was not recorded, phase is blank and only amplitude is shown. The gain sweep phase axis works the same way.
  • plem code: While a Pendant Job for that robot is running or paused, the AI's switch to Freedrive (hand guiding) is rejected like moves and gripper actions, with a hint to end the Job with ⏹ on the Pendant. Engaging the brake and clearing P-STOP still work during a Job, and during P-STOP the Freedrive switch is allowed so the arm can be moved by hand to a safe pose. Jobs on other robots do not block it.
  • Lab: A brief rosbridge disconnection no longer sends the console back to the connect screen. The experiment being edited, unapplied gains and the Abort for a move in progress are kept; while disconnected, a Disconnected indicator is shown and mode changes, gain apply and new moves are blocked. The connect screen appears only when you press Disconnect.
  • plem code: Fixed cancelling a move or gripper action near the end of its budget being judged as an unconfirmed stop, which applied an extra brake and reported the wrong result. It now waits for the cancel result and reports the actual final state.
  • Install & update: Fixed RT setup wizard menu 3 reporting "no slaves connected" before the link came up; it now waits up to 10 s before counting slaves. The menu 1 summary now marks steps that changed nothing on a re-run as skipped instead of done.
  • Gripper: The serial gripper bridge now turns off flow control left on by a previous user, so shutdown no longer hangs when the device does not respond. A polling period of 1 s or longer no longer uses all of the CPU.
  • Servo drive: Fixed pdo_mapping: generated on a bus with two or more drives putting the next drive's axes into the first drive's mapping, which got the file rejected or produced a wrong mapping. Each drive now maps only its own axes.
  • Servo drive: Fixed leaving move_to inside with Bus(...) with Ctrl-C stopping the axes but leaving the trajectory move request uncancelled. The stop performed when leaving the block now also cancels that move.
  • Install & update: Fixed login sessions of users in the realtime group running at the lowest priority (nice 19). On devices already installed, it is fixed by re-running RT setup wizard menu 1, upgrading plem-drive, or switching from prod with plem-deploy dev; sessions already open need a new login.
  • Install & update: The RT setup wizard no longer reports as passed a version pin that differs from the installed version, a load generator that stopped midway, a failed config file write, or a disabled jetson-clocks service. Re-running menu 1 corrects the pin and the service.
  • Servo drive: Fixed Bus.release() failing when called right after plem drive run printed every slave in OP, because the trajectory controller had not started yet. Release now waits for the controller to come up within the Bus timeout (default 10 s), and the bench no longer ends without approval because of this failure.
  • Install & update: When a step fails in the RT setup wizard (setup/rt/setup.sh), it no longer waits for Enter at that point; it shows the step summary table (with the reason if it aborted) and then waits once. Previously, when a critical step failed, the summary table was erased on returning to the menu.
  • Sensor: The F/T sensor can now be zeroed while the robot is stationary even when it shows over-rated. Fixed a wrongly saved zero causing over-rated with nothing touching the tool, which made it impossible to zero again.
  • Servo drive: SERVO_FAULT_RESET_RESULT on robot and drive buses is no longer logged as ERROR regardless of the result. During recovery (R, reset_error, Bus.reset()), axes skipped because they were not faulted, and cases where a reset was used in recovery or auto-initialization, are INFO. Requests dropped because the statusword could not be interpreted stay ERROR.
  • Servo drive: SDO reads during startup (stored_sdo comparison, hardware and software versions for the approval record, position before first enable) and bench SDO reads that fail with an I/O error (-EIO) without an abort code are now retried up to three times, after 0.1, 0.3 and 0.5 s. If the version still cannot be read, you are told to start again shortly instead of re-running the bench.
  • Servo drive: plem drive run no longer leaves a new working folder (plem-drive-run-*) on every start; if a private $XDG_RUNTIME_DIR exists, it reuses one folder per bus under it.
  • TUI: Over SSH, dragging over the log now sends the copy to your laptop's terminal (terminals that accept OSC 52; tmux 3.3 or later needs set-clipboard on). Previously it put the text in the device's display clipboard and reported Copied.
  • Servo drive: The hardware parameter master_index (the value set by plem drive run --master N) now accepts digits only. Instead of reading 1x as 1 and -1 as a very large number, it is rejected at startup with the reason.
  • Gripper: An RG6 gripper driver started before the robot driver now waits up to 30 s for the tool channel to appear instead of exiting immediately when it cannot find it.
  • Servo drive: Errors in drive model files now show the file's key and path (such as slaves[0].axes[1]). Argument errors in plem drive run show only the one-line usage.
  • Servo drive: release() in plem.drive now judges a rejection by the bus state (brake engaged, no brake operation in progress). It no longer mistakes a previous request's rejection for the current one, and does not wait for the timeout on rejections without a reason (it does wait while an earlier brake operation is running).
  • Developer SDK: apply_rt_thread_config given CPUs outside [0, CPU_SETSIZE) now rejects with EINVAL and leaves the thread's CPU mask unchanged, instead of pinning to the remaining CPUs.
  • Developer SDK: DriveHost::write rejects timestamps that are ahead (more than 50 ms ahead of CLOCK_MONOTONIC) or at or below 0, and EtherCATController refuses to start if the CiA 402 table for csp or csv axes lacks the Quick stop row (transition 11). Exported CMake targets require C++20.
  • Install & update: Fixed RT setup wizard menu 2 wrongly warning on devices whose boot configuration was edited to isolate two or more CPUs, and recommending a re-run of menu 1 (which reverts isolation to one CPU).
  • Servo drive: The bench stop check now requires the driver's line confirming that the brake engaged on stop. Without that line the brake state is unknown, so the check fails instead of passing.
  • Servo drive: When a drive reports a negative mode (a manufacturer-specific mode, such as -1), the MODES_OF_OPERATION_MISMATCH value and the rejection message now show -1 instead of 255.
  • Servo drive: When bus initialization is rejected, plem drive and the drive node now report the failed step and its cause instead of a numeric code (such as -9).
  • Calibration: Stopping the robot stack no longer logs the calibration server as process has died … exit code 1. It was a normal stop but was recorded as an error almost every time.
  • Calibration: If the analysis of the proposed joint correction (Δq) hits its time limit before finishing the repeatability check, it now rejects with repeatability unverified instead of proposing a correction. Previously an unverified correction could be proposed as if it had high repeatability confidence.
  • TUI: Esc on the start screen (Start session) no longer quits plem; pressing it once more when leaving Settings used to exit right away. Use q to quit.
  • TUI: Calibration in the Settings robot detail now shows the linked record (name · RMS · date), and if the record is corrupted or from a different camera model, a warning color tells you how startup will behave. The Calibration field in the robot form appears only when a camera is selected.
  • TUI: Stopping a robot now leaves Stopped 1 robot in the LOG pane (the start line is Launched 1 robot).
  • TUI: While a confirmation, pose name or first-robot dialog is open, the key bar shows that dialog's keys. The first-robot dialog also saves with ctrl+s.
  • TUI: The angle fields of Joint Move on the Session screen accept numeric characters only. Other letter keys such as s (stop) act as shortcuts immediately even while typing and are not entered into the field. The first Tab goes straight to the J0 field.
  • TUI: Fixed the robot edit and add forms in Settings taking nearly 2 s to open in a development workspace.
  • TUI: The SYSTEM pane on the Session screen shows EtherCAT, CPU and memory even before a robot is started, and on stop the Mode, Safety, gripper and F/T chips are cleared instead of keeping their last values.
  • TUI: Fixed ← in the LOG pane of the Session screen scrolling the log sideways instead of returning to the robot list after the terminal was narrowed.
  • TUI: Fixed robot geometry measurement lines ([measured] …: applied, rejected, violation) appearing twice in the LOG pane when they followed a warning or NOTICE line.
  • TUI: y/n in confirmation dialogs (pose delete or overwrite, robot delete) also work on a Korean keyboard layout (ㅛ/ㅜ).
  • TUI: Fixed selecting Theme in the command palette (ctrl+p) quitting the TUI (the Theme entry was removed). ctrl+q and Quit in the palette now exit like q, showing the stop steps in the status bar.
  • ROS 2: event_sequence in the robot and drive rt_events topic is now numbered in order of occurrence for every event (from 0 per bus). Until now most events, including Protective Stop, brake and limit stop events, were published with 0.
  • Sensor: Fixed sudo plem-camera-recover.sh --force stopping with "cannot open, not proceeding with recovery" because of the recovery lock file created by robot startup.
  • Sensor: Fixed MoveIt logging "Unable to transform object from frame" every frame when a camera without extrinsic calibration ran only its camera driver and published its own TF tree detached from the robot TF. ZED and RealSense no longer publish that TF.
  • ROS 2: Fixed the robot adapter's three action server nodes for mode, brake and B0 tuning sharing one name (/<robot>/plem). They now appear separately as plem_set_mode, plem_set_joint_brake and plem_tune_b0; action paths (such as /<robot>/plem/set_mode) are unchanged.
  • Lab: Fixed the Runs screen for hardware runs failing to build the tracking error channel (built-in controller measured_ signal names) and showing signals by internal key. It now opens with the tracking error of the joint the stimulus moved, and signals use the same names as the signal tree.
  • Lab: Fixed graph axes for nearly flat signals (live plot, Runs) repeating the same value (-0.00000000) at every tick.
  • Lab: The default sidebar is wider so the last digits of gain values in the tuning panel are no longer cut off.
  • Lab: If a mode change (SetMode) response does not arrive within 5 s, Lab now says the mode may still change and to check the Mode indicator before retrying, instead of showing an internal transport message. Also fixed the Simulation 3D view clipping the robot wrist and tool, and the pause indicator wrapping onto two lines and pushing the toolbar.
  • Servo drive: Fixed velocity and torque axes continuing at their last command when only the stream controller was deactivated (ros2 control switch_controllers). No command is retained now, so the 50 ms command watchdog puts the whole bus (all axes) into Protective Stop. To move again, reactivate the stream controller, start streaming, then call reset() and release(). This stop applies to a released bus or a bus with torque axes.
  • TUI: R (Recover) now appears only for an active P-STOP, joints out of range, and servo drive faults that may still be present. Past events alone no longer show it. Recovering a joint beyond its limit engages the brake first and then enters FreeDrive; a drive fault is reset with the brake engaged.
  • TUI: While you move the arm by hand in recovery FreeDrive during P-STOP, the robot list shows FREE P-STOP instead of BRAKE to indicate the brake is released, and f or r engages the brake. Engaging the brake then also clears P-STOP as a safe pose confirmation; if the cause remains, it trips again.
  • TUI: When the terminal or SSH disconnects, the TUI cleans up the robot stack and then exits too. After stopping and restarting on the same screen, the mode indicator and P-STOP notices carry on, and the r key label shows the current action (release brake, brake). Starting more robots than there are masters no longer exits the TUI but explains why, and the warning in the delete confirmation is no longer cut off.
  • Lab: Switching between the sidebar Tuning and Experiment tabs or the main tabs keeps the experiment draft and generated trajectory, and the Abort for a move in progress stays visible. Run & capture can be aborted while it waits for the mode switch. A new move cannot start while another is in progress.
  • Lab: If applying gains is rejected or fails, the entered values stay so you can apply again right away, and clamped values show what the controller actually uses. Recordings and convergence reports store the gains the controller confirmed or read back; if neither is confirmed, the last confirmed values are kept.
  • Lab: Closing the convergence report with Escape, a backdrop click or ✕ no longer removes the band. Remove the band with "Remove band" (the same as the violation report).
  • Lab: Fixed falling signals drawn jagged like a sawtooth in live graphs with a long time window (they looked smooth when paused).
  • Lab: Graph axis tick labels now show exact interval values. Fixed rounding such as "0.3 0.5 0.8" for a 0.25 interval and "68 70 73" for a 2.5 interval.
  • Lab: Fixed recording showing only Capturing after it hit the 300,000-sample limit. It now changes to "Capture full", the move continues, and the saved run is marked as truncated.
  • Lab: Abort now sends the BRAKED request even if the mode indicator updates late, and if it was waiting for the TRAJECTORY switch, sends it once more after the switch completes. It is not sent during a Protective Stop or when the mode is unknown. An Abort right after a move finishes shows "Aborted after the move completed".
  • Lab: Fixed a previous run, after disconnecting and reconnecting during execution, ending the new session's recording or moving the robot after a mode switch. Reconnecting to the same robot while saving now shows the saved run in the Runs list right away.
  • Lab: On reconnect, Lab no longer uses the previous robot's controller, mode and pose until the new robot reports them, and late gain apply responses from the previous connection no longer overwrite the new connection's values. Connecting to a different robot closes the previous comparison view in Runs. If you change the robot name on the connect screen during a brief disconnection, runs are saved under the reconnected robot's name.
  • Lab: If the controller's signal layout changes during recording, recording stops and shows the reason even when the signal count is the same (runs are no longer saved with swapped signal names).
  • Lab: If the controller rejects a gain change, it is shown as failed instead of "verified", even if the same value was already in use.
  • Robot: The MoveIt octomap warnings and errors and the RViz "Found remap rule" warnings printed on the launch screen when starting the robot are gone, and deceleration limit warnings ("Failed loading deceleration limits") are reduced.
  • plem code: If the AI requests a robot stack start twice at the same time, only one stack starts and the other request is rejected as already running.
  • Servo drive: plem drive check now rejects the file when a csp axis's velocity limit is within the rounding margin of one cycle's position counts (leaving no speed for the planner). Previously it passed and wrote velocity_cap_rad_s as 0 or less.
  • Servo drive: Python move_to now rejects before sending the trajectory if the bus has not sent state for more than 1 s (previously it failed after sending, which could leave the move pending). Creating Bus() from a robot description without ros2_control hardware raises a DriveError with a reason, and a failed stop when a with block exits on an exception is logged as a warning.
  • Install & update: Fixed RT setup wizard menu 3 reinstall installing over the old module and reporting verified while an app (such as plem drive run) held the EtherCAT master; it now aborts and tells you to stop that app. Menu 1 step 6 adds irqaffinity= to boot entries that only have isolcpus= (previously it failed every time).
  • Docs: Corrected the public repository docs to match the code for the condition of operation_enabled (up to the declared mode), the scope of the acceleration check in move_to (average between points), and the menu 3 reinstall procedure.
  • Server API: Fixed a one-off deployment whose start was rejected (for example, a start during a Protective Stop) blocking the next deployment with 409. A rejected deployment can be started again as is, and deployments not started for more than 5 minutes are cleaned up on the next deployment.
  • Pendant: Job deployment, program and Job deletion, Job label changes, and variable value and definition changes and deletion are no longer resent automatically when no response arrives. On an unstable network, Jobs are no longer created twice and variable values no longer revert; the failure is reported so the operator can decide whether to retry. Saving a program is still resent.
  • Install & update: Fixed uninstall overwriting a boot configuration (/boot/extlinux/extlinux.conf) changed after install with the install-time backup, which reverted the RT kernel and CPU isolation settings. If it changed, the current configuration is kept and the backup path is shown.
  • Pendant: A cell object you remove now disappears from the 3D view at once. Before, the last object could stay drawn until the camera moved.
  • Pendant: An edit the program editor refuses (for example Tidy or Wrap in loop) no longer shows as "Cannot run" with a problem count. The reason stays in the problem list as a warning you can dismiss.
  • Pendant: ▶ Run is now locked, with the reason shown, while a program's target robot is BRAKED and the program has a motion node. Programs with no motion nodes and simulations are not affected.
  • Pendant: Wrap in loop no longer leaves the new loop over its neighbours: the nodes after it move out of the way, nodes not in the way stay put, and a single undo restores everything. The loop also grows to fit the card, so the card no longer covers the loop's floor slots.
  • Install & update: First install no longer stops with a raw apt error on a device whose package lists are stale or empty. The installer now refreshes the lists before it installs the tools it needs, and if the refresh fails it says what to check.

Removed8

  • Docs: The operator manual and integration guide PDFs are no longer produced. PLEM documentation is provided only on the public docs site (https://www.wimcorp.co.kr/plem).
  • Pendant: Removed the "Robot mode" text to the left of the mode button in the bottom robot control bar. The button and its behavior are unchanged.
  • Pendant: Removed the sidebar collapse button next to the top logo. Clicking the current group (highlighted icon) in the left bar again collapses and expands the panel, and Ctrl+B still works.
  • Pendant: Removed the "Joint" tab (joint Jog) from the Jog panel. For joints, set the angles under Joint (the default view) on the "Target" tab and hold to move; the on-screen "No IK solution" hint also points there. In a singularity stop, exit with servo initialization, or end the operation and use Target › Joint. The robot-side joint Jog path was removed too.
  • TUI: Removed camera Overrides and its Edit… screen from the Settings robot form. The robot stack did not use the depth and frame rate values on that screen; depth and rate are set by Camera quality in Start session (and ~/.plem/perception_overrides.yaml). Saved values are left in place.
  • TUI: Removed the plem_server WebSocket address (ws://<device>:8080/plem) from the robot control screen and the development plem-server hot reload switch from the settings screen (plem_server_dev_mode in settings.yaml still works).
  • ROS 2: Removed MoveIt Servo. The enable_servo and jog_natural_rotation_lever arguments of Neuromeka move_group.launch.py and the servo_node and jog_gateway nodes no longer exist; Jog runs through the per-robot Jog engine node (/<robot_id>/jog/*). Installation no longer requires ros-<distro>-moveit-servo.
  • ROS 2: The Pilz sequence action /<robot>/sequence_move_group and service /<robot>/plan_sequence_path, which were never documented or used by product features, are no longer started.

v0.10.1​

Show 15 changes

Breaking changes1

  • Developer SDK: plem init no longer accepts --example and always creates a skeleton package. It includes gravity/Coriolis (ManipulatorDynamics) and Payload (ToolLoad) helpers; the PID example is gone (a PD example using the helpers is in CONTROLLER_PLUGIN_GUIDE.md, gains not tuned). Remove the --example argument from any script that passes it.

New4

  • Pendant: A single tap on "Save position", left of "Stop" in the bottom robot control bar, saves the current pose as a Waypoint without a dialog. It is named automatically from the date and time (e.g. wp_20261007_093015) and appears right away in the notification and the Waypoint list.
  • Pendant: You can rename a Waypoint from the ⋯ menu in Robot › Waypoints. Programs and deployed Jobs that use it keep running, and the name they show changes with it. A Waypoint used by a program or Job cannot be deleted; its row shows where it is used.
  • Servo drive: The agent skill add-drive, which writes drive model files, is now installed. plem code can use it right away; Claude Code needs one link in its skills folder. It reads the drive read-only, finds the manual and ESI and cites a source for each value, asks you for decisions such as limits, and leaves unsupported values empty so plem drive check rejects them. You run the bench yourself.
  • Servo drive: Model files can be shorter. Several identical drives fit in one entry with ring_position: [0, 1], with only the axis name, flip and zero_offset_count per drive. Position/velocity unit, and error_code_pdo when the mapping contains 0x603F, can be omitted, and pdo_mapping: standard builds the mapping from the CiA 402 objects PLEM uses.

Improved5

  • Pendant: One undo reverts one operation (a confirmed value, a drag or a command). Right-click, keys and the toolbar act on the same target (a node inside the selection means the whole selection) with the same result, new loops default to 3 iterations, and Ctrl+V pastes at the center of the visible canvas. In selection mode, a touch drag only draws a rectangle and the mode turns off when it ends.
  • plem code: Starting the robot uses the cell last selected in the plem TUI robot settings (default if none). If startup is refused because the robot is not in that cell, select its cell in the TUI or add the robot to the cell.
  • Pendant: In a cell with robots from different vendors, the second vendor's robot can also use Jog, and its Jog session is released when the last Pendant leaves.
  • Server API: Move nodes reference a Waypoint by a unique id (waypoint_id) as well as its name. Programs with names only still work, and the id is filled in on save and deploy. A node pointing at a Waypoint that does not exist on this robot is rejected at deploy, Job start and resume instead of during execution (including Jobs already deployed). waypoint_rename and waypoint_usage are added, and waypoint_delete rejects Waypoints in use.
  • Pendant: The name field for a new program is larger and easier to tap with gloves. If the program cannot be created because the open program fails to save, the entered name is kept and the reason is shown; Esc closes the field.

Fixed5

  • Pendant: Fixed the "Joint target" tab of the Jog panel being cut off at the panel edge and the "Release session" and speed buttons looking misaligned when the right panel is narrow (portrait tablet, or panel shrunk to minimum width). When narrow, the buttons now stack in full-width rows.
  • Pendant: Fixed creating a new program while another program was open overwriting the open program on the server with an empty new one. The new program is now saved separately under its own name.
  • Install & update: Fixed the robot stack and server stopping immediately with "error creating node" when plem was started on a device installed without the development setup (confirmed on JP7; JP6 is affected under the same conditions). Install and update now also install the kernel receive buffer settings ROS 2 communication needs and apply them right away.
  • plem code: Canceling after approving robot stack startup, motion preparation, Freedrive or error reset, but before it actually runs, now prevents it from running (previously the stack could still start or the brakes release). Canceling a move or gripper command before it is sent no longer tells the AI it was executed.
  • plem code: Fixed the uptime of a stopped robot stack continuing to increase after it ended.

v0.10.0​

Show 171 changes

Breaking changes21

  • TUI: Removed the plem env command. New terminals are set up automatically with the same ROS 2 environment as the robot. If you changed settings, restart plem and then open a new terminal.
  • ROS 2: ROS_DOMAIN_ID, CYCLONEDDS_URI and RMW_IMPLEMENTATION set with export in your shell no longer affect robot startup. Delete those lines from ~/.bashrc and similar files (if left, ros2 in that shell cannot see the robot) and change the domain in TUI settings (,). After updating, run ros2 daemon stop once in a new terminal.
  • ROS 2: PLEM_CYCLONEDDS_SYSTEM_DEFAULT=off is no longer read. On devices that allow remote PC access, copy /usr/share/plem/cyclonedds-localhost.xml to /etc/plem/cyclonedds.xml and change only the network interface line (PLEM Docs "ROS 2 integration"). Otherwise communication stays inside the device.
  • ROS 2: RtRawBatch (/rt_raw), RtEvent (/rt_events) and SetControlCommand (<robot>/plem/control_command) move from the plem_msgs package to plem_drive_msgs. Topic and service paths and field names are unchanged, so code that subscribes to or calls them directly only needs new imports and type names.
  • ROS 2: /rt_raw messages gain applied_command, axis_count and dc_sync_monitor_ns, so /rt_raw and /rt_events bags recorded with earlier versions cannot be decoded by this version. Analyze those bags with the version that recorded them, and have tools that subscribe directly read axis_count joint values per cycle.
  • ROS 2: The workspace field is removed from the goal of the motion planning action (plem/plan_trajectory), and the failure reasons workspace_invalid and workspace_violation_* no longer occur. Update scripts that call this action directly so they do not set workspace.
  • ROS 2: When starting with ros2 launch directly and omitting profile_dir, ~/.plem (or $PLEM_HOME) is used. A robot with no profile there, or masters shorter than the number of robots, now stops before startup instead of starting with a default profile without equipment and a guessed bus. Create a profile for each robot in the TUI and enter its master.
  • Robot: The environment variable that enables motion planning diagnostic logs is renamed from IKFAST_AUDIT_LOG to PLEM_MOTION_AUDIT_LOG. Move any value set in your shell profile or elsewhere to the new name.
  • Pendant: Joint and linear move nodes take their target only as a Waypoint name. Deploying old nodes with typed-in angles is rejected, and deployed Jobs with such a node on the execution path refuse new starts and checkpoint recovery (resuming a paused Job still works). Enter a name in the node details, tap "Save as Waypoint" and deploy again (the robot does not move).
  • Pendant: A gripper node now produces only one result: "Object gripped, stopped" or "Reached target position". If an object is gripped, the "Reached target position" branch does not run, so connect the steps that follow a pick to "Object gripped, stopped".
  • Pendant: The loop box's "Stop loop" exit is merged into "After loop". Old files are migrated when opened, but if both exits were used, the "Stop loop" connection is lost, so open and check them. If an expression on the execution path references outputs.<loop ID>.exit, deploy is rejected and shows where to fix it.
  • Pendant: Variables are stored in a per-robot variable list, and their values persist after a run ends. persistent: false is gone; if you need an initial value at start, put a set-variable node at the beginning. Old declarations are added to the list automatically on save, saving is rejected if the same name exists with a different type, and parallel branches share variables (the last value written wins).
  • Server API: GET/PUT/PATCH/DELETE /api/variables is added for variables, and the variables block is removed from saved and deployed workflow documents (only references remain). Changing a value or type and deleting are rejected while running (409).
  • Server API: Removed the AI workflow authoring WebSocket messages (workflow_agent_*), /api/agent-sessions, /api/stt/token, /api/setup/settings, the reach query (/api/robots/{robot_id}/reach_envelope) and the environment variable PLEM_URDF_XACRO_PATH. External clients that used them must be updated.
  • Server API: GET /api/calibration/extrinsics and GET /api/calibration/robots are removed; move to the per-robot GET …/robots/{robot} (DELETE …/extrinsic-ref is added for clearing). The per-robot query and PUT/DELETE …/extrinsic-ref handle only robots this server drives and return 403 for others; change those in the robot settings of the plem screen.
  • Server API: The WebSocket capture_seed now captures only the first seed and returns secondView.token; before generate_plan, call the new capture_second_seed {token} to capture the second seed (the robot moves slightly and returns). mount in save_camera_extrinsic becomes optional (today's date if empty), and missing_mount is removed.
  • Server API: Removed the WebSocket actions move_to_waypoint, gripper_command, waypoint_save, waypoint_get, get_state and ping. Use move_to_joints (waypoint_name), waypoint_save_joints, waypoint_list, the robot_state broadcast and the ROS gripper action instead.
  • Install & update: The first startup after updating deletes stored AI workflow session history. To keep it, back up ~/.plem/<device ID>/plem.db (under PLEM_DATA_DIR if you changed it) before updating.
  • License: The device token follows the license expiry date. After expiry, plem update is refused and plem code is refused from the next key renewal (remote support stays available); both work again once your WIM contact extends the license. Use a new token when reinstalling or replacing a device; when your contact deletes a device, its token is revoked too.
  • Developer SDK: The calculate_torque() override is removed from custom torque controllers. Plugins already built keep working, but to rebuild, move the body to compute() and use accessors such as measured.position(j) (PLEM Docs "Custom torque controller").
  • Robot: gripper_payload_* and camera_payload_* parameters in a hand-written URDF are no longer accepted, and the robot does not start. Combine everything mounted into one set of tool_payload_mass, tool_payload_com_x, tool_payload_com_y and tool_payload_com_z. Robot descriptions generated by plem are updated automatically.

Security1

  • Server API: The QA-only /api/debug/* routes (Job audit log query, P-STOP test) are now off by default. Previously anyone on the same network could read the audit log without authentication. Enable them with PLEM_DEBUG_ROUTES=1 for testing only.

New43

  • Sensor: "Measure weight" on the Pendant F/T card measures the mass and center of gravity of the tool (gripper, camera, etc.) and copies them for you. Paste them into tool_load.hpp of a torque plugin created with plem init and it uses force/torque with the Payload removed, whatever the pose. Optional; currently Indy7 only.
  • ROS 2: plem_drive_msgs/RtEvent carries constants for event kinds, severities and LIMIT_STOP reason codes (RtEvent.LIMIT_STOP, RtEvent.SEVERITY_ERROR, etc.). Code that subscribes to /rt_events directly should compare against these names instead of numbers. The message format is unchanged.
  • Robot: A robot with measured kinematics registered for its individual unit is validated at startup and then runs with those measured values. The startup log records in one line whether they were applied, and if validation fails, startup stops so the robot does not move with wrong geometry.
  • Robot: On registered devices, the robot stack also starts a collection agent that sends WIM copies of the robot profile and settings, operating and safety modes, controller type and tuning, control events, diagnostic statistics, joint data (except while braked; 10 ms summaries, about 100 per second), operation logs, Job audit records and more. Items, purposes and retention: license agreement Annex 6 (v1.1); opt-out: PLEM Docs "License".
  • Servo drive: You can run a single CiA 402 servo drive bus without a robot arm. Each axis uses torque (cst), position (csp) or velocity (csv) mode, and drives are defined in YAML files (the values in the example example_drive.yaml are made up). Use the tools plem-drive check and plem-drive run (or plem drive …) (PLEM Docs "Connect your own servo drive").
  • Servo drive: Encoders must be absolute. PLEM has no homing, so with incremental encoders the zero and position limits do not match.
  • Servo drive: plem-drive run brings the bus up under ros2_control; position axes move via FollowJointTrajectory (including MoveIt), and velocity and torque axes via stream topics.
  • Servo drive: In Python plem.drive, bus.move_to({...}) (position axes; trapezoidal, SCurve or your own Profile) and bus.stream({...}) (velocity and torque axes) check commands against the file's limits. bus.reset() clears faults and Protective Stops and reports any remaining cause as an error; bus.status and bus.velocities show state.
  • Servo drive: The bus name bus.name is now required in the model file; the bus comes up at /<bus.name> and Python attaches with Bus("<bus.name>") (--ns is removed). The name is not part of the approval, and plem-drive run refuses to start if a bus with the same name is already up. If with Bus(...) exits with an exception, the axes are stopped.
  • Servo drive: To run two buses on one device, use plem-drive run --rt-cpu N to put the two RT loops on different CPUs.
  • Servo drive: Motion is enabled only with an approved file. plem-drive check reports, without a drive, in JSON (plem-drive-check/1) any file the bus would reject. For an unapproved file, plem-drive run offers a bench at the drive in the terminal (mode, polarity, torque, brake, etc.) and, if it passes, records the approval in the file's approval block. Change the file, drive or firmware and you bench again.
  • Servo drive: At startup, if the vendor_id/product_code at a ring position, or the mapping and revision of a drive whose mapping is scanned, differ from those at file or approval time, PLEM shows both values and stops before enabling. A drive fault left over before the bench starts is reset once after a warning; if it persists, PLEM stops, so clear the drive alarm and run again.
  • Servo drive: If a position or velocity command exceeds a limit or command publishing stops for more than 50 ms, PLEM triggers a Protective Stop immediately without clamping the value, then engages the brake. PLEM does not decelerate in this case, so set the drive's stop deceleration (0x6084, 0x6085, etc.) with startup_sdo. Set the torque limit limits.torque_nm only on torque (cst) axes (position and velocity axes use the drive's 0x6072).
  • Servo drive: protective_stop and Ctrl-C in plem-drive run decelerate position and velocity axes with the per-axis limits.acceleration_rad_s2 (required), then apply the brake; if an axis does not stop in time, the drive's Quick Stop (0x6085, 0x605A) takes over. Buses with a torque axis are switched off immediately. If engagement cannot be confirmed, an error is logged with each axis's statusword.
  • Servo drive: On a bus without torque axes, releasing the brake holds the position at that moment (velocity axes at 0) and follows from the first command; with a torque axis, torque commands must already be streaming before release. release_brake and protective_stop reply requested, so check operation_enabled and brake_engaged in status, and see rt_events for rejection causes.
  • Servo drive: Axes without end stops (limits.position: null) can also be position (csp) axes and keep going past the end of the 32-bit count. After a restart, counting starts from the drive's value; PLEM stops beyond 2⁴⁸ counts in one direction and warns at shutdown if it ends outside the 32-bit range. Disable the drive's software position limits and follow PLEM Docs "Drive model file" for other drive-side settings.
  • Servo drive: Model files can specify the torque unit rated_per_mille, dc.write_cycle_time to write the SYNC0 period to 0x1C32:02 (only when the drive lists it as rw), dc.sync0_shift_ns, and stored_sdo, which compares the drive's stored values at startup and only warns. The DC reference clock is the first drive in the ring (PLEM Docs "Drive model file").
  • Servo drive: By default plem-drive run shows only a startup summary, warnings and errors; use --verbose for the full log. --monitor shows bus state as a table, one row per second, and --plot shows per-control-cycle records in PlotJuggler (PlotJuggler is installed too when the ROS apt repository is reachable).
  • Servo drive: The Panasonic MINAS A6B two-axis example folder a6b_pair (DC operation, referenced to the 21:1 gearbox output shaft) now installs with demo.py, which moves two coupled axes as mirror images, and a sync graph layout. The stop deceleration (3200 rad/s² at the motor) is a no-load bench value, so set it for your equipment, and make the first run with the load removed.
  • Sensor: When an Aidin AFT200-D80 F/T sensor is assigned to a Neuromeka Indy7 v3 in the robot profile, force and torque are published on /<robot name>/ft_sensor/wrench (relative to the measurement origin <robot name>_ft_sensor_frame), values and status appear in the Pendant 3D view and the TUI, and you zero it from the Pendant or the ft_sensor/zero service. It cannot be used in programs yet (PLEM Docs "F/T sensor").
  • Sensor: The F/T sensor is drawn in the Pendant 3D view in its real shape including the connector, and path planning avoids it, connector included. If values stop updating (cable unplugged, etc.), the sensor status reports it and no values are published; this clears by itself once values change again. Your code can tell the reasons apart by the state value of the status topic. Gravity compensation is not applied.
  • Sensor: Site-specific perception settings (collision grid, nvblox map range, voxel size, etc.) written to ~/.plem/perception_overrides.yaml override the defaults without editing PLEM files. Invalid keys or values refuse startup, and the TUI perception profile preview shows the values that will apply (if the file is broken or unreadable, the preview shows why it is rejected).
  • Calibration: On a robot with camera calibration, saving a changed gripper or F/T sensor shows a one-time warning that the calibration was measured with the previous configuration and should be redone (Pendant, TUI robot settings, plem profile, plem code). Saving and startup are not blocked.
  • Pendant: Jog has a new "Joint target" tab. Enter six joint angles and hold "Hold to move" to move to that pose; releasing it, the window losing focus or the connection dropping cancels the move (for an immediate stop, use the Emergency Stop).
  • Pendant: In Job › Variables you register, edit and delete variables and see their values during a run. Nodes that use unregistered variables fail validation, and adding an existing name or deleting a variable used by a saved program is refused (showing where it is used). Deletion is locked during a run, and changing a type warns you before saving.
  • Pendant: If no server confirmation arrives after tapping ⏸ ⏹ ▶ in the bottom bar, the button changes to "Not confirmed" and a resend button appears. If a stop or pause is not confirmed, the Pendant points you to the Emergency Stop; commands are never resent automatically.
  • Pendant: When the execution status connection drops, the canvas and bottom bar turn gray and show when it dropped, so you can tell they no longer show the robot's current state. The 3D view also keeps the last pose in gray when the robot connection drops.
  • Pendant: While viewing a deployed Job, "Freeze view" pauses the node status display and "Follow" returns to live updates.
  • Pendant: A new Structure tab in the sidebar lists the open program or Job in order from the start node. Tapping a row moves the canvas to that node, and during a run it follows the current node.
  • Pendant: Enter opens the details of the selected node (for nodes of a deployed Job, double-tap to view the saved values read-only), and a selected connection can be deleted with Delete. Double-tapping empty canvas to zoom is removed.
  • Pendant: Pause, resume and stop sent from the bottom bar are now also recorded in the audit log with who sent them and why.
  • Pendant: Korean and Latin text use one bundled typeface (Wanted Sans), so text looks the same on any device, even offline.
  • Lab: When connected to a robot with an F/T sensor, ft_sensor appears in the signal tree so you can graph force and torque and export them as CSV or JSON (they are not included in Runs recordings).
  • TUI: plem profile set-gripper and set-ft-sensor <robot> <model|none> change a robot profile's gripper and F/T sensor from the command line (applied from the next startup). Leading and trailing spaces in the model name are ignored, and none in any letter case clears it.
  • Server API: The /plem actions gain move_to_joints (joint angles or waypoint_name; request_id required; cancel with cancel_action) and waypoint_save_joints (registers joint angles as a Waypoint).
  • Server API: GET /api/calibration/robots/{robot}/pending-result returns a result that was measured but not applied (measurement time, residual, pass/fail). It handles only robots this server drives and returns 403 for others.
  • Server API: GET /api/jobs/{id}/resume-preview is added, and resume and a start that takes over a checkpoint are rejected (422) if the robot is away from the reference pose. Set the tolerance with PLEM_RESUME_ALIGN_TOLERANCE_DEG.
  • plem code: The AI coding agent plem code is included in the default install as a beta. It runs with the device key received at device registration (/etc/plem/code/plem-code-key.json); the plem group can modify this key, so add only accounts that need it. Robot moves and gripper actions require operator confirmation and are refused while a Job is running. The interface is in English.
  • License: When your WIM contact extends the license, run sudo plem-register --refresh on the device to get the new license; it takes effect after restarting the robot stack (PLEM Docs "Update").
  • Developer SDK: Custom torque controllers can read F/T sensor force and torque every control cycle with measured.wrench(). Values are in the sensor frame without gravity compensation, and wrench_state() and wrench_zero_seq() tell you why a value is missing and when the zero changed. Existing plugins work without rebuilding (PLEM Docs "Custom torque controller").
  • Install & update: plem uninstall --remove-cumotion (included in --all) can also remove the packages and repository registrations of the collision avoidance components installed during setup (cuMotion, nvblox). Other Isaac ROS packages and pip packages such as torch remain.
  • Pendant: A "Stop" (■) button is added at the right end of the bottom robot control bar. Even when other controls are locked, it requests cancellation of robot arm and gripper motion and engages the brakes immediately, without waiting for an ongoing transition as the BRAKED mode button does. A stopped gripper may hold the part loosely or release it. This is not an Emergency Stop; in danger, press the physical E-Stop.
  • Install & update: The plem command is now installed by the new plem-cli package. plem <command> runs the plem-<command> installed on this device and plem --help lists installed commands, so the available commands depend on the installed packages (a drive-only device has plem drive). Existing plem <command> commands keep working.

Improved56

  • Servo drive: Usage and help text of the drive tool now refer to plem drive …. Calling plem-drive … directly still works.
  • Server API: Startup logs, TUI logs, and server error and response messages (including those shown in Pendant notifications, the validation panel, and AI chat) are now consistently in English (for example rejected:). Update any scripts that filter logs by these messages. The Pendant's own screen text is unchanged.
  • Pendant: The robot mode switch in the bottom bar shows icons only: a lock for BRAKED, a curve for TRAJ (replacing the play icon that was easily confused with Run ▶), and a hand for FREE. Names appear as tooltips.
  • Robot: A BRAKED request is no longer rejected while another mode transition is in progress, such as brake release or TRAJ→FREEDRIVE deceleration; it interrupts that transition and engages immediately.
  • Robot: Brake release is rejected for any axis whose EtherCAT slave is not in OP, and SLAVE_NOT_OPERATIONAL is recorded in rt_events (the servo drive bus behaves the same). If this happens right after startup before the slave reaches OP, resend shortly; if it persists, look for the cause in sudo dmesg | grep -i ethercat.
  • Robot: At startup the drives' communication mapping is validated; if a required entry is missing or mismatched, startup stops and reports the cause before the robot moves.
  • Robot: Each fault reset request now sends a new signal, so repeated requests while a fault persists are delivered every time. If the error indication clears but the robot stays stopped, confirm it has returned to BRAKED, then select the target mode again.
  • Robot: For Neuromeka robots, PLEM does not automatically send reset commands to a faulted axis (including the final step of brake engagement); resolve the cause, then request a reset. For Huayan Elfin, automatic reset requests to a drive with a persistent fault are sent about every 200 ms, up to 25 times per fault (unchanged under 1 kHz control).
  • Robot: The collision model margin for Neuromeka Indy7 v3 is widened to 12 mm, so path planning in tight spaces may be slightly more conservative.
  • Robot: On JP6 (Humble) devices, the motion-planning IK solver changes from IKFast to pick_ik, so robots with measured kinematics are solved accurately (JP7 still uses TRAC-IK). The Neuromeka IKFast assets and the motion_solver key in the robot catalog are removed; if your hand-edited robot_models.yaml contains that line, you can delete it.
  • ROS 2: ros2 in a newly opened terminal is pinned to the same CycloneDDS as the robot stack (required packages are installed with it), so commands like ros2 topic list see the robot right away.
  • ROS 2: A plem/control_command request that combines protective_stop with a brake release (release_brake or free_drive) now executes only the stop and responds with failure. Previously the release could override the stop; send the release as a separate request after the stop.
  • Calibration: The "Records" and "Robot" screens are merged into a "Current value" card for the connected robot, and "New calibration" becomes "New measurement". The card shows running/restart required, next-startup failure warnings, and re-measurement advice, and lets you use, unset, import, rename, export, or discard values; values below threshold or without a verdict are locked until "On-robot check".
  • Calibration: The save button becomes "Apply (after restart)" and shows the values that will change (old → new). Unapplied results stay on the device and can be applied from the "Current value" card even after restarting the stack. The record name field is removed and the label is optional; if empty, the name comes from the camera model and date (for example zedxm-2026-10-01-v1). A record's measurement time is when computation finished.
  • Calibration: Screen terms are standardized to "Hand-eye calibration", "Pass"/"Below threshold", and "On-robot check", and error messages say what to check (error codes are unchanged). In-measurement guidance and measurement engine and server messages are in English, and the robot stack restart instructions now use the S key procedure on the plem screen.
  • Calibration: New measurement shows the camera view large in the center and locks other operations such as Jog and mode changes during autonomous motion (except E-Stop). If termination cannot be confirmed, it shows likely causes and actions and blocks new motion until you check the E-Stop. The browser asks before you leave the page during a measurement or with unsaved results.
  • Calibration: When a measurement fails, you resume from the step that matches the cause: "Rerun with the same plan", "Re-aim", or "Re-enter board spec". The board spec input is prefilled with the board from the current value, and you can still copy results after saving.
  • Calibration: For autonomous measurement seeds, you aim at the board once and approve the move; the robot then captures a second seed and returns. If no second pose is found, it tells you how far to back off, and if the returned pose differs from the first by more than 5 mm or 5°, it asks you to aim again. Autonomous motion is the default capture method, and seed capture, moves, and plan generation can be canceled (reloading also cancels).
  • Calibration: Fine mastering and reachability planning are now available on robots that use measured kinematics. If the geometry changes after a session, approval is rejected, so redo the session; regenerate existing automatic capture plans for robots switched to measured kinematics.
  • Pendant: The robot control bar at the bottom gathers robot mode (BRAKED, TRAJ, FREE), ▶ ⏸ ⏹, progress, and errors in one row, with status shown in Korean (Stopped, Failed, Error). The top bar keeps connection status for the robot, server, run channel, and server requests. ⏸ pauses after the current node finishes and shows that it is waiting.
  • Pendant: The "How do you want to resume?" dialog after Protective Stop recovery is removed; ▶ Continue and ⏹ Stop Job in the bottom bar replace it. Before continuing, the bottom bar shows the robot's deviation from the resume reference pose (tap ⓘ on narrow screens) and the 3D view shows that pose translucently; hold "Move to start position" to go there. Resume is rejected outside the tolerance (default 5°).
  • Pendant: While still in Protective Stop, ▶ Continue is locked and shows the reason. Old checkpoints without a recorded pose have no reference pose, so Continue is rejected; use ⏹ Stop Job and run from the beginning.
  • Pendant: If the server shuts down or stops and then restarts, a Job that was running is shown as "Awaiting recovery" when it has a checkpoint, and you can continue or stop it. Paused and awaiting-recovery Jobs can be continued or stopped after a page reload or from another device.
  • Pendant: The left sidebar splits into an icon rail (Work, Robot, Calibration) and a panel; on narrow screens the panel opens over the canvas. The four tabs at the bottom right are removed, Jog sits below the 3D view, and the right 3D column can be collapsed (it expands when you run). Adding nodes moves to Work › Nodes, and the top "+" is removed.
  • Pendant: The screen border is unified into one dark background and the central work area is brighter; canvas tool buttons and section links in node details are larger and easier to press with gloves. Row actions in lists (rename, delete, etc.) move into the "⋯" menu at the right of each row, and delete asks for confirmation once more.
  • Pendant: The screen now loads before the server reports the robot name, and only operations that move the robot are locked with "Checking robot connection". If the connection keeps failing, a retry button appears in the top banner.
  • Pendant: During manual operation, if the robot mode changes, the 3D view is collapsed, or the connection drops, the operation stops automatically and the reason stays in the Jog panel. When all Pendants are closed, the server tries to release the operation session.
  • Pendant: The Jog servo indicator now reads "Servo OK", and the Cartesian ± buttons use the same axis colors as the 3D view (X red, Y green, Z blue). "Move to this position" in the Waypoint list moves only while held, cancels on release, and moves only the Waypoint whose name matches exactly.
  • Pendant: "Update to current position" in move node details now goes through a confirmation dialog that first warns it applies to every node using that name.
  • Pendant: The run list shows finished Jobs 20 at a time with "Show more", and runs that other clients start without saving appear at the top as "Server run". Right after deployment and when a run starts, the canvas shows that Job, and the top bar shows only the open document's name and status.
  • Pendant: In the robot editor's gripper and F/T sensor selection, models not installed on this device appear as "<model> (not installed)" instead of "(none)".
  • Pendant: Parallel nodes become lanes (motion and auxiliary). Nodes that move the robot run only in the motion lane, and nodes inside a lane connect only within the same lane. Old files are converted when opened; files whose branches shared nodes must be fixed.
  • Pendant: Loop boxes now have a type (Always, Count, Condition), and the header shows the current iteration while running. The "End loop" and "Next iteration" inlets connect a break and a continue (skipping the rest of the body); loops saved earlier read as "Count" if they had a count, otherwise "Always". The maximum execution steps (max_steps) also applies inside loops and parallel blocks.
  • Pendant: switch now has one comparison subject, case rows, and an "Otherwise" exit; old switches are converted when opened. Exits that did not match the subject type (for example 2.50) remain as unset cases, so delete them or fix the value. Condition node details show the saved expression at the top, and comparisons are chosen with the same symbols as the expression, such as == and >.
  • Pendant: Node exits become slot rows: tapping an empty slot opens the node palette, and tapping a node on the canvas connects to it directly. The "+" above nodes is removed; create the connection that ends a loop by tapping the box header.
  • Pendant: A flow that ends at an unconnected exit is recorded as a normal completion, and the completion indicator in the bottom bar shows that exit. If several exits of a node are true, the first in saved exit order (including empty slots) is chosen, and during a run the canvas highlights only the connections actually traversed and the exits taken.
  • Pendant: Node cards and the node list show color icons by type instead of skill codes (such as motion.move_linear; the code is in the node details window). Loop and condition boxes show summaries such as "Always", "5 times", or "Condition" instead of long expressions; the full text is in the details window. Validation errors and warnings in the details window are shown in Korean.
  • Pendant: Loop and parallel boxes get a solid border and inner padding (old files may widen a box once when opened; node positions are unchanged). Nodes created from the palette are placed where they do not overlap and loop boxes grow as needed; if there is no room, the node is not created and the reason is shown.
  • Pendant: Moving a node into or out of a loop box cuts connections that cross the boundary and reports how many were cut. Deleting a box moves its nodes outside, and you cannot create a box inside a box. Copying a box copies its nodes, connections, and condition-expression references (except the start node).
  • Pendant: - in node IDs changes to _ when opening or deploying so IDs can be used in condition expressions; connections and references are updated too. Nodes inside a loop that are not reachable from the start slot are marked "Unreachable" and are not executed.
  • Pendant: Zoom ranges from 25 to 150%, below 80% the canvas shows an overview, and tapping a node zooms in centered on it. Opening a program shows the area around the start node; use the ⤢ button for the full view.
  • Pendant: Protective Stop is shown by a P-STOP marker next to the robot mode in the bottom bar and a ↻ recovery button instead of a banner at the top. Meanwhile TRAJ, ▶, Jog, Waypoint moves, and calibration motion are locked; BRAKED, FREE, ⏸, ⏹ Stop Job, and "Stop" at the far right remain (BRAKED is also locked while the robot reports Protective Stop). "Move to start position" for recovery moved next to ▶ ⏹ in the bottom bar.
  • TUI: Logs from the TUI and the robot stack (launch, nodes, server) are collected in ~/.plem/log. The TUI creates a new plem_tui_<time>.log on each start and the robot stack a new <time>/ folder on each startup, keeping the latest 20 of each (logs in the old location are not deleted). Auxiliary tools such as RViz and manually started ros2 launch still log to ~/.ros/log.
  • TUI: The domain shown on the settings screen and status line is the value applied at startup; after a change it is marked "restart plem to apply" until plem restarts. If ros_domain_id in ~/.plem/settings.yaml is not an integer from 1 to 101, startup is refused with the file path and allowed range instead of falling back to domain 0; fix or delete that line.
  • TUI: The default Joint Move poses (zero, packaging, jog left/right) are written to poses in ~/.plem/settings.yaml on first run, and from then on that file is the reference. Deleted poses are not restored, and you can edit the file directly.
  • Install & update: Drive features move to a new package, plem-drive. plem update installs it as well, so no action is needed.
  • Install & update: plem uninstall --keep-license also preserves the plem code device key along with the license. Uninstalling leaves the device registration in place, so reinstalling requires handling the existing registration; to only update packages, use plem update (details under plem uninstall in "Command line" in PLEM Docs).
  • License: If the license is missing, expired, or cannot be verified, a page explaining the cause and the fix appears instead of the Pendant and Lab, and server features are blocked. After fixing it, restart the robot stack (PLEM Docs "Troubleshooting").
  • License: Token and registration error messages in plem-register, plem remote, plem update, and plem code now differ by cause. A token rejection distinguishes a revoked token from an expired license, each with its action, and if only the license file was lost, you are told to ask your contact for a reissue (Renew if expired) rather than re-register.
  • License: The license agreement moves to edition 1.1; an appendix lists collected data (device registration, version, plem code conversations, tool I/O, server access logs, remote support session logs, robot operation logs (item 6)) with purpose and retention. plem code conversations are not used for model retraining and are deleted after retention; do not paste credentials or personal data. Full text: /usr/share/doc/plem-core/ on the device.
  • License: A proviso added to Article 8(3) of the license agreement (edition 1.1) permits modifying PLEM, and reverse engineering to debug those changes, as far as third-party licenses such as LGPL require; WIM provides on request the source code of GPL and similar components on devices it installed and delivered, for at least 3 years from delivery; 8(4) states where dependency license notices are (THIRD-PARTY-NOTICES) (PLEM Docs "License").
  • Docs: The changelog on the public docs site becomes a per-version timeline with a table of contents, with older versions collapsed. The overview adds a summary of breaking changes and entry points by situation; switching channels keeps you on the same page, and tables and headings are easier to read on mobile.
  • Install & update: plem update fetches the latest update procedure when it starts, so even if you skip several versions, all steps added in between are run. Packages no longer used after the update are listed by name with a cleanup command (they are not removed automatically).
  • Install & update: Rerunning the install command on an installed and registered device changes nothing and points you to plem update. If a leftover license belongs to another device (e.g. a disk moved from one), install stops at that step (previously the run screen locked on the mismatch after install). Non-Jetson hosts are refused up front, the system locale is left unchanged, and the final screen lists remaining tasks such as logging in again.
  • Calibration: "Stop" in autonomous measurement (now an icon button) stops the robot in place even while moving and ends the measurement. It does not engage the brakes.
  • Server API: WebSocket execute_stop is processed immediately even if another action on the same connection is running; it requests cancellation of all clients' trajectory, gripper, and calibration goals and of the running Job, then requests BRAKED until confirmed, and replies with an error if that fails.

Fixed35

  • Lab: Applying controller tuning is blocked, with the reason, while joint brakes are still releasing or engaging. Apply again after the brake operation finishes.
  • Calibration: Detection quality during measurement no longer drops to 0% right after a capture. While there are no new observations, such as during moves, countdowns, or camera dropouts, the last value is shown dimmed as "Last value", and the board detection indicator lights only on a new observation.
  • Robot: Fixed an issue where, on the first startup after powering on an Elfin, joint angles before servo-on appeared different from the actual pose (by 15°, 20°, etc.) and the first brake release triggered a Protective Stop with a J2 fault. The actual pose is now shown from the start, and the first release proceeds normally.
  • Robot: Fixed the motion planning node (move_group) leaving an abnormal termination (exit code -11) error every time the robot stack was stopped.
  • Robot: Fixed /rt_events events that occurred at the same instant being lost or mixed up.
  • Robot: Requests to reactivate robot hardware that was deactivated in the same stack are now rejected. Previously they appeared to succeed, but later deactivation failed to stop control. To use it again, restart the robot stack.
  • Robot: Fixed the position drifting slightly while stationary without a motion command after brake release.
  • Robot: Fixed the arm being pulled toward a rejected target when releasing a motion that tracker teleoperation had rejected because the start position did not match (JP7 only).
  • Robot: Fixed an old-format profile bringing back the previous gripper at the next startup after the gripper was removed.
  • Gripper: Fixed a gripper with an unplugged cable or tool power off continuing to show its last state as if normal. connected in gripper_status now becomes false and the TUI shows not answering; after reconnection it recovers on its own within a few seconds.
  • Gripper: Fixed gripper commands occasionally being dropped or mixed with the previous command. When you cancel a motion, the stop command is sent at the next status check (up to about 0.1 s). After updating, fully shut down the robot stack and start it again.
  • Gripper: The driver publishes no status until it receives the first state, and commands sent in the meantime fail; resend once the status appears. Danhae shows a width of 0.0 until the first open or close, and the first close may be judged as already closed.
  • Sensor: Fixed cameras failing to open with "motion sensor not found" after restarting the camera daemon or connecting the camera after boot (a symptom that looked like a bad cable).
  • Calibration: Motion planning in automatic calibration now checks collisions using the gripper and camera in the robot settings. Previously it assumed an RG6 gripper and a ZED X Mini regardless of the settings.
  • Calibration: The default camera position used before calibration now follows the F/T sensor and gripper rotation (previously the camera was computed about 52 mm too low, the sensor's height). Calibration values whose camera model or tool rotation differs from measurement time now warn instead of blocking startup, and this default position is used with perception off until you re-measure. Previously, changing the camera made startup fail.
  • Calibration: Fixed clicking the board in "On-robot check" being rejected because motion planning found no joint solution. It now finds a joint solution starting from the tool's current pose and moves by joint motion to 2 cm above the clicked point; you can stop it with "Cancel" during the following countdown.
  • Pendant: Fixed Jobs ending up in the wrong state or losing resume information when stop, pause, resume, rerun, and delete requests overlapped. A stop pressed right after starting now applies before the first motion, ▶ Run starts only after edits finish saving and shows the reason if saving fails, and editing during a save and then closing the window still saves the latest content.
  • Pendant: Protective Stop is still detected after pause and resume, and continuing after a Protective Stop between nodes resumes from the next node (inside loops and subprograms, that node restarts from the beginning).
  • Pendant: Fixed ▶ in the Deploy tab sending a new start instead of a resume for Jobs in Protective Stop or awaiting recovery, and a new Job started while viewing another Job being canceled. To resume, open the Job and use ▶ Continue in the bottom bar.
  • Pendant: Fixed the run status connection not reattaching after a server restart or network drop, finished Jobs staying "Running", "Connection" staying "Connection issue" when opening a finished Job, and opening a program from the Design tab leaving you on the Job screen.
  • Pendant: Fixed node errors of a deployed Job not appearing in the error list while errors from the previous run remained. A screen opened just as a Job ends now shows the final result, and the stop button tooltip explains that stopping discards the resume point.
  • Pendant: Fixed undo (Ctrl+Z) and redo changes not being saved, so canceled edits were run (deleting several nodes at once is also undone in one step). Also fixed nodes being selected during two-finger zoom.
  • Pendant: Fixed the editor and server evaluating condition expressions differently, so the editor flagged expressions the server accepts as errors. Both now accept Korean output names and special whitespace, and numbers accept only regular digits (0–9).
  • Pendant: Fixed "Go to node" in the error list jumping to the wrong node inside loop boxes, and canvas screen reader announcements being in English.
  • TUI: Fixed saving a robot on the settings screen applying gripper removal only partially or writing the connection type incorrectly as the EtherCAT tool channel. If the connection type is unknown, saving is refused or the field is left empty so the gripper driver does not start.
  • TUI: Saving a robot on the settings screen no longer reverts items the Pendant changed in the meantime. If both changed the same item, saving is refused with a prompt to reopen and save again.
  • TUI: When the gripper or camera list is empty, the message no longer suggests the unrelated plem init and instead asks you to check the PLEM environment and robot package installation.
  • TUI: Fixed Del on a robot row in the settings screen deleting the robot profile immediately without confirmation. It now warns that this cannot be undone and deletes only after you press y.
  • TUI: Fixed the R hint during Protective Stop giving a sequence that does not clear joint or workspace limit stops. For limit stops it now guides you to press f to enter Freedrive, move the arm back within range, press R, then press f to engage the brakes once the safety state is NORMAL and the mode is FREE.
  • Install & update: Fixed cameras producing no video on devices with the collision avoidance component installed (libgxf_serialization.so: cannot open shared object file in the launch log). Updating applies the fix automatically; if you upgraded directly with apt, run sudo /usr/share/plem/setup-cumotion.sh once.
  • Install & update: Onboarding on JetPack 7 devices no longer configures an unused virtual display. The configuration on already onboarded devices remains and is reverted by plem uninstall (takes effect after reboot).
  • License: Instructions for manually restoring the license file now give a command that also sets permissions (sudo install -m 0644 …), and a non-string token or depot_url in /etc/plem/depot.json is reported as a configuration error, not a token rejection. Replacing the board or network module registers a new device; if "already registered" still appears after a replacement, check the detected serial and MAC.
  • Robot: Fixed startup proceeding without the Payload when the tool mass was negative or over 10 kg; startup now stops and reports which value is wrong.
  • Robot: Fixed a camera configured on an Elfin being left out of the robot model and gravity compensation. A ZED camera is mounted after it is calibrated on this robot.
  • Robot: The center of mass of a camera mounted on the gripper with a bracket now follows the gripper rotation and F/T sensor height, so gravity compensation is accurate in that configuration.

Removed15

  • Server API: Job /restart and command reception on /ws/jobs/{id} are removed. Use REST start, pause, resume, and stop for run control; to run from the beginning, call stop then start. started_at and completed_at are also removed from Job details.
  • Server API: collision_avoidance, nvblox_enabled, and perception_mode, unused since the Pendant's 3D environment map surface and "3D check" tab were removed, are dropped from the session_meta sent right after connecting to /plem. Clients that read these values should remove that handling.
  • Server API: POST /api/catalog/reload, which reread the skill list from disk, is removed. The server reads the skill list at startup; remove this call from scripts that used it.
  • Server API: Device discovery the server answered on UDP port 9999 (PLEM_DISCOVER) and the environment variables that configured it, PLEM_UDP_HOST, PLEM_UDP_PORT, and PLEM_DEVICE_MODEL, are removed. The Pendant does not use this feature and is unaffected.
  • Developer SDK: Unused IPC channels, legacy communication modes, and the umbrella headers plem/ipc.hpp, plem/fieldbus.hpp, and plem/control.hpp are removed from the PLEM core C++ headers. If you build from source, include the individual headers you need directly.
  • Pendant: The "Quick run" button and program mode selection (Design, Snapshot, Live, Ctrl+1–Ctrl+3) are removed; a single ▶ now validates, deploys, and starts. The canvas shows one program or one deployed Job, and you cannot return to the program while running, in Protective Stop, or awaiting recovery. To start over, press ⏹ then ▶.
  • Pendant: The program's workspace box and its check are removed. The remaining safeguards are operator presence, speed limits, joint limits, self-collision checks, and Emergency Stop; saved box values are discarded automatically when read.
  • Pendant: AI program authoring (the AI tab in the library, voice input) and the OpenAI API Key setting in the Pendant and TUI settings are removed. You can delete any leftover openai_api_key in ~/.plem/settings.yaml.
  • Pendant: Camera, vision, and IO nodes, which had no execution function, are removed. Deploying a program with these nodes connected in the execution flow is rejected; delete them in the editor.
  • Pendant: The "Redeploy needed" indicator shown after editing a program and the "Connect PoseRef" option, which did not work on linear move nodes, are removed.
  • Pendant: The environment map surface and perception status badge in the 3D view, and the "3D check" tab in the calibration review window, are removed. The card button becomes "On-robot check", residuals and current value status appear on the on-robot check screen, and on-robot check works with collision avoidance (cuMotion) and environment map (nvblox) off as long as the camera is on.
  • Pendant: Running subprograms (custom.* nodes) is removed. These nodes could not be created in the Pendant, so ordinary programs are unaffected; if an imported file has one connected in the execution flow, deployment is rejected as before as an unknown skill, so delete it in the editor.
  • TUI: plem ros2 <args> is removed. Use ros2 directly in a new terminal.
  • TUI: The NITROS field in the top status line is removed, and the EtherCAT field adds a red ✖ only when disconnected.
  • ROS 2: The /<robot name>/perception/environment_scene topic that published the nvblox environment mesh, the plem_msgs/EnvironmentScene message, and the plem-perception-scene package that carried them are removed. plem update removes the package automatically; obstacle avoidance (nvblox) is unchanged.

v0.9.0​

Show 24 changes

Breaking changes7

  • Robot: Joint brakes now operate together with power on all vendors. Releasing powers the joints and holds the pose while the brakes open (accepted only in TRAJECTORY and Freedrive modes); engaging cuts power and locks the joints.
  • Robot: Releasing only the brakes with power off to push the arm by hand is no longer possible. To reposition after a collision, clear the fault with the on-screen recovery action, then move the arm by hand in Freedrive with gravity compensation. If a Protective Stop is still active, first remove the cause (E-Stop button, external force pushing the arm) so the safety state returns to NORMAL, then enter Freedrive.
  • Robot: Indy7-family robots and the Elfin10-L now stop with an error at once when started without a device serial. The per-device profile (~/.plem/profiles/<serial>.json) is the only source of joint offsets, so this prevents the earlier silent start with zero offsets and a wrong pose. Starting from the plem TUI passes the serial registered in the robot profile automatically.
  • Robot: Motion planning for Elfin robots is now Pilz only (PTP, LIN, CIRC). RViz or MoveIt configurations that set the planner to ompl must switch to Pilz, and obstacle-avoiding planning is not available on Elfin.
  • Robot: Planning requests that need obstacle avoidance are now rejected, not handed to another planner, when collision avoidance (cuMotion) is off. Avoidance planning runs only on Neuromeka robots on the Humble train with cuMotion enabled; elsewhere, send default (deterministic) planning requests. planner_hint no longer selects a planner and is rejected if it differs, so leave it empty and request by whether avoidance is needed.
  • Gripper: The gripper hardware plugin is renamed from neuromeka_robot_driver/GripperHardwareInterface to plem_robot_nodes/GripperHardwareInterface. URDFs that spell out the old name fail to start and must use the new name (configurations that use the provided gripper xacro as is need no action).
  • Tuning: b0 auto-tuning is unified on the position domain, and the tuning action keeps its name but changes its contract. Callers of TuneB0Position (tune_b0_position) must switch to TuneB0 (tune_b0), the tuning tool uses the online subcommand instead of online-position, and adapt_sign must be set explicitly to ±1 (the velocity-domain tuner is retired).

New1

  • Docs: The public docs site adds per-screen user guides for plem TUI, Teaching Pendant and Plem Lab. They walk through launch configuration, control, stop and recovery, operation, tuning and running step by step with real screenshots.

Improved6

  • Docs: Hardware and launch guides now state that the camera (ZED X Mini) and collision avoidance (cuMotion) are available only on the ROS 2 Humble train.
  • Robot: The server resolves the robot's reference frame and vendor tools (mastering, reachability check) from the installed robot catalog. With the Neuromeka hard-coded values removed, scene and calibration flows use the correct frame on other vendors' robots (Huayan Elfin) too.
  • Safety: The robot motion lock (which prevents simultaneous operation from calibration, the TUI and the server) now has a single implementation. Separate per-component copies could take different lock files and silently lose mutual exclusion; that path is gone.
  • Docs: The documentation for AI coding agents (depot.wimcorp.dev/docs/<version>/llms.txt) is now a wiki compiled from the public docs site and the code (complete index plus self-contained pages), replacing the republished developer manual chapters. Any coding agent uses it at the same URL without a plugin (the plem-docs plugin for Claude Code is retired).
  • Robot: You can select a Huayan Elfin robot in the plem TUI and start it directly. If no robot type is set, it reports an error immediately instead of starting the wrong robot, and joint lists are read correctly regardless of vendor.
  • Jog: The Teaching Pendant sets Jog speed in 1 % steps. The slider moves on a 1 % grid, with ±1 % buttons and a percent readout.

Fixed8

  • Docs: Each release now updates the public docs site to the same version for both the Humble and Jazzy trains. Previously the Jazzy docs stayed at 0.6.5.
  • Robot: Fixed all joint motion commands being rejected with an "IK solver" error on JP7 devices. The robot packages on the Jazzy train now install the IK solver plugin (TRAC-IK).
  • Teaching Pendant: Fixed the rosapi node exiting after the 3D panel was opened on JP7 devices, which broke the 3D robot model and robot search in Plem Lab. Install and update now patch a known rosapi defect automatically, and the patch is reapplied when rosapi is updated through apt.
  • Teaching Pendant · Plem Lab: Loading the robot model no longer queries a node that does not exist, which left Service /robot_state_publisher/get_parameters is not available in the log.
  • Robot: Removed the 'planning not supported' badge wrongly shown for Elfin robots on the settings screen. These robots do support motion planning.
  • Robot: Fixed the Elfin10-L drive dropping into a fault while releasing the brakes, which left the joints locked and collapsed into a Protective Stop. Faults left over from a previous run are now also cleared without a power cycle.
  • Robot: Corrected the Elfin10-L link masses, centers of mass, inertias and torque conversion values from vendor data, and re-tuned the control defaults. This reduces the excess gravity compensation that pushed the arm in Freedrive and the error in the on-screen torque readout; some joint modules and the Freedrive drift still await verification on hardware.
  • Docs: The docs site address now opens the docs home page directly instead of a distribution picker. Switch distributions (Humble/Jazzy) with the toggle at the top.

Removed2

  • Docs: The plem-tui package no longer ships the developer manual PDF (/opt/plem/share/doc/plem-developer-manual.pdf). The public docs site (https://www.wimcorp.co.kr/plem/) is the canonical developer documentation, and the PDF is provided only as a release artifact.
  • Robot: Removed 12 robot models not registered in the driver (icon, indyrp2, nuri, opti and indy12 families) from the selection list. Only models in the driver registry (Indy7 family, Elfin10-L) remain; previously, choosing a removed entry failed with 'Unknown robot model'.

v0.8.0​

Show 6 changes

New2

  • Gripper: The Danhae gripper package is now also installed on JP7 (Ubuntu 24.04) devices.
  • Tuning: Adds a position-domain b0 online tuning tool (for experts).

Improved2

  • Packaging: All release packages are built in isolated containers, and only artifacts that pass install verification are published.
  • Jog: When it is uncertain whether a Jog command took effect, the screen now shows that case separately.

Fixed2

  • Jog: Fixed recovery not continuing after a Jog failure on JP7 devices.
  • Robot: Fixed Freedrive commands not being delivered correctly on JP7 devices.

v0.7.1​

No user-facing changes in this version.

v0.7.0​

Show 15 changes

New1

  • Install: Python components ship with the libraries they need bundled in the package, so install and update complete even if the internet connection drops.

Improved6

  • Install: The packages now manage communication settings, real-time permissions, environment variables and camera permissions directly. Installing always sets them up, and removing cleans them up.
  • Update: A single top-level package manages the list of install targets, so plem update does not miss components.
  • Remote support: The remote support tool is always installed together with the license tool.
  • Onboarding: Install, update and removal share a lock so they never run at the same time.
  • Packaging: Package versions include the distribution name (for example 0.7.0-1jammy).
  • Docs: Redesigned the public docs site with a brand theme, screenshots and a changelog page.

Fixed7

  • Onboarding: A network drop during install no longer leaves the script half-run.
  • Install: The ROS 2 repository key is now verified on download and put in place atomically.
  • Removal: --keep-license now actually keeps the license.
  • Removal: Restoring the ROS 2 repository preserves key references used by other packages.
  • Update: Versions are shown correctly regardless of the system language setting.
  • License issuance: Fixed authentication failing because of leading or trailing spaces in the token.
  • License issuance: Passing an empty token now reports an error immediately.

Removed1

  • Update: Retired plem update --rollback. Running it now stops with guidance; recover by reinstalling.