Connecting to sources…

How to build T-Top (tabletop socially assistive robot): the whole process

100 steps to build T-Top (tabletop socially assistive robot), from buying parts, printing and assembly to software, calibration and training, with the bill of materials,…

Not sold and no kit. The BOM (00_ORDER_PRINT_LASER_CUTTING.md) lists quantities and shop links only, with no unit prices or total; its big-ticket parts include an NVIDIA Jetson AGX Xavier or AGX Orin developer kit, an Intel RealSense D435i and 7 Dynamixel XL430‑W250‑T servos

Bill of materials · Digi-Key

PartQtyANY
Audio Amplifier - Adafruit MAX9744 · X · X · 1 · 22
Robot Power Connector - Female · X · X · 1 · 11
Robot Power Connector - Male · X · X · 1 · 11
19V Power Adapter · X · X · 1 · 11
Computer Power Connector - Male · X · X · 1 · 11
Power Switch · X · X · 1 · 11
Micro USB Connector · X · X · 1 · 11
Ethernet Connector · X · X · 1 · 11
Jumper · X · 1 · 11
WiFi Antenna · X · 1 · 22
Intel RealSense D435i · X · X · 1 · 11
Standoff - M2x10mm · X · X · 1 · 44
Standoff - M2x15mm · X · X · 1 · 44
Standoff - M3x10mm · X · X · 1 · 88
Standoff - M3x25mm · X · X · 1 · 44
Standoff - M3x10mm - Plastic · X · X · 1 · 44
M3 Plastic Nuts · X · X · 1 · 44
JST B2P-VH · X · X · 1 · 22
JST VHR-2N · X · X · 1 · 22
JST SVH-21T-1.1 · X · X · 1 · 44
Push Button · X · X · 1 · 44
Light Sensor · X · X · 1 · 44

Bill of materials · McMaster-Carr

PartQtyANY
Plastic Screw - M2x5mm · X · X · 25 · 14
Plastic Screw - M2.5x5mm · X · X · 25 · 14
Plastic Screw - M2.5x8mm · X · X · 25 · 352
Plastic Screw - M2.5x12mm · X · X · 25 · 16
Plastic Screw - M3x5mm · X · X · 25 · 368
Plastic Screw - M3x6mm · X · X · 25 · 116
Plastic Screw - M3x8mm · X · X · 25 · 250
Plastic Screw - M3x12mm · X · X · 25 · 484
Plastic Screw - M5x10mm · X · X · 25 · 13
Socket Cap Screw - M2x5mm · X · X · 100 · 14
Socket Cap Screw - M2x12mm · X · X · 100 · 128
Socket Cap Screw - M3x5mm · X · X · 100 · 118
Socket Cap Screw - M3x10mm · X · X · 100 · 16
Socket Cap Screw - M3x55mm · X · 1 · 44
Socket Cap Screw - M5x16mm · X · X · 100 · 16
Socket Cap Screw - M5x30mm · X · X · 10 · 13
M2 Nuts · X · X · 100 · 14
M3 Nuts · X · X · 100 · 110
M5 Washer · X · X · 100 · 118
Dowel Pin · X · X · 50 · 12
Small Spring · X · X · 5 · 14
Big Spring · X · X · 5 · 12
Diffuser Plastic Sheet · X · X · 1 · 11
Cast Acrylic Sheet · X · X · 1 · 11

Buy parts

  • Open the STEP file without SOLIDWORKS

    Download and open step/robot.STEP to view the robot assembly model.

  • Review the parts list excluding custom PCBs

    Open the linked bill of materials to obtain the required parts excluding custom PCBs.

  • Buy the robot parts

    Buy the required items from the listed suppliers using the bill of materials excluding custom PCBs. The robot can use a Jetson AGX Xavier or a Jetson AGX Orin.

  • Prepare the T-Top robot

    Prepare a T-Top robot with Jetson Orin AGX or Xavier AGX running Jetpack 5.x.x.

Print and make

  • Manufacture the PSU control PCB

    Manufacture the PSU control PCB from the Gerber files located at ../../PCB/psu_control/gerber.

  • Manufacture the Dynamixel control PCB

    Manufacture the Dynamixel control PCB from the Gerber files located at ../../PCB/dynamixel_control/gerber.

  • Manufacture the Buck-Boost PCB

    Manufacture the Buck-Boost PCB from the Gerber files located at ../../PCB/psu_control/gerber.

  • Prepare common Buck-Boost PCB parts

    Prepare the parts listed under Common for the 12V Buck-Boost PCB and the 19V Buck-Boost PCB.

  • Prepare 12V Buck-Boost PCB parts

    Additionally, prepare the other parts required by the 12V Buck-Boost PCB.

  • Prepare 19V Buck-Boost PCB parts

    Additionally, prepare the other parts required by the 19V Buck-Boost PCB.

  • 3D print the robot parts

    3D print the parts located at ../../CAD/STL to assemble the robot.

  • Cut the acrylic parts

    Cut the required robot parts from 6 mm acrylic. The cutting files are located in ../../CAD/DXF.

  • Follow the 3D printing guide

    Open the linked 3D printing guide and follow its printing instructions to prepare the parts.

  • Follow the laser cutting guide

    Open the linked laser cutting guide and follow its cutting instructions to prepare the parts.

  • Obtain the DXF and STL manufacture files

    Obtain the DXF and STL manufacture files from the CAD folder.

  • Fabricate the PSU Control PCB

    Fabricate the PCB that controls and monitors the battery, audio amplifier, fans and LEDs, using the Gerber files in the psu_control folder.

  • Fabricate the Dynamixel Control PCB

    Fabricate the PCB that controls the Dynamixel motors, using the Gerber files in the dynamixel_control folder.

  • Fabricate the Buck-Boost PCB

    Fabricate the Buck-Boost PCB using the Gerber files in the buck_boost folder.

Software

  • Install Visual Studio Code

    Install Visual Studio Code on your computer so you can work on the robot over SSH.

  • Install Remote - SSH extension

    Install the Remote - SSH extension from the Extensions tab or menu in Visual Studio Code.

  • Install ROS extension pack

    Install the ROS extension pack from the Extensions tab or menu in Visual Studio Code.

  • Install Python extension

    Install the Python extension from the Extensions tab or menu in Visual Studio Code.

  • Install C/C++ extension

    Install the C/C++ extension from the Extensions tab or menu in Visual Studio Code.

  • Install CMake Tools extension

    Install the CMake Tools extension from the Extensions tab or menu in Visual Studio Code.

  • Create and copy SSH key

    Open a terminal, go to ~/.ssh, create an ED25519 SSH key pair, and copy the public key to the robot. Skip this step if SSH keys are already configured.

  • Test the SSH Connection

    Run the SSH command to connect to the robot; the document says this should not ask for a password.

  • Open the SSH Config File

    Open the current user's SSH configuration file with nano.

  • Add an SSH Host Configuration

    Set `HostName`, `User`, and `IdentityFile` for the `ttop` host, replacing the placeholders with your own values.

  • Connect Using the SSH Alias

    After saving the configuration, use `ssh ttop` to connect to the robot instead of the full SSH command.

  • Connect to the ttop Host

    Select `Remote-SSH: Connect to Host...`, then choose `ttop` from the list.

  • Open the VS Code Terminal

    After connecting, select `Terminal` from the top menu and choose `New Terminal` to open a terminal.

  • Create the Workspace and Clone the Repository

    Create the `~/t_top_ws/src` workspace directory and enter it; use another name if the directory already exists. The example then clones the t-top repository with its submodules.

  • Return to the Workspace Root

    Return from `~/t_top_ws/src` to the workspace root, `~/t_top_ws`, to create the colcon configuration file.

  • Create the colcon_defaults.yaml file

    Create the `colcon_defaults.yaml` file in the workspace root.

  • Add colcon default settings

    Configure CMake to export compile commands, ignore unused CLI arguments, use `/usr/bin/python3`, use the Debug build type, and enable `-march=native -ffast-math` for C++ and C; also enable `symlink-install`.

  • Copy the Jetson sample configuration

    Go to `~/t_top_ws` and copy the repository's `colcon_defaults_jetson.yaml` to the workspace as `colcon_defaults.yaml`. Then modify it in nano as needed.

  • Build the ROS 2 workspace

    Go to the workspace root, source the ROS 2 Humble environment, and build the workspace with colcon.

  • Source ROS 2 and the workspace

    Open a terminal in Visual Studio Code, go to `~/t_top_ws`, and source the ROS 2 Humble and built workspace environments in order.

  • Launch the robot control panel

    Launch the control panel from the terminal. This graphical interface can visualize the robot's state, control its movements, and interact with its sensors.

  • Connect to the ttop host

    Select `Remote-SSH: Connect to Host...`, then choose `ttop` from the list.

  • Open the robot workspace

    After connecting, select `File` in the top menu and then select `Open Folder...`.

  • Select the t_top_ws folder

    Select the `~/t_top_ws` folder and click "OK".

  • Confirm the colcon defaults file

    Make sure the `colcon_defaults.yaml` file is in the root of the workspace.

  • Install the required VS Code extensions

    Make sure the CMake Tools, C/C++, Python, and ROS extensions are installed.

  • Configure ROS and the integrated terminal

    Configure the ROS extension and terminal in the workspace's `.vscode/settings.json` file.

  • Open the VS Code integrated terminal

    In Visual Studio Code, select `Terminal` in the top menu and then select `New Terminal`.

  • Build the robot workspace

    Run `colcon build` in the terminal to build the workspace.

  • Open the workspace folder

    Open the workspace folder as described in the previous section.

  • Create launch.json

    Create a `launch.json` file in the `.vscode` folder.

  • Add the VS Code launch configuration

    Open the `launch.json` file and add the ROS launch debugging configuration shown below. Replace the `target` with the full path to your launch file.

  • Set the Debug build type

    When debugging, set `CMAKE_BUILD_TYPE` to `Debug` in the `colcon_defaults.yaml` file.

  • Set the Python interpreter

    When debugging, set `PYTHON_EXECUTABLE` to `/usr/bin/python3` in the `colcon_defaults.yaml` file.

  • Understand that all nodes launch

    When you launch the debugger, all nodes in the launch file will launch, and the other nodes will run until the breakpoint is hit. You can create a separate launch file that launches only the node you want to debug.

  • Install T-Top dependencies

    Install the dependencies by following the computer configuration guide in the T-Top assembly documentation.

  • Clone the OpenTera WebRTC ROS repository

    Clone the opentera-webrtc-ros repository in the workspace.

  • Install OpenTera and Python requirements

    Install the OpenTera system and Python requirements using the opentera-webrtc-ros documentation.

  • Build the ROS workspace

    Build the ROS workspace with colcon build.

  • Generate stand-alone certificates and keys

    Generate CA certificates and keys by following the CA certificate setup guide for stand-alone mode.

Calibrate and test

  • Set Output and Filename Prefix

    Set output_directory to the directory for saving recorded files and filename_prefix to the recorded filename prefix.

  • Set Video Stream Parameters

    Set video_stream_name, video_stream_format, video_stream_width, and video_stream_height; video_stream_format is rgb8 or bgr8.

  • Set Video Framerate and Codec

    Set video_stream_framerate, video_stream_codec, video_stream_bitrate, video_stream_delay_s, and video_stream_language_code; the video codec is h264, h265, vp8, vp9, or av1.

  • Set Audio Stream Parameters

    Set audio_stream_name, audio_stream_format, audio_stream_channel_count, and audio_stream_sampling_frequency.

  • Set Audio Codec and Channel Merge

    Set audio_stream_codec, audio_stream_merge_channels, and audio_stream_language_code; the audio codec is aac or mp3, and audio_stream_merge_channels is boolean.

  • Control Recording State

    Use the video_recorder/filter_state service to enable or disable recording; its service type is hbba_lite_srvs/SetOnOffFilterState.

  • Set the database_path parameter

    Set database_path (string) to the path of the SQLite database.

  • Set the frame_id parameter

    Set frame_id (string) to the frame id of the positions and directions stored in the database.

  • Configure Google node parameters

    Set `sampling_frequency` to 16000, `frame_sample_count` to 92, `request_frame_count` to 20, and `language` to `en` or `fr`; these are the defaults.

  • Connect the Google node audio input

    Connect the sound input to the `audio_in` topic, whose message type is `audio_utils_msgs/AudioFrame`.

  • Configure Whisper node parameters

    Set `language` to `en` or `fr`, `model_size` to `base.en`, `device` to `cpu`, `compute_type` to `float32`, `prebuffering_frame_count` to 4, and `minimum_voice_sequence_size` to 8000; these are the defaults.

  • Select the Whisper model size

    Choose `tiny`, `tiny.en`, `base`, `base.en`, `small`, `small.en`, `medium`, `medium.en`, `large`, or `large.en`; the default is `base.en`.

  • Connect the Whisper node audio input

    Connect the sound input to `audio_in` and the voice activity detector output to `voice_activity`; they use `audio_utils_msgs/AudioFrame` and `audio_utils_msgs/VoiceActivity` message types.

  • Configure tools and initial context with JSON

    Tools are called dynamically using the service name and service message, and can be configured with a JSON file; the initial context can also be configured with a JSON file.

Data and training

  • Record Image and Audio

    Use video_recorder_node.py to record one image topic and one audio topic.

  • Connect the Image Recording Topic

    Subscribe to the video_{video_stream_name} image topic; its message type is sensor_msgs/Image.

  • Connect the Audio Recording Topic

    Subscribe to the audio_{audio_stream_name} audio topic; its message type is audio_utils_msgs/AudioFrame.

  • Subscribe to video_analysis and audio_analysis topics

    The node subscribes to video_analysis (perception_msgs/VideoAnalysis, must contain 3d positions) and audio_analysis (perception_msgs/AudioAnalysis, with audio classes, voice embedding and sound direction).

  • Subscribe to talk/text and speech_to_text/transcript

    The node also subscribes to talk/text (talk/Text, the text spoken by the robot) and speech_to_text/transcript (perception_msgs/Transcript, the text spoken by the human).

  • Use the Script According to Help

    Run script.py according to the usage shown in the help.

Use it

  • Read the Google node transcript output

    Read the spoken text from the `transcript` topic, whose message type is `perception_msgs/Transcript`.

  • Enable or disable Google processing

    Use the `audio_in/filter_state` service to enable or disable processing; its service type is `hbba_lite_srvs/SetOnOffFilterState`.

  • Read the Whisper node transcript output

    Read the spoken text from the `transcript` topic, whose message type is `perception_msgs/Transcript`.

  • Enable or disable Whisper processing

    Use the `audio_in/filter_state` service to enable or disable processing; its service type is `hbba_lite_srvs/SetOnOffFilterState`.

  • Launch the control panel and test the robot

    Redirect the display to the robot and launch the control panel, then use the GUI tabs to test the robot capabilities.

  • Run the robot with the control panel

    Run `ros2 launch control_panel control_panel.launch.xml` in the terminal to run the robot.

  • Open the robot's stand-alone interface

    On the development machine, open the stand-alone interface using the robot's IP address on the LAN.

  • Open the OpenTera server login page

    On the development machine, open the OpenTera login page, log in with an account, and select the robot to control.

  • Check the demos/chatbot chatbot demo

    The repository's demos/chatbot folder provides a chatbot demo application to try out the chat node.

Common problems

  • Demos break after the weather API migration because obsolete dependencies remain. #117
  • Perception analyzer has duplicated callbacks and inflexible class configuration. #118
  • Smart speaker and home logger demos do not run. #120
  • ODAS output lacks pre-VAD samples, degrading recognition of short speech. #127
  • Dependency installation is fragmented, and setup documentation lacks a unified workflow. #115

Parts

  • NVIDIA Jetson AGX Xavier or AGX Orin developer kit (SSD, Wi‑Fi card and so on differ by version); Teensy 4.0 motor MCU and Teensy LC battery MCU
  • 7 Dynamixel XL430‑W250‑T servos (BOM): the Stewart platform (±3 cm travel, ±20° in x/y and ±30° in z, with 6 M3×180 mm threaded-rod links and 12 ball joints) and the endlessly rotating base (through an M220-24 slip ring, listed as 36-wire in the BOM)
  • Intel RealSense D435i, Arducam AR0230 wide-angle camera and lens, 16 xSoundsMicrophones plus a 16SoundsUSB sound card
  • 7-inch 1024×600 touchscreen, 4 Dayton Audio DMA45‑8 speakers with 2 MAX9744 amplifiers, WS2812B LED strips, 2 Noctua NF‑A4x20 5V fans
  • RRC2054‑2 battery and RRC‑PMM240 charger module, 19 V power adapter; 3 custom PCBs (PSU control, Dynamixel control, buck-boost; KiCad and Gerbers)
  • 32 STL print files (one torso inner frame each for Xavier and Orin, mostly 1.2 mm walls and 25% infill) and one 6 mm acrylic base disk (laser-cut)

Tools

  • A 3D printer and a laser cutter (or CNC)
  • Screwdrivers, pliers, soldering iron and solder, heat gun
  • JST XH and RJ12 crimp tools, tie wraps, epoxy, super glue, blue threadlocker
  • A micro USB cable and a 12 V power supply (as the assembly doc lists)

Skills

  • Soldering and assembling the 3 custom PCBs, crimping JST and RJ12 harnesses
  • Dynamixel setup, Teensy firmware flashing and robot calibration (doc steps 3, 12 and 13)
  • ROS 2 Humble and colcon builds on a Jetson (JetPack 5), with remote development over SSH and VS Code

Software

  • ROS 2 perception packages: video and audio analysis, person identification, robot name detection, speech to text (Google Cloud or Faster Whisper), ego-noise reduction
  • Behaviour packages: talk (Piper or Google speech synthesis driving the mouth), LLM chat (OpenAI or local Ollama, with tool calls), face following, dance, explore, sound following, teleoperation, LED emotions
  • Demos: control panel, smart speaker, OpenTera telepresence, chatbot, Connect 4 experiments, home logger; HBBA Lite behaviour architecture

Documents