About this video

• Video Title: Unboxing the Unitree G1 Edu Humanoid
• Channel: sentdex
• Speakers: None explicitly named, but the primary speaker is the video creator.
• Duration: 51:59

Overview

This video provides a detailed unboxing and initial exploration of the Unitree G1 Edu Humanoid robot. The creator, who has an advisory role with Lucky Robots, shares their long-standing desire to test Unitree's robots. The video covers the purchasing process, pricing tiers of the G1 Edu variants, the physical dimensions and weight of the robot, its numerous degrees of freedom, and the available ports and sensors. A significant portion is dedicated to the challenges and process of programming the robot using its SDK, including the use of an LLM to help create a Python API, and troubleshooting initial attempts at basic movements.

Key takeaways

• The Unitree G1 Edu Ultimate B (U4) variant, with Dex 3-in-1 hands and tactile sensors, was unboxed.
• Pricing varies significantly, with the base model around $16,000, but the "to your door" cost in the US can reach $24,000 or more, with the ultimate version costing in the mid-$60,000 range after taxes and tariffs.
• The robot is 4.5 ft tall and weighs approximately 85 lbs (38 kg), making it heavy and somewhat difficult to handle.
• The G1 Edu has extensive degrees of freedom in its limbs, torso, wrists, and head, allowing for a wide range of motion.
• Programming the robot primarily involves a C++ SDK, but the creator used an LLM to develop a Python API, which significantly simplified interaction.
• Initial programming attempts highlighted the importance of specific states (like "damp mode" and "balance stand") and the need for continuous communication to maintain control, with failures often occurring due to unexpected state transitions or communication loss.
• The creator successfully demonstrated basic movements like standing and a short walk, though troubleshooting was a significant part of the process.
• Future development plans include creating APIs for the hands, improving arm control, integrating the robot's sensors (RGB, depth, LiDAR), and implementing robust safety fallbacks.

I can't create a PDF document directly, but I can provide you with a detailed step-by-step guide based on the transcript on how to connect to the robot and begin programming. I will also include important details and a glossary for key terms used in the video.

---

Guide to Connecting and Programming the Unitree G1 Robot

This guide outlines the essential steps and information for connecting to and programming your Unitree G1 robot, based on the provided transcript.

I. Understanding the G1's Computing Architecture

The Unitree G1 has a multi-computer setup:

• Primary Unitree Computer: The main onboard computer of the robot.
• Secondary Development Board: For the Edu variants, this is an NVIDIA Jetson Orin NX (or similar). This is the board you will primarily interact with for programming.

II. Network Setup and Connection

1. Physical Connection:

   • The robot has communication ports located on the back of its neck, covered by rubberized material that can be pulled off.
   • Connect an Ethernet cable from your computer to one of the robot's LAN ports.
   • The robot has two LAN ports. One is for communication with the G1, and the other can be used for internet/home network access.

2. IP Configuration:

   • Your computer needs to be on the same subnet as the robot's development board.
   • The robot's development board (Jetson Orin NX) typically has the IP address: 192.168.1.164.
   • You may need to configure your computer's network adapter to be on the 192.168.1.x subnet (e.g., 192.168.1.100).
   • Security Note: It is highly recommended to set up the robot on a separate network (a different subnet) from your main network for security reasons. Avoid connecting it directly to your primary security network.

3. Accessing the Development Board (SSH):

   • You can connect to the Jetson Orin NX board via SSH.
   • Username: unitree
   • Default Password: 1123
   • CRITICAL SECURITY STEP: Immediately change the default password after your first login. This board has sudo access, making it a potential security risk if left with default credentials.
   • To SSH into the board, use a terminal command like: ssh unitree@192.168.1.164

III. Software Development Kit (SDK) and Programming

1. Obtaining the SDK:

   • The Unitree SDK is available on GitHub. You will need to clone this repository to your development environment.
   • The SDK contains libraries, tools, and examples for interacting with the robot.

2. SDK Structure:

   • The SDK typically includes high-level and low-level examples.
   • Low-level Examples: Often written in C++ and deal with very fast, deterministic loops (e.g., 2ms cycle time) required for core functions like balancing. These are usually not suitable for direct Python interaction.
   • High-level Examples: These provide more abstract commands (e.g., setting torso height, hand position) that the robot's internal C++ systems handle. These are more amenable to being called from Python.

3. Programming Approach:

   • Low-Level Control (C++): For tasks requiring precise timing and direct hardware control (e.g., maintaining balance, motor control loops), C++ is generally preferred.
   • High-Level Control (Python): Python is suitable for sending commands to the robot's high-level functions, sequencing actions, and building more complex behaviors. This is often achieved by creating a Python wrapper or facade that calls the underlying C++ SDK functions or interacts with the robot's command-line interface (CLI).
   • LLM Assistance: The creator found large language models (LLMs) extremely helpful in understanding the SDK, converting C++ examples, and generating a Python API, significantly speeding up the development process.

4. Running Examples:

   • Build Process: After cloning the SDK, you will likely need to build the C++ components. This often involves using build tools like cmake. Navigate to the SDK directory and follow the build instructions provided (e.g., unitree_sdk/build, then make).
   • Interface Name: When running commands or scripts, you will need to specify the correct network interface name that is connected to the robot. This can be found in your system's network settings (e.g., enp6s0f1 or similar).
   • Example Execution: The SDK provides examples (e.g., examples/G1/LowCmd/B1_LowCmd.py or examples/G1/HighCmd/B1_HighCmd.py). You'll need to navigate to the build directory (build/bin) and execute them, providing the correct interface name.
   • Example command structure might look like: ./example_program --<interface_name> <robot_ip>

IV. Key Concepts and Troubleshooting

1. Robot States: The robot operates in different states, which are crucial for understanding its behavior and programming commands:

   • Damp Mode: A state where the robot fights gravity to prevent immediate collapse. It slows descent but doesn't actively balance. Useful for initialization.
   • Balance Stand: The robot actively balances on its feet. It can withstand some external forces (pushing/pulling) but requires sufficient force on the feet to enter.
   • Continuous Gate: Allows for continuous movement commands (like walking forward). This state requires frequent communication; if communication is lost, the robot reverts to a previous state (e.g., Balance Stand) as a safety mechanism.

2. Initialization and Standing Up:

   • The robot needs to transition through states like "damp mode" and then slowly extend its legs to achieve a stable "balance stand."
   • Simply issuing a "stand up" command might not be enough; the robot requires sufficient ground contact pressure on its feet to enter the balance state.
   • The creator found that a specific loop extending legs until sufficient pressure is detected was necessary, rather than just setting a static height.

3. Communication Protocol:

   • The robot relies on frequent communication. Commands need to be sent in quick succession.
   • The underlying communication likely uses a protocol like DDS (Data Distribution System), though this is not explicitly detailed.
   • If communication fails, the robot enters a safe fallback state.

4. Debugging:

   • The robot provides limited debugging feedback. You can query its Finite State Machine (FSM) ID and Mode.
   • Mode 0: Indicates the robot is in Balance Stand.
   • Mode 1: Indicates the robot is in Continuous Gate.
   • If the robot refuses to enter a desired mode (e.g., Balance Stand), check connections, Estop status, and battery levels. The exact reason for rejection is often not explicitly communicated.

5. Safety:

   • Gantry/Hanger: A gantry or suspension system is highly recommended for safe R&D to prevent the robot from falling and damaging itself or its surroundings.
   • Initialization Routine: Develop a robust initialization routine that ensures the robot starts in a stable, safe position.
   • Emergency Stop: Implement reliable emergency stop mechanisms, either through software or hardware.
   • Network Security: Isolate the robot's network connection.

V. Glossary of Key Terms

• SDK (Software Development Kit): A set of tools, libraries, and documentation that allows developers to create software for a specific platform or system.
• SSH (Secure Shell): A network protocol used for secure remote login and other secure network services between two networked computers.
• IP Address: A unique numerical label assigned to each device connected to a computer network that uses the Internet Protocol for communication.
• Subnet: A logical subdivision of an IP network.
• LLM (Large Language Model): An AI model trained on vast amounts of text data, capable of understanding and generating human-like text, assisting with coding, explanation, and more.
• API (Application Programming Interface): A set of rules and protocols that allows different software applications to communicate with each other.
• Facade (in programming): A design pattern that provides a simplified interface to a larger body of code, such as a class library or a framework.
• Degrees of Freedom (DOF): The number of independent parameters that define the configuration of a mechanical system. In robotics, it refers to the number of ways a robot's joints can move.
• LiDAR (Light Detection and Ranging): A remote sensing method that uses light in the form of a pulsed laser to measure variable distances to the Earth or other objects.
• RGB Camera: A camera that captures color images (Red, Green, Blue).
• Depth Camera: A type of camera that captures information about the distance of objects in a scene, creating a depth map.
• FSM (Finite State Machine): A computational model used to design computer programs and digital logic circuits. It consists of a set of states, a starting state, and transitions between states.
• Damp Mode: A robot operational mode that provides resistance against gravity without full active balancing.
• Balance Stand: A state where the robot actively maintains its balance on its feet.
• Continuous Gate: A mode allowing for continuous movement commands, typically requiring constant communication.
• Gantry/Hanger: A support structure used to suspend the robot during development, preventing falls.
• Estop (Emergency Stop): A button or mechanism designed to immediately shut down a machine in an emergency.

---

This guide should provide a solid foundation for starting your programming journey with the Unitree G1. Remember to consult the official Unitree SDK documentation and community resources for the most up-to-date information.