Hi, thanks for getting a Petoi robot.

If you have a construction kit, you can follow the following instructions to build it.

• Bittle

• Bittle X

  • If you have a Bittle X V2 kit(as indicated on the package barcode label)

    • pay attention to the BiBoard V1 servo wiring

    • select BiBoard V1 during the firmware upload process with Petoi Firmware Uploader

• Nybble

After you’ve assembled a Petoi robot or have bought a pre-assembled version, the following steps are recommended:

1. Play with mobile app

   • Play with the default actions

   • Play with simple joint control

   • Add more commands to the controller panel

   • Play with group commands to make your robot perform multiple actions in sequence

2. Play with voice commands(for Bittle X or any robot with the voice command module)

   • If the robot doesn’t respond to your voice commands, please see the troubleshooting guide.

   • You can turn off the voice command functionality(for example: in a public space, or in a classroom setting requiring quiet periods) to avoid accidentally triggering voice responses and robot reactions.

3. Do some coding

   • Follow Petoi Coding Blocks curriculum to program some Petoi robotics moves

   • Visually design some new robotics skills with Petoi Skill Composer

   • Follow C++ curriculum to code some Petoi robotics moves in C++

   • For Bittle/Bittle X, you may 3D-print this stand to make your robot not run around while you program it.

4. Work on some quadruped robotics competition projects

FAQ

Question: I am confused by the product packaging and unsure if you sent me the right robot.

Answer: We reuse the packaging for Bittle and BIttle X. If you order a Bittle but receive a package with “Bittle X” marking, or vice versa, you can check the text label with the barcode. That text identifies what’s inside the packaging.

Check other FAQs on our official website or those in the Petoi Doc Center.

Since the ESP8266 can be used as a regular Arduino board, we can write a simple Arduino code to open the serial port and send the serial commands to control the robot. It's like a stand-alone serial commander written in C and can go with the robot. You may write hundreds of pre-defined tasks without worrying about the memory limits on the main controller.

You can find a short test8266Master in OpenCat/ModuleTest:

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  Serial.setTimeout(5);
  bool connected = false;
  while (!connected) {
    Serial.print("b 20 8 22 8 24 8");
    for (byte t = 0; t < 100; t++) {
      if (Serial.available())
        if (Serial.read() == 'b') {
          connected = true;
          while (Serial.available() && Serial.read())
            ;
          break;
        }
      delay(10);
    }
    delay(1000);
  }
}

void sendCMD(const char cmd[], int wait = 0) {
  Serial.print(cmd);
  while (true) {
    if (Serial.available() && toLowerCase(Serial.read()) == cmd[0]) {
      delay(10);
      while (Serial.available() && Serial.read())
        ;
      break;
    }
    delay(2);
  }
  delay(wait);
}

void loop() {
  sendCMD("d", 500);                    //rest and wait 0.5 seconds 趴下并等待0.5秒
  sendCMD("khi");                       //greetings 打招呼
  sendCMD("kpu");                       //pushups 俯卧撑
  sendCMD("kvtF", 1000);                //stepping 原地踏步
  sendCMD("G");                         //Turn off the gyro 关闭陀螺仪
  sendCMD("kwkF", 1500);                //walk 行走
  sendCMD("kck");                       //check 观察
  sendCMD("kpu1");                      //push ups with on hand 单手俯卧撑
  sendCMD("kvtR", 2000);                //spin 旋转
  sendCMD("G", 100);                    //turn on the gyro 打开陀螺仪
  sendCMD("ktrF", 1500);                //trot 跑步
  sendCMD("kjy", 0);                    //joy 加油
  sendCMD("i 0 45 8 -90 9 -90", 1000);  //rotate the head and arm joints 伸手转头
  sendCMD("ksit", 1000);                //sit 坐下
}

There's also a ROS wrapper for developpers to easily connect to the ROS environment. It is recommended to use ROS with Raspberry Pi.

Using ROS on Raspberry Pi

Currently, it's recommended to install ROS using docker.

• install docker on Raspberry Pi (ref)

sudo apt-get update && sudo apt-get upgrade
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker pi
# test installation
docker run hello-world

• prepare workspace

mkdir -p workspace/src
cd workspace/src
git clone https://github.com/PetoiCamp/ros_opencat
cd ros_opencat
git submodule init && git submodule update
cd ../../..

• run the container

docker run -v path/to/workspace:/workspace \
-it --rm --privileged --network host --name ros ros:noetic-robot

• source files and build inside the container

cd /workspace
source /opt/ros/noetic/setup.bash
catkin_makbase
source devel/setup.bash

• run examples (see Examples for more)

rosrun opencat_examples opencat_examples_serial

Using ROS for remote control

Ros is designed with distributed computing in mind. Here's a simple example on how to run nodes on different machines.

• on host machine (usually more powerful than Raspberry Pi)

# launch server
roscore

• run service node on Raspberry Pi

export ROS_MASTER_URI=http://<Host_IP>:11311/
rosrun opencat_server opencat_service_node

• send command from host

rosrun opencat_examples opencat_examples_client_cpp

Examples

• using serial library

rosrun opencat_examples opencat_examples_serial

• using ROS service

# start core
roscore
# start service server
rosrun opencat_server opencat_service_node
# examples using oppencat ros service in C++
rosrun opencat_examples opencat_examples_client_cpp
# examples using opencat ros service in python
rosrun opencat_examples opencat_examples_client_py

There are 2 serial ports,which are separately located on 2 expansion sockets (P16, P17) ,on BiBoard.

The serial port 1 on the P16 can be connected to the USB downloader and the external serial device. Please do not use the downloader and the external serial device at the same time. The serial port voltage division will lead to communication errors.

In the Arduino demo, Serial represents the serial port 0, Serial1 represents the serial port 1.Serial and Serial1 send to each other.

/* In this demo, we use Serial and Serial1 
*  Serial and Serial1 send to each other 
*/

void setup() {
  // initialize both serial ports:
  Serial.begin(115200);
  Serial1.begin(115200);
}

void loop() {
  // read from port 1, send to port 0:
  if (Serial1.available()) {
    int inByte = Serial1.read();
    Serial.write(inByte);
  }

  // read from port 0, send to port 1:
  if (Serial.available()) {
    int inByte = Serial.read();
    Serial1.write(inByte);
  }
}

The instructions of ADC on BiBoard

The 34, 35, 36 and 39 pins of the ESP32 module support input only. We configure it as an analog input port on BiBoard, which makes it convenient for developers to connect 4 foot sensors.

The usage of analog input analog-to-digital converter (ADC) on BiBoard is the same as the basic Arduino UNO, but the accuracy is higher (12 bits, UNO is 10 bits), and a programmable gain amplifier is added to make the ADC work in the best range.

When a 1V voltage signal is input, if 12bit access is used according to the normal configuration, the reference voltage is equal to the power supply voltage (3.3V): the corresponding output is 0～1241, a large part of the ADC range will be wasted, resulting in inaccurate data. When we configure the programmable gain, we can make the 1V input signal fill almost the entire ADC range, and the accuracy and resolution are greatly improved.

This demo uses 4 inputs, respectively configured as: 0/2.5/6/11 decibel amplification gain, it should be noted that the default configuration of ESP32 Arduino is 11 decibel amplification gain.

We use "analogSetPinAttenuation(PIN_NAME, attenuation)" to configure the gain of a single input pin, or use "analogSetAttenuation(attenuation)" to configure the gain of all analog input pins.

// Ain 34 - 0dB Gain - ADC_0db
analogSetPinAttenuation(34, ADC_0db);

// Ain 35 - 2.5dB Gain - ADC_2_5db
analogSetPinAttenuation(35, ADC_2_5db);

// Ain 36 - 6dB Gain - ADC_6db
analogSetPinAttenuation(36, ADC_6db);

// Ain 39 - 11dB Gain - ADC_11db    (default)
analogSetPinAttenuation(39, ADC_11db);

In the actual test, when the 1V standard voltage is input, the ADC values are: 3850/2890/2025/1050. In future productions, the ADC range can be changed by changing the ADC gain without the replacement of the reference voltage source.

The usage of EEPROM is the same as Arduino UNO, there are two operations: read and write.

Read:

• I2C address of EEPROM

• The internal address of EEPROM (the address for storing data)

• Read data

Write:

• I2C address of EEPROM

• The internal address of EEPROM (the address for storing data)

• Write data

In the BiBoard demo, the address of EEPROM on the I2C bus is 0x54, and the capacity is 8192Bytes (64Kbit). We sequentially write a total of 16 values from 0 to 15 in the EEPROM from the first address, and then read them for comparison. Theoretically, the data written in EEPROM and the data read from the corresponding address should be the same.

In the NyBoard factory test, we also use this method, but it is more complicated. We will use a fixed list to fill the EEPROM and read it out for comparison.

#include <Wire.h>

#define EEPROM_ADDRESS 0x54
#define EEPROM_CAPACITY 8192       // 64Kbit
#define EEPROM_TESTBYTES 16

// write 1 byte EEPROM by address
void writeEEPROM(int deviceaddress, unsigned int eeaddress, byte data ) 
{
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8));   // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.write(data);
  Wire.endTransmission();
 
  delay(5);
}

// read 1 byte EEPROM by address
byte readEEPROM(int deviceaddress, unsigned int eeaddress ) 
{
  byte rdata = 0xFF;
 
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8));   // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.endTransmission();
 
  Wire.requestFrom(deviceaddress,1);
 
  if (Wire.available()) 
    rdata = Wire.read();
  return rdata;
}

void testI2CEEPROM(){

    byte tmpData = 0;

    Serial.println("EEPROM Testing...");
    
    // write EEPROM from 0 to EEPROM_TESTBYTES
    for(int i = 0; i < EEPROM_TESTBYTES; i++){
        writeEEPROM(EEPROM_ADDRESS, i, i % 256);
        delay(1);
    }

    Serial.println();
    
    // read from 0 to EEPROM_TESTBYTES
    for(int i = 0; i < EEPROM_TESTBYTES; i++){
        tmpData =  (int)readEEPROM(EEPROM_ADDRESS, i);
        Serial.print(tmpData);
        Serial.print("\t");
    }
}


void setup(){

    Serial.begin(115200);
    Wire.begin();
    
    testI2CEEPROM();
}

void loop(){
  
}

Note: the EEPROM operations, especially write operations, are generally not put into the loop() loop. Although the EEPROM is resistant to erasing (100,000 times), if a certain block is frequently written in the loop, It will cause the EEPROM to malfunction.

There is no separate GPIO port on BiBoard, but the multiplexed serial port 2 (pin 16, 17) or the PWM pin of the unused PWM servo interface can be used as GPIO port. The GPIO port is also relatively simple to use. After configuring the input and output mode, the usage is exactly the same as that of Arduino UNO. You can use any IO control program of Arduino UNO, just change the number of IO .

/* In this demo, we use TX2, RX2 as general purpose IO
*   TX2 : IO17
*   RX2 : IO16
*/

void setup() {
  // initialize digital pin 16 & 17 as an output.
  pinMode(16, OUTPUT);
  pinMode(17, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
    
  digitalWrite(16, HIGH);            // GPIO 16 & 17 HIGH
  digitalWrite(17, HIGH);
  delay(1000);                       // wait for a second

  digitalWrite(16, LOW);             // GPIO 16 & 17 LOW
  digitalWrite(17, LOW);
  delay(1000);                       // wait for a second
}

Bluetooth Low Energy (BLE, Bluetooth Low Energy) serial port pass-through is widely used. On Apple's iOS platform, Classic Bluetooth requires MFi certification to connect with Apple's iOS devices. The Bluetooth low energy device does not have this restriction.

The protocol stack and principle of Bluetooth low energy will not be repeated here, there are many related articles and videos. In short, the bluetooth service is provided in the form of a profile, and there are N characters with independent IDs (UUID) under the profile of each service. Each character has different permissions (read, write, notify, indicate). After the user defines the character and combines it with the authority, a complete service can be provided.

What BLE pass-through is actually to establish a BLE Service, and there are 2 characters under this profile.

#define SERVICE_UUID           "6E400001-B5A3-F393-E0A9-E50E24DCCA9E" // UART service UUID
#define CHARACTERISTIC_UUID_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"

One for TX (transmit data) and one for RX (receive data). For this they have different permissions. The following code is to create a new service and character:

  // Create the BLE Service
  BLEService *pService = pServer->createService(SERVICE_UUID);
  
  // Create a BLE Characteristic
  pTxCharacteristic = pService->createCharacteristic(
										CHARACTERISTIC_UUID_TX,
										BLECharacteristic::PROPERTY_NOTIFY
									);
                      
  pTxCharacteristic->addDescriptor(new BLE2902());

  BLECharacteristic * pRxCharacteristic = pService->createCharacteristic(
											 CHARACTERISTIC_UUID_RX,
											BLECharacteristic::PROPERTY_WRITE
										);

Next are two callback functions, which are performed when there is a connection and when there is a write RX character:

class MyServerCallbacks: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) {
      deviceConnected = true;
    };

    void onDisconnect(BLEServer* pServer) {
      deviceConnected = false;
    }
};

class MyCallbacks: public BLECharacteristicCallbacks {
    void onWrite(BLECharacteristic *pCharacteristic) {
      std::string rxValue = pCharacteristic->getValue();

      if (rxValue.length() > 0) {
        Serial.println("*********");
        Serial.print("Received Value: ");
        for (int i = 0; i < rxValue.length(); i++)
          Serial.print(rxValue[i]);

        Serial.println();
        Serial.println("*********");
      }
    }
};

Finally, the main loop is the control of the connection, which determines whether there is a connection and whether it is disconnected.

    if (deviceConnected) {
        pTxCharacteristic->setValue(&txValue, 1);
        pTxCharacteristic->notify();
        txValue++;
		    delay(10); // bluetooth stack will go into congestion, if too many packets are sent
	  }
    
    // disconnecting
    if (!deviceConnected && oldDeviceConnected) {
        delay(500); // give the bluetooth stack the chance to get things ready
        pServer->startAdvertising(); // restart advertising
        Serial.println("start advertising");
        oldDeviceConnected = deviceConnected;
    }
    // connecting
    if (deviceConnected && !oldDeviceConnected) {
		// do stuff here on connecting
        oldDeviceConnected = deviceConnected;
    }

For the complete code, see the example of the official library: ble_uart, and the debugging tool can use LightBlue.

The sample code mainly demonstrates the mutual forwarding of information between the Bluetooth serial port and the serial port, which is derived from the official demo of ESP32, which is simple and easy to understand. So the description mainly explains the concepts that appear in the code.

1. Bluetooth protocol

At present, the main Bluetooth protocols are divided into two categories, traditional Bluetooth (HS/BR/EDR) based on RFCOMM and Bluetooth low energy (BLE) based on GATT.

Traditional Bluetooth is faster and has many specific application protocols, such as audio-oriented A2DP, Bluetooth serial port SPP, etc. However, the power consumption is high, and access to Apple devices requires MFi (Made For iOS) chips and certification.

Bluetooth Low Energy (BLE) can define various GATT profiles by itself, and it is also equipped with commonly used profiles (such as device information, battery, etc.). It has low power consumption and is widely used. It can be used on Apple devices. The disadvantages is that it is slower than traditional Bluetooth. Bluetooth low energy is mostly used on devices with low data volume but sensitive to power consumption, such as bracelets/smart watches/beacons.

2. Classic Bluetooth serial port (SPP)

This demo uses the SPP protocol based on traditional Bluetooth, which comes with all serial port protocols. When the computer or Android phone is connected and paired, a serial port number will be automatically generated in the system for communication, and the experience is not much different from that of a normal wired serial port.

//This example code is in the Public Domain (or CC0 licensed, at your option.)
//By Evandro Copercini - 2018
//
//This example creates a bridge between Serial and Classical Bluetooth (SPP)
//and also demonstrate that SerialBT have the same functionalities of a normal Serial

#include "BluetoothSerial.h"

#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
#endif

BluetoothSerial SerialBT;

void setup() {
  Serial.begin(115200);
  SerialBT.begin("BTSPP_Test");          //Bluetooth device name
  Serial.println("The device started,");
  Serial.println("Now you can pair it with bluetooth!");
}

void loop() {
  if (Serial.available()) {
    SerialBT.write(Serial.read());
  }
  if (SerialBT.available()) {
    Serial.write(SerialBT.read());
  }
  delay(20);
}

The bluetooth low energy serial port will be demonstrated in the next chapter. In essence, it is a profile configured with a serial port and requires host software support.

This is the Petoi robot product documentation hub. We constantly iterate on our models and codes to bring bionic robotic pets to the world. Please read the notes regarding versions carefully before configuring your robot.

If you need help, please write to support@petoi.com or post on our forum at petoi.camp.

Hardware Products

Check the Getting Started guide.

😼 Nybble Cat User Manual

🐶 Bittle Dog User Manual

🐶 Bittle X User Manual

Intelligent Search

You can use the find (Cmd+K/Ctrl+K) feature on this site. It supports Lens, a ChatGPT-based service.

Connect to the mainboard.

NyBoard

When you use a USB uploader to upload the firmware for the NyBoard, if there is no serial port in the port list of Device Manager.

Please download and install the USB driver:

• Mac: http://www.wch-ic.com/download/CH341SER_MAC_ZIP.html

• Windows: http://www.wch-ic.com/downloads/CH341SER_EXE.html

• Linux: http://www.wch-ic.com/downloads/CH341SER_LINUX_ZIP.html

BiBoard

BiBoard V0

When you use a USB type-C data cable to upload the firmware for the BiBoard, if there is no serial port in the port list of Device Manager.

Please download and install the USB driver:

For more details, please refer to the BiBoard V0 USB Driver to access the serial port.

BiBoard V1

When you use a USB type-C data cable to upload the firmware for the mainboard BiBoard V1.

• On Windows, if there is no serial port in the port list of Device Manager:

• On Mac, open the Terminal program under the Applications-Utilities folder and type the following commands. If no serial device name starting with "tty.wchusbserial" or "cu.wchusbserial" is found:

  Copy

  cd /dev
  ls

Please download and install the USB driver:

• Windows: https://www.wch-ic.com/downloads/CH343SER_EXE.html

• Mac: https://www.wch-ic.com/downloads/CH34XSER_MAC_ZIP.html

For the macOS(from the version Sequoia), after installing the driver, you need to enable the driver, as follows:

Settings -> General -> Login Items & Extensions -> Driver Extensions

Upload the firmware

There are two methods to Upload the firmware to the robot:

• The simplest method is to use the Petoi Desktop App. No programming is involved. You can play with some preset modes.

• If you have some programming experience, you can use the Arduino IDE. You will be able to modify the open-source codes for your new projects.

  • If you are using NyBoard, please refer to Upload Sketch for NyBoard.

  • If you are using BiBoard, please refer to Upload Sketch for BiBoard.

Bittle vs Bittle X

The doc seems to refer to Bittle and Bittle X interchangeably. Why is that?

Bittle and Bittle X are from the same family and share a lot of common things, except for the microcontroller difference where Bittle X uses BiBoard and Bittle uses NyBoard. So we just refer to Bittle most of the time without specifically mentioning Bittle X.

The difference of mainboards

The differences in specifications of different mainboards are shown in the figure below:

Sound

What do different melodies from the board mean?

Please refer to the Buzzer beep meaning.

How to adjust the buzzer volume?

Software

When using the mobile app, I found that my Petoi robot(Bittle or Nybble) was walking very slowly.

Try turning off the Gyro in the mobile app, as shown in the following picture:

When using the mobile app, Bittle cannot turn back up now.

Try turning on the Gyro in the mobile app, as shown in the following picture:

Bittle doesn't walk very stable.

• Make sure you calibrate the joints with the included L-shaped tuner and understand the references

• Remove the rubber toe covers

• Turning off the Gyro will make slow gaits more stable

When I use the play dead command with the mobile app, Bittle seems to be stuck in a forever loop trying to play dead again and again.

There's a known bug in one of the older firmware. Please upgrade to the latest firmware.

NyBoard can't upload firmware

The error that occurs when uploading the sketch is shown below:

Why there are two calibration stages?

There are two calibration steps for different components.

Because the controller board has limited resources, we divide the program into two stages.

In the first stage, we upload the program and large data to the onboard EEPROM (hard disk) and use the remaining programming space to calibrate the IMU, a sensor that measures the body orientation. The board should be leveled and untouched during the (IMU) calibration.

In the second stage, we upload the standard functional code. For the first-time configuration, we need to enter the (joint) calibration state and attach the legs in the right direction.

If you use the Arduino IDE to set up the board, you will handle those stages explicitly. The Petoi Desktop App can finish the two-stage uploading in the background. The mobile app can work only with an already configured board. Its (joint) calibration is only for attaching the legs.

If I buy the pre-assembled Bittle, does it still need to be calibrated?

Yes, you still need to use the desktop app/mobile app/Arduino IDE to fine-tune the joints if your robot doesn't walk very stable.

If I buy a microcontroller such as NyBoard or BiBoard alone, do I have to buy a separate software program to make it work?

Our microcontrollers are specifically designed for our robots. The open source code is free to use and can be downloaded on GitHub.

Could Python be used to control any Petoi robot?

You can use Python to control any Petoi robot. The scripts can work either on your computer and connect to the robot wired or wirelessly.

Can your robot (Bittle / Nybble) function on its own? Or does it only work with the commands I give it? Also, can it learn?

It follows your instructions via the infrared remote, mobile app, or desktop app. It can also do random behaviors if you enable the random mode. Best of all, the program is open source on GitHub, and you can refer to the relevant technical documents to create new skills for your robot.

When running the Petoi Desktop App in MacOS14.1 (Sonoma), the buttons are not responsive. How to solve this problem?

This is due to the incompatibility of the Python Tk library with MacOS. The temporary solution is that you can press the button and drag the mouse slightly at the same time.

How to set up Arduino IDE on ChromeOS (for Chromebook)

1. Download the Arduino IDE(e.g. 1.8.19) for Linux from https://github.com/arduino/Arduino/releases/download/1.8.19/arduino-1.8.19.tar.xz

2. Install it on the Chromebook. Please refer to the video at https://www.youtube.com/watch?v=2cve6n4LZqI

3. Plug the USB adapter with a USB data cable (for NyBoard) or USB type-C data cable (for BiBoard) into the robot's microcontroller and the Chromebook.

4. Set the Chromebook Linux VM to recognize the USB port

Settings => Advanced => Developers => Linux development environment => Manage USB devices => USB Serial (turn on)

Unable to find the OpenCat library

If you have downloaded and unzipped the OpenCat folder but see the following error:

OpenCat:82:10: fatal error: src/OpenCat.h: No such file or directory 
#include "src/OpenCat.h" 
        ^~~~~~~~~~~~~~~
compilation terminated.

You should rename the unzipped OpenCat-main folder to OpenCat so that the OpenCat.ino matches the root name.

For more information, please refer to: https://docs.petoi.com/arduino-ide/upload-sketch-for-nyboard#setup-process

BTW, you also can upload the firmware via the Petoi Desktop App:

https://docs.petoi.com/upload-firmware https://docs.petoi.com/desktop-app/firmware-uploader

I'm on Windows 11 and cannot find the robot in the Bluetooth device list

Try to set "Bluetooth devices discovery" to "Advanced" as follows:

How to install the CP210x driver on Windows

In the Device Manager, if you open the Other devices list, you may see a CP210X device with a triangle exclamation sign. Right-click it to find the "update driver" option, then select the enclosing folder of your downloaded driver to install.

When use mobile App connects to the robot, it indicates "The device doesn't seem to be a Petoi robot."

When connecting, the app will send handshake signals to the robot, and the robot should be running the firmware in standard mode to respond correctly. If the app returns a "not Petoi robot" error, it's probably due to a firmware issue. Please follow this debugging process:

[1]. Please check the version of the app as follows:

• App Store

• Google Play

[2]. For the startup melody in normal mode, please refer to the 00:13 in the video below:

For how to open the serial monitor and input the serial command, please refer to the instructions in the Petoi Doc Center.

• BiBoard

• NyBoard

[3]. You can upgrade the firmware via the Petoi Desktop App.

For NyBoard, if the firmware can not be upgraded, please refer to NyBoard can't upload firmware

Hardware

How can I easily install the springs into the upper legs of Bittle?

Please check out the forum post discussing installing springs with various tools. Or you can request Bittle upper legs with pre-installed springs

I can't find the toe covers. What are the toe covers for?

The toe covers are for special experiments that require more friction. They are not required for regular walking and performance. We have removed them from the standard kit recently, and you may order them as optional accessories.

Some frame structures are broken. Where can I get replacement parts?

You may contact us. Show the picture of the broken pieces and explain how they broke. You may find the 3D-printable files or get a replacement directly from us.

Bittle's neck is loose and may fall accidentally. How can I reinforce the connection?

Please refer to Bittle's instruction in Final Assembly.

Where can I get the bone shown in Bittle's picture?

The little bone is included in the Intelligent Camera Module box, and it is not being sold separately. You may download its 3D-printable file at: https://github.com/PetoiCamp/NonCodeFiles/blob/master/stl/Bittle_bone.stl

Does it come with a battery, or do you have to buy a lithium battery?

Both Bittle kit and pre-assembled Bittle include one Lithium battery with a built-in charging circuit. You may add more spare batteries.

Does Rasberry Pi require any additional components?

You can solder the 2x5 socket on the NyBoard and then mount the Rasberry Pi on the NyBoard.

Read more at https://docs.petoi.com/api/raspberry-pi-serial-port-as-an-interface

The robot servos don't seem to be working. How to debug the servos?

Quick fix the servo motor engagement

In some cases, the motor's output gear may disengage with the following gear. It will result in an abnormal buzzing sound inside the servo. You can take off the bottom of the servo and push the motor inward very hard until you hear a clicking sound.

The camera module can't work after being connected to the BiBoard extension hat.

Please refer to the FAQ on the MU camera.

The serial port can't be found when using a USB type-C data cable to connect the BiBoard to the computer.

Turn off the battery's power to see if the serial port can appear. Please refer to Connect to BiBoard via USB type-C data cable.

Resources and links

Driver for CH340 USB uploader

• Mac: http://www.wch-ic.com/download/CH341SER_MAC_ZIP.html

• Windows: http://www.wch-ic.com/downloads/CH341SER_EXE.html

Can I use block-based coding with any Petoi robot? Do I need to purchase add-on components/modules?

You can use Petoi Coding blocks to do Scratch-like block-based programming with all of Petoi robots.

There's nothing else to purchase.

The pre-assembled robot should have the legs installed, but you can further improve its performance by fine-tuning the joints' calibration.

Make sure you have uploaded the OpenCat Main function firmware before calibrating.

This is a cool tutorial video made by one of our users, which briefs the process and explains its logic.

* The logic behind calibration is:

1. You don't know where the servos are pointing before they are powered and calibrated. So if you attach the legs, the legs will rotate to random angles and may collide with the robot's body or other legs and get stuck. If a servo is stuck for a long time, it may break.

2. The robot has a "calib" posture with all joints set at zero degrees. You can put the robot to the calib posture so that you know all the joints should be rotated to their zero points (though you cannot see because the legs are not attached to the servos yet). Then, you can attach the legs to the servos one joint by one joint, perpendicular to their nearby references on the body frame.
3. Because the servo's gear teeth are discrete, aligning the legs to the right angles perfectly is impossible. So, you will need to fine-tune the offsets within the software.

The principles are the same for Nybble and Bittle.

Prepare to Enter the Calibration State

Entering calibration mode requires the following preparations: ‌

1. All servo circuits are connected to the motherboard

2. The battery is plugged into the controller board and is turned on (long-press the button on the battery to turn on/off the power)

3. The USB adapter or Bluetooth dongle is used to connect the robot to a computer or mobile phone

Enter the Calibration State

The robot's legs may point to unknown angles when booting up. When entering the calibration state, the joints will be moved to their zero positions. You can see the output gears of the servos rotate and then stop. Then, you can attach the legs and fine-tune the joint offsets in the software interface. There are 3 software interfaces to enter the calibration state and fine-tune the joints.

• Use the Mobile App Petoi

• Use Petoi Desktop App

• Use Arduino IDE

Install the screws

After completing the joint calibration, install the center screws to fix all the joint parts and servo gears.

We humans and many other legged animals have many joints. They give us the freedom to move in many ways. Though it's difficult to reproduce those complex motions on a robot, we can simplify all those joints to limited numbers of actuators.

When controlling so many joints, the first thing is to index them. We can define an order according to their distance from the torso. For example, the shoulder joint is closer to the torso than the elbow joint, and the joint that let us look around is closer to the torso than the joint that let us nod. If we had tails, it would be as close as the head compared to the shoulder joints.

So we can order the joints in this way: head panning, head tilting, tail panning, tail tilting, 4x shoulder (or hip) roll, 4x shoulder (or hip) pitch, 4x elbows (or knees). For the joints in the same distance group, we can index them clockwise from the front-left corner if the body is looked at from behind.

And when we map those joints to a specific robot, the indexing becomes more practical. The ordering for the joint servo pins on NyBoard is like below:

NyBoard

Bittle

Nybble

BiBoard

Although the BiBoard has only 12 pins, the joint index numbers are configured in the same order as the NyBoard. The connection between the joint servo and the pin is shown in the figure below：

Bittle

Nybble

Coordinate values and directions.

The rotation angle range of the joint servo is between [-125~125]. For the leg servo, when viewed from the left side of the robot, when the leg rotates counterclockwise from the 0-degree position around the joint center point (the screw fixing position), the angle is a positive value; clockwise rotation, the angle is a negative value; viewed from the right side of the robot, the leg rotation angle is mirror-symmetrical to the left side (when rotating clockwise from the 0-degree position around the joint center point, the angle is a positive value; Rotate counterclockwise, the angle is negative). For the robot's neck servo, looking down from the top of the robot's head, when the neck rotates counterclockwise from the position of 0 degrees around the joint center point (the position where the screw is fixed), the angle is a positive value; when it rotates clockwise, the angle is a negative value.

If you want to use Joint Calibrator, Skill Composer in the Petoi Desktop App, or a coding block in Mind+ via computer Bluetooth, you need to pair the mainboard's Bluetooth with the computer first.

Connection Steps

For BiBoard

1. Power on the mainboard via the battery (plug in the battery to the mainboard, and long-press the battery button > 3 seconds); after powering on, the mainboard's blue LED and yellow LED should be on.

2. For Windows, Open the Bluetooth & other devices setting page, and turn on the Bluetooth button as follows:
3. Add the BiBoard Bluetooth for the first time as follows:

   Select the one with the name Bittle**_BLE:

After paired successfully, it shows：

Check the outgoing serial port, which we will use later in the Mind+ or Petoi Desktop App in the More Bluetooth options:

1. Test in Mind+:

For NyBoard

Please refer to the Bluetooth module for NyBoard.

Thanks for choosing Petoi's robot, Bittle or Nybble. This guide will help you set up your robot buddy and provide a simpler UI to calibrate the joints, control the robot, and program it. For advanced users, we recommend you keep the robot updated with the OpenCat firmware on Github for the best compatibility and the newest features.

Download and installation

The app works on both Android and iOS devices.

• iOS 11+

• Android 4.4+

APK

You can also download the Android APK and install it on your phone. You need to unzip it before installation.

If the Bluetooth dongle blinks while the connection panel within the App shows a blank Bluetooth connection list, first check if you have given the Bluetooth and location permission to the App. If it still shows a blank list, you may try to install the previous stable version.

• The v8a version of the app mainly supports most of the current new mobile phone models

• The v7a version of the app is compatible with older mobile phone models

Connect to your robot

You need to plug the Bluetooth dongle into the 6-pin socket on the NyBoard. Pay attention to the Bluetooth dongle's pin order. Long-press the button on the battery to turn on the robot's power.

The LED on the Bluetooth dongle should blink, waiting for a connection. Open the app and scan available Bluetooth devices. Don't connect the robot with the phone's system-wide Bluetooth settings! Connect the device with the name Bittle, Petoi, or OpenCat. Remember to open the Bluetooth service and grant the app access to the service. On some devices, you may also need to allow the location service for the app, though we are not using any of that information.

If Bluetooth is connected, its LED will light steadily. The robot will play a three-tone melody. If the robot doesn't respond or malfunctions later, press the reset button on the NyBoard to restart the program on the NyBoard.

The App should automatically detect Nybble or Bittle with the latest OpenCat firmware. Otherwise, it will show the selections for Nybble or Bittle. The option "Select a robot" also can be re-visited in the control panel.

Petoi Desktop App provides a neat graphical user interface to configure the firmware, calibrate the robot, and design customized motions for your robot. The major function modules are the Firmware Uploader, Joint Calibrator, and Skill Composer.

Download & Installation

You can download the latest version of the desktop App and unzip it.

Before running the app, you must use the included USB adapter or the Bluetooth dongle to connect to a Petoi robot. You may need to install drivers for USB connection.

Windows

Run the UI.exe in the unzipped folder. Do NOT move the UI.exe to another location in Windows.

Mac

After downloading the Mac version, you must drag it into the Application folder.

If you see the error message that "Petoi Desktop App" cannot be opened because the developer cannot be verified, you can right-click the icon, hold the Shift key and click Open.

Linux

Please see the next chapter to run the app from a terminal

Run the app from the Terminal

In the case of compatibility issues, or if you want to modify the source and test, you can also run the code from the Terminal.

The Terminal is a built-in interface on Mac or Linux machines. The equivalent environment on Windows machines is called the Command-Line Tool (CMD). It's recommended that you install Anaconda to manage your Python environment. It can also provide the Powershell as a Terminal for older Windows machines.

Depending on your existing Python configuration, you may need to upgrade to Python3 and install the following libraries:

• pyserial

• pillow

You can install them by entering pip3 install pyserial pillow in the Terminal or use the package manager in Anaconda.

To run the code:

1. In the Terminal, use the cd command to navigate to the OpenCat/pyUI/ folder. You can use the Tab key to auto-complete the path name.

2. After entering the pyUI/ folder, enter ls and ensure you can see the UI.py and other python source codes listed.

3. Enter python3 UI.py.

Open Source Codes

The source code is written with Tkinker in Python3 and is open source.

UI.py is the general entry for all the modules:

• UI.py

-> FirmwareUploader.py

-> Calibrator.py

-> SkillComposer.py

-> translate.py provides multi-language support for the UI. You may help to translate the UI into your language.

Configure the Linux environment

You need to turn on Linux on the Chromebook to access the Linux environment via the terminal app.

Then, follow the following steps to install Mind+.

Check the processor architecture

Use the following command to check the processor architecture in the terminal: uname -m The output will be similar to "i686", "x86_64" or "armv7": i686 (or similar) - 32-bit Intel/AMD processor (common in older computers). x86_64 (or similar) - 64-bit Intel/AMD processors (modern laptops, desktops, and most Chromebooks). armv7 (or higher) - ARM processor. (Mobile phones, tablets, 2nd and 3rd generation Raspberry Pis running Ubuntu Mate, and some Chromebooks. Most are 32-bit now)

Download package

According to different architectures to download different versions:https://mindplus.dfrobot.com/linux

Installation

Use the following command in the terminal to install it (Replace ***** with the file name of the installation package): sudo dpkg -i *****.deb sudo apt-get -f install

After installed, you can start the Mind+ app in the Chromebook launcher:

Run Mind+

Now, you can proceed to the Mind+ tutorial.

Gaits

Postures and behaviors

The built-in postures and behaviors can be triggered by pressing the buttons. Don't press the button too frequently and repeatedly. Allow some time for the robot to finish its current tasks.

Customized commands

• Press and hold the button and drag to change the button position.

• Double-tap the command button to edit it.

• You can also create a customized single command/group command by pressing the "+" button.

Create a single command

After pressing the Create Command button, you can see the following interface:

After entering the editing state, there's a serial console to test the command and configure the robot.

You can try the following useful serial commands in the Code text box:

* move Bittle's head (move joint angle)

m0 45

* move head left and right (move joint1 angle1 joint2 angle2 .... The angle is -127~128)

m0 -70 0 70

* sit

ksit

* move joints one by one

m 0 -70 0 70 8 -30

* MOVE joints simultaneously

i 0 -45 8 -30 12 -60

Below are the indexes of the joints for your reference. Observe the patterns of the ordering and try to remember them.

* show current joint angles

j

* long meow once (Nybble）

u0 1

* short meow three times (Nybble）

u2 20

* mute/unmute the buzzer beep

b

* adjust the buzzer volume (b[0-10])

b1

* play a short tone (beep tone duration, duration is 0~256)

b12 20

* play a melody (beep tone1 duration1, tone2 duration2, tone3 duration3, .... only 64 characters are allowed, the actual duration is calculated as 1/duration)

b14 4 14 4 21 4 21 4

More common commands to be added

Please see this list of common commands that may be added as customized commands. You can enter the "Voice command" column values as the "Name" values and the "Customized command code for Petoi mobile app" column values as the "Code" values.

A more detailed command table can be found in the Serial Protocol.

Import new skills as a customized button

Import your local customized skill (created by the Skill Composer)

You can send the skill file to your phone using Messenger or email and open the file on the phone using the Petoi App. A button will be created for the new skill; you can see it when you open the control panel.

Import new skills from the skill library on GitHub

Create a group command

The group command feature lets you chain multiple commands together and play them in sequence.

After pressing the Create Group Command button, you can see the following interface:

You can name the command group in the Name text box and add the command to the Command Group list by clicking the command button in the Command Library selection box. In the Command Group list, you can press and hold the command button and drag to change the command position.

Click the Delete button to Delete the group command.

Make your robot act randomly

If your robot doesn't have any random behavior, you may need to upgrade your robot to the latest firmware.

Updates and support

We keep improving the app and will inform you of the updates when available. Please write to support@petoi.com if you have any questions about the app.

Switch to the Python coding mode

If you are familiar with the Petoi coding blocks and Python language, you can change to the Code mode in Mind+ as follows:

The Code mode is a Python3 development environment. You can write any Python script in it and call all the API interfaces of the PetoiRobot library imported by Mind+.

You can find the PetoiRobot library in the following directory. There are all the definitions of API interfaces in the PetoiRobot.py

• Windows C:\Users\{username}\AppData\Local\DFScratch\extensions\petoi-robot-thirdex\python\libraries\PetoiRobot.py

• MacOS /Users/{username}/Library/DFScratch/extensions/petoi-robot-thirdex/python/libraries/PetoiRobot.py

Here is a sample code :

# The code starts here
from PetoiRobot import *    # must import the PetoiRobot library

# enter the code below
# auto connect serial ports
autoConnect()

# call the APIs to control the Petoi robot
sendSkillStr('ksit', 0.5)
sendCmdStr('T', 0.5)
loadSkill("skillFileName", 0.2)

# close the serial port
closePort()

You can also copy the code in the Auto Generate area in the Blocks mode and then paste it into the code file in the Code mode. Then you can edit and run the code.

** Download the latest version of the Petoi Desktop APP. **

• After downloading the compressed file(.zip), please unzip it first.

• Do NOT move the UI.exe to another location in Windows.

From version 1.2.1, the Petoi Desktop App has included a new module, Debugger. This module provides convenient tools to fix your robot's frequent problems.

Reset voice module

It is used to reset the voice command module, simplifying its debugging process. If the voice module does not respond to your voice, you can use this tool to reset it. It's pretty simple to use: click the Reset voice module button.

After clicking the button, please follow the instructions in the message box.

If the problem persists, please email support@petoi.com.

Calibrate the joints

Nybble

Bittle

Prepare for calibration

You need to connect the Bluetooth module (for NyBoard only) with computer, install the battery and long-press the button on the battery to power the robot.

Enter the calibration state

After the robot is powered on, there are 2 methods to enter the calibration state:

• Click the Start Calibration button.
• Click the Calibration button in the calibration interface.

Install the head

In the calibration state, place the head as close to the central axis as possible and insert its servo shaft into the servo arm of the neck.

Press down on the head so it is firmly attached to the neck.

Install the legs

Install upper leg and lower leg components to the output teeth of the servos when the Bittle is powered on and in the calibration state. Please keep the torso, upper leg, and lower leg installed vertically as much as possible, and do not install the lower leg backward, as shown in the picture.

Use the included L-shaped tool as a reference!

Nybble

Bittle

When calibrating, first select the index number of the joint servo from the diagram(when adjusting the leg servo, adjust the thigh first, and then adjust the calf), and then click the "+" or "-" button to fine-tune the joint to the right angle state.

You can click the skill buttons to switch between Rest, Stand, and Walk to test the calibration effect.

If you want to continue calibrating, please click the Calibration button, and the robot will be in the calibration state again (all servos will move to the calibration position immediately).

After calibration, remember to click the "Save" button to save the calibration offset. Otherwise, click "<" in the upper left corner to abandon the calibration.

Install the screws

After completing the joint calibration, install the center screws to fix the leg parts and servo gears.

NyBoard is equivalent to a generic Arduino Uno board with rich peripherals. Besides the native Arduino IDE, you can also program it using Mind+ blocks. But be aware that if you use this mode, the original OpenCat firmware will be over-written, and you will need to re-upload the firmware later to resume the default robot animal function.

Setting up the coding environment is as easy as the following steps.

Prepare to Enter to the Calibration State

Entering the calibration state requires the following preparations: ‌

Prepare to Enter the Calibration State

Entering the calibration state requires the following preparations: ‌

1. All servo circuits are connected to the motherboard

2. The battery is fully charged

3. Connect the USB adapter and communicate normally

If you build the robot with an unassembled kit, do not install the head and leg components until calibrated.

You need to install the battery and long-press the button on the battery to power the robot.

The calibration has three steps:

1. Power on the robot with battery, and let servos rotate freely to zero angle/calibration state

2. Attach body parts to the servos

3. Fine-tune the offsets in the serial monitor

1. Enter the calibration state

You must plug the servos and external batteries into the NyBoard and check the position and direction of all servos.

Type ‘c’ in the serial monitor to enter the calibration state. Depending on their initial shaft direction, some may travel larger angles until stopping at the middle point. There will be noise coming from the gear system of the servos. You will see a calibration table like the following:

The first row is the joint indexes; the second row is their calibration offsets:

Initial values are “-1” or “0” and should be changed by later calibration.

2. The rationale for calibration

2.1 Understand the zero state and the coordinate system

After typing ‘c’ in the serial monitor, with all servos rotated to their zero angles, attach the head, tail, and legs prepared in the previous section to the body. They are generally perpendicular to their linked body frames. The calibration pose is shown below:

Rotating the limbs counter-clockwise from their zero states will be positive (same as in polar coordinates). Viewed from the left side of the robot's body, the counter-clockwise rotation of the joint is defined as the positive direction.

2.2 Discrete angular intervals

If we look closer at the servo shaft, we can see it has a certain number of teeth. That’s for attaching the servo arms and avoiding sliding in the rotational direction. In our servo sample, the gears divide 360 degrees into 25 sectors, each taking 14.4 degrees(offset of -7.2~7.2 degrees). That means we cannot always get a perfect perpendicular installation.

2.3 Attach body parts to the servos

Install the head

In the calibration state, place the head as close to the central axis as possible and insert its servo shaft into the servo arm of the neck.

Press down on the head so it is firmly attached to the neck.

Install the legs

Install upper leg and lower leg components to the output teeth of the servos after the Bittle is powered on and in the calibrated neutral position. Please keep the torso, upper leg, and lower leg installed vertically as much as possible, and do not install the lower leg backward, as shown in the picture.

3. Fine-tune the calibration using the serial monitor

3.1 Joint Control Commands

The command for fine-tuning calibration (refer to the serial protocol) is formatted as cIndex Offset. Notice that there’s a space between cIndex and Offset. The index number of the robot's joints is shown in the pictures below:

For example :

• c8 6 This means giving the 8th servo an offset of 6 degrees.

• c0 -4 This means giving the 0th servo(the head) an offset of -4 degrees.

Find the best offset that can bring the limb to the zero states. It's a process of trial and error.

After calibration, remember to type ‘s’ to save the offsets. Otherwise, they will be forgotten when exiting the calibration state. You can even save every time after you’re done with one servo.

3.2 Use ‘L’ shaped joint tuner

When watching something, one's observations will change from different perspectives. When measuring length, one always wants to read directly above a referencing ruler.

You must keep a parallel perspective when calibrating Bittle. Use the 'L'-shaped joint tuner as a parallel reference to avoid reading errors. Align the tips on the tuner with the center of the screws in the shoulder and knee joints and the little hole on the tip of the foot. Look along the co-axis of the centers. For each leg, calibrate the shoulder servos (index 8~11) first, then the knee servos(index 12~15). When calibrating the knee, use the matching triangle windows on both the tuner and shank to ensure parallel alignment.

Nybble

Bittle

3.3 Testing and validation

After calibration, type ‘d’ or ‘kup’ to validate the calibration. This will result in Bittle / Nybble symmetrically moving its limbs between the rest and stand states.

You may need to do a few rounds of calibrations to achieve optimal states.

Take Bittle, for example, as follows:

3.4 Install the screws

After completing the joint calibration, install the center screws to fix the leg parts and servo gears.

3.5 Center of mass

Try to understand how the robot keeps balance even during walking. If you add new components to the robot, distribute its weight symmetrically about the spine. You may also need to slide the battery holder back and forth to find the best balance spot. Because the battery is heavier in the front, you can insert it in a reversed direction to shift the center of mass more toward the back.

Please do not force the robot to add heavy objects, which may cause the servos to sweep or get stuck.

** Download the latest version of the Petoi Desktop APP. **

Petoi Desktop App works on both Nybble and Bittle controlled by NyBoard based on ATmega328P or Bittle X controlled by BiBoard based on ESP32. For NyBoard, more detailed documentation can be found at NyBoard V1_0, NyBoard V1_1, or NyBoard V1_2 (which is similar to NyBoard V1_1).

Connect the mainboard to the computer

NyBoard(for Bittle & Nybble)

Use the USB uploader for NyBoard.

For more details, please refer to the Connect NyBoard section in the USB uploader module for specific steps.

NyBoard Version

You can find the board version number on the NyBoard.

BiBoard(for Bittle X)

Use the USB type-C data cable for BiBoard.

BiBoard V0

You can find the board version number on the BiBoard V0:

BiBoard V1

Upload the firmware using the Petoi Desktop app.

Download the latest version of the Petoi Desktop APP.

Open the PetoiDesktopApp

After properly connecting the USB uploader, open the PetoiDesktopApp (for Windows: UI.exe / for Mac: Petoi Desktop App), and select your Model and Language.

Menu bar in Petoi Desktop APP

Click the Firmware Uploader button

Auto Detect the Serial Port

If there is no serial port or more than one serial port are detected by the desktop app:

After clicking the Firmware Uploader button, there will be a message box prompt as follows:

Please follow the prompts in the message box. After clicking the Confirm button, If you complete the prompts within 10 seconds, the desktop app will automatically identify the serial port name connecting the robot to the computer. If you complete the operation of unplugging and plugging the USB interface on the computer for more than 10 seconds, the desktop application will enter the manual selection of the serial port name mode：

Click the OK button in the Warning message box first, then you can refresh the serial port list or select one of them (e.g. COM3) and click the OK button in the Manual mode window to open the Firmware Uploader interface as follows:

Once the Firmware Uploader interface is opened, you can also unplug and replug the USB cable from the COMPUTER side. The desktop app will automatically identify the serial port name connecting the robot to the computer.

If unplug the COM5 and replug it on the computer side, it will be discovered by the desktop app as follows:

Select the correct options to upload the latest firmware.

Uploading options

• Factory Reset Our factory uses it to improve efficiency. However, it automatically resets all the parameters, including the calibration parameters of the servos and the IMU, so it's not recommended for regular users.

• Upgrade the Firmware It will upgrade both the parameters and the main function.

  • It is mandatory if you just downloaded a new version of this desktop app.

• Update the Mode Only If you have upgraded the firmware at least once after downloading a new version of this desktop app, you can switch between the modes without refreshing the parameters. It's faster by skipping the firmware upgrade stage.

Upgrade the firmware process for NyBoard

After clicking the Upgrade the Firmware button, the uploading process starts immediately. The status bar at the bottom shows the current progress in real time and the results of key processes.

After the Parameters firmware has been successfully uploaded, the board runs the configuration program. Some message windows will pop up in sequence for you to confirm or cancel:

• Reset joint offsets? (Y/N)

Select "Yes, " and the program will reset all servo calibration parameters to zero. The status bar will update the corresponding process and result in real time.

Select "No" to preserve the calibration value(so that you don't need to calibrate again if you have done so before).

• Calibrate IMU? (Y/N)

Select "Yes, " and the program will calibrate the gyroscope (IMU) to balance the robot correctly. The status bar will update the corresponding process and result in real time.

Select "No," and the program will skip this step.

When all the steps are completed, a message window will appear showing "Parameter initialization complete!" You must confirm to proceed to the second round of uploading the main functional code.

Finish uploading the firmware

After the upload, the status bar will update the corresponding result, such as the success or failure of firmware uploading. If the uploading is successful, a message window of "Firmware upload complete!" will pop up simultaneously.

Check the log file

If the uploading fails, the following message box will pop up:

The log file is located at:

• For Windows: The log file is in the same directory as UI.exe
• For macOS: You can check the log file as follows:

When you contact our support@petoi.com, please attach the log file to your email.

We introduced the position feedback feature for servos manufactured after March 2024. This feature utilizes the same PWM signal wire to return the servo's actual position, opening up a new control interface for the robot.

This feature should be present on all servos with labels or laser marks after May 2024. If the labels are missing, they may still have it. However, the feature is only available on ESP32-based BiBoards (not NyBoards).

To check it, you need to upgrade your robot's firmware. Enter the serial command 'f' in Arduino's serial monitor or the mobile app's customized button. If the monitor keeps printing values that change when you move the servos, they are position feedback. The number of columns corresponds to the number of servos with feedback.

The servos have to be all feedback servos to perform the following features:

1. Enter 'fF' in the serial monitor, then slowly drag one of the legs. The other legs will follow the motion.

1. Enter 'c16'. The robot will enter its resting posture. Push the robot down flat to the table, move its head straight towards the front, and enter any character in the serial monitor. The robot will automatically set the calibration values of all its joints. Some joints can still be off and require standard calibration, but it saves most of the time.

2. Enter 'fl', which means learning new movements. Move the legs to your intended starting position, then keep the robot steady for about 2 seconds. The robot will count down and then beep slightly to indicate that it has started recording. It won't record small movements so that you can pause in the middle. After 124 frames, if you enter any character in the serial monitor or stop moving it for over 2 seconds, it will stop recording. Enter 'fr', which means replay to recall the taught movement.

3. The skill will also be printed on the serial monitor, and you can import it into SkillComposer and the smartphone app.

If you wish to write new applications based on the feedback servo, refer to the source codes in OpenCatEsp32/src/espServo.h.

Nested task queue

You can join multiple serial commands as one task queue:

• The token is T_TASK_QUEUE. ('q')

• Use 'q' to start the sequence.

• Add a sub token followed by the subcommand.

• Use ':' to add the delay time (mandatory)

• Add '>' to end the sub-command

• Example: qk sit:1000>m 8 0 8 -30 8 0:500> will make the robot sit and then move the shoulder joint.

Attach a trigonometric function to each joint to compose smooth and periodical movements

Function

JointAngle[index]= FunctionOf(amplitude, midpoint, freq, phase, resolution, frame)

• The token is T_SIGNAL_GEN. ('o')

• The command format is:o resolution speed,jointIdx1 midpoint amplitude frequency phase,jointIdx2 midpoint amplitude frequency phase,...

• For example: o 1 0, 0 40 -20 4 0, 1 -30 20 4 30, 8 -70 10 4 60, 12 -10 10 4 0, 15 10 0 4 0

• It doesn't matter if you use ',' or space ' ' to separate the numbers. However, using ',' to group can clarify one joint's parameters.

Formula

for (int t = 0; t < 360; t += resolution)  
  angle = midpoint + 
         round(amp * sin(2.0 * M_PI * ((t + phase * 3 / freq) / (360.0 / freq))));

• The motion's iterator loops from 0 to 360.

• The resolution is how it increases to 360: t += resolution.

• The speed defines the transition speed. It will move by [1~125] degrees towards the target angle. 0 is the maximum speed possible.

• frequency defines how many cycles the joint can oscillate in one loop.

• phase is defined as -120 to 120. So phase = 30 means shifting by Pi/2. 120 is one entire period.

• For example, the head’s pan/tilt angles can be bound to form the Lissajous Figure.

Pan+tilt:

qksit:100>o 1 8, 0 0 30 4 0, 1 -30 30 4 30:100>o 1 0, 0 0 30 4 0, 1 -30 30 4 15:100>o 1 0, 0 0 30 4 0, 1 -30 30 8 30:100>o 1 8, 0 0 30 8 0, 1 -30 30 4 30:100>o 1 8, 0 0 30 4 0, 1 -30 30 16 30:100>o 1 0, 0 0 30 32 0, 1 -30 30 8 0:100>Wash face:qksit:100>i0 20 1 0 8 -70 12 0 15 10:0>o1 0, 0 40 -20 4 0, 1 -30 20 4 30, 8 -70 10 4 60, 12 -10 10 4 0, 15 10 0 4 0:100>m0 0 1 -20 2 0:0>ksit:0

We have defined a set of serial communication protocols for robots:

All the tokens start with a single ASCII-encoded character to specify their parsing format. They are case-sensitive and usually in lowercase.

Try the following serial commands in the serial monitor:

• “ksit”

• “m0 30”

• “m0 -30”

• “kbalance”

• “kwkF”

• “ktrL”

• “d”

You can refer to the macro definitions in OpenCat.h to utilize the most updated sets of tokens.

Some more available commands for skills:

The complete set of skills in effect is defined in InstinctBittle.h or InstinctNybble.h: For example:

const char* skillNameWithType[]={"bdFI","bkI","bkLI","crFI","crLI","hlwI","mhFI","mhLI","pcFI","phFI","phLI","trFI","trLI","vtFI","vtLI","wkFI","wkLI","balanceI","buttUpI","calibI","droppedI","liftedI","restI","sitI","strI","zeroN","bfI","ckI","climbCeilI","fdI","ffI","hiI","jyI","pdI","peeI","puI","pu1I","rcI","rlLI","rtI","stpI","tsI",};

All the skill names in the list can be called by adding a 'k' to the front and deleting the suffix. For example, there's "sitI" in the list. You can send "ksit" to call the sitting posture. If a skill has "F" or "L" as the second last character, it's a gait. It means walking forward or left. Walking right is a mirror of walking left. So you can send "kwkF", "kwkL", "kwkR" to make the robot walk. Similarly, there are other gaits like trot ("tr"), crawl ("cr"), and stepping ("vt").

1. Preparation

The remote doesn't require pairing. Make sure its plastic insulation sheet is removed, and point the remote‘s transmitter to the receiver on the robot's back when operating. If the robot doesn't respond, you can use your phone‘s camera to check the transmitter. If it doesn't blink when clicking a button, you need to change its battery. If it blinks, it may indicate the program on the robot is not configured correctly.

2. Keymap

Only the position of the buttons matters, though those symbols can help you remember the functionalities. It's better to define position-related symbols to refer to those keys, such as K00 for the 1st row and 1st column, and K32 for the 4th row and 3rd column.

Abbreviations for key definitions can reduce SRAM usage. Due to the limited keys of a physical remote, you can change the definitions for convenience.

We also made a customized remote panel for future batches. Previous users can download the design file and print it on A4 paper.

3. Check out the following featured motions

• Rest puts the robot down and shuts down the servos. It's always safe to click it if Nybble is doing something awkward.

• Balance is the neutral standing posture. You can push the robot from the sides and it will try to recover. You can test its balancing ability on a fluctuating board. Balancing is activated in most postures and gaits.

• Pressing F/L/R will make the robot move forward/left/right

• B will make the robot move backward

• Calibrate puts the robot into calibration posture and turns off the gyro

• Stepping lets the robot step at the original spot

• Crawl/walk/trot are the gaits that can be switched and combined with the direction buttons

• Buttons after trot are preset postures or other skills

• Gyro will turn on/off the gyro for self-balancing. Turning off the gyro can accelerate and stabilize the slower gaits. But it’s NOT recommended for faster gaits such as trot. Self-righting will be disabled because the robot no longer knows it's flipped.

• Different surfaces have different friction and will affect walking performance. The carpet will be too bushy for the robot's short legs. It can only crawl (command kcr) over this kind of tough terrain.

• You can pull the battery pack down and slide along the longer direction of the belly. That will tune the center of mass, which is very important for walking performance.

• When the robot is walking, you can let it climb up/down a small slope (<10 degrees)

1. Read the Quick Start Guide

For the specific parameters of each functional module of BiBoard, please refer to：

• BiBoard V0 Guide

• BiBoard V1 Guide

2. Set up BiBoard

2.1 Prepare the ESP32 development environment

Please refer to Chapter 3.2.1 of the BiBoard Quick Start Guide.

2.2 Modify the code file in the package

• sdkconfig.h

Append a line of code at the end of the file:

#define CONFIG_DISABLE_HAL_LOCKS 1

2.3 Setup the options

Please refer to the option list to set up the board's upload speed, CPU frequency, etc.

There is a setting for the Flash Size and Partition Scheme among the options. For more information, refer to the next section.

2.4 Choose hardware partition

The BiBoard V0 uses an ESP32 with a 16M flash. To simplify, you can use the default 4 MB partition map without a problem. There's plenty of programming space for the standard OpenCatEsp32 firmware.

The BiBoard V1 uses an ESP32 with a 4M flash.

4 MB partition

You can use the default 4MB with spiffs. You can also use other partition schemes under the 4 MB flash limit, such as "No OTA" or "Huge APP".

16 MB partition

Suppose you want to fully utilize the 16 MB flash of BiBoard (it's unnecessary and takes a longer uploading time). You can read the user manual for the Add hardware partition configuration option in Arduino IDE.

2.5 Download the source code & install the library

1. Download the ​OpenCatEsp32 repository from GitHub repository: https://github.com/PetoiCamp/OpenCatEsp32 We suggest you utilize GitHub’s version control feature. Otherwise, make sure you download the WHOLE OpenCatEsp32 FOLDER every time. All the codes have to be the same version to work together.

1. If you download the Zip file of the codes, you will get an OpenCatEsp32-main folder after unzipping. Please rename it to OpenCatEsp32 before opening the OpenCatEsp32.ino so that the two names match.

• There are several test***.ino codes in the ModuleTests folder. You can upload them separately to test specific modules (I recommend using testBuzzer.ino as your first test sketch).

1. Install the latest version of library (ArduinoJson) in the Library Manager:

2.6 Connect to BiBoard via USB type-C data cable

Set the serial port in the Arduino IDE:

2.7 Compile and upload the sketch

Modify the device type macro definition in OpenCatEsp32.ino according to the device type.

#define BITTLE    //Petoi 9 DOF robot dog: 1 on head + 8 on leg
//#define NYBBLE  //Petoi 11 DOF robot cat: 2 on head + 1 on tail + 8 on leg
//#define CUB

Modify the motherboard model macro definition in OpenCatEsp32.ino according to the mainboard (BiBoard) version.

// #define BiBoard_V0_1  //ESP32 Board with 12 channels of built-in PWM for joints
#define BiBoard_V0_2
// #define BiBoard_V1_0

if the robot(Bittle R) with the robotic arm, you should also activate the macro definition as follows:

#define ROBOT_ARM                 // for attaching head clip arm

Otherwise, please comment out this line code.

After the modification is completed, you can click the Upload button (as below) to upload the sketch OpenCatEsp32.ino, and the changes in the code file will be automatically saved.

2.8 Program Initialization

If the version date of the currently uploaded sketch is newer than the version date of the mainboard firmware, it will automatically enter the initialization startup mode after the sketch upload is completed.

• You can check the version date of the currently uploaded sketch in the source code file (OpenCatEsp32/src/OpenCat.h): #define DATE "250218" // YYMMDD

When the mainboard is powered on, open the serial monitor and you will see the startup information:

ets Jun  8 2016 00:22:57

rst:0xc (SW_CPU_RESET),boot:0x1b (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0030,len:1344
load:0x40078000,len:13964
load:0x40080400,len:3600
entry 0x400805f0
k
Flush the serial buffer...

* Start *
Bittle X
Software version: B02_250121
Scanning I2C network...
- I2C device found at address 0x54:	EEPROM
- I2C device found at address 0x5C:	Misc.
- I2C device found at address 0x68:	MPU6050
- I2C device found at address 0x69:	ICM42670
- I2C device found at address 0x7E:	Misc.
- done
GroveVisionQ	0
MuQ	0
Set up the new board...
Unmute and set volume to 5/10
Using constants from I2C EEPROM
- Name the new robot as: Bittle45

Next you will see the following prompt questions:

Reset the joints' calibration offsets? (Y/n): 

• Send 'Y' to the question, which means resetting all servo corrections to zero.

• Send "n" to skip this step.

- Calibrate the Inertial Measurement Unit (IMU)? (Y/n): 

• Send 'Y' to the question, which means calibrating the IMU, i.e. the gyro/accelerometer sensor.

• Send "n" to skip this step.

Run factory quality assurance program? (Y/n)        

Input 'n' and press Enter to continue. Or you can do nothing, it will Auto skip in 5 seconds.

The details of serial port printing information are as follows：

* Start *
Scanning I2C network...
- I2C device found at address 0x54  !
- I2C device found at address 0x68  !
- done
Set up the new board...
// 蓝牙连接时使用的设备名称
- Name the new robot as: BittleED    
Reset the joints' calibration offsets? (Y/n): 
Y
Buzzer volume: 5/10
- Calibrate the Inertial Measurement Unit (IMU)? (Y/n): 
Y

Put the robot FLAT on the table and don't touch it during calibration.

Initializing MPU6050...
OK
If the program stucks, reinstall Arduino ESP32 boards version 2.0.12. Newer version may cause bugs!
- Testing MPU connections...attempt 0
- MPU6050 connection successful
- Initializing DMP...
MPU offsets: 2691	1893	1181	72	-57	0	
Calibrate MPU6050...
>....................>....................
MPU offsets:
//           X Accel  Y Accel  Z Accel   X Gyro   Y Gyro   Z Gyro
//OFFSETS     2759,    1871,    1173,      73,     -56,      -4
- Enabling DMP...
- DMP ready! Waiting for the first interrupt...
BLE:		Bittle45_BLE
Waiting for a BLE client connection to notify...
SSP:		Bittle45_SSP
The SSP device is started, now you can pair it with Bluetooth!
Setup ESP32 PWM servo driver...
Calibrated Zero Position
135	225	135	135	190	80	190	80	190	80	80	190	
Build skill list...88
Run factory quality assurance program? (Y/n)
(Auto skip in 5 seconds)
5...4...3...2...1...n
TaskQ
rest
11
Init voice
Number of customized voice commands on the main board: 
10
Turn on the audio response
Show Petoi Logo color
S,	A,	T,	L,	D,	I,	B,	U,	G,	C,	Q,	
0,	1,	0,	0,	0,	0,	0,	0,	0,	0,	0,	
Ready!
g
rest
d
XAaXAc
Switch English

When the string "Ready!" is output in the serial monitor, the program will enter the regular startup mode.

Every time the mainboard is powered on, it compares the BIRTHMARK in the EEPROM to determine whether the program has been initialized. If the program has already been initialized, it will not enter the initialization startup mode again.

2.9 Swith working mode via the serial commands (Optional)

The default code runs the Standard mode (including the Voice command function). If you want to switch modes, Please open the serial monitor and send the following serial commands:

2.10 Power on

• Long-press the battery button and boot up the robot with one side up. It will enter the calibration state automatically in the regular startup mode. The picture below shows the head, the upper and lower legs installed after the robot enters the calibration state.

Please refer to Chapter 5 🔌 Connect Wires and Chapter 6 📐 Calibration for the complete calibration process.

• If you power on the robot and it is upright (with its back upward), the robot will start from the "rest" posture (fold the legs and unlock the servos) in the regular startup mode.

3. Configuration with App

The BiBoard has built-in Bluetooth, and you can connect it with the mobile app to do joint calibration and remote control.

You can check the update history information in the ChangeLog.md.

After uploading the MicroPython firmware on ESP8266, we can use it run MicroPython scripts.

1. Run the script directly

We can execute the python scripts directly in the interpreter.

# Simple script：
print("Hello MicroPython")

2. Use the .py file to run the script

The NyBoard WiFi module ESP8266 uses the IO2 pin to connect with a red LED to indicate the connection status. This LED is programmable. Write a simple python blink script:

from machine import Pin
import time

# GPIO LED IO2
def blink():
    
    led = machine.Pin(2, machine.Pin.OUT)     # Pin 2 ,Output mode
    
    while(True):			# loop
        led.on()			# light on LED
        time.sleep(1)		# delay 1s
        led.off()			# light off LED
        time.sleep(1)		# delay 1s

if __name__ == "__main__":
    blink()

Press the green start button on the toolbar, and the script will be sent to the WiFi module through the serial port, and then run after being interpreted by the built-in MicroPython interpreter of ESP8266. Because the Blink script is an endless loop when it needs to stop, press the red stop button to end the program interruption and reset.

3. Upload the .py file to the ESP8266

We can click View -> File to open the file toolbar, and the file is displayed on the left side of Thonny. The upper part is the directory of the local machine, and the lower part is the files stored in the MicroPython device. By default, there is only one boot.py file, please do not delete this file, it is the startup file of the MicroPython device.

We save the script as blink.py and save it on the machine, right-click on the file and select Upload to / :

Select the MicroPython device in the pop-up window:

There is a blink.py file on the device. So the file is saved on the device.

4. Write a script to let robot perform actions sequentially

ESP8266 can send commands to NyBoard through the serial port. We only need to write a simple serial port sending script to send a series of serial port commands to NyBoard, and then the robot can execute sequence actions.

from machine import UART
import time

uart = UART(0, baudrate=115200,timeout=5)

# walk
def walk(time_ms):
    print("walk")
    uart.write("kwkF")      # walk cmd
    time.sleep_ms(time_ms)  # keep time
    uart.write("d")         # stop
    time.sleep_ms(1500)
    
# backward
def back(time_ms):
    print("back")
    uart.write("kbk")
    time.sleep_ms(time_ms)
    uart.write("d")
    time.sleep_ms(1500)

# stop
def stop():
    uart.write("d")
    
def initConnection():
    connected = False
    while True:
        uart.write("d")
        for t in range(30):
            uos.dupterm(None, 1)        # disable REPL on UART(0), detach the REPL from UART0
            time.sleep_ms(5)            #delay is a must
            result = uart.read(1)
            uos.dupterm(uart, 1)        # enable REPL on UART(0), reattach REPL

            if result != None:
#                 uart.write(result)    # for debug
                if result == b"d":

                    connected = True
                    break
            time.sleep_ms(10)

        if connected:
            break

    uart.write("b22 4 24 4 26 4")
 

def actSeq():
    initConnection()
    time.sleep_ms(2000)
    walk(3000)
    back(3000)
    uart.write("m0 90")
    time.sleep_ms(3000)
    uart.write("i8 -20 9 -60")
    time.sleep_ms(2000)
    uart.write("b26 4 24 4 20 4")
    time.sleep_ms(1000)
    uart.write("d")
    uos.dupterm(None, 1)        # disable REPL on UART(0), detach the REPL from UART0

    
if __name__ == "__main__":
    actSeq()
    

When the actSeq() function is executed, It can output a series of commands through the serial port. Using the serial monitor we can debug. Use the serial port monitor to monitor the output as follows (for the convenience of reading, please use the automatic frame break of the serial port debugger, in fact, there is no automatic line break).

5. Power on and run automatically

After we debug the sequence action, unplug the ESP8266 and plug it into the NyBoard, the robot dog does not respond because the actSeq() function is not running. We want to run the scripts automatically after power on. There are two methods:

• Please change the file name to "main.py" and save to the device (Recommend)

• Modify the Boot.py

The previous tutorial realized the function of the robot to perform sequence actions by editing Python code offline. But this is very inconvenient. Whenever we need to modify the code, we need to unplug the WiFi module for modification, and we cannot flexibly pause and modify parameters during execution. The reason is that ESP8266 only has one serial port, and we need to use it to communicate with NyBoard. Fortunately, MicroPython uses the WiFi function provided by ESP to realize remote wireless Python debugging - WebREPL.

The official document

On the basis of official documents, combined with the characteristics of ESP8266, we wrote the following tutorials:

1. Enable webREPL

After connecting the device, enter import webrepl_setup in the shell interface, and input according to the prompt information:

1. Enable it running on boot: E

2. Set password for it: your own password(e.g. 1234)

3. Repeat the password to confirm

4. Reboot the ESP8266: y

2. The script to setup webREPL

We use the demo script below, to replace the SSID and password with the network information your own around you.

import network
import time
import webrepl

def do_connect():
    
    # WiFi SSID and Password
    wifi_ssid = "YOUR SSID"             # YOUR WiFi SSID
    wifi_password = "YOUR PASSWORD"     # YOUR WiFi PASSWORD

    # Wireless config : Station mode
    station = network.WLAN(network.STA_IF)
    station.active(True)

    # Continually try to connect to WiFi access point
    while not station.isconnected():
    
        # Try to connect to WiFi access point
        print("Connecting...")
        station.connect(wifi_ssid, wifi_password)
        time.sleep(10)

    # Display connection details
    print("Connected!")
    print("My IP Address:", station.ifconfig()[0])
    

if __name__ == "__main__":
    do_connect()
    webrepl.start()

After running the script, it will keep trying to connect to the WiFi network. Once connected, it will automatically start the WebREPL service of the device.

Connected!
My IP Address: 192.168.xxx.xxx
WebREPL daemon started on ws://192.168.xxx.xxx:8266
Started webrepl in normal mode

Remember this IP address (automatically assigned by router DHCP), useful when configuring WebREPL.

3. Configure the WebREPL service

We are now debugging the Python script through WebREPL, and the previous serial port is used to communicate with NyBoard. So in the options, change the previous USB-COMx interface to WebREPL.

Then we fill in the IP address, port and password of WebREPL, and click OK.

When WebREPL Connected is displayed, the connection is successful.

We can try some simple scripts, such as blink.py.

WebREPL saves serial ports and supports wireless debugging. The disadvantage is that the speed is slow (because of network delay), and the waiting time for software reset is relatively long.

4. Separate the serial port from the debugger

Now we can use webREPL to debug the script, but when we open the serial port monitor, we will find that whenever we run the script, the serial port will send out a series of debugging content: These massive strings will cause the NyBoard to be too late to process and crash. As shown below：

We hope that when debugging the program, the serial port only outputs the commands we want to output, not the Debug information. Open the boot.py on the device, uncomment the line of code uos.dupterm(None, 1) and save it , and unbind the serial port and REPL debug. Restart the module, and the serial port debugging assistant will no longer print the debug information.

As a supplement, we can output debug information through the print() statement, which will be displayed in the Shell through WiFi.

So far, you can easily use the ESP8266 to debug robot through webREPL to edit action sequences based on MicroPython.

A Brief Introduction to the Interface

See the video tutorials.

Connection method

To run the Skill Composer, you can use the following methods to connect the robot's mainboard to the computer:

NyBoard

• Wired connection: The kit includes a USB Adapter and USB data cable connecting the robot's mainboard to the computer.

• Wireless connection(Bluetooth)： The kit includes a Bluetooth module connecting the robot's mainboard to the computer.

BiBoard

• Wired connection: The kit includes a USB Type-C data cable connecting the robot's mainboard to the computer.

• Wireless connection(Bluetooth)： The motherboard's built-in Bluetooth communication module allows you to establish a wireless connection between the robot motherboard and the computer.

** Download the latest version of the Petoi Desktop APP. **

Open the Petoi Desktop App (for Windows: UI.exe / for Mac: Petoi Desktop App), click the "Skill Composer" button, and open the skill composer interface.

The Skill Composer Interface

Nybble

Bittle

Menu Options

• Model

  • Nybble

  • Bittle

  Nybble cat and Bittle dog have different back leg joint directions. Their skill data are not interchangeable. Select the correct model before operating the Skill Composer. Otherwise, some joints may conflict with the robot's body.

• Language

  Currently, there are English, 中文, and Italian. You may contribute to the translation script.

• Utility

  We will keep adding small gadgets to the utility tab. We have an eye color picker for the Nybble cat's ultrasonic sensor with built-in LEDs. We also have an entry where you can add your creator credential to the skills you create.

Connection and State Dials

Listening / Connect button

Connect the robot to your computer through either the USB uploader or system Bluetooth settings, then open up this desktop app. It should automatically detect and connect to the robot. The robot's serial port will appear in the following drop-down menu. The button should turn from "Listening" to "Connected". If the robot fails to connect for the first time, you can click the "Listening" button to disconnect all the ports, then press the "Connect" button again.

Servo

The robot's joints will hold position when the force is on. You should NOT rotate them by hand. Turning it off can allow you to rotate the robot's joints freely. It's helpful to quickly pose the robot to plan its center of mass for balancing.

Gyro

The robot has a gyroscope to detect its body angle and movements. It's used for balancing and roll-recovering. Turning it off can avoid unexpected reactions when rotating the robot.

Random

In certain experimental modes (e.g. RandomMind mode), the robot will move randomly. This button can toggle the behavior on/off.

Send a serial command

Like the serial monitor, you can enter a serial command in the text box and send it to the robot by pressing the Enter key or clicking the Send button.

Preset Postures

A few preset static postures move the robot's joints to specific positions. You can use them as a starting point to build your motion sequence. We usually start with the "balance" posture, with the robot standing on all four legs.

You can switch between different postures and observe how the sliders in the Joint Controller area update to reflect the changes in joint angles.

Joint Controller

The angle sliders can show the robot's current joint angles. They can reversely rotate the robot's joints if you change their values. You can drag the slider bar for large angle adjustments or click above or below the slider bar for fine adjustments (by 1 degree). Some joints will have smaller accessible ranges than the sliders. Try to use angles between -125 and 125 degrees. Sending larger angles will increase the response time.

The sliders correspond to the robot joints if you look down at the robot's body with its head pointing forward. Joints closer to the body are closer to the center of the panel. The robot's joints can be mapped to your own body and become your avatar.

You can control multiple joints by clicking the dial "+" or "-" on each slider. All sliders with their "+" pressed will change by the same increments. Sliders with their "-" button pressed will change by the negative increments. The button can be toggled on and off. Click the "Unbind All" button to disengage all the joints at once.

You can also control the robot's whole body joints with the sliders in the center panel. You can tune these central sliders to adjust the robot's global orientation and translation. The neutral "balance" posture can generate better results than other tilted postures.

Skill Editor

The previous functions can modify a single posture. The Skill Editor is a stop-motion animation scheduler. You can add, delete, and insert frames of poses and make the robot perform continuous and smooth motions.

Every frame has a row of buttons and input fields as parameters. The first static row contains the column header to indicate the parameters' names.

Basic Operation

The Activated Frame

You can click the "=" button (the 2nd item of a frame) to activate the corresponding frame and move the robot to the frame's posture. The frame will hold all your new edits on the robot's current posture. The "=" symbol will become bold, and the button will become larger. The "=" symbol will become a red "!" mark if the current frame is edited. You can click this button to save your edits. Otherwise, the current edits will be abandoned if you click the "=" buttons of the other frames.

Add a Frame

You can click the "v" button (the 9th item of a frame) to add a frame after the current frame and activate it. The new frame will be identical to the previous activated frame.

Insert a Frame

You don't always add a new frame after the last frame. You can click the "v" button (the 9th item of a frame) of any intermediate frames to insert a new frame below the "v" button. The new frame carries information identical to the previously activated frame.

Mirror a frame

You can mirror the activated frame's posture by clicking the ">|<" button.

Delete a Frame

You can click the "<" button (the 8th item of a frame) to delete the current frame holding the button. All the following frames will shift up. If the activated frame is deleted, its preceding frame will be activated. If the activated frame is the first frame and is deleted, its following frame will be activated.

Add a Note to a Frame

You may lose track of what each frame holds with multiple edits to the frame list. Switching to individual frames can be time-consuming. We provide a "Note" field (the 7th item of a frame) where you can add short keywords to identify the frames. By default, a random animal name will be added to a frame when created.

Bound joints and passed-through edits

If a joint's angle is the same in the current frame and the next frame, editing and saving its angle will also update the angles in the following frames until the angle differs. For example, if joint 8's angles are 4,4,4,4,6,7 in all the frames, changing the angle in the second frame to 8 will update the sequence to 4,8,8,8,6,7.

Play the Skill Sequence

Besides manually clicking the "=" button (the 2nd item of a frame) to view the single posture, you can click the "Play" button to show the postures in order starting from the activated frame. During playing time, the button's text becomes "Stop" to allow you to stop in the middle.

Export the skill

After clicking the "Export" button, you can choose a location and filename to save the skill (from the activated frame. If the activated frame is the last action frame, all action frames in the action frame list are exported) as a text file. You can cancel the savings to skip. The desktop app will still send the skill to the robot for real-time performance. And you can call the last exported skill by the serial token "T." There are two ways:

• Open the serial monitor and input the serial command "T."

• Open the mobile app, use the Create Command function, and enter the serial port command "T" in the Code text box.

• Export the skill as a customized button in the mobile app. It can be permanent even if you create multiple skills.

Import the Skill

You will see a pop-up window after clicking the "Import" button. It allows you to copy-paste a skill data array in the text editor or import an existing skill file you or other users created. You can find example skill data in OpenCat/src/InstinctBittle.h or InstinctNybble.h. A complete skill format should include the "{ }" pair and the numbers between them. Only the first one will be imported if there are multiple skill arrays. The importer will do some simple format checks.

Reset the Skill Editor

You can use the "Restart" button to clear the Skill Editor panel and start over.

Advanced operation

Set up Action Frame Loops

If you need some consecutive action frames in the action frame list to run multiple times in a loop, you can first enter the number of loops in the Repeat text box above the action frame list (on the left side of the label "Set"), and then use the left mouse button to select them in turn, The index numbers (the 1st item of a frame) of the first and last two frames of the continuous action frame that want to achieve cyclic motion (the index number button will appear in a recessed state after selection), as shown in the following figure:

Set Movement Speed

In the action frame list, you can set the running speed of each frame of action (the 3rd item of a frame). There are the following 9 options for you to choose from (speed up the running speed in the order of numerical value):

1，2，4，8，12，16，32，48，max

Set Delay

In the action frame list, the "Delay" option (the 6th item of a frame) in each action frame indicates how long the robot delays before doing the next frame of action after the action of this frame is completed.

There are 17 presets for you to choose from: 0，50，100，200，300，400，500，600，700，800，900，1000，2000，3000，4000，5000，6000.

Of course, you can also enter any integer value in the range of 0~6000 in the "Delay" option box. The unit is milliseconds (ms).

Set Trigger and Angle

The "Trigger" option (the 4th item of a frame) in the action frame is used to set the body rotation direction when the robot triggers the next action frame. There are the following 5 setting options:

• None means that there is no trigger and the angle condition is set

• Pitch means the robot body rotates nose-down

• -Pitch means the robot body rotates nose-up

• Roll means that the robot body rolls to its left side (counter-clockwise when looking from the tail)

• -Roll means the robot body rolls to its right side (clockwise when looking from the tail)

The "Angle" option (the 5th item of a frame) is defined with reference to the angle of the polar coordinate system. As shown in the figure above, when the body is horizontal, the angle of the polar coordinate axis is 0 degrees. If the polar coordinate axis rotates counterclockwise, the angle is positive and gradually increases. The angle setting range is an integer value between -125~125.

When a specific trigger and angle are set in the action frame, the next frame of action will be triggered only when the robot rotates over the trigger angle in the trigger's direction. If a delay time is also set in this action frame, it will delay an additional time after the trigger condition is met before moving to the next frame.

When creating actions related to the rotation of the robot body (such as backflips, doing high bar exercises, etc.), it's vital to trigger the motion at a certain body angle whose timing can be hard to estimate, and it may also change during the motion. We can use the gyroscope to monitor the rotation angle of the robot body in real-time, so that the robot can trigger the joint servo at the exact time of the trigger event.

Export Mirror Actions

When exporting the action frames, if you want to mirror all the action frames in the action frame list (the robot's left and right side joints will be exchanged, as if seen in a mirror), you can first click the "MirrorAll" button, and then click the "Export" button. If you want to cancel the mirrored export, you can deselect the "MirrorAll" button.

Behavior and Gait Options

Before exporting action frames, select the "Behavior/Gait" options in the "Skill Editor" area as "Behavior". After clicking the "Export" button, the program will run on the robot and automatically interpolate between these action frames to make the robot move smoothly. All action frames will execute for only one round.

If the "Gait" option is selected before you click the "Export" button, the robot will continue to execute in a loop, and each action frame will run at the fastest speed; NO interpolation between action frames will be added. The motion can be quite brutal. Therefore, it is recommended that beginners always use the "Behavior" option to develop new skills.

When importing some pre-built skill array, the desktop app will automatically select the "Behavior/Gait" option according to the data format. The frames will be loaded into the frame editor, and the robot will automatically move to the first frame's posture.

Simultaneous Control of Multiple Robots

The desktop app supports the connection of multiple robots through their own serial ports (such as the Bluetooth communication module) to achieve simultaneous control of multiple robots. After a physical connection, the app can only recognize a serial port as a robot. So after the robot is powered on normally:

• USB

First, connect the USB uploader to the main board of the robot, and then use the data cable to connect it to the computer's USB interface.

• Bluetooth

First, plug the Bluetooth module into the main board of the robot (no need for the ESP32-based board) and pair the board with the computer's Bluetooth setting interface. The desktop app will keep detecting if there is a new serial port connection. When multiple serial ports are successfully connected, the serial port option button in the "State Dials" area will change to "All." Click the drop-down list to view all serial ports that have been successfully connected. All robots will be synchronized in real-time in this way. You can also select any one of the serial ports to control the corresponding robot.

If you unplug a USB serial port on the computer (or disconnect the Bluetooth module in the Bluetooth setting interface), the corresponding serial port will be removed from the drop-down list in real-time.

If you unplug all USB serial ports (disconnect all Bluetooth modules), the serial port option button displays "None," and the left button displays "Listening." The desktop app still automatically detects whether there is a serial port connection. When a robot is reconnected to the computer through the serial port, the button on the left side of the drop-down menu will display "Connected." The corresponding serial port name is displayed in the serial port option button.

If you want the desktop app to stop detecting serial connections, click the "Connected" / "Listening" button. The text in the button will change to "Connect," and all serial connections will be disconnected. Click the "Connect" button again to restart the real-time detection function.

Professional extensions

You can modify the source code of the Skill Composer in OpenCat/pyUI/SkillComposer.py.

Teach by pulling legs using the Feedback servo

We have added the position feedback feature to recent batches of Petoi servos. The servo can reply to a specific PWM pulse (3500µs) with its current position in the form of pulse length. The central controller (BiBoard) can convert the signal to angles for more interaction.

First, send the robot a serial command "xl" to start the learning process. In the demo, it's triggered by our customized voice command. The robot's servo driver will switch to reading mode. Joint jigs can occur during this transition. Organize the robot's legs and then hold it still. The learning starts when no significant movements are detected.

Pull the legs, and the movement will be recorded. Stopping in the middle is okay because identical postures will be skipped. The recording will stop if the maximal frame is reached or the robot's joints are not moved for 2 seconds.

The recorded command can be called by "xp" to replay. The skill data is also printed to the screen so you can save it and import it into the Skill Composer or other OpenCat interfaces.

The control logic is defined in OpenCatEsp32/src/reaction.h and motion.h.

Part 1: Hardware Setup

1.1 hardware list

• USB Uploader (CH340C)

• WiFi ESP8266

1.2 Connection

Insert the ESP8266 module into the module configuration interface of the USB uploader, and find the corresponding COM port in the Windows device manager.

Part 2: Software Setup

2.1 Download Thonny

Download the latest version of Thonny, an out-of-the-box Python editor that natively supports MicroPython.

Download address: https://thonny.org/

2.2 Download the MicroPython firmware

The compiled ESP8266 firmware is provided on the MicroPython official website, because our WiFi module is 4MB, please select the latest firmware with the name of ESP8266 with 2MiB+ flash, and download the bin file.

Firmware download address: https://micropython.org/download/esp8266/

2.3 Upload the MicroPython firmware to the ESP8266 module

There are two ways to upload the MicroPython firmware to the ESP8266 module:

• Using the ESPtool download tool, you can more precisely control the partition and use of Flash.

• Using Thonny's built-in tool.

For convenience, we use Thonny's built-in tool. The specific steps are as follows:

1. Open the Thonny, the main interface is as shown below. Thonny uses the Python interpreter in the installation directory by default.
2. Open Tools -> Options to enter the options page. In the first tab General, we can choose the language we need (needs to be restarted).
3. Open the second tab Interpreter, we replace the default Python3 interpreter with MicroPython (ESP8266) and select the corresponding port.
4. At this time, the ESP8266 module has not yet uploaded the MicroPython firmware. Click "Install or update firmware" in the lower right corner of the above picture to update the firmware using the built-in tool.

5. Select the port (COMx) where the ESP8266 module is located, and select the location where the downloaded MicroPython firmware (.bin file) is located. Check the flash mode: from image file (keep) (the speed will be slower, but it only needs to be burned once and it is not easy to make mistakes), and check the option Erase flash before installing. Press the Install button.
6. The progress will be displayed in the lower-left corner of the interface, erase the Flash first, and then write the firmware. When the word Done appears, it means that the programming has been completed.
7. The software preparation work is over, and the following display will appear after closing the download interface. The red text is garbled because ESP8266 will print a string of codes with a baud rate other than 115200 when it starts up. This code cannot be recognized by MicroPython Shell. When Python’s iconic symbol >>> appears, it means that the firmware is uploaded successfully.

Setup Process

OpenCat software works on both Nybble and Bittle, controlled by NyBoard based on ATmega328P. More detailed documentation can be found at the NyBoard V1_0 or NyBoard V1_1.

Dial the I2C switch (SW2) to Arduino.

The I2C switch changes the master of I2C devices (gyro/accelerometer, servo driver, external EEPROM). On default “Arduino”, NyBoard uses the onboard ATmega328P as the master chip; On “RPi”, NyBoard uses external chips connected through the I2C ports (SDA, SCL) as the master chip.

Quick Start Tutorial Video

The setup process for Nybble is almost the same, except that you need to change the model definition to #define NYBBLE. Make sure you read through the following detailed steps.

Downloads and installations of Arduino IDE

With NyBoard V1_*, you can simply choose Arduino Uno.

Connect the uploader (sometimes referred to as the programmer)

For specific steps, please refer to the Connect NyBoard section in the USB uploader module.

Connect Bluetooth uploader (optional)

For specific steps, please refer to the Connect NyBoard section in the Dual-Mode Bluetooth Module.

Download the OpenCat package

• Download a fresh ​OpenCat repository from GitHub: https://github.com/PetoiCamp/OpenCat. It’s better if you utilize GitHub’s version control feature. Otherwise, make sure you download the WHOLE OpenCat FOLDER every time. All the codes have to be the same version to work together.

• If you download the Zip file of the codes, you will get an OpenCat-main folder after unzipping. Rename it to OpenCat before opening the OpenCat.ino, so that the two names match.

• There are several testX.ino codes in ModuleTests folder. You can upload them to test certain modules separately. Open any testX.ino sketch with prefix “test”. (I recommend using testBuzzer.ino as your first test sketch)

• Open up the serial monitor and set up the baud rate. With NyBoard V1_*, choose the board as Arduino Uno and later set the baud rate to 115200 in both the code and the serial monitor.

• Compile the code. There should be no error messages. Upload the sketch to your board and you should see Tx and Rx LEDs blink rapidly. Once they stop blinking, messages should appear on the serial monitor.

Upload

To configure the board, please follow these steps:

1. Configure the robot type and board version

Open the file OpenCat.ino and select your robot and board version. For example:

#define BITTLE    //Petoi 9 DOF robot dog: 1x on head + 8x on leg
//#define NYBBLE  //Petoi 11 DOF robot cat: 2x on head + 1x on tail + 8x on leg

//#define NyBoard_V0_1
//#define NyBoard_V0_2
#define NyBoard_V1_0
//#define NyBoard_V1_1

2. Setup the configuration mode

Comment out #define MAIN_SKETCH so that it will turn the code to the board configuration mode. Upload and follow the serial prompts to proceed.

// #define MAIN_SKETCH

3. Plug the USB uploader into your computer

Install the driver if no USB port is found under Arduino -> Tools -> Port.

4. Plug the USB uploader into the NyBoard

For specific steps, please refer to the Connect NyBoard section in the USB uploader module.

5. Upload the configuration mode sketch

Press the upload button.

6. Open the serial monitor

You can find the button either under Tools, or at the top-right corner of the IDE.

Set the serial monitor as No line ending and 115200 baud rate.

7. Reset joint offsets

The serial prompts:

Reset joint offsets? (Y/n):

Input ‘Y’ and hit enter if you want to reset all the joint offsets to 0.

The program will do the reset and then update the constants and instinctive skills in the static memory.

8. IMU (Inertial Measurement Unit) calibration

The serial prompts:

Calibrate the IMU? (Y/n): 

Input ‘Y’ and hit enter, if you have never calibrated the IMU or want to redo calibration.

Put the robot flat on the table and don't touch it. The robot will long beep six times to give you enough time. Then it will read hundreds of sensor data and save the offsets. It will beep when the calibration finishes.

When the serial monitor prints "Ready!", you can close the serial monitor to do the next step.

9. Calibrate the servo controller chip PCA9685 on the NyBoard

After the IMU calibration, there's an optional step to calibrate the servo driver.

Optional: Connect PWM 3 -> Grove pin A3 to calibrate PCA9685

If later you find one of the servos stops working but can resume working after re-powering it, it's probably due to an inaccurate PWM driver signal. You must redo the previous uploading, and this step CANNOT be skipped.

This calibration makes the servo controller (PCA9685 chip)'s angle signal more precise. Use a short jumper wire to connect the PWM pin 3 (the signal pin of one of the servo pins) and Grove pin A3 and hold the wire steady. It doesn’t have to be a dedicated jumper wire. Any thin metal wire, such as a straightened paper clip, can work as long as it can connect the pins.

The program will measure the pulse width of the signal and automatically calibrate the chip after getting three identical readings successively. It usually takes less than 2 seconds. The board will beep three times to indicate the calibration is done. The calibration offset will be saved to the board for the next time of bootup. The process should be done at least once, and we have calibrated every board after October 2022. But you can still do it by yourself, just in case.

10. Upload the major functionalities sketch

Uncomment #define MAIN_SKETCH to make it active. This time the code becomes the normal program for the major functionalities. Then upload the code.

#define MAIN_SKETCH

Open the serial monitor. When the serial monitor prints "Ready!", the robot is ready to take your next instructions.

11. The module macro in the code

The default code runs the standard mode. If you have some extensible modules, you may uncomment the macro definition of a specific module. It will disable the Gyro code to save some programming space and activate the demo of the module.

The behavior of the official modules is defined in separate header files in OpenCat/src/. You can find them in OpenCat/src/io.h -> readSignal(). The behavior of OTHER_MODULES is defined in OpenCat/OpenCat.ino -> otherModule(). You can study the example code to write your own functions.

12. Modify the "joint - pin" mapping

In certain cases, you may want to modify the "joint - pin" mapping of the robot. You can modify it in OpenCat/src/OpenCat.h. Make sure you are modifying the code block corresponding to the board version at the beginning of OpenCat.ino. After the modification, remember to save the changes and redo the uploading process from step 2.

Memory arrangement

Congratulations! Now, you have finished the standard setup steps. You may read the source codes if you want to dive deeper into the program. The skills are saved in multiple places on a NyBoard due to ATmega328P's limited resources. The following diagram may give you some hints to help you understand.

Use the library in your own project

The project is built as a dynamic library so that the program can easily link to it. The recommended practice to use the library is to clone it as a git submodule:

git submodule add https://github.com/PetoiCamp/opencat_serial_cpp opencat_serial

If you are using cmake, simply create a CMakeLists.txt file and link the library to your executable:

cmake_minimum_required(VERSION 3.0.2)
project(serial_examples)
option(CATKIN_ENABLE "Enable using the Catkin make extension to cmake (ie for ROS)" OFF)
add_subdirectory(opencat_serial)
add_executable(serial_examples path/to/cpp)
target_link_libraries(serial_examples opencat_serial)

Examples

Below is a very simple example on how to use the library.

#include "opencat_serial/opencat_serial.hpp"
int main(int argc, char *argv[])
{
    // connect to the serial device
    OpenCat::Robot rob("/path/to/port");
    // create task
    OpenCat::Task task;
    // set command type to calibration pose
    task.command = OpenCat::Command::CALIB_POSE;
    // time delayed after execution
    task.delay = 2;
    // send command
    rob.SendTask({OpenCat::Command::CALIB_POSE, 2});
    return 0;
}

see examples for a more comprehensive example.

Free curricular

Connection

You can solder a 5-pin socket on BiBoard V1 to plug in a Raspberry Pi.

After plug in the Raspberry Pi board , power on the BiBoard via USB data cable or Battery. Then open the serial monitor, and send serial command XS to enable the Serail 2 working mode.

Serial port name on Pi

You can solder a 2x5 socket on NyBoard to plug in a Raspberry Pi. Pi 3A+ is the best fit for NyBoard's dimension.

Nybble

Bittle

The red Pi standoff can be 3D printed.

As shown in the serial protocol, the arguments of tokens supported by Arduino IDE's serial monitor are all encoded as Ascii char strings for human readability. While a master computer (e.g. RasPi) supports extra commands, mostly encoded as binary strings for efficient encoding. For example, when encoding angle 65 degrees:

• Ascii: takes 2 bytes to store Ascii characters '6' and '5'

• Binary: takes 1 byte to store value 65, corresponding to Ascii character 'A'

Obviously, binary encoding is much more efficient than the Ascii string. However, the message transferred will not be directly human-readable. In the OpenCat repository, I have put a simple Python script ardSerial.py that can handle the serial communication between NyBoard and Pi.

1. Config Raspberry Pi serial port

In Pi's terminal, type sudo raspi-config

Under the Interface option, find Serial. Disabled the serial login shell and enable the serial interface to use the primary UART:

1. Run raspi-config with sudo privilege: sudo raspi-config.

2. Find Interface Options -> Serial Port.

3. At the option Would you like a login shell to be accessible over serial? select 'No'.

4. At the option Would you like the serial port hardware to be enabled? select 'Yes'.

5. Exit raspi-config and reboot for changes to take effect.

If you plug Pi into NyBoard's 2x5 socket, their serial ports should be automatically connected at 3.3V. Otherwise, pay attention to the Rx and Tx pins on your own AI chip and its voltage rating. The Rx on your chip should connect to the Tx of NyBoard, and Tx should connect to Rx.

KERNEL=="ttyS0", SYMLINK+="serial0" GROUP="tty" MODE="0660"
KERNEL=="ttyAMA0", SYMLINK+="serial1" GROUP="tty" MODE="0660"

sudo chgrp -h tty /dev/serial0
sudo chgrp -h tty /dev/serial1

sudo adduser $USER tty
sudo adduser $USER dialout

sudo chmod g+r /dev/ttyS0
sudo chmod g+r /dev/ttyAMA0

2. Change the permission of ardSerial.py

If you want to run it as a bash command, you need to make it executable:

chmod +x ardSerial.py

You may need to change the proper path of your Python binary on the first line:

#!/user/bin/python

3. Use ardSerial.py as the commander of robot

Typing ./ardSerial.py <args> is almost equivalent to typing <args> in Arduino's serial monitor. For example, ./ardSerial.py kcrF means "perform skill crawl Forward".

Both ardSerial.py and the parsing section in OpenCat.ino need more implementations to support all the serial commands in the protocol.

Preparation

1. Install python (version≥ 3.6, such as Anaconda3-5.2.0-Windows-x86_64.exe)

2. Install pyserial library (version 3.5)

Connect the serial port

When using a USB adapter to connect to the NyBoard or USB type-C data cable to connect to the BiBoard, there should be only one serial port number:

When using the Bluetooth function, there can be two serial port numbers:

Download a fresh ​OpenCat repository from GitHub:

https://github.com/PetoiCamp/OpenCat

Please utilize GitHub’s version control feature. Otherwise, make sure you download the WHOLE OpenCat FOLDER every time.

Open a Terminal (such as Anaconda Prompt) and enter the path where the Python API is located (***/OpenCatPythonAPI). Then, run the two example scripts in the folder(petoiRobotExample.py and ardSerialExample.py). The script will automatically identify the serial port number at the beginning and complete the connection.

Run the scripts

Run the ardSerialExample.py

***\OpenCatPythonAPI>python3 ardSerialExample.py

ardSerialExample.py demonstrates how to call the functions defined in ardSerial.py（in the ***/OpenCatPythonAPI/PetoiRobot）

The list testSchedule in ardSerialExample.py is used to test various serial port commands. Run the following script code to see the execution effect of each serial port command in the list:

for task in testSchedule:
    wrapper(task)

You can also refer to the content of the testSchedule list (in ***/serialMaster/demos/hlw.py), write a list of behaviors according to your actual needs, and realize your creativity. 🤩 It was used in a Halloween puppet show.

Note: When running the scripts under the path of /serialMaster/demos, you must first use the "cd demos" command to enter the path where the scripts are located (/serialMaster/demos) and then use the python3 command to run the script (e.g., "python3 hlw.py")

Explanation of the serial port commands in the list testSchedule:

['kup', 2]

• 'kup' indicates the command to control Bittle to stand normally

• 2 indicates the postponed time after finishing the command in seconds.

• m indicates the command to control the rotation of the joint servo

• 0 indicates the index number of joint servo

• -20 indicates the rotation angle (this value is expressed relative to the reference 0 value used after calibration). The unit is in degrees.

• 1.5 indicates the postponed time after finishing the command in seconds. It can be a float number.

['m', [0, 45, 0, -45, 0, 45, 0, -45], 2]

['M', [0, 45, 0, -45, 0, 45, 0, -45], 2]

The meaning of this example is the same as the previous command.

['d', 2]

• d indicates the command to put the robot down and shut down the servos

• 2 indicates the postponed time after finishing the command in seconds

['c', 2]

• c indicates the command to enter calibration mode

• 2 indicates the postponed time after finishing the command in seconds. After these motion commands are completed, the next command will be executed after a 2-second delay.

['c', [0, -9], 2]

• c indicates the command to enter calibration mode

• 0 indicates the index number of joint servo

• -9 indicates the rotation angle. The unit is in degrees.

• 2 indicates the postponed time after finishing the command in seconds