KAIST Deployment

Start the operator GUI

On your workstation, launch the DDS Robot GUI (from the Desktop (Stanford Logo)). Also, start the Docker Desktop application (also on desktop).

After Docker Desktop is running, click the Local Stack Docker Start button in the Robot GUI (bottom right of the application). If you need sensor data capture, use the Capture Start button directly under it (see step 3).

Start the operator DDS Communication

Open the windows Terminal application. At the top of the application click the drop down button and open a new "Ubuntu WSL 1" tab. (Alternatively, you can directly open an Ubuntu WSL 1 terminal by searching for "Ubuntu WSL 1" in the Windows search bar.)

Important: This Ubuntu terminal should be WSL1, make sure you do not use the plan Ubuntu Terminal (which is WSL2)!

Navigate to the dds_robot_platform/dds/ repository, activate the dds conda environment, and run ./start_scripts.sh

cd dds_robot_platform/dds
conda activate dds
./start_scripts.sh

Data Storage Docker Containers

NOTE: This step is only necessary if you care about storing all the sensor data for later analysis (or for image testing).

In the Robot GUI Local Stack panel (bottom right), click the Capture Start button directly under the Local Stack Docker Start button. This starts the dds_robot_platform/capture Docker Compose stack.

Central Machine Setup Complete

The central machine setup is now complete. You can click the "Retry loading map" button in the Robot GUI to see the map. If robots are online, they should become available in the right hand side of the GUI.

Power on the robots

Power on the robots, wait a few minutes, the display screen should power on and you should see the desktop. Turn on the switch for the microcontroller and motors (the switch at the bottom), the red LED should turn on to signify the electronics are on.

Start the Robot Software (From DDS Robot GUI)

I have tried to make this as simple as possible and you can do this in multiple ways: by SSHing into the robot from a terminal, from the Robot GUI, or from the display app on the robot itself. Here I will walk you through all possible options.

Starting via SSH

SSH into the Jetson (username/password = jetson):

ssh jetson@<jetson_ip_address>

Then start the docker container:

sudo docker run --runtime nvidia --network=host -v ~/workspaces/catkin_ws:/workspace/catkin_ws -v ~/gemini_api:/gemini_code -v /dev/bus/usb:/dev/bus/usb -v /dev/video0:/dev/video0 -v /dev/video1:/dev/video1 -it --device=/dev/ttyUSB0 --device=/dev/spidev0.0 --rm --privileged --name ros_noetic ghcr.io/satomm1/ml_ros:latest bash -lc 'python3 /workspace/catkin_ws/src/startup_script.py & exec bash'

Then start the ROS node via the kaist.launch file:

roslaunch mattbot_bringup kaist.launch

Starting via the Robot GUI

Select the robot you want to start from the "saved addresses" dropdown under "Robot Startup" on the right hand side column. If the robot is powered on and the Robot GUI detects the robot, the little dot next to the robot should be yellow (not red).

Click the "Start Docker" button for the selected robot to start the required docker containers on the robots.

Click the "KAIST" checkbox to enable startup according to KAIST configuration.

Click the "Start ROS" button to start the ROS node. The LiDAR should start spinning and the robot will show up in the Robot Desktop GUI.

Starting via the Robot Display

The robot display app should automatically start upon booting up. If it doesn't, or you accidentally exit out, double tap the "Start-Mattbot-Display.sh" icon on the Desktop.

First, start Docker. There should be a button that says "Start Docker". This may take a few seconds and a success message will print on the screen.

Second, start the ROS node. Simply click the "Start ROS" button in the display. The LiDAR should start spinning and the robot will show up in the Robot Desktop GUI.

Note: These start up procedures must be completed individually for each robot

If there are software updates, you should pull software updates via the "Software Update" button in the Robot GUI. You must do this individually for each robot.

Select the robot

In the Robot GUI, click the robot you want to operate in the status panel (left column). The selected robot is used for all map clicks until you choose a different one.

Switch to Set Initial Position mode

In the map toolbar, select Set Initial Position. This tells the GUI you are seeding AMCL localization, not sending a navigation goal.

Set Initial Position

Click and drag on the map to indicate the robot’s actual location and orientation. This only needs to be in roughly the correct location. The robot will perform a spinning sequence to localize. The robot icon on the map should jump to that pose.

Confirm localization

Make sure the robot’s position on the map matches where it is in the room. Navigation goals will fail or behave incorrectly if localization is wrong.

Switch to Set Robot Goal mode

In the map toolbar, select Set Robot Goal.

Click the destination on the map

With the correct robot selected, click and drag to set the goal location and orientation on the map. The robot should plan a path and drive to that point.

To send a new goal, stay in Set Robot Goal mode and click another point. Use Stop in the GUI if you need to halt motion before sending a new goal.

Stop data storage Docker containers (optional)

Skip this step if you did not start the capture stack during startup.

In the Robot GUI Local Stack panel, click the Capture Stop button (directly under the Local Stack Docker controls).

Stop operator DDS communication

In Windows Terminal, find your Ubuntu WSL 1 tab (the same WSL1 environment used at startup — not plain Ubuntu / WSL2).

End the scripts by pressing Ctrl + C:

Alternatively, open a new Ubuntu WSL 1 tab and navigate to the DDS scripts directory and run the stop script:

cd dds_robot_platform/dds
./stop_scripts.sh

Stop the Local Stack Docker services

In the Robot GUI, click the Local Stack Docker Stop button (bottom right of the application). This stops the GraphQL, InfluxDB, and related compose services started at startup.

Close the operator GUI and Docker Desktop

Close the DDS Robot GUI application. You may quit Docker Desktop if you are finished for the day; leave it running if you plan to restart the stack soon.

Select the robot and enable patrol

Under Robot Startup on the right-hand side, select the desired robot, then check the Patrol checkbox.

Open the patrol panel

Click Set Patrol. A panel opens on the left-hand side showing the patrol points for that robot.

Edit points and dwell time

Remove existing points or add new ones by clicking/dragging on the map. You can also set how long the robot should stay at each patrol point before moving to the next one.

Send to the robot

When finished, click Send to Robot.

Start ROS to begin patrolling

The next time you Start ROS for that robot, it will automatically patrol between the saved points. You still need to initialize the robot position (set initial pose) as usual before navigation will work correctly.

Download the viewer HTML

On the central machine, download watch_robot_images.html from the dds_robot_platform docs folder (use Raw → Save As, or open the file from your local clone at dds_robot_platform/docs/watch_robot_images.html).

Open it and set robot IDs

Open the HTML file in a browser on the central machine. At the top of the page, set the four robot ID fields to 1, 2, 3, and 4 (match the IDs used on your KAIST fleet).

Start robots and confirm live images

Make sure the central stack is running, including Capture from the Robot GUI Local Stack panel (Capture Start, under Local Stack Docker Start), and start at least one robot as in Running the Robots. Live camera images for active robots should appear in the 2×2 grid on the page.

If a cell shows “no frame” or “unreachable,” check that that robot’s ROS stack is up, capture is running, and the robot ID matches the GUI / robot_env.sh configuration.

Connect each robot to the new Wi-Fi

On each robot’s display, go to the Ubuntu desktop. In the upper-right corner, click the power/system menu, then open the Wi-Fi settings. Select the new Wi-Fi SSID and enter the password to connect.

Repeat for every robot in the fleet.

Record each robot’s new IP address

Plug a USB keyboard into the Jetson. Open a terminal and run:

ifconfig

Find the wlan0 section and note the address next to inet — that is the robot’s Wi-Fi IP. Write down both the robot number and this IP address.

Repeat for every robot so you have a full list (e.g. Robot 1 → 192.168.x.x, Robot 2 → …).

Update saved addresses in the Robot GUI

On the central machine, open the Robot GUI. In the right-hand Robot Startup panel:

1. Under saved addresses, select each existing robot entry one by one and click the X next to it to remove the old address.
2. For each robot, enter the robot ID in the label field, type the new IP from step 2, and click Save.

If the robots are powered on and reachable, the new IPs should be recognized and the status dot next to each robot should be solid gray (not red, and not flashing gray).

Update Windows Firewall (Matts Rule)

On the central Windows machine, allow the new robot IPs through Windows Defender Firewall so ROS/DDS traffic is not blocked.

1. Open the Windows Defender Firewall app (search for “Windows Defender” in the Windows search box).
2. In the left column, click Inbound Rules.
3. Find the rule labeled Matts Rule (scroll down if the list is alphabetical).
4. Double-click Matts Rule. In the dialog that opens, select the Scope tab at the top.
5. Under Remote IP address, add the robot IP addresses from step 2. You can add each IP individually, or use an IP address range to include all robots at once. You may remove old robot IPs, but that is optional.
6. Click Apply, then OK.
7. In the left column, click Outbound Rules. The Matts Rule should be near the top of this list.
8. Double-click Matts Rule, open the Scope tab, and again add the robot IPs under Remote IP address (optionally remove old IPs). Click Apply, then OK.

Update cyclonedds.xml on the central machine (WSL1)

On the central machine, open an Ubuntu WSL 1 terminal. Pull the latest dds_robot_platform so you have update_wifi_ips.sh, then run the script. It prompts for the central machine IP and each robot IP, then updates cyclonedds.xml automatically:

cd ~/dds_robot_platform
git pull
cd dds
./update_wifi_ips.sh

Enter the central machine IP and every robot IP from step 2 when prompted.

If you are already running ./start_scripts.sh, restart it after the script finishes (stop with ./stop_scripts.sh or Ctrl+C, then run ./start_scripts.sh again from ~/dds_robot_platform/dds) so discovery picks up the new peers.

Update Wi-Fi IPs on each robot

Repeat this step for every robot.

Start Docker on the robot if it is not already running (Robot GUI Start Docker, or Start Docker on the robot display app).

SSH into the Jetson from an Ubuntu WSL 1 terminal on the central machine (username/password = jetson):

ssh jetson@<robot_ip_address>

Enter the running ROS container:

docker exec -it ros_noetic bash

Download and run the Wi-Fi IP update script. It prompts for the central machine IP and each robot IP, then updates robot_env.sh and cyclonedds.xml automatically:

cd /workspace/catkin_ws/src
wget -O update_wifi_ips.sh "https://raw.githubusercontent.com/satomm1/Robot/main/Jetson/update_wifi_ips.sh"
chmod +x update_wifi_ips.sh
./update_wifi_ips.sh

Enter the same IP addresses you used in step 5 when prompted.

Test locally with minimal.launch

Still inside the container, with the electronics/motor switch on, run:

roslaunch mattbot_bringup minimal.launch

If everything is working, you should see a launch summary (Parameters, Nodes), messages about processes that were started, and an [INFO] message that includes the robot ID.

Press Ctrl+C to stop the test launch when finished. Repeat steps 6–7 for each remaining robot.

Test on the network

After every robot has been updated and tested locally, verify that the central machine can talk to the robots over the new Wi-Fi network.

1. On the central machine, start Local Stack Docker from the Robot GUI if it is not already running.
2. In an Ubuntu WSL 1 terminal, start the DDS scripts:

   cd ~/dds_robot_platform/dds
   conda activate dds
   ./start_scripts.sh

   Copy
3. From the Robot GUI, start each robot (Docker + ROS with the KAIST checkbox, as in Running the Robots).

If the network configuration is correct, the robots should appear on the map in the Robot GUI. In the terminal where ./start_scripts.sh is running, you should also see messages indicating that the central machine has connected to the robots that were started.

Complete standard startup

Follow every step in Running the Robots before starting Jaewoo’s code:

• Central Machine Startup — operator GUI, Local Stack Docker, DDS scripts, and capture containers (if needed)
• Robot Startup — power on and start ROS on each robot (via SSH, Robot GUI, or robot display)

Do not skip these steps. Jaewoo’s application layer expects the central DDS stack and all target robots to already be running.

Localize each robot

In the Robot GUI, set the initial position for every robot you plan to control (see Robot Operation → Set initial position (GUI) in Running the Robots).

Confirm each robot’s icon on the map matches its real location and orientation before proceeding. Automated goal commands will fail or behave incorrectly if localization is wrong.

Start Jaewoo’s robot control code

With startup and localization complete, run Jaewoo’s application layer on the central operator workstation. This code publishes goal and patrol commands over DDS to the running robots.

Contact Jaewoo for the current repository location, environment setup, and launch command for your scenario.

SSH into the Jetson

Connect to the robot you will map (username/password = jetson):

ssh jetson@<jetson_ip_address>

Start the ros_noetic Docker container

On the Jetson, start the ROS container:

sudo docker run --runtime nvidia --network=host -v ~/workspaces/catkin_ws:/workspace/catkin_ws -v ~/gemini_api:/gemini_code -v /dev/bus/usb:/dev/bus/usb -v /dev/video0:/dev/video0 -v /dev/video1:/dev/video1 -it --device=/dev/ttyUSB0 --device=/dev/spidev0.0 --rm --privileged --name ros_noetic ghcr.io/satomm1/ml_ros:latest bash -lc 'python3 /workspace/catkin_ws/src/startup_script.py & exec bash'

Wait for the container shell to appear.

Start the mapping launch file

In the first terminal (inside the Docker container), launch SLAM mapping:

roslaunch mattbot_bringup sense_and_map.launch

Drive the robot with keyboard teleop

Open a second terminal, SSH into the same Jetson again, and enter the running container:

docker exec -it ros_noetic bash

Start the keyboard teleop node:

roslaunch mattbot_teleop keyboard.launch

Focus the teleop terminal and use the keyboard to drive the robot through the entire area you want mapped.

Finalize and save the map

When you have driven through the entire area, press Ctrl+C in the teleop terminal to exit keyboard control.

In the same terminal (still inside the Docker container), finalize the map — replace <map-name> with a short name for this space (e.g. lab_floor1):

rosrun mattbot_mcl finalize_map.py --name <map-name>

This saves the map and generates the files needed by the robots and the central operator computer. For large maps, this step can take a few minutes.

Stop mapping

Press Ctrl+C in the first terminal (where sense_and_map.launch is running) to stop mapping once map saving has finished. Then stop the Docker container by typing exit.

Load the map on the central computer GUI

On your operator workstation, open the DDS Robot GUI and start the local Docker stack (see Operation → Starting User GUI / DDS if needed).

1. In the right-hand column, select the robot you used for mapping.
2. Open the drop-down for loading/syncing robot maps.
3. Enter a name for the map (use the same name as in step 5, or another label you prefer for the GUI).
4. Click Sync Map From Robot.

The on-screen map should update with your new map once the sync completes.

Send the map to other robots

Repeat these steps for each robot that should use the new map (on the central computer GUI):

1. In the right-hand column, select the robot you want to send the map to.
2. Open the Maps drop-down.
3. Click the Send Map option.
4. Select the map to send.
5. Click the button to send the map.

Repeat for every other robot in the fleet that needs the updated map.

Install MPLAB X IDE and XC32 compiler

Download and install MPLAB X IDE from Microchip on your PC.

During installation, when prompted to choose which compilers to install, you only need the XC32 compiler (32-bit MCU). You can skip the other compiler options unless you plan to use them for other projects.

Clone the firmware repo and open the MPLAB project

On your PC, clone the Robot repository:

git clone https://github.com/satomm1/robot.git

Open MPLAB X IDE, then go to File → Open Project and select the robot/Software/MCU directory inside the cloned repo.

Select device and compiler

In the bottom-left window, under Packs, click PIC32MZ… (the label may show a different device name on your machine). In the popup:

1. Set Device to PIC32MZ2048EFH144.
2. In the Compiler Toolchain box, select the available XC32 compiler.
3. Click Apply, then OK.

Configure robot settings and build

In the file navigator (top-left window), open FrameworkHeaders/ES_Configure.h. Update these #define values for the robot you are flashing:

• ROBOT_ID — set to the ID for this robot (must match the value in robot_env.sh on the Jetson).
• PCB_REV — 3
• MOTOR_TYPE — 1
• WHEEL_RADIUS — 0.040
• CAR — 1

After saving the file, click Clean and Build at the top of MPLAB (broom icon). Fix any build errors before continuing.

Connect the MPLAB Snap programmer

Matt will supply an MPLAB Snap In-Circuit Debugger and Programmer when he visits. Only 6 pins need to be connected: the left 6 pins on the Snap programmer cable connect to the matching exposed header pins on the robot main circuit board.

1. Connect the Snap programmer to the circuit board (6-pin header).
2. Connect the Snap to your laptop via USB.
3. Turn the microcontroller on using the main robot power switch.

Program the MCU

Click the Program button at the top of MPLAB (down-arrow icon) to flash the firmware to the microcontroller. If MPLAB asks you to select a programmer, choose the Snap programmer.

If the Snap programmer does not appear in the list:

• Make sure the Snap is plugged into your laptop via USB.
• If it still does not show up, quit and restart MPLAB X, then try again.

Wait for the operation to finish — MPLAB will report success or show an error if programming failed.

Power off the robot

Make sure the Jetson and all robot electronics are fully powered off before starting the mechanical change.

Disconnect upper-level cables from the Jetson

Unplug the HDMI and USB cables from the upper levels of the robot that connect to the Jetson. You may also need to disconnect the microphone wires so the upper assembly can be rotated freely.

Rotate the upper assembly 180°

Unscrew the four screws visible from the top of the 3rd layer platform. This loosens the top four layers of the robot. Rotate those layers 180 degrees, then reattach the four screws.

Reconnect cables to the Jetson

Reattach the HDMI and USB cables from the upper levels back to the Jetson.

Reprogram the microcontroller

Reprogram the MCU using the procedure in Flashing the MCU above. Use CAR set to 1 in FrameworkHeaders/ES_Configure.h when building and flashing the firmware.