Use Case 01: Product Assembly Line
Product Assembly Line (PAL) is a use case deployed at the testbed LocalSEA in CEA List. The use case aims to test the bridge solution developed in ROS6GBridge in a physical simulation of the industrial environment.
Description
PAL use case simulates a factory plan's segment with two workstations. In the first workstation, a robot picks a part from a parts tray and places it on a carrier. The carrier transport the object to the second workstation, where a worker will pick the object and assembles it with different type of part. The worker clicks a button to notify that the object is already picked. The number of sucessful objects will be calculated by a counter.
Deployment Instructions
Five devices required by this use cases are: (a) UR3e, (b) TurtleBot3 Waffle Pi (T3WP), (c) PLC Opta, (d) Rapsberry Pi 2 (RPi2), and (e) the board FPGA designed and developed by Logiicdev.
Figure 3 illustrates the topology of the PAL use case. In detail, all field-level devices communicate through the NPB bridge which is the FPGA board. The AAS DT of the NPB bridge plays a role of an Software-Defined Network (SDN) controller to monitor and control the NPB bridge. The AAS DT of the PAL is an orchestrator which monitor and control the field-level devices to deploy the PAL use case.
Figure 4 illustrates the AAS information model used to generate bridge NPB and its AAS DT. It shows that bridge NPB has four interfaces corresponding to four protocols OPC UA FX, ROS 2, EtherNet/IP, and Modbus TCP. Each interface has one or several routing nodes.
Figure 5 illustrates the BPMN diagram depicting the production process of the PAL use case. The AAS DT of PAL has two threads: one monitors the states of field-level devices, and the other orchestrates the devices for production. The other components (UR3e, T3WP, RPi2, and Opta) wait for events before proceeding with their operations.
To deploy the PAL use case, users need to setup hardware devices and their software. The software has several exact configurations associated to the hardware devices as follows.
Step 1: Network setup
Field-level devices can connect to the FPGA board via either an Ethernet cable
or WiFi. However, they all need to be on the 192.168.56.0/24 network.
In detail,
- UR3e: 192.168.56.16/24
- T3WP: 192.168.56.3/24
- RPi2: 192.168.56.18/24
- Opta: 192.168.56.12/24
- Brx: 192.168.56.11/24
otherwise, the software part may not work properly.
AAS PAL and AAS Brx can be either in the same network or in another network and they need to be able to connect to Brx.
Step 2: Software setup
To support the deployment, many programs and Docker images are prepared in ROS6GBridge UC01 kit. After downloading, users can extract it using the command:
$
unzip UC01_kit.zip
Inside the zip, there are different resources for different devices.
a. UR3e
To install the program for UR3e, users need a running UR3e. The deployment steps are as follows.
Step 1: Extract the UR3e package and copy the inner files to an USB
$
tar -zxvf ur3e_app.tar.gz
$sudo mount /dev/sda1 /mnt
$cp ur3e_app/* /mnt
Step 2: Plug the USB onto the UR3e teach pendant. Load the files:
- File > Load Installation > select ur3e.installation
- File > Load Program > select ur3e_program.urp. The file ur3e.variables
will be auto-loaded.
Step 3: Run the program by clicking Play on the teach pendant.
b. T3WP
To install the program for T3WP, users need a running T3WP with ROS2 middleware. The deployment steps are as follows.
Step 1: Extract the T3WP package and copy the inner file to an USB
$
tar -zxvf t3wp_app.tar.gz
$sudo mount /dev/sda1 /mnt
$cp t3wp_app/* /mnt
Step 2: On T3WP, enter the ROS2 workspace (e.g. ~/ros2ws, then create a python ROS2 package
$
cd ~/ros2ws
$ros2 pkg create palusecase --build-type ament_python --dependencies rclpy
Step 3: Plug the USB onto the Raspberry Pi of T3WP, copy the file, then build it with colcon
$
sudo mount /dev/sda1 /mnt
$cp /mnt/t3wp_program ~/ros2ws/src/palusecase/palusecase/t3wp_program.py
$sudo chmod +x ~/ros2ws/src/palusecase/
$colcon build
Step 4: Run the program
$
source install/setup.bash
$ros2 run palusecase t3wp_program.py
c. OPTA
To install the program for Opta, users need an Opta connect with the computer using a USB-C cable and a preinstalled Arduino IDE. The deployment steps are as follows.
Step 1: Extract the Opta package
$
tar -zxvf opta_app.tar.gz
Step 2: Open Arduino, open the file: File > Open... >
select opta_program.ino. Click Verify to verify the code,
then click Upload to build and push the binary to the Opta.
Step 3: Opta only needs a power supply to run. However, to run the program, users need to use a Modbus TCP client to set the target number to be produced first, then users click the USER button on the Opta to start the program.
d. RPi2
To install the program for RPi2, users need an Raspberry Pi with python3. The deployment steps are as follows.
Step 1: Extract the RPi2 package and copy the inner file to an USB
$
tar -zxvf rpi2_app.tar.gz
$sudo mount /dev/sda1 /mnt
$cp rpi2_app/* /mnt
Step 2: Plug the USB onto RPi2, copy the files to a workspace (e.g. ~/rpi2ws) then run the program
$
sudo mount /dev/sda1 /mnt
$cp /mnt/* ~/rpi2ws/
$sudo chmod +x ~/rpi2ws/rpi2_program
$cd ~/rpi2ws && ./rpi2_program
e. Brx
The Brx is put in a Docker image for arm64. Users need a FPGA running Ubuntu arm64 or a Raspberry Pi working as bridge. The deployment steps are as follows.
Step 1: Copy brx_app.tar.gz onto the arm64 device.
Step 2: Users need to load the docker image, then run it.
$
docker load -i brx_app.tar.gz
$docker run -it --net=host --rm npb_brx:0.3.arm64
f. AAS Brx
The AAS Brx is put in a Docker image. Users need to load, then run it.
$
docker load -i aas_brx_app.tar.gz
$docker run -it --net=host --rm aas_brxfpga:0.1.0-SNAPSHOT
g. AAS PAL
The AAS PAL is put in a Docker image. Users need to load, then run it.
$
docker load -i pal_app.tar.gz
$docker run -it --net=host --rm aas_pal:0.1