Add documentation for KUKA Sunrise features and programs

- Created a new document for the Station interface, detailing its menu structure, process data, safety functions, frames, and smartPAD function buttons.
- Added a document for RobotPowerControl, explaining its purpose for safely shutting down or restarting the KUKA Sunrise Cabinet controller.
- Introduced ServerFriRos2 documentation, outlining its role in establishing an FRI connection between the KUKA LBR iiwa and a ROS 2 computer.
- Documented the TeachKuka application, which allows manual teaching of the KUKA LBR iiwa, including position capturing and trajectory recording.
- Added an overview of Sunrise Workbench, including installation instructions for Windows and Linux.
- Created a section on installing a Windows compatibility tool (PortProton) on Linux.
- Documented the installation process for SunriseWorkbench on Linux using PortProton.
- Added installation instructions for SunriseWorkbench on Windows.
- Created troubleshooting documentation for configuration errors and SSL errors during installation.
- Implemented a hook to generate the shared PDF only during the default-language build.
This commit is contained in:
Даниил Грабарь
2026-08-13 18:01:59 +03:00
parent 08ebd40671
commit 79d88db930
42 changed files with 2973 additions and 17 deletions
@@ -0,0 +1,85 @@
# Installing libraries
Additional libraries distributed as `.zip` archives must be installed for the SunriseWorkbench project to work fully.
!!! note "Prerequisite"
Before installing the libraries, make sure that the project has been created or loaded. See [Creating a new project](new-project.md) or [Loading an existing project](load-project.md).
## Opening the settings
In the SunriseWorkbench main menu, select **Window → Preferences**. In the window that opens, go to **Install/Update → Available Software Sites**.
![Window → Preferences menu](../assets/config/libraries/step-01.png)
## Adding library archives
Click **Add**. In the dialog, click **Archive...** and add a library `.zip` archive.
![Available Software Sites](../assets/config/libraries/step-02.png)
### Windows users
Use the standard file-selection dialog to locate and select the archive.
### Linux users
Because SunriseWorkbench runs in an emulated Windows environment, use the following procedure to access the Linux file system:
1. In the file-selection dialog, click **Look in:** and select **My Computer**.
![Adding a software source](../assets/config/libraries/step-03.png)
2. A list of mounted drives appears. It may contain more entries than the number of physical drives because of how the compatibility environment works.
![Selecting an archive](../assets/config/libraries/step-04.png)
3. Check each drive in turn. One of them contains the Linux file system (drive H in this example).
![My Computer](../assets/config/libraries/step-05.png)
4. Open the directory containing the libraries, select one of the `.zip` archives, and click **OK**.
![Drive list](../assets/config/libraries/step-06.png)
5. Confirm the selected archive by clicking **OK** in the next window.
![Linux file system](../assets/config/libraries/step-07.png)
## Adding the remaining archives
The archive appears in the **Available Software Sites** list. Repeat the procedure for every remaining library `.zip` file.
![Selecting an archive](../assets/config/libraries/step-08.png)
After adding all archives, click **OK** to save the settings.
## Installing the libraries
Select **Help → Install New Software...** from the menu. In the **Work with** field, select **All Available Sites**. Components from all added archives appear in the list.
![List of added archives](../assets/config/libraries/step-09.png)
Select every available component and click **Next**. Review the installation summary and click **Next** again.
![Help → Install New Software](../assets/config/libraries/step-10.png)
Accept the license agreements and click **Finish** to begin installation.
![Component list](../assets/config/libraries/step-11.png)
!!! warning "Installation duration"
Installing the libraries may take a significant amount of time. Do not interrupt the process.
![Selecting components](../assets/config/libraries/step-12.png)
## Restarting the application
When installation finishes, SunriseWorkbench prompts you to restart. Click **Restart Now**.
![Installation process](../assets/config/libraries/step-13.png)
After the restart, the interface switches to Russian and all installed libraries appear in `StationSetup.cat`.
![Restart prompt](../assets/config/libraries/step-14.png)
!!! tip "Next step"
If the project has not yet been configured, see [Creating a new project](new-project.md) or [Loading an existing project](load-project.md).
@@ -0,0 +1,30 @@
# Loading a project from the controller
This section explains how to import an existing project directly from the KUKA controller into SunriseWorkbench.
!!! note "Prerequisite"
Make sure that SunriseWorkbench is installed and running. See the [Windows](../sun_install/windows.md) and [Linux](../sun_install/linux/linux.md) installation guides.
## Starting the project import wizard
In the main SunriseWorkbench window, click **New Sunrise Project**.
![Main SunriseWorkbench window](../assets/config/new-project/step-01.png)
In the dialog that opens, select **Load project from controller** and enter the IP address of the KUKA Sunrise Cabinet controller.
![Controller connection dialog](../assets/config/load-config/step_01.png)
!!! info "Controller IP address"
The default controller IP address is `172.31.1.147`. If the controller has been reconfigured, enter its current address. This configuration uses `192.168.21.147`. To find the current address, see [Station configuration](../kuka/features/station.md).
Click **Next** to begin downloading the project from the controller.
![Project download process](../assets/config/load-config/step_02.png)
When the download is complete, the imported project appears in the SunriseWorkbench project tree. In this example, the project is named `SunriseProject`.
![Imported project in the workspace](../assets/config/load-config/step_03.png)
!!! tip "Next step"
All required libraries must be installed for full robot operation. See [Installing libraries](libraries.md).
@@ -3,7 +3,7 @@
В данном разделе описана процедура импорта существующего проекта непосредственно с контроллера KUKA в среду SunriseWorkbench.
!!! note "Предварительное требование"
Убедитесь, что SunriseWorkbench установлен и запущен. Инструкции по установке приведены в разделах [Windows](../install/windows.md) и [Linux](../install/linux/linux.md).
Убедитесь, что SunriseWorkbench установлен и запущен. Инструкции по установке приведены в разделах [Windows](../sun_install/windows.md) и [Linux](../sun_install/linux/linux.md).
## Запуск мастера импорта проекта
@@ -27,4 +27,4 @@
![Импортированный проект в рабочей области](../assets/config/load-config/step_03.png)
!!! tip "Следующий шаг"
Для полноценной работы с роботом необходимо установить все требуемые библиотеки. Инструкции приведены в разделе [Установка библиотек](libraries.md).
Для полноценной работы с роботом необходимо установить все требуемые библиотеки. Инструкции приведены в разделе [Установка библиотек](libraries.md).
@@ -0,0 +1,63 @@
# Creating a new project
This section explains how to create a SunriseWorkbench project and perform the initial configuration for a KUKA LBR IIWA 7.
!!! note "Prerequisite"
Before creating a project, make sure that SunriseWorkbench is installed. See the [Windows](../sun_install/windows.md) and [Linux](../sun_install/linux/linux.md) installation guides.
## Starting the new-project wizard
In the main SunriseWorkbench window, click **New Sunrise Project**.
![Main SunriseWorkbench window](../assets/config/new-project/step-01.png)
## Configuring the controller connection
Enter the IP address of the KUKA Sunrise Cabinet controller in the dialog.
![Entering the controller IP address](../assets/config/new-project/step-02.png)
!!! warning "Controller IP address"
The default controller IP address is `172.31.1.147`. If your configuration uses a different address, replace it with the current value.
## Project name
Enter the project name in the corresponding field.
![Entering the project name](../assets/config/new-project/step-03.png)
## Selecting the robot model
Select the robot model from the drop-down list. For a KUKA LBR IIWA 7, choose **LBR iiwa 7 R800**.
![Selecting the robot model](../assets/config/new-project/step-04.png)
## Selecting the flange
Select the flange type that matches your robot configuration.
![Selecting the flange](../assets/config/new-project/step-05.png)
!!! warning "Flange selection"
The flange type must exactly match the physical robot configuration. This setup uses **Medien-Flansch elektrisch**. Leave its orientation at the default value of 0°.
## Reviewing the configuration
Review all parameters in the summary window. If they are correct, click **Finish**.
![Reviewing the parameters](../assets/config/new-project/step-06.png)
## Selecting an application template
After the project is created, the template selection dialog opens. Select one of the examples and click **Finish**.
![Selecting a template](../assets/config/new-project/step-07.png)
## Main editor window
After the wizard completes successfully, SunriseWorkbench opens the new project in its main editor window.
![Main editor window](../assets/config/new-project/step-08.png)
!!! tip "Next step"
All required libraries must be installed for full robot operation. See [Installing libraries](libraries.md).
@@ -3,7 +3,7 @@
В данном разделе описан процесс создания нового проекта в SunriseWorkbench и его первоначальная конфигурация для работы с роботом KUKA LBR IIWA 7.
!!! note "Предварительное требование"
Перед созданием проекта убедитесь, что SunriseWorkbench установлен. Инструкции по установке приведены в разделах [Windows](../install/windows.md) и [Linux](../install/linux/linux.md).
Перед созданием проекта убедитесь, что SunriseWorkbench установлен. Инструкции по установке приведены в разделах [Windows](../sun_install/windows.md) и [Linux](../sun_install/linux/linux.md).
## Запуск мастера создания проекта
@@ -0,0 +1,59 @@
# Applications
The **Applications** section lets you select and control programs developed in SunriseWorkbench and deployed to the controller. Open it with the **Applications** button in the smartHMI navigation bar.
## Application list
The application selection page has two columns:
| Column | Description |
|---|---|
| Robot applications | Control programs started manually by the operator |
| Background applications | Programs that run automatically as a `backgroundTask` |
Each list entry contains:
- a **status indicator** — the colored dot to the left of the name;
- the **application name** — the Java class name;
- the **package** — namespace or category such as `[application]`, `[ros]`, or `[demo]`;
- a **checkbox** — used to select or deactivate the application.
![Applications menu](../../assets/kuka/applications/menu.jpg)
The **Reset selected robot application** button (hand icon) clears the active application selection without stopping it. Running background applications are shown with a green dot and a **Stop** button.
## Selecting and activating an application
Click an application name in the list to select it. The selected application is highlighted in orange, its checkbox is selected (✓), and its name appears in the smartHMI navigation bar. The system automatically opens the **Application control** page, which shows the current program state and execution log.
## Application states
### Activated
A gray circular indicator means that the application has been selected and loaded into the controller but has not started yet.
![Selecting an application](../../assets/kuka/applications/choose_app.jpg)
### Running
A green play indicator means that the program is running. Events defined by the developer appear in the log in real time. If the program requires operator interaction, a selection dialog appears over the log.
![State: activated](../../assets/kuka/applications/app_active.jpg)
### Motion paused
A yellow pause indicator means that execution has been interrupted. Resume the program in the same way it was started.
![State: paused](../../assets/kuka/applications/app_stoped.jpg)
### Error
A red indicator means that an unhandled exception occurred during execution. The status line displays the error code. Logic errors must be corrected in SunriseWorkbench.
![State: error](../../assets/kuka/applications/app_error.jpg)
## Deactivating an application
Open **Applications**, find the active application (orange highlight and selected checkbox), and click its checkbox to deactivate it.
![Deactivating an application](../../assets/kuka/applications/selected_app.jpg)
@@ -0,0 +1,84 @@
# Extra menu
In addition to the main functional areas under [Station](station.md), smartHMI provides additional robot control parameters through the smartPAD side panel. These panels open over the current view without navigating to another section.
## Manual control method
The **Manual method options** panel configures manual motion: the active tool, control point (TCP), base coordinate system, and motion frame.
![Manual method options](../../assets/kuka/extra-menu/move_method.jpg)
### Selecting the tool and TCP
| Parameter | Description |
|---|---|
| Tool | Active tool attached to the flange. Default: `Flange` |
| TCP | Tool control point. Default: `Flange (Root)` |
### Selecting the base
The base coordinate system relative to which manual motion is performed. Select it from the frames defined in the project, for example `P1`.
### Motion frame
Determines the coordinate system used by the A1A7 axis buttons:
| Mode | Description |
|---|---|
| Axes | Joint-by-joint control. Each button moves its corresponding axis independently. |
| World | Motion in the universal (world) coordinate system. |
| Base | Motion in the selected base coordinate system. |
| Tool | Motion in the coordinate system of the active tool (TCP). |
## Control speed
The **Speed** panel sets the percentage limit for manual motion and program execution speed.
![Speed panel](../../assets/kuka/extra-menu/speedmenu.jpg)
## Motion mode
The **Motion mode** panel controls how the **Start** button works and how the robot approaches frames.
![Motion mode](../../assets/kuka/extra-menu/viewmove.jpg)
### Application mode
| Mode | Description |
|---|---|
| Start — continuous | The Start button runs the application continuously (default). |
| Step execution | The Start button executes one program step at a time. Used for debugging. |
### Approaching a frame
| Type | Description |
|---|---|
| PTP approach | Motion along the shortest path in joint space (Point-to-Point). |
| LIN approach | Straight-line TCP motion in Cartesian space (Linear). |
The **Open frame view** button opens the Frames section.
## Clock
Clicking the clock icon displays the controller's current system time and date.
![Clock](../../assets/kuka/extra-menu/clock.jpg)
!!! note
System time is synchronized with the KUKA Sunrise Cabinet controller clock. Change it in the controller operating system settings.
## User group
The **Log on** dialog changes the active user group and the corresponding HMI access level.
![User group](../../assets/kuka/extra-menu/groupusers.jpg)
The access level determines which operations are available, including editing frames, managing Safety settings, and changing the project configuration.
## Changing the language
The **Language selection** dialog changes the smartHMI interface language.
![Changing the language](../../assets/kuka/extra-menu/changelang.jpg)
The change takes effect immediately without restarting the system. The current interface locale appears in the lower-left corner of smartHMI, for example `ru-RU`.
@@ -0,0 +1,41 @@
# IO Group menu
The **I/O groups** section provides monitoring and manual control of digital input/output signals configured in the Sunrise project. Open it from the smartHMI navigation bar.
## Available groups
Click **I/O groups** in the navigation bar to open the list of available groups. This project defines the following groups:
![I/O group list](../../assets/kuka/io-group/main.jpg)
| Group | Description |
|---|---|
| FRI | FRI (Fast Robot Interface) signal group |
| IO_group | Custom digital input/output group |
## Viewing signals
Selecting a group opens a page containing all of its signals.
![Controlling output signals](../../assets/kuka/io-group/output.jpg)
### Signal table structure
| Column | Description |
|---|---|
| Input / Output | Signal direction icon |
| Name | Signal name, such as `In_1` or `Out_16` |
| Type | Signal type; digital Boolean for this group |
| Value | Current signal state (`0` / `1`) |
## Controlling output signals
For signals whose direction is **Output**, the lower panel provides buttons that force a value:
| Button | Action |
|---|---|
| True | Set the output signal to `1` (active) |
| False | Set the output signal to `0` (inactive) |
!!! note
**Input** signals are read-only.
@@ -0,0 +1,146 @@
# Robot menu
The **Robot** section is one of the main areas of KUKA smartHMI. It provides diagnostic robot-state information, mastering functions, tool and base calibration, and load parameters.
![Robot menu](../../assets/kuka/robot-menu/step-01.jpg)
The table below lists the main menu items.
| Item | Description |
|---|---|
| Axis position | Displays the current position of each robot axis in degrees |
| Cartesian position | Displays the current tool position in Cartesian coordinates |
| Axis torques | Displays the current torque on each robot axis |
| Mastering | Provides axis mastering and tool-offset teaching functions |
| Load data | Enters or calibrates the load parameters at the flange |
| Move enable | Displays the manual-motion enable signal state |
| Log | Displays events and errors; equivalent to the item under [Station](station.md) |
| Device state | Displays the current device state with a color indicator |
| Calibration | Provides tool and base calibration functions |
## Axis position
This section displays the current angular position of each of the robot's seven axes in degrees. Values update in real time. Software limits are also shown as minimum and maximum permitted values for each axis.
![Axis position](../../assets/kuka/robot-menu/step-02.jpg)
## Cartesian position
This section displays the tool center point (TCP) position in Cartesian coordinates relative to the selected base. The following parameters are available:
- **X, Y, Z** — linear TCP coordinates in millimeters;
- **A, B, C** — orientation angles in degrees.
!!! info "Angle-axis correspondence"
**A** is rotation around Z, **B** around Y, and **C** around X, following the ZYX convention.
The current calculation context is also displayed:
- selected Tool;
- active TCP;
- selected Base.
Change these values under **Manual method options**; see [Extra menu](extra-menu.md). After selecting another tool, TCP, or base, the values on this page are recalculated accordingly.
![Cartesian position](../../assets/kuka/robot-menu/step-03.jpg)
## Axis torques
This section displays current torque on each of the seven axes in newton-meters (Nm). Values update in real time. This information lets the operator:
- monitor the load on each axis;
- diagnose possible mechanical problems;
- identify characteristic torque values for later control-program tuning.
![Axis torques](../../assets/kuka/robot-menu/step-04.jpg)
## Mastering
Mastering maps the mechanical robot position to its software model. Without correct mastering, software coordinates do not match the actual axis positions.
The main mastering menu provides functions for updating mastering data, unmastering individual axes, and teaching tool offsets.
![Main mastering menu](../../assets/kuka/robot-menu/step-05.jpg)
Use **Update mastering data** to save new mastering values after completing the procedure. The controller records the current mechanical axis positions as references.
![Updating mastering data](../../assets/kuka/robot-menu/step-06.jpg)
**Unmaster** removes mastering data from a selected axis. An unmastered axis is considered uncalibrated and may move beyond software limits.
![Unmastering an axis](../../assets/kuka/robot-menu/step-07.jpg)
!!! warning "When should an axis be unmastered?"
Unmaster an axis if it reaches a software limit and cannot continue moving. After moving it away from the limit, master it again to restore correct robot operation.
**Teach tool offset** applies a correction to an axis zero position without repeating the complete mastering procedure. Use it for small mechanical offsets.
![Teaching a tool offset](../../assets/kuka/robot-menu/step-08.jpg)
!!! warning "Important"
Select the tool whose offset will be taught before activating this function.
## Load data
Correct load parameters are required for accurate motion planning, prevention of axis overload, and proper operation of Power and Force Limiting (PFL).
The main load-data menu lists the available tool slots. Load parameters can be entered or calibrated for each tool.
![Main load-data menu](../../assets/kuka/robot-menu/step-09.jpg)
Under **Determine load data**, enter or automatically determine mass, center of mass, and inertia tensor.
![Determining load data](../../assets/kuka/robot-menu/step-10.jpg)
The **Tool mass calibration** procedure lets the controller measure the attached tool mass automatically by performing test motions. Follow the on-screen instructions.
![Tool mass calibration](../../assets/kuka/robot-menu/step-11.jpg)
When the procedure finishes, the controller displays the measured load parameters. Review them and verify that they match the actual tool characteristics.
![Calibration results](../../assets/kuka/robot-menu/step-12.jpg)
After confirmation, the controller saves and immediately applies the updated load data.
![Updated load data](../../assets/kuka/robot-menu/step-13.jpg)
## Move enable
This item displays the state of the manual-motion enable signal. The signal is activated by pressing the enable button on the manipulator body. smartHMI indicates the active state by changing the axis indicators from gray to white.
!!! note "Mode limitation"
Move enable is unavailable in **automatic mode** (AUT). The signal is active only in manual modes T1 and T2.
## Log
This section is equivalent to **Log** under [Station](station.md). It displays controller events, warnings, and errors so that the operator can review their chronology and diagnose faults.
## Device state
This section displays the current device state with a color indicator:
| Color | State |
|---|---|
| Green | The device is operating normally |
| Yellow | A warning or potential issue requires attention |
| Red | A critical error or fault has been detected |
## Calibration
The **Calibration** section contains procedures for determining the geometric parameters of tools and bases used by the controller to calculate Cartesian coordinates.
The main menu contains two categories: base calibration and tool calibration.
![Main calibration menu](../../assets/kuka/robot-menu/step-14.jpg)
**Base calibration** defines the position of a working coordinate system relative to the World coordinate system. It associates the program with the physical location of a workpiece or equipment in the robot cell.
![Base calibration](../../assets/kuka/robot-menu/step-15.jpg)
**Tool calibration** determines the TCP position and tool orientation relative to the robot flange. Several calibration methods are available for each tool.
![Tool calibration](../../assets/kuka/robot-menu/step-16.jpg)
The selected method determines the procedure. The common **XYZ 4-Point** method approaches one reference point from four different orientations.
![Selected tool calibration method](../../assets/kuka/robot-menu/step-17.jpg)
@@ -0,0 +1,168 @@
# Station
The **Station** section is the main navigation level of KUKA smartHMI. Open it by pressing **Station** in the smartPAD navigation bar. It provides access to the primary robot-cell control functions.
![Station main window](../../assets/kuka/station/main.jpg)
## Menu structure
The Station interface contains four functional areas:
| Area | Description |
|---|---|
| Navigation menu | Station, Applications, Robot menu, and IO Group menu |
| Station menu | Process data, Safety, Frames, KUKA_Sunrise_cabinet, HMI status, Information, and Log |
| Extra menu | Motion mode, clock, and user buttons |
| smartPAD function buttons | Program and motion control |
## Process data
**Process data** displays the current state of the active application, for example `Ok`. Use it to monitor parameters of the running program in real time.
## Safety
The **Safety** section provides access to robot safety-system settings and status.
![Safety](../../assets/kuka/station/safety1.jpg)
### Safety functions
| Function | Description |
|---|---|
| Status | Displays the current safety configuration state |
| Activation | Activates or deactivates the safety configuration |
### Actions on the Activation page
| Action | Description |
|---|---|
| Activate | Apply and activate the current safety configuration |
| Deactivate | Disable the active safety configuration |
| Reset | Restore the previous safety configuration state |
The **Safety configuration ID** field displays the unique identifier of the loaded configuration, for example `2BCAB6DD`.
![Safety — Activation](../../assets/kuka/station/safety2.jpg)
## Frames
The **Frames** section opens the coordinate-system editor.
![Frames overview](../../assets/kuka/station/frames.jpg)
It lists all frames defined in the Sunrise project and lets you inspect, correct, and navigate their hierarchy.
### Frame table structure
| Column | Description |
|---|---|
| Frame name | Frame name in the project |
| X, Y, Z | Axis offsets in millimeters |
| A, B, C | Orientation in degrees |
Frame data is also available in SunriseWorkbench.
### Navigation and correction
To open child frames, press **>** next to the required frame. The breadcrumb path updates automatically. Select an item in the breadcrumb to return to a previous level.
![Nested frames](../../assets/kuka/station/frames2.jpg)
Press **Correct** to open a dialog that compares current and new values. Press **Save** to confirm or **Cancel** to discard the changes.
![Correcting a frame](../../assets/kuka/station/frames3.jpg)
Frames support multiple nesting levels. The navigation bar displays the complete hierarchy path, for example `World > grant_RNF > P4`.
![Frame hierarchy](../../assets/kuka/station/frames4.jpg)
## KUKA_Sunrise_cabinet
**KUKA_Sunrise_Cabinet** displays the status of the controller hardware components.
![KUKA Sunrise Cabinet](../../assets/kuka/station/cabinet.jpg)
| Component | Description |
|---|---|
| Boot status | Controller boot status |
| Fieldbuses | EtherCAT bus status |
## HMI status
**HMI status** displays the connection state between smartHMI and the Sunrise Cabinet controller.
## Log
The **Log** section opens the system event log.
![Log](../../assets/kuka/station/protocol.jpg)
### Log filters
| Filter | Description |
|---|---|
| Source(s) | Station, LBR_iiwa_7_R800, or both |
| Level | Information, warning, or error |
| Time period | Time range to display |
Each entry contains a severity icon, event date and time, source, name, and description.
## Information
The **Information** section contains detailed system information about the controller and connected robot.
![Information](../../assets/kuka/station/info.jpg)
## smartPAD function buttons
The physical smartPAD buttons are divided into three groups: program control buttons on the left, manual axis control buttons on the right, and user buttons.
### Program control buttons
| Button | Description |
|---|---|
| Edit | Enters Teach mode and enables manual modification of program points |
| Stop | Stops program execution or robot motion |
| Backward step | Executes one program step in reverse; used for debugging |
| Start | Starts the selected application or resumes a stopped program; in T1/T2, the enabling device must be held |
!!! note
Editing from the smartPAD is not used in this project. Programs are written in Java and changed only in SunriseWorkbench.
### Axis control buttons (T1 and T2)
| Button | Description |
|---|---|
| A1 / A1 + | Move axis 1 in the negative or positive direction |
| A2 / A2 + | Move axis 2 in the negative or positive direction |
| A3 / A3 + | Move axis 3 in the negative or positive direction |
| A4 / A4 + | Move axis 4 in the negative or positive direction |
| A5 / A5 + | Move axis 5 in the negative or positive direction |
| A6 / A6 + | Move axis 6 in the negative or positive direction |
| A7 / A7 + | Move axis 7 in the negative or positive direction |
In Cartesian control mode, the same buttons move the TCP along X, Y, and Z and rotate it around A, B, and C.
### Speed control (Override)
| Button | Description |
|---|---|
| 0 | Decrease manual motion speed |
| 100 | Increase manual motion speed |
The value is displayed as a percentage of maximum speed. In T1 mode, TCP speed is hardware-limited to 250 mm/s.
### User buttons
Four white round buttons are located at the bottom of the left panel. Their behavior is programmed through the Sunrise project API. They are unassigned by default.
## Operating modes
| Mode | Description |
|---|---|
| T1 | Manual control with TCP speed limited to 250 mm/s; the enabling device must be held |
| T2 | Manual control at normal speed; the enabling device must be held |
| AUT | Automatic mode; axis buttons are unavailable and Start/Stop buttons control execution |
!!! tip "Extra menu"
See [Extra menu](extra-menu.md) for additional control parameters.
@@ -0,0 +1,45 @@
# RobotPowerControl
**RobotPowerControl** is a SunriseWorkbench background task for safely shutting down or quickly restarting the KUKA Sunrise Cabinet controller from the smartPAD. When the task starts, a **System** panel appears on the smartPAD with two user buttons: **REBOOT** and **SHUTDOWN**.
This is particularly useful when the controller battery is faulty, because pressing the physical power button may cause an abrupt shutdown. The task lets you shut down the controller correctly or restart it without going to the control cabinet.
!!! warning "Before shutdown or restart"
Stop robot motion and make sure that the operation is safe for the entire robot cell. These buttons control power to the **controller**. After confirmation, the robot connection and running applications are interrupted.
## Source code
The Java task class is located at [`src/iiwa_sunrise/src/RobotPowerControl.java`](https://github.com/Daniel-Robotic/lightweight-cobot/blob/dev/src/iiwa_sunrise/src/RobotPowerControl.java). Open or download it from this link to add it to a Sunrise project.
The shutdown and restart scripts are already installed on the controller. The task calls them through `cmd.exe` at `D:\Programme\reboot.cmd` and `D:\Programme\shutdown.cmd`.
## Starting the task
`RobotPowerControl` runs as a background application (`backgroundTask`). See [smartHMI Applications](../features/applications.md) for details.
![RobotPowerControl in the background application list](../../assets/programms/power_control/apps.png)
The screenshot shows `RobotPowerControl` in the **Background applications** list with a green status indicator.
## Using the smartPAD buttons
| Button | Action |
|---|---|
| **REBOOT** | Runs `reboot.cmd` and restarts the controller |
| **SHUTDOWN** | Runs `shutdown.cmd` and safely shuts down the controller |
Open the user buttons from the smartPAD side menu. See [smartPAD function buttons](../features/station.md#smartpad-function-buttons) for details. The **System** panel contains the **REBOOT** and **SHUTDOWN** buttons.
![System panel with power controls](../../assets/programms/power_control/choose.png)
Each button requires confirmation to prevent accidental activation:
1. Press **REBOOT** or **SHUTDOWN**. smartHMI displays a warning about the critical operation.
2. Press the button again in the confirmation dialog only if you intend to perform the selected action.
3. The corresponding script starts. The button indicator briefly turns yellow. If the script cannot be started, it turns red for two seconds and then returns to gray.
![Confirming a critical operation](../../assets/programms/power_control/use-btn.png)
The image shows the dialog displayed after the first press. Press the button again to start the operation.
The task hands the script to the operating system and does not wait for it to finish. The controller begins shutdown or restart independently. If the indicator turns red, ask the controller administrator to check the system scripts.
@@ -0,0 +1,180 @@
# ServerFriRos2
**ServerFriRos2** is a KUKA Sunrise Cabinet controller program that creates an FRI connection between the KUKA LBR iiwa and a ROS 2 computer. Through this connection, `ros2_control` receives the current robot state and, depending on the selected mode, sends motion commands to the controller.
The program connects the two parts of the system: the KUKA controller application and the ROS 2 control node on the external computer. A physical robot cannot be controlled through ROS 2 unless `ServerFriRos2` is running.
The program has been tested on a KUKA LBR iiwa 7 R800 with Sunrise OS 1.16 and FRI 1.16. The source code is located at [`src/iiwa_sunrise/src/ServerFriRos2.java`](https://github.com/Daniel-Robotic/lightweight-cobot/blob/dev/src/iiwa_sunrise/src/ServerFriRos2.java).
See [FRI protocol](../../../getting-started/concepts/fri-protocol.md) for an overview of the communication channel and [SunriseWorkbench setup](../../../getting-started/sunrise-setup.md) for cabling and Sunrise project preparation.
!!! warning "Before starting"
Verify that the configured initial positions are safe for the installed tool and robot cell. Keep the workspace clear during automatic motion. Impedance and manual-guidance modes do not replace standard KUKA safety functions.
## Required configuration
Before synchronizing the project with the controller, open `ServerFriRos2.java` in Sunrise Workbench and check the parameters for your setup.
### Network addresses
The Java class contains addresses of the **ROS 2 computer** as seen through each controller interface:
```java
private static final String KONI_IP = "192.170.10.10";
private static final String KLI_IP = "192.168.21.31";
```
Do not confuse these with `robot.ip` in `cobot-setting.yaml`. That parameter is the address of the **KUKA controller** accessed by the ROS 2 computer. See [System configuration](../../../getting-started/configuration.md) for details.
### Tool and load data
The program attaches the tool named in the `@Named` annotation to the flange:
```java
@Named("tool1")
private Tool _tool;
```
Replace `tool1` with the tool name from **Sunrise Workbench → Object Templates**. In Monitor mode, **Load Data** must contain the mass, center of mass, and inertia tensor. Before enabling gravity compensation, the program checks these parameters and warns the operator if the load model is invalid.
See [Load data](../features/robot-menu.md#load-data) for calibration and verification instructions.
### Initial positions
Before FRI starts, the robot automatically moves to one of the configured joint positions:
```java
private static final double[] ZERO_POSITION =
{0, 0, 0, 0, 0, 0, 0};
private static final double[] MONITOR_WORKING_POSITION =
{0, 0, 0, -1.57, 0, 1.57, 0};
```
`ZERO_POSITION` is used in Position and JointImpedance modes. In Monitor mode, the robot first passes through the zero position and then moves to `MONITOR_WORKING_POSITION`. If necessary, change these arrays to prevent collisions with fixtures, the table, or the installed tool.
### FRI period
For Position and JointImpedance, the value selected on the smartPAD must match `robot.fri_cycle_ms` in `cobot-setting.yaml`:
| Selected period | Update rate | When to use it |
|---|---:|---|
| 10 ms | 100 Hz | Standard and most stable option; required for KLI |
| 5 ms | 200 Hz | Higher-rate control through the dedicated KONI interface |
Monitor uses a fixed 2 ms period and does not display a separate period-selection dialog.
## Starting the application
Open [Applications](../features/applications.md) on the smartPAD, find `ServerFriRos2` in the robot application list, and activate it. The program then appears in the top smartHMI bar.
![Selecting ServerFriRos2 in the application list](../../assets/programms/server_fri_ros2/apps.png)
Press the green **Start** button on the smartPAD. The program prompts you to select a network interface, control mode, and any additional FRI parameters required by that mode.
## Step 1: selecting the network interface
The first dialog displays the configured ROS 2 computer addresses. Select the interface to which the control computer is physically connected.
![Selecting the FRI network interface](../../assets/programms/server_fri_ros2/chose-interface.png)
| Interface | Characteristics | Available modes | Period |
|---|---|---|---|
| **KONI (X66)** | Dedicated FRI network; recommended | Position, JointImpedance, Monitor | 5 or 10 ms; Monitor: 2 ms |
| **KLI (X6)** | Shared control network; fallback option | Position, JointImpedance | 10 ms only |
KONI is better suited to real-time control because its dedicated channel provides lower latency and a more stable cycle. Use KLI when KONI is unavailable. Monitor mode is disabled over KLI because of shared-network latency.
## Step 2: selecting the control mode
Available buttons depend on the selected network interface.
Over KLI, only Position and JointImpedance are available:
![Selecting the control mode over KLI](../../assets/programms/server_fri_ros2/chose-interface-kli.png)
Over KONI, Monitor is also available:
![Selecting the control mode over KONI](../../assets/programms/server_fri_ros2/koni-choose-mode.png)
### Position
Position is the primary mode for ordinary ROS 2 control, including MoveIt trajectory execution. The controller follows position commands precisely; joint stiffness cannot be adjusted in this mode.
After the parameters are selected, the robot moves to `ZERO_POSITION`, creates an FRI session in `POSITION` command mode, and waits for the ROS 2 client.
![Waiting for the ROS 2 client in Position mode](../../assets/programms/server_fri_ros2/pose-start.png)
### JointImpedance
JointImpedance also receives position commands from ROS 2, but executes them with configured joint stiffness. Use this mode to control mechanical impedance while following a target trajectory.
After selecting the mode, the program asks for one stiffness value for all seven joints:
![Selecting joint stiffness](../../assets/programms/server_fri_ros2/koni-choose-jointImpedance-stiffnes.png)
| Stiffness | Robot behavior |
|---:|---|
| 1500 Nm/rad | Stiffest command tracking among the available options |
| 1000 Nm/rad | High joint stiffness |
| 800 Nm/rad | Medium joint stiffness |
| 500 Nm/rad | Softest behavior among the available options |
The program sets damping to 0.7 for every joint. After configuration, the robot moves to `ZERO_POSITION` and waits for an FRI client as in Position mode.
![Waiting for the ROS 2 client in JointImpedance mode](../../assets/programms/server_fri_ros2/jointmpedance-start.png)
### Monitor
Monitor is intended for manual guidance while transmitting the current robot state to ROS 2. The computer sends no motion commands: the FRI session uses `NO_COMMAND_MODE`, and the controller transmits joint positions and torques every 2 ms.
Before connecting, the robot moves through `ZERO_POSITION` to `MONITOR_WORKING_POSITION`. The program then checks the tool Load Data and enables joint impedance with zero stiffness and damping of 0.7. Gravity compensation allows the robot to be guided carefully by hand.
Start the ROS 2 node on the computer before confirming the dialog. Press **OK — ROS2 ready** only after `ros2_control_node` is active.
![Starting the ROS 2 client for Monitor mode](../../assets/programms/server_fri_ros2/monitor-start.png)
!!! danger "Monitor and the load model"
Do not enable manual guidance with invalid tool parameters. Incorrect mass, center of mass, or inertia makes gravity compensation inaccurate: the robot may resist the operator or drift unexpectedly.
## Step 3: selecting the send period
For Position or JointImpedance over KONI, the program offers a 10 or 5 ms period. Over KLI, this step is skipped because the period is fixed at 10 ms.
![Selecting the FRI send period](../../assets/programms/server_fri_ros2/koni-choose-pose-and-jointImpedance-time.png)
Start with 10 ms unless the task requires a higher control rate. Use 5 ms over KONI only for tasks that need a 200 Hz cycle.
## Connecting ROS 2
Start the physical-robot stack on the ROS 2 computer:
```bash
cobot run
```
Select the physical robot when prompted. The command starts `ros2_control_node`, the FRI hardware interface, controllers, MoveIt, and configured additional services. See [cobot CLI commands](../../../getting-started/cli-reference.md) and [Control via ROS 2](../../../getting-started/control/ros2-control.md).
For the most reliable startup, run `cobot run` on the computer first and then start `ServerFriRos2` on the smartPAD. If the KUKA application is already waiting for a client, ROS 2 must start within 30 seconds. After the timeout, the program closes the FRI session and reports an error in the log.
After connection, the smartHMI log displays:
- FRI session state;
- connection quality;
- `latency`;
- packet delivery time variation (`jitter`).
When the FRI client stops, the session closes, the active mode ends, and connection resources are released. Start the smartPAD application again for a new connection.
## If the connection cannot be established
Check the following first:
1. The selected interface is the one connected to the ROS 2 computer.
2. `KONI_IP` or `KLI_IP` matches the computer address on the selected network.
3. `cobot-setting.yaml` contains the KUKA controller address, not the computer address.
4. The 5/10 ms period in the Java program matches `robot.fri_cycle_ms`.
5. `ros2_control_node` starts before the 30-second timeout expires.
6. FRI UDP port `30200` is configured and not blocked by a firewall.
If the application cannot start because the tool or frame configuration was lost, see [Configuration error](../../../troubleshooting/config-error.md).
@@ -0,0 +1,114 @@
# TeachKuka
**TeachKuka** is a SunriseWorkbench application for manually teaching the KUKA LBR iiwa. Without writing a trajectory in code, an operator can guide the robot by hand, save a position, and record and replay a motion sequence.
The program uses gravity compensation. When enabled, the robot is easy to guide by hand and holds the position set by the operator. This is useful for quickly teaching simple operations, checking the workspace, and preparing repeatable motions.
The source code is located at [`src/iiwa_sunrise/src/TeachKuka.java`](https://github.com/Daniel-Robotic/lightweight-cobot/blob/dev/src/iiwa_sunrise/src/TeachKuka.java). Open or download the file to add it to a Sunrise project.
!!! warning "Safety"
Before starting, make sure that the workspace is clear and that the robot is not executing another motion. Continuously monitor the robot during trajectory playback. Do not run the program near people or objects if motion could cause injury or equipment damage.
## Tool configuration
The program attaches a tool to the robot flange through this annotation:
=== "java"
```java
@Named("tool1")
private Tool _gripper;
```
Replace `tool1` with the name of your tool.
Check the tool and its parameters in Sunrise Workbench:
1. Open the robot project.
2. Go to **Object Templates**.
3. Find the tool installed on the robot.
4. Check its name and **Load data**.
5. Replace `tool1` in the `TeachKuka` class's `@Named(...)` annotation with this name.
6. Verify that mass, center of gravity, and inertia match the physical gripper.
!!! warning "Correct load model"
The program may start with incorrect load data, but gravity compensation will be inaccurate. The robot may feel too heavy, drift unexpectedly, or fail to hold its position. Calibrate the tool mass and center of gravity to avoid equipment damage.
## Starting the program and main menu
When `TeachKuka` starts, the robot first moves to **Home**. Before entering any operating mode, it passes through Home and moves to the configured working position. The tool named in `@Named(...)` is attached to the robot flange first.
Find and start the program under [Applications](../features/applications.md) on the smartPAD. That section also describes application states and activation.
![Selecting TeachKuka under Applications](../../assets/programms/teach_kuka/apps.png)
smartHMI displays the **Select operating mode** menu:
| Menu item | Purpose |
|---|---|
| **Mode 1: Position** | Guide the robot by hand and read the selected position coordinates |
| **Mode 2: Trajectory** | Record, play, and repeat a motion trajectory |
| **Exit** | End the program and return the robot to Home |
In **Position** mode, the robot can be moved by hand. In **Trajectory** mode, the program records the robot motion for later playback. **Exit** ends the program and returns the robot to Home.
![Selecting the TeachKuka operating mode](../../assets/programms/teach_kuka/choose-mode.png)
## Mode 1: capturing a position
After selecting the mode, the program moves to the working position, checks the load model, and enables gravity compensation. You can now guide the robot by hand; it follows the operator and remains at the selected position.
The following actions are available:
| Action | Result |
|---|---|
| **Get position** | Writes flange `X/Y/Z` in millimeters, `A/B/C` orientation in degrees, and joint positions in degrees and radians to the log |
| **Back** | Disables gravity compensation, stops motion, and engages the brake |
The **Get position** button writes the Cartesian robot pose (`X/Y/Z`, `A/B/C`) and joint positions to the log. **Back** returns to the previous step and moves the robot to `(0, 0, 0, -1.57, 0, 1.57, 0)`.
![Manual motion mode](../../assets/programms/teach_kuka/move-mode.png)
The following video demonstrates manual guidance in this mode:
<video controls autoplay muted loop playsinline width="50%">
<source src="../../../../../sunrise/assets/programms/video/HandMode.mp4" type="video/mp4">
Your browser does not support video playback.
</video>
## Mode 2: recording and playing a trajectory
When this mode starts, the program clears the previous recording, enables gravity compensation, and begins saving current joint positions. A new point is recorded every 100 ms.
Recording is limited to 3,000 points, or about five minutes of motion. When the limit is reached, the program stops recording and writes a message to the log.
### Mode actions
| Action | Result |
|---|---|
| **Replay trajectory** | Stops recording, moves the robot to the initial point, and plays the saved trajectory; a new recording starts afterward |
| **Restart** | Deletes the current trajectory and immediately starts a new recording |
| **Back** | Stops recording and gravity compensation and exits the mode |
After guiding the robot along the required path, select **Replay trajectory**. The program moves the robot to `(0, 0, 0, -1.57, 0, 1.57, 0)` and then replays the recorded motion. If an error occurred during teaching, press **Restart** to discard the recording and begin again. **Back** returns to the previous menu and moves the robot to the working position.
![Trajectory recording mode](../../assets/programms/teach_kuka/traj-mode.png)
### Playback
Before playback, the program pauses for two seconds so that the operator can move away. It then moves to the first recorded point and replays the motion through SmartServo at 20% relative speed.
During playback, the program monitors external joint torques. If torque on any joint exceeds 6 Nm, the robot holds its current position and pauses the trajectory. Playback continues from the paused point after the path is cleared.
!!! note "Obstacle detection limitation"
External-torque monitoring can stop a trajectory when unexpected resistance occurs, but it does not replace standard KUKA safety functions. The operator must continuously monitor the workspace.
The following video demonstrates trajectory recording and playback:
<video controls autoplay muted loop playsinline width="50%">
<source src="../../../../../sunrise/assets/programms/video/TeachMode.mp4" type="video/mp4">
Your browser does not support video playback.
</video>
## Finishing operation
When the main menu is closed, the program stops active recording and gravity-compensation threads, cancels the active motion, returns the robot to **Home**, and then exits.
+12
View File
@@ -0,0 +1,12 @@
# Sunrise Workbench overview
Programming the KUKA LBR IIWA 7 requires **SunriseWorkbench**, an Eclipse-based integrated development environment for writing, debugging, and deploying control programs to the KUKA Sunrise Cabinet controller.
!!! info "About the installer"
The SunriseWorkbench distribution is not publicly available.
Contact your system administrator to obtain the installer and confirm its location.
This guide explains how to install SunriseWorkbench on the following operating systems:
- [Windows](sun_install/windows.md)
- [Linux](sun_install/linux/linux.md)
@@ -0,0 +1,73 @@
# Installing a Windows compatibility tool
Windows applications can be run on Linux with **PortProton**, installed from the **Flathub** repository using the **Flatpak** package manager.
## Installing Flatpak
On Ubuntu 18.10 or later, run:
=== "Bash"
```bash
sudo apt update && sudo apt upgrade -y
sudo apt install flatpak
```
## Installing the GNOME Software plugin
To add Flatpak support to GNOME Software:
=== "Bash"
```bash
sudo apt install gnome-software-plugin-flatpak
```
## Adding the Flathub repository
=== "Bash"
```bash
flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo
```
!!! warning "Restart required"
Restart the system after adding the repository so that the changes take effect.
## Installing PortProton
PortProton can be installed either from the terminal or through GNOME Software.
**From the terminal:**
=== "Bash"
```bash
flatpak install flathub ru.linux_gaming.PortProton
```
Start it with:
=== "Bash"
```bash
flatpak run ru.linux_gaming.PortProton
```
**From GNOME Software:**
After Flathub has been added, PortProton is also available in GNOME Software.
![Installing Flatpak](../../assets/sun_install/linux/emulator/step-01.png)
## Initial setup
On first launch, PortProton automatically installs the required Wine dependencies and helper components. This process takes several minutes.
![Adding the Flathub repository](../../assets/sun_install/linux/emulator/step-02.png)
After initialization, the application's main functions become available, including:
- **Wine settings** — manage the Wine environment;
- **Windows command prompt** — run `cmd.exe` inside Wine;
- **File manager** — access the virtual Windows file system.
![PortProton interface](../../assets/sun_install/linux/emulator/step-03.png)
!!! tip "Next step"
After installing PortProton, proceed to [Installing SunriseWorkbench](workbench.md).
@@ -0,0 +1,11 @@
# Installation on Linux
SunriseWorkbench is compatible only with Windows. On Linux, install a compatibility tool that can run Windows applications.
Several popular solutions are available:
- **PortProton**
- **ProtonPlus**
- **Bottles**
The [Windows emulator installation](emulator.md) section explains how to install each of these tools.
@@ -0,0 +1,57 @@
# Installing SunriseWorkbench
This section explains how to install SunriseWorkbench on Linux using PortProton.
!!! note "Prerequisite"
Before starting, make sure that PortProton is installed and configured. See [Installing a Windows compatibility tool](emulator.md).
## Starting the installer
**Step 1.** Open the directory containing the SunriseWorkbench installer. Right-click the `.exe` file and select **Open with → PortProton**. Leave the default settings in the dialog and click **Run**.
![Starting the installer with PortProton](../../assets/sun_install/linux/workbench/step-01.png)
## Installation process
**Step 2.** Select the installation language (English by default) and click **OK**.
![Selecting the language](../../assets/sun_install/linux/workbench/step-02.png)
**Step 3.** Click **Next** in the installation wizard's welcome window.
![Welcome window](../../assets/sun_install/linux/workbench/step-03.png)
**Step 4.** Review the license agreement and accept its terms.
![License agreement](../../assets/sun_install/linux/workbench/step-04.png)
**Step 5.** Keep the default installation path unless you have a specific reason to change it.
![Installation path](../../assets/sun_install/linux/workbench/step-05.png)
**Step 6.** Select **Desktop** to create a SunriseWorkbench desktop shortcut.
![Desktop shortcut](../../assets/sun_install/linux/workbench/step-06.png)
**Step 7.** Click **Install** and wait until all required components have been installed.
![Installation process](../../assets/sun_install/linux/workbench/step-07.png)
Click **Create shortcut** to place the shortcut on the desktop.
## First launch
**Step 8.** Start SunriseWorkbench from the desktop shortcut. Click **Run** so that PortProton can initialize the application environment.
![Selecting a workspace](../../assets/sun_install/linux/workbench/step-08.png)
**Step 9.** The application asks for a workspace path. Keep the default value and select **Use this as the default and do not ask again**.
![Main SunriseWorkbench window](../../assets/sun_install/linux/workbench/step-09.png)
**Step 10.** After the main window loads, click **New Sunrise Project**.
![Creating a new project](../../assets/sun_install/linux/workbench/step-10.png)
!!! tip "Further configuration"
See [Creating a new project](../../config/new-project.md) for project configuration instructions. You should also [install the required libraries](../../config/libraries.md).
@@ -0,0 +1,42 @@
# Installation on Windows
This section explains how to install SunriseWorkbench on Windows.
## Installing SunriseWorkbench
**Step 1.** Start the SunriseWorkbench installer. Select the installation language (English by default) and click **OK**.
![Selecting the language](../assets/sun_install/windows/step-01.png)
**Step 2.** Click **Next** in the installation wizard's welcome window.
![Welcome window](../assets/sun_install/windows/step-02.png)
**Step 3.** Review the license agreement and accept its terms.
![License agreement](../assets/sun_install/windows/step-03.png)
**Step 4.** Keep the default installation path unless you have a specific reason to change it.
![Installation path](../assets/sun_install/windows/step-04.png)
**Step 5.** Select **Create Desktop Shortcut** for convenient access.
![Desktop shortcut](../assets/sun_install/windows/step-05.png)
**Step 6.** Click **Install** and wait until all required components have been installed.
![Installation process](../assets/sun_install/windows/step-06.png)
## First launch
**Step 7.** On first launch, the application asks for a workspace path. Keep the default path and select **Use this as the default and do not ask again**.
![Selecting a workspace](../assets/sun_install/windows/step-07.png)
**Step 8.** After the main window loads, click **New Sunrise Project** to create a project.
![Main SunriseWorkbench window](../assets/sun_install/windows/step-08.png)
!!! tip "Further configuration"
See [Creating a new project](../config/new-project.md) for project configuration instructions. You should also [install the required libraries](../config/libraries.md).