I am getting this error in the motion app, any idea why this comes and how to fix it?

I found the diagnostics but i dont understand could anyone please explain?

https://docs.automation.boschrexroth.com/doc/2914906033/090f0060-error-when-filtering-the-actual-values/latest/en/

Thank you

Step 2:

Step 3:

The axis done appear, but it says i have added it.

I am using the below, firmware in the drive,

I am not able to understand if i am doing something wrong

Could you please help me?

I am currently working on an interoperability test between a Siemens MTP1200 Unified Comfort Panel and a Rexroth ctrlX CORE X3C using OPC UA.

Has anyone successfully established a secure OPC UA connection (Sign & Encrypt) between these two devices?

Or does anyone know a suitable contact person at Siemens or Rexroth who has experience with this particular combination?

Important: This is a Unified Comfort Panel, not a classic Comfort Panel. The certificate handling and commissioning process differ significantly from the older Comfort Panel concepts.

Test Setup

OPC UA Client

• Siemens MTP1200 Unified Comfort Panel

• TIA Portal V20

OPC UA Server

• Rexroth ctrlX CORE X3C

Current Status

Communication without encryption

OPC UA communication works perfectly when security is disabled (Security Policy = None).

• Read access works

• Write access works

• Connection is stable

Engineering communication

Communication between TIA Portal and the ctrlX CORE also works with encryption enabled, provided that the TIA certificate is imported and marked as Trusted on the ctrlX side.

This indicates that the certificate and trust infrastructure of the ctrlX system is generally working.

Security Test Performed

The latest test was carried out together with Siemens Support.

The following certificates were created using the TIA Portal Certificate Manager:

• Client certificate for the Unified Panel

• CA certificate for the controller

The client name was configured using the MAC address of the panel.

Unlike previous attempts, an actual certificate exchange could be observed:

1. The Unified Panel sends its client certificate to the ctrlX CORE.

2. The certificate is accepted and marked as Trusted on the ctrlX side.

3. The ctrlX CORE sends its server certificate to the panel.

4. The server certificate is accepted and marked as Trusted on the panel.

5. The panel then sends its client certificate again.

6. The secure connection is still not established.

According to Siemens Support, the client certificate of the Unified Panel is rejected by the controller at this stage.

Observed Behavior

The behavior looks very similar to a classic trust loop:

• Panel sends certificate

• Controller trusts certificate

• Controller sends certificate

• Panel trusts certificate

• Panel sends certificate again

• Controller rejects it again

As a result, the secure OPC UA session is never established.

Questions

Has anyone experienced a similar behavior with:

• Siemens Unified Panels acting as OPC UA Client

• Rexroth ctrlX CORE acting as OPC UA Server

• Certificates generated with the Siemens Certificate Manager

• CA-based trust configuration

Any experience, hints, or ideas regarding the root cause of such a trust loop would be greatly appreciated.

Thank you in advance for any feedback.

Is it possible to configure the CtrlX Core in a way that it uses a generic WiFi profile for any WiFi adapter showing up in the network interfaces? If so, how to achive that?

The goal is to have a reduced installation process and an easier trouble-shooting.

I am new to the whole system and this is my first post. Let me know if you need any more input. My system shows: core20 20230622, Runtime environment based on Ubuntu 20.04

Prerequisite:
ctrlX CORE X5/X7 with following apps:

• ROKIT Navigator Client V2.0

• ROKIT Locator Client V2.0

• ROKIT Locator Server V2.0 (only for one AGV application)

• ctrlX OS - Motion V3.6

• ctrlX OS - PLC V3.6

• ctrlX OS - Container Engine V3.6

• ctrlX OS - Node-Red V3.6
  
  You will find them either under the ctrlX OS apps or under this link.
  
  System Architecture

The diagram above illustrates the interaction between ROKIT Locator, ROKIT Navigator, the PLC and the Motion App. Here is an explanation of the interaction between these apps:

• Localization & Path Planning: The ROKIT Locator processes the incoming scans to determine the exact pose (x, y and yaw). It provides the pose and the current map of the ROKIT Navigator. The ROKIT Navigator receives VDA5050 commands from the MQTT Dashboard and implements control loops for motion control using information from the ROKIT Locator. It sends these motion commands to the PLC.

• Machine Logic: After the Navigator sends the movement commands to the PLC, the PLC handles low-level machine logic, translates the commands into axis profiles and communicates with the Motion app.

  • Dashboarding: The Navigator publishes system status and operational data via MQTT, which can be visualized in Node-RED or fleet management systems. Using this dashboard, users can send commands via VDA 5050 protocol to the ROKIT Navigator.

Starting the PLC projects and configuring the motion app

Running the robot requires some kind of logic in which vehicle physics, SafeMotion, etc. are defined. This is mostly done in the form of a PLC program. After starting the PLC program, you should also be able to see in ctrlX OS that the PLC is running.

Here is a screenshot of the common axis configuration for different drives in the motion app. The axes will be commanded by the PLC project through the axis interface.

Configuration of the ROKIT Locator and Navigator

When signing in to any of the three ROKIT modules (ROKIT Navigator Client, ROKIT Locator Client, and ROKIT Locator Server), you will be prompted to sign in with a username and password. The default username is "admin"; the default password is "bbZGs3wFsB35" and can later be changed in the settings.

First, you can log in to the ROKIT Locator Server and add a new vehicle in Home > Fleet Manager. Every setting for the ROKIT Locator can be configured from the ROKIT Locator Server settings page.

Now you can configure the sensor connection under Sensor Settings. Depending on your laser scanner, you can select the correct laser type and enter the address of the laser scanner. If you want to use two laser scanners for localization, you need to activate the “Enable Localization on Laser 2” button.

Now you need to add the transformation parameters for localization laser 1 (and laser 2) during the calibration.

After the laser scanner and the frame are configured, you can start to recording a map on the Home > Quick Start page. You can then move around the environment unit the map is fully covered and visible in the ROKIT Locator interface. It is recommended to move around the map at least twice times from different directions.

You can edit and align the recorded map under Home > Maps > Sketches. Afterwards, you can use the edited sketch and assign it to the vehicle.

Now you can open the Live View and start the localization for this vehicle. (Home > Live View > Client List).

You can localize the vehicle by performing self-localization, or by driving the vehicle around (e.g., via Foxglove). After a while, the ROKIT Locator will be able to calculate its current position. Once the vehicle has been localized, you can start configuring the ROKIT Navigator Client.

All the settings for the ROKIT Navigator Client can be configured from the Home > Configuration page of the ROKIT Navigator Client.

The following configuration is an example a basic example configuration for ROKIT Navigator. Optimization and customization for your specific application may be required.

In the Client Motion section, you can set up the interface between the ROKIT Navigator and the vehicle controller (in this case, the PLC).

In the Client Sensor section, you can configure the connection to the laser scanner (through the ROKIT Locator) for e.g. obstacle avoidance.

In the Client Order and Client Application section, you can configure the interface to the Fleet Manager or to the Node-RED dashboard. Please be aware that the IP address of your MQTT server may be different from that shown in screenshot.

The ClientOrder.vda5050.mqtt.interface, ClientOrder.vda5050.mqtt.versionOverwrite, ClientApplication.manufacturer, and ClientApplication.serialNumber parameter determine your MQTT topic for the interface to the Node-RED dashboard/ Fleet Manager.

After configurating the ROKIT Navigator client, you can save it and configure the Node-RED dashboard (see this link) or your Fleet Manager. Finally, you can start Automatic Mode on the Navigator Client and send commands from Node-RED dashboard.

Related Links:

• Regarding configuration tuning, you might also want to take a look at this HowTo.

• ROKIT Dashboard with Node-RED for ctrlX AUTOMATION

• ctrlX OS Store

  • ctrlX OS – Navigator​

  • ctrlX OS – Locator​

  • ctrlX OS - Motion

  • ctrlX OS - PLC

  • ctrlX PLC Engineering

  • ctrlX OS - Container Engine

  • ctrlX OS - Node-RED

We have 40 axes that have STO via fieldbus and we have just one SAFEXC.12,

If we use one SAFEX in the IO Engineering we see that there are just 32 FSoE connections so if we want to handle 40 axes we should use two SAFEX,

Also we have seen that the SAFEXC.15 has also the same limitation

The question is, is this a hardware or a software limitation? Is there a way or is it planned in the future to have more FSoE connections?

Thank you,

I'm trying to connect an asynchronous motor with an external encoder to a drive to set it up in a closed-loop system.

The drive is an XCS2-W0023ARN-02ADLM5 (R9114509431) with FWA-XD1-AXS-V-0612N-NN-00 firmware , the motor is a TECHTOP T1A712-4 asynchronous motor, and the encoder is a SICK DFS60B-BDAK04096.

If I connect the motor in open-loop mode (without the encoder), it works perfectly, but when I connect the encoder and switch to closed-loop mode, I get a “disturbed signal” error. I've checked the continuity and the cable connections, and everything shows proper continuity.

Backup Parameters are in the Zip File

Thanks,

In most cases when it faults the result is the following:

However I have seen the following on occasion:

Why is the fault only properly generated in certain circumstances? What is the proper way to manage the attempt to jog in quick succession?

LabJack devices are accessed using the native LabJack LJM library. Python applications use the labjack-ljm Python wrapper to communicate with this library.

On ctrlX CORE, the native library, Python application and required configuration files must be packaged inside a snap.

Here is the simpler way to install LabJack LJM library in ctrlX OS to communicate with the LabJack T7 device.

Prerequisites

Hardware

• ctrlX CORE X3/X5/X7

• LabJack T7

• Engineering PC

• Ethernet Cables

• Signal source for testing AIN0 and AIN1 on LabJack T7

Software

• ctrlX OS v3.6

• ctrlX WORKS v3.6

• App Build Enviornment

• Snapcraft

• LabJack LJM 1.23.4 Linux x64 Package

• Python 3.10

Network configuration

The ctrlX CORE and LabJack T7 must be reachable on the same network. For example -

• ctrlX CORE - 192.168.1.1

• LabJack T7 - 192.168.1.9

Step 1: Create the project structure

• Download the LabJack LJM installer for Linux x64 (same as our app build environment) from this external link -- https://support.labjack.com/docs/ljm-software-installer-downloads-t4-t7-t8-digit

• After download, extract the zip file and place the installer file under the folder named 'driver'

• Create the project structure as shown in the image

Step 2: Create the python script

Create the python script with the name 'main.py' and place it at the root location of the project folder.

This python script acts as a wrapper for the LJM library. It tries to establish the connection with LabJack T7, get the device info and reads both analog input channels every 500 milliseconds.

import time 
from datetime import datetime 
from labjack import ljm 

DEVICE_IP = "192.168.1.9" 
CHANNEL_NAMES = ["AIN0", "AIN1"] 
READ_INTERVAL = 0.5 
TEST_DURATION = 5 


def main(): 
    handle = None 
    
    try: # Open T7 over Ethernet using fixed IP 
        print(f"Trying to connect to T7 at {DEVICE_IP} ...", flush=True) 
        handle = ljm.open(ljm.constants.dtT7, ljm.constants.ctETHERNET, DEVICE_IP) 
        
        print(f"Opened the handle", flush=True) # Get and print device info 
        
        dev_type, conn_type, serial, ip_int, port, max_bytes = ljm.getHandleInfo(handle) 
        print(" Connected to LabJack T7") 
        print(f" Device Type : {dev_type}") 
        print(f" Connection Type : {conn_type}") 
        print(f" Serial Number : {serial}") 
        print(f" IP Address : {ljm.numberToIP(ip_int)}") 
        print(f" Port : {port}") 
        print(f" Max Bytes / MB : {max_bytes}", flush=True) 
        print("\nStarting simple reads (no stream, no file)...", flush=True) 
        
        start_time = time.time() read_count = 0 
        while time.time() - start_time < TEST_DURATION: # Read all requested channels in one call 
            values = ljm.eReadNames(handle, len(CHANNEL_NAMES), CHANNEL_NAMES) 
            read_count += 1 
            ts = datetime.now().strftime("%H:%M:%S.%f")[:-3] 
            line = f"[{ts}] Read #{read_count}: " + ", ".join( f"{name} = {val:.5f} V" for name, val in zip(CHANNEL_NAMES, values) ) 
            print(line) 
            
            time.sleep(READ_INTERVAL) 
            
        print(f"\nFinished test. Total reads: {read_count}", flush=True) 
    
    except ljm.LJMError as e: 
        print(" LJM Library Error:", e, flush=True) 
        
    except Exception as e: 
        print(" Unexpected Error:", e, flush=True) 
        
    finally: 
        if handle is not None: 
            try: 
                ljm.close(handle) 
                print("Closed T7 handle.", flush=True) 
                
            except Exception: 
                print("Got an expection while closing handle", flush=True) 
                
                
if __name__ == "__main__": 
    main()

Step 3: Create snapcraft YAML file

Create the snapcraft.yaml and place it under the 'snap' folder

name: ctrlx-labjack-ljm
base: core22
version: '1.2'
summary: LabJack LJM driver for ctrlX CORE 
description: LabJack LJM runtime (C library) packaged for ctrlX CORE. GUI tools are stripped.
grade: stable
confinement: strict

architectures:
  - build-on: [amd64, arm64]
    build-for: [amd64]
  - build-on: [amd64, arm64]
    build-for: [arm64]

parts:
  ljm:
    plugin: dump
    source: ./driver
    stage-packages:
      - libusb-1.0-0
    #   - libstdc++6
    #   - libc6
    override-build: |
      set -eux

      cd "$SNAPCRAFT_PART_SRC"

      chmod +x ./labjack_ljm_installer.run

      ### Install into the snap's filesystem (not the host)
      
      ./labjack_ljm_installer.run --accept --quiet --target "$SNAPCRAFT_PART_INSTALL/usr/local"
      
      ### Remove GUI app (Kipling) and host-specific bits we don't want on ctrlX.
      rm -rf "$SNAPCRAFT_PART_INSTALL/usr/local/labjack_kipling" || true
      rm -f  "$SNAPCRAFT_PART_INSTALL/usr/local/bin/labjack_kipling" || true
      rm -rf "$SNAPCRAFT_PART_INSTALL/opt" || true
      
      echo "Installed LabJack LJM into $SNAPCRAFT_PART_INSTALL/usr/local"

      ### Add a small test script for runtime verification
      mkdir -p "$SNAPCRAFT_PART_INSTALL/bin"
      cat > "$SNAPCRAFT_PART_INSTALL/bin/ljm-info" << 'EOF'
      #!/bin/sh
      export LD_LIBRARY_PATH="$SNAP/usr/local/ljm/lib:$SNAP/usr/local/lib:$LD_LIBRARY_PATH"
      echo "LJM libs:"
      ls -l "$SNAP/usr/local/ljm/lib"/libLabJackM.so* 2>/dev/null || echo "libLabJackM not found"

      echo "LJM driver installed inside snap at: $SNAP/usr/local"
      echo "Files:"
      
      ls -1 "$SNAP/usr/local" || true
      EOF
      
      chmod +x "$SNAPCRAFT_PART_INSTALL/bin/ljm-info"

  python-ljm:
    plugin: python
    source: .
    # Install LabJack's Python package (gives you `from labjack.ljm import ljm`)
    python-packages:
      - LabJackPython
    after: [ljm]
    override-build: |
      set -eux
      snapcraftctl build

      # Place your script inside the snap (adjust name/path as you like)
      mkdir -p "$SNAPCRAFT_PART_INSTALL/app"
      cp main.py "$SNAPCRAFT_PART_INSTALL/app/main.py"

      # Wrapper to run the script with correct env + library path
      mkdir -p "$SNAPCRAFT_PART_INSTALL/bin"
      cat > "$SNAPCRAFT_PART_INSTALL/bin/ljm-python-demo" << 'EOF'
      
      #!/bin/sh
      # Make sure LJM's shared library is visible to Python
      export LD_LIBRARY_PATH="$SNAP/usr/local/ljm/lib:$SNAP/usr/local/lib:$LD_LIBRARY_PATH"
      exec "$SNAP/usr/bin/python3" "$SNAP/app/main.py"
      EOF
      chmod +x "$SNAPCRAFT_PART_INSTALL/bin/ljm-python-demo"

apps:
  ljm-python-demo:
    command: bin/ljm-python-demo
    environment:
      LD_LIBRARY_PATH: "$SNAP/usr/local/ljm/lib:$SNAP/usr/local/lib:$LD_LIBRARY_PATH"
    plugs:
      - raw-usb
      - network
      - hardware-observe

plugs:
  raw-usb:
    interface: raw-usb
  hardware-observe:
    interface: hardware-observe

Step 4: Build the snap

From the project root, run:

snapcraft clean
snapcraft

After the successful packaging, the generated file should be similar to:

ctrlx-labjack-ljm_1.2.0_amd64.snap

Download the file to your computer

Step 5: Install the snap on ctrlX CORE

Open the ctrlX OS web interface and follow these steps:

1. Open Settings

2. Open Apps

3. Select Install from file

4. Select labjack-ljm_1.0.0_amd64.snap

5. Complete the installation

Step 5: Check the logbook for the output

Related links

• ctrlX OS Store

  • SDK for ctrlX AUTOMATION

  • ctrlX WORKS

• https://support.labjack.com/