ABS (Agile But Safe)

The unitree_legged_sdk is used for communication between a PC and the Controller board, or between PCs via UDP.

Supported Robots:

• Go1

Unsupported Robots:

• Laikago
• B1
• Aliengo
• A1

Note: For support for other robots, check the v3.3.1 release.

When using chrono conversions, the resulting Python type depends on which C++ clock is used. There are three standard clock types:

1. std::chrono::system_clock: Measures current date and time. It is subject to OS updates (e.g., NTP synchronization).
   • Python Mapping: Converts to datetime.datetime (naive, local timezone).
2. std::chrono::steady_clock: Ticks at a constant rate and is never adjusted. Ideal for measuring intervals/timing, but does not represent wall-clock time.
   • Python Mapping: Converts to datetime.timedelta (representing time since the clock's epoch).
3. std::chrono::high_resolution_clock: The clock with the highest resolution available on the system.
   • Python Mapping: Behavior varies by system. If it is a typedef of system_clock, it returns datetime.datetime. If it is a different clock, it returns datetime.timedelta.

When using std::shared_ptr as a holder type, avoid returning raw pointers from functions that return objects managed by smart pointers. Returning a raw pointer causes pybind11 to create a new, independent std::shared_ptr that claims ownership, leading to a double-free (segmentation fault) when both pointers attempt to deallocate the object.

To resolve this, use one of two methods:

1. Consistent Wrapping: Always return the smart pointer type itself instead of a raw pointer.
2. Enable Shared From This: Inherit the managed class from std::enable_shared_from_this<T>. This allows pybind11 to recognize and communicate with the existing std::shared_ptr.

// Method 1: Return the shared_ptr directly
std::shared_ptr<Child> get_child() { return child; }

// Method 2: Use enable_shared_from_this
class Child : public std::enable_shared_from_this<Child> { };

Passing functions between C++ and Python involves instantiating wrapper code to translate invocations between the two languages. This introduces computational overhead.

Performance Risks:

• Frequent roundtrips (e.g., C++ $\rightarrow$ Python $\rightarrow$ C++ $\rightarrow$ Python) in a tight loop can significantly decrease performance due to accumulated wrapper overhead.

Optimization:

• pybind11 can optimize stateless functions (function pointers or lambdas without captured variables). If a stateless function is passed from Python to a C++ function exposed in Python, pybind11 extracts the underlying C++ function pointer to avoid the C++ $\rightarrow$ Python $\rightarrow$ C++ roundtrip.

In C++, functions often use mutable references (int &i) or pointers (int *i) to modify arguments. While Python passes arguments by reference, basic Python types like str, int, bool, and float are immutable.

Binding a C++ function that modifies an immutable type will result in a Python function that appears to do nothing because the modification doesn't affect the original Python object.

Workarounds:

1. Encapsulation: Wrap the immutable type in a custom C++ class that allows modifications.
2. Lambda Wrapper: Bind a small lambda function that calls the C++ function and returns the modified values as a tuple.

// C++ function using a reference
int foo(int &i) { i++; return 123; }

// Binding using a lambda to return a tuple of (return_value, modified_arg)
m.def("foo", [](int i) { 
    int rv = foo(i); 
    return std::make_tuple(rv, i); 
});

The Python interpreter's lifecycle is primarily managed by py::scoped_interpreter.

• RAII approach: Use py::scoped_interpreter guard{};. The interpreter starts when the guard is created and shuts down when the guard is destroyed. Creating a second concurrent scoped_interpreter guard is a fatal error.
• Manual approach: Use py::initialize_interpreter() and py::finalize_interpreter() to set the state directly.

Warning: Do not use raw CPython API functions Py_Initialize and Py_Finalize, as they do not correctly handle pybind11's internal data. Also, be aware that while pybind11 modules can be re-initialized after a restart, third-party extension modules might not fully unload, potentially leading to memory leaks.

When a bound function accepts ordinary Eigen dense objects (e.g., Eigen::MatrixXd), pybind11 accepts any numpy.ndarray with compatible dimensions.

Behavior:

• pybind11 copies the values from the NumPy array into a temporary Eigen variable.
• For sparse matrices, it copies to/from scipy.sparse.csr_matrix or scipy.sparse.csc_matrix.
• Limitation: This involves an implicit copy, which is expensive for large matrices and prevents the function from modifying the original NumPy array.