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.

The purpose of the DAC is the opposite of that of the ADC. The DAC converts a digital signal into an analog signal for output.

Remember the music when NyBoard is turned on? It is using PWM to make music sound which uses high-speed switching to adjust the duty cycle to output voltage.

Compared with PWM, the DAC will directly output the voltage without calculating the duty cycle. ESP32 integrates a 2-channel 8-bit DAC with a value of 0-255. The voltage range is 0-3.3V. Therefore, the formula for calculating the output voltage of the DAC is as follows:

The demo is as follows:

#define DAC1 25 

void setup() {  
}

void loop() {
  
  // 8bit DAC, 255 = 3.3V, 0 = 0.0V 
  for(int i = 0; i < 255; i++){
    dacWrite(DAC1, i);
    delay(10);
  }
}

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

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.

Connect the USB Adapter

Connect the USB adapter to the mainboard and select the correct serial port. Please refer to the in the USB Uploader Module for specific steps.

You can choose the "Serial Monitor" in "Tools" menu bar, or click the button to open the serial monitor window:

Open up the serial monitor and set up the baud rate. With NyBoard V1_*, set "No line ending" and the baud rate to 115200 in the serial monitor.

Connect Bluetooth uploader (optional)

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

Then you can select it under Tools->Port of Arduino IDE, and use it in the same way as the USB adapter.

With the USB adapter / Bluetooth module connecting NyBoard and Arduino IDE, you have the ultimate interface - Serial Monitor to communicate with NyBoard and change every byte on it(via sending the serial commands based on the ).

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.

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.

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.

You may check a more detailed tutorial in the following post.

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.

Setup environment

Please refer to the instruction of the WiFi ESP8266 and use the Arduino IDE to open the sample program (ESP8266WiFiController.ino) to upload the WiFi control firmware for the ESP8266 moudle.

Install Python3, and download the Python scripts to control the robot.

Script introduction

For Python 3.8 and above, the calling syntax is different for the definition of type. This script is compatible with this, but you need to comment and uncomment several corresponding statements in the script according to the version of Python you have installed. For example, the following script supports Python versions below 3.8:

"""
In Python 3.8 and earlier, the name of the collection type is
capitalized, and the type is imported from the 'typing' module
"""
# from typing import Union, Optional             # for Python 3.9+
from typing import Union, Dict, List, Optional   # for Python 3.7

This script can control only one robot alone, or control multiple robots at the same time, which can be realized by modifying the following statement in example.py:

# ip = "192.168.0.108"                     # for only one robot
ip = ["192.168.0.110", "192.168.0.108"]    # for multiple robots

How to Use

Refer to the instruction of the WiFi ESP8266 to assign the IP address to the ESP8266 module and then insert it into the main board of the robot. After the robot is powered on normally, you can use python to run the script example.py to control the robot wirelessly. You can modify the following script statements (modify the content of the list) according to your actual needs to make the robot perform various actions:

cmds = [
        Command.sit, Command.balance, Command.stepping, Command.pee,
        Command.stop
    ]

For currently supported skill action commands, please refer to the code file actions.h (in ESP8266WiFiController).

BiBoard is equipped with an infrared sensor, which is connected to the 23rd pin. The use of infrared is exactly the same as which is on Arduino UNO based on AVR.

First download the 2.6.1 version of the IRremote library, you need to manually select the 2.6.1 version. Because the infrared-related codes have changed in later versions, if you use the 3.X version, the commands will not be translated. In order to be compatible with our previous products, we decided to use the 2.6.1 version after testing.

When using NyBoard, in order to ensure that the code can be compiled smoothly, we need to remove unnecessary code in the IRremote library, that is, remove the encoder/decoder that we don't use, and only keep the NEC_DECODER, which is the 38KHz signal decoder in NEC format.

Due to the flash memory capacity of BiBoard is “huge”, we don’t need to remove unnecessary code in the IRremote library.

Finally, a demo is attached, which accepts infrared signals and prints via the serial port. You can also use official demo for testing.

#include <Arduino.h>
#include <IRremote.h>

int RECV_PIN = 23;

IRrecv irrecv(RECV_PIN);

decode_results results;

void setup() {
  Serial.begin(115200);
  irrecv.enableIRIn();
  Serial.println("IR Receiver ready");
}

void loop() {
  if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);
    Serial.print(" - ");
    irrecv.resume(); // Receive the next value
  }
  delay(300);
}

MPU6050 is the most widely used 6-axis gyroscope, which can not only measure 3-axis angular velocity and 3-axis acceleration more accurately, but also use the built-in digital motion processor (DMP) for hardware based attitude fusion calculation. So novices can use it very conveniently. For this reason, we also use MPU6050 gyroscope.

There are many demos of MPU6050 on Arduino UNO, the most famous is jrowberg's I2Cdev and MPU6050DMP library:

Unfortunately, this library cannot be run directly on BiBoard based on ESP32. We found the ported library on Github, which is easy to use. This library adds the definition of PGMSpace for the ARM and ESP series, adds the calibration function, and removes the FIFO overflow processing function (friends who are interested can use Beyond Compare for code comparison). The library contains I2Cdev and MPU6050, the address and compressed package are as follows:

After the download is complete, create a MPU6050 folder under Documents/Arduino/library, and copy the library files in the compressed package into it. The library of this modified MPU6050 is also compatible with ARM and AVR, so if you have the original I2Cdev and MPU6050 libraries in your computer, you can delete them.

We can use the official MPU6050_DMP6 demo.

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:

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:

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.

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

Using ROS on Raspberry Pi

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

• install docker on Raspberry Pi ()

• prepare workspace

• run the container

• source files and build inside the container

• run examples (see for more)

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)

• run service node on Raspberry Pi

• send command from host

Examples

• using serial library

• using ROS service

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

All the token starts 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 :

• “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 or : For example:

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").

The Nyboard V1 used by robot uses the Atmel ATMEGA328P controller, which only supports only one serial port. We separate the serial port of Nyboard to support more modules. The pins of the serial port are compatible with the 6-pin Arduino Pro Mini. Pin definitions are shown in the table below:

The default serial baud rate is 115200bps.

There're 3 communication modules for the NyBoard V1:

• dual mode（EDR & BLE）JDY-23

• ESP8266

Products and Framework

Programming Language Support

• Coding can be done in C-style language with the .

• Bittle X/ Bittle / Nybble can be programmed with a Scratch-like IDE . we also provide a free sample .

3rd-party Open Source Projects

• - a web interface to control Opencat-based robots

  • need to mount a Raspberry Pi

  • by the author leukipp

• can control a few open source Robots, including Bittle.

  Please check out the following video for the app configuration to support controlling Bittle.

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.

1. The introduction of PWM function on BiBoard (ESP32)

The ESP32 used by BiBoard is different from the 328P used by UNO. Because the PWM of ESP32 uses the matrix bus, it can be used on unspecified pins.

The PWM of ESP32 is called LED controller (LEDC). The LED PWM controller is mainly used to control LEDs, and it can also generate PWM signals for the control of other devices. The controller has 8 timers, corresponding to 8 high-speed channels and 8 low-speed channels, totaling 16 channels.

Compared with UNO, directly use "analogWrite()" to input any duty ratio between 0-255. The PWM control of ESP32 on BiBoard is more troublesome. The parameters that need to be controlled are as follows:

1. Manual selection of PWM channels (0-15) also improves the flexibility of the use of pins

2. The number of bits of the PWM waveform determines the resolution of the duty cycle of the PWM waveform. The higher the number of bits, the higher the accuracy.

3. The frequency of the PWM waveform determines the speed of the PWM waveform, the higher the frequency, the faster the speed.

The frequency of the PWM waveform and the number of bits are relative, the higher the number of bits, the lower the frequency. The following example is quoted from the ESP32 programming manual:

For example, when the PWM frequency is 5 kHz, the maximum duty cycle resolution can be 13 bits. This means that the duty cycle can be any value between 0 and 100%, with a resolution of ~0.012% (2 ** 13 = 8192 discrete levels of LED brightness).

The LED PWM controller can be used to generate high-frequency signals, enough to clock other devices such as digital camera modules. Here the maximum frequency can be 40 MHz, and the duty cycle resolution is 1 bit. In other words, the duty cycle is fixed at 50% and cannot be adjusted.

The LED PWM controller API can report an error when the set frequency and duty cycle resolution exceed the hardware range of the LED PWM controller. For example, if you try to set the frequency to 20 MHz and the duty cycle resolution to 3 bits, an error will be reported on the serial port monitor.

2. Configure the PWM frequency on BiBoard in Arduinoin Arduino

As shown above, we need to configure the channel, frequency and number of bits, and select the output pin.

Step 1: Configure the PWM controller

const int freq = 5000; // PWM frequency
const int ledcChannel = 0; // ledc channel, 0-15
const int resolution = 8; // resolution of PWM，8bit（0～255）
ledcSetup(ledcChannel, freq, resolution);

Step 2: Configure the PWM output pins

ledcAttachPin(ledPin, ledcChannel);

Step 3: Output PWM waveform

ledcWrite(ledcChannel, dutyCycle);

In the demo, we choose IO2 as the output pin, connect IO2 to an LED, and you can observe the effect of the LED breathing light.

3. Complete code:

/* In this demo, we show how to use PWM in BiBoard(ESP32)
* It's different from the Arduino UNO based on the ATMega328P
*/

// define the PWM pin
const int ledPin = 2;  // 16 corresponds to GPIO16

// setting PWM properties
const int freq = 5000;          // PWM frequency
const int ledcChannel = 0;      // ledc channel, in ESP32 there're 16 ledc(PWM) channels
const int resolution = 8;       // resolution of PWM
 
void setup(){
  // configure ledc functionalitites
  // channels 0-15, resolution 1-16 bits, freq limits depend on resolution
  // ledcSetup(uint8_t channel, uint32_t freq, uint8_t resolution_bits);
  ledcSetup(ledcChannel, freq, resolution);     
  
  // attach the channel to the GPIO to be controlled
  ledcAttachPin(ledPin, ledcChannel);
}
 
void loop(){
  // increase the LED brightness
  for(int dutyCycle = 0; dutyCycle <= 255; dutyCycle++){   
    // changing the LED brightness with PWM
    ledcWrite(ledcChannel, dutyCycle);
    delay(15);
  }

  // decrease the LED brightness
  for(int dutyCycle = 255; dutyCycle >= 0; dutyCycle--){
    // changing the LED brightness with PWM
    ledcWrite(ledcChannel, dutyCycle);   
    delay(15);
  }
}

Function introduction

Petoi RGB Ultrasonic Sensor is a new module that integrates RGB LED and ultrasonic ranging. Only one GPIO is needed to operate the ultrasonic transceiver. While the ultrasonic probe measures the distance, the other GPIO pin can drive RGB LEDs with various light effects.

Hardware setup

Connecting to the NyBoard with wire as shown in the following picture:

Attach the ultrasonic sensor to Nybble's eye.

Software setup

• You can use the Firmware Uploader within the Petoi Desktop App to finish the configuration.

• You can also use Arduino IDE for the most freedom to upload and modify the codes.

Use the latest OpenCat code to finish the setup. As shown below:

If you have already uploaded the latest OpenCat code to make Nybble walk, you only need to uncomment the #define ULTRASONIC at the beginning of OpenCat.ino then upload the code.

If you are not sure, you need to finish the upload process for the standard mode (Step 1 to Step 10) to ensure everything is configured correctly, then upload the code in the Ultrasonic mode.

If the Ultrasonic code is uploaded correctly, you can see success messages printed on the serial monitor of Arduino IDE. As shown below:

Ultrasonic module code realization function: According to the different distances monitored by the ultrasonic module in real-time, the probe inside the ultrasonic module lights up with lights of different colors, and Nybble will make different action responses at the same time.

The demo video is as follows:

Mind+ demo code

Driver

NyBoard Driver to access the USB uploader (adapter)

When you use a USB uploader to upload the firmware for NyBoard, please download and install the driver first:

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

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

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

For example, for Windows:

BiBoard Driver to access the serial port

When you use a USB Type-C interface data cable to upload the firmware for BiBoard or control the robot via the Petoi Desktop App, please download the driver as below:

For example, for Windows:

Mac

You can download the Mac version and run the *dmg file to install. You need to allow the permission settings during the installation.

Win

For Windows, the installation steps are as follows:

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 unziped folder of your downloaded driver to install.

The head of Bittle is designed to be a clip to hold extensible modules. We compiled a sensor pack with some popular modules, but its contents may change in the future. You can also wire other add-ons thanks to the rich contents of the Arduino and Raspberry Pi communities.

Light sensor

Touch sensor

Gesture sensor

PIR motion sensor

IR distance sensor

MU vision sensor

Voice command module (Built-in on Bittle X)

Ultrasonic sensor (Built-in on Nybble)

You can also purchase the following third-party sensors (such as Seeed studio):

The loudness and light level modules can generate analog readings for the corresponding signals and should be connected to the analog Grove socket.

Grove - Sound Sensor/ Noise Detector

Grove - Light Sensor v1.2 - LS06-S phototransistor

The touch, reflection, and PIR sensors can generate digital 1 or 0 as a switch signal. So, they should be connected to the digital Grove socket. We use the fourth socket with D6 and D7 in the demo code.

Grove - Touch Sensor

Grove - Infrared Reflective Sensor v1.2

Grove - mini PIR motion sensor

The intelligent camera, gesture, and OLED module should be connected to the I2C Grove socket.

Grove - Gesture Sensor for Arduino (PAJ7620U2)

Grove - OLED Display 0.96" (SSD1315)

1. What is OTA?

The configuration of our BiBoard is 16MB Flash, and the specific partitions are as follows:

OTA mainly operates OTA data areas, namely APP1 and APP2 areas. The principle is:

• BiBoard runs the firmware with OTA function, at this time, the boot points to the APP1 area.

• The OTA command is sent to ESP32 via Wi-Fi, and the binary file of the upgrade program is transferred to the APP2 area.

• If the transmission of APP2 is completed and the verification is successful, OTAdata points to the APP2 area, and the next time it starts from the updated firmware area (APP2), the APP1 data is retained. Next time, OTA will write to APP1 area to overwrite the old firmware.

• If the transmission of APP2 is not completed due to a network transmission error, because APP2 has not passed the verification, OTAdata does not point to the APP2 area. The program in the APP1 area will still be executed after the reset is started, and the damaged APP2 area will be completely erased and overwritten during the next OTA.

OTA operation in Arduino program

In the demo, first configure WiFi, and configure the WiFi mode as STA (Station, base station mode). Enable the WiFi function and pass in the account password "WiFi.begin(ssid, password);"

When the Wi-Fi is successfully connected, the IP address will be printed via the serial port; if the connection is wrong, the ESP32 will restart.

In the demo, you can configure the port number, the OTA key or the hash of the key, and the area and type of the OTA (commented by default).

The following are several code snippets similar to callback functions, which are used to judge the state of each stage of OTA.

After configuring according to the demo, call "ArduinoOTA.handle();" in the loop function. The following analogWrite function is to distinguish the effects of different firmware updates (by changing the value).

The first time you use the serial port to download, the python tool "esptool" is called. You can use OTA after the download is complete. In the port options, you will find an extra port based on the IP address, which is the OTA address.

Select this address, the lower right corner is the IP address of ESP32 Dev Module on your BiBoard (192.168.1.178)

At the same time, a warning will pop up: "Serial monitor is not supported on network ports such as 192.168.1.178 for the ESP32 Dev Module in this release".

The ESP32 OTA of Arduino is only suitable for updating the program and cannot complete the serial port debugging work. If you need to debug BiBoard, please connect the USB-C interface.

Download the program, as shown in the figure.

Function introduction

The sensor integrates two photoresistors (depending on the light intensity adjustment resistance) to detect the light intensity. The photoresistor is a special resistance that uses the photoconductive effect, and its resistance is directly related to the intensity of the incident light. When the light intensity increases, the resistance decreases; when the light intensity decreases, the resistance increases. The output signal is an analog value, the brighter the brightness, the larger the value. You can realize the function you want by judging the value of the detected light intensity, such as the function of a robot tracing light.

Hardware setup

• NyBoard

Connecting to the NyBoard with wire as shown in the following picture:

• BiBoard

For specific use, the end connected to the sensor can be fixed on the robot's head (included in Bittle's mouth, or attached to the top of Nybble's head), of course, you can also use your creativity according to your needs.

Software setup

The code using this sensor has been integrated into the (NyBoard)/ (BiBoard) project. Uncomment the line #define DOUBLE_LIGHT in the OpenCat.ino / OpenCatEsp32.ino, as shown in the figure below, and then use the to upload the sketch to the robot main board, which can reproduce the example function of integrating the robot action.

NyBoard

Prepare the Arduino UNO development environment

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

BiBoard

If you want to test a light sensor's function alone or learn more about its principles. You can use the Arduino IDE to upload the demo sketch(doubleLight.ino), as shown below:

This demo sketch implements real-time printing of the analog values of the two analog pins (A2 and A3) in the . You can also use the serial plotter to view the two analog pins (A2 and A3) more intuitively. The waveform graph is generated by the analog value of the pin output along the time axis.

The demo code

Function introduction

This sensor allows you to detect the movement of animals, usually the movement of humans within its detection range. Just connect it to the NyBoard and program it, and when anyone moves within its detection range, the sensor will output a high potential on its SIG pin.

Hardware setup

• NyBoard

Connecting to the NyBoard with wire as shown in the following picture:

• BiBoard

For specific use, the end connected to the sensor can be fixed on the robot's head (included in Bittle's mouth or attached to the top of Nybble's head), of course, you can also use your creativity according to your needs.

Software setup

The code using this sensor has been integrated into the (NyBoard)/ (BiBoard) project. Uncomment the line #define PIR in the OpenCat.ino / OpenCatEsp32.ino, as shown in the figure below, and then use the to upload the sketch to the robot main board, which can reproduce the example function of integrating the robot action.

NyBoard

Prepare the Arduino UNO development environment

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

BiBoard

If you want to test the function of a PIR motion sensor alone or want to learn more about its principles. You can use the Arduino IDE to upload the demo sketch(test_Touch_Reflection_PIR.ino), as shown below:

This demo sketch implements real-time printing of sensor detection results in the - when anyone moves within its detection range, print 1; otherwise, print 0.

The demo code

The demo code is in the OpenCat code repository on GitHub (specific path: OpenCat/ModuleTests/test_Touch_Reflection_PIR). You can visit our GitHub code repository to download the complete code, as shown in the following picture:

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.

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.

The module uses a CH340C USB bridge. Windows10, Linux, and macOS are all drive-free. The specific interface is shown in the following figure:

NyBoard download interface: used to connect to NyBoard, download program firmware to the robot, and communicate with the computer via serial port.

Communication module debugging interface: used to connect the Bluetooth or WiFi module, update the module program and debug the parameters. In order to avoid the cumbersome operation when connecting with Dupont wires, the pin ordering is slightly different from the NyBoard download interface - the TX/RX interface is reversed, and a GND pin becomes an RTS pin. For details on how to use the debugging interface of the communication module, see the following chapters.

Connect NyBoard

Insert the 6-pin(H1) of the USB uploader to the NyBoard's uploader socket and then use the included USB data cable to insert one end into the MicroUSB interface of the USB upload module; the other end into the USB interface of the PC.

Right-click on "This PC" on the Windows desktop, and then click on "Manage" with the left mouse button (of course, you can also operate in the folder browser), as shown in the figure below, and then select "Device Manager" in the "Computer Management" page to check the connected serial port:

Open the Arduino IDE, or the Desktop App Firmware Uploader interface, and select the corresponding COM port to upload the firmware for the NyBoard and use the serial monitor to communicate.

The uploader has three LEDs: power, Tx, and Rx. Right after the connection, the Tx and Rx should blink for one second indicating initial communication, then dim. Only the power indicator LED should keep lighting up. You can find a new port under Tool->Port as

• “/dev/cu.usbserial-xxxxxxxx” (Mac)

• “COM#” (Windows)

• “ttyUSB#” (Linux)

If Tx and Rx keep lighting up, there’s something wrong with the USB communication. You won’t see the new port. It’s usually caused by overcurrent protection by your computer, if you’re not connecting NyBoard with an external power supply and the servos move all at once.

The Drivers

CH340

If you cannot find the serial port after connecting to your computer, you may need to install the driver for the CH340 chip.

• 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

CH343G (with two USB ports)

The CH343G version should install the driver automatically on most systems. However, if you are using the module on Mac to configure the ESP8266 module, please download the driver. It will be recognized as two USB devices (usbserial and usbmodem). You may try either one to connect.

Function introduction

Petoi Intelligent Vision Sensor can recognize many objects with a deep-learning algorithm. For example, it can detect color blocks, balls, the human body, and cards. Its detection result can be transmitted through the UART or I2C interface. MU is compact, has low power consumption, processes all algorithms locally, and can be widely used in intelligent toys, AI+STEAM lessons, creators, and other products or fields.

Software setup

• You can use the Firmware Uploader within the Petoi Desktop App.

• You can also use Arduino IDE for the most freedom to upload and modify the codes.

1. First, download and install the MU camera library into your Arduino IDE.

2. Use the latest OpenCat/OpenCatEsp32 code to finish the setup.

NyBoard using OpenCat.ino

If you have already uploaded the latest OpenCat code to make Bittle / Bittle X walk, you only need to uncomment #define CAMERA at the beginning of OpenCat.ino, then upload the code.

If unsure, you need to finish the upload process for the standard mode (Step 1 to Step 10) to ensure everything is configured correctly, then upload the code in the camera mode.

BiBoard using OpenCatEsp32.ino

Set the development environment for BiBoard and modify the source code as follows:

Hardware setup

After uploading the firmware, switch the dial switches on the MU Vision Sensor and connect to the mainboard with wire as shown in the following picture:

NyBoard

BiBoard

Fix the end connected to the camera to the robot's head (included in Bittle's / Bittle X's mouth).

If the camera code is uploaded correctly, Bittle / Bittle X maintains the rest position. Success messages are printed on the serial monitor of Arduino IDE. When the MU Vision Sensor recognizes a target, the two LEDs will turn blue, and Bittle's / Bittle X's head can follow the target and swing left and right. The demo code will auto-switch the target between a yellow tennis ball and a human body if it fails to find any object.

FAQ

For more details, please refer to the Technical Support Document.

Demos

The demo video is as follows:

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

Prepare for calibration

You need to connect the USB adapter and USB data cable or Bluetooth module (for NyBoard only ) to the 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:

• It will enter the calibration state automatically when you click the Joint Calibrator button.
• Click the Calibrate button in the calibrator interface.

The Joint Calibrator interface

Nybble

Bittle

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.

Use the included L-shaped tool as a reference during calibration. According to the index numbers of the joints shown at the top of the interface (when calibrating the servos, adjust the upper leg first, then adjust the lower leg). Drag the corresponding slider (below the index number), or click the blank part of the slider track to fine-tune the joint to right angles.

Nybble

Bittle

You can switch between "Rest", "Stand up" 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 the "Abort" button to abandon the calibration data. You can save the calibration in the middle in case your connection is interrupted.

Install the screws

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

Function introduction

The sensor contains two touch parts (left and right) and can detect changes in capacitance when a finger approaches. This means the touch sensor will output a high level whether your finger touches lightly or presses hard. You can realize the function you want by judging the detected value (1 for high level, 0 for low level).

Hardware setup

• NyBoard

Connecting to the NyBoard with wire as shown in the following picture, connect to the NyBoard Grove interface which include D6, D7:

• BiBoard

For specific use, the end connected to the sensor can be fixed on the robot's head (included in Bittle's mouth, or attached to the top of Nybble's head), of course, you can also use your creativity according to your needs.

Software setup

The code using this sensor has been integrated into the OpenCat (NyBoard)/ OpenCatEsp32 (BiBoard) project. Uncomment the line #define DOUBLE_TOUCH in the OpenCat.ino / OpenCatEsp32.ino, as shown in the figure below, and then use the Arduino IDE to upload the sketch to the robot main board, which can reproduce the example function of integrating the robot action.

NyBoard

Prepare the Arduino UNO development environment

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

BiBoard

Prepare the ESP32 development environment

Arduino C++ demo

If you want to test the function of a touch sensor alone or want to learn more about its principles. You can use the Arduino IDE to upload the demo sketch(doubleTouch.ino), as shown below:

This demo sketch implements real-time printing of the detection values of D6 and D7 pins in the serial monitor:

The demo sketch

Mind+ Demo

If you want to use the sensor with the Mind+ program for NyBoard:

1. You can upload the firmware via the Petoi Desktop App:

2. Follow the instructions to import the Petoi Coding Blocks in the app Mind+, and load the Mind+ code file.

1. Connect the robot and computer with the USB adapter(USB uploader) or Bluetooth module.

2. Power on the robot and click the Run button in Mind+.

Mind+ demo code

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.

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:

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.

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

Gaits

The left panel sets both the robot's gaits and directions and send combined command, such as "walk left" and "trot forward". The robot will only move if an initial gait and direction are selected. The "step" has no direction, and "backward" has left and right directions. The pause button "||" will pause the robot's motion and turn off the servos, so that you can rotate the joints to any angle. The "Turbo" button ( ) turns on/off the gyro, a sensor to detect the robot's body orientation. Turning it on will make the robot keep adjusting to body angles, and will know when it's upside down. Turning it off will reduce calculation and make it walk faster and more stable.

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)

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

* sit

* move joints one by one

* MOVE joints simultaneously

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

* long meow once (Nybble）

* short meow three times (Nybble）

* mute/unmute the buzzer beep

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

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

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

More common commands to be added

Please see 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 .

Import new skills as a customized button

Import your local customized skill (created by the )

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 Test or Play () button to test the function of the command group. click the Pause () button to interrupt the command list execution flow.

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 .

Updates and support

We keep improving the app and will inform you of the updates when available. Please write to [email protected] if you have any questions about the app.

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 can be 3D printed.

As shown in the , 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 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.

2. Change the permission of

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.

The robot battery

Though you can program BiBoard directly or NyBoard with the USB uploader, external power is required to drive the servos separately.

When the mainboard is powered by USB, the blue LED lights up. When external batteries power the mainboard, the yellow LED lights up.

Parameters

Rechargeable Li-ion Battery

Model: ZCF503060

Rated Capacity: 1000mAh/7.4Wh

Input: 5V-1.5A

The servos require 7.4~8.4V external power to move. Our customized Li-ion battery has a built-in charging and protection circuit. Clicking the battery's button will show its status. Blue light indicates it has power, and red means the power is low. Long-pressing the button for 3 seconds to power on/off the battery.

Connection and Power On

Be careful with the polarity when connecting the power supply. The terminal on the main board has an anti-reverse socket, so you won't be able to plug in the wrong direction. See for the detailed connection instructions. Before powering, insert the battery's plug into the main board's terminal.

Battery Life

It can last hours if you're mainly coding and testing postures or less than 30 minutes if you keep Bittle running.

The battery light will turn red when the power is low and will soon be cut off automatically.

Charging

Use a 5V-1A USB charger to charge the battery. We don't recommend using fast chargers. The battery will NOT supply power during charging. Keep the battery in your sight when charging.

During the charging process, the red LED light is on.

When the charging is finished, the green LED light is on.

WARNING:

• The battery should be charged under adult supervision, for battery charged using a battery charger for use by children, the battery is only to be charged by persons of at least eight years old.

• The supply terminals are not to be short-circuited.

After Using

After using, remember to turn off the battery. The blue LED will stay light if the USB power still powers it. You can check if the yellow LED on the main board is turned off.

Attaching the Battery to the body

The battery can be attached to the robot's body conveniently without any screws. Check the following video:

The infrared remote control's battery

The infrared remote control's battery is a coin battery. Its model is CR2025.

Please remove the plastic insulator when opening the package for the first time and using the remote control.

To remove and install the battery, please follow the diagram on the back of the remote control.

• This coin battery is not to be recharged;

• The battery is to be inserted with the correct polarity (+ and -);

• Exhausted battery is to be removed from the remote control;

• The supply terminals are not to be short-circuited.

WARNING: Contains coin battery. Hazardous if swallowed - see instructions.

WARNING: This product contains a coin battery. If swallowed, the battery can cause serious internal chemical burns.

WARNING: Dispose of used batteries immediately. Keep new and used batteries away from children. If you think batteries might have been swallowed or placed inside any part of the body, seek immediate medical attention.

Introduction

The Bluetooth module is a standard transparent transmission module, which sends serial port data to devices connected to Bluetooth.

You can wirelessly upload firmware or control the motion of the robot through a Bluetooth connection. You can even control the robot using our smartphone app . We have included our official Bluetooth module in the standard robot kit. As shown below:

Connection with NyBoard

The connection between the Bluetooth module and the NyBoard is shown in the figure below, you need to plug the Bluetooth module into the 6-pin socket on the NyBoard. Note the pin order of the Bluetooth module. Once the battery is connected to the NyBoard, press and hold the button on the battery to power the robot. A blinking LED on the Bluetooth module indicates waiting for a connection.

Connect the dongle with your phone

You need to connect the dongle within the Petoi App, rather than your phone's system Bluetooth settings. On some phones, you need to grant Bluetooth and location services permissions to the app.

A more detailed setup can be found in the section.

Connect the dongle with your computer

In your system's Bluetooth settings, search for a Bluetooth device name started with Petoi or Bittle, and connect. The default PIN for pairing is “0000“ or “1234”. After the pairing is successful, the system will assign a serial port name.

You can then select it under Tools->Port in the Arduino IDE, using the same method as the USB uploader. After opening the serial monitor, please select: No line ending, and the baud rate is set to 115200.

Configure the Bluetooth module

If you want to configure the Bluetooth module, please refer to "JDY-23 AT Command List". Plug the Bluetooth module into the USB adapter debugging interface. As shown below:

The commonly used commands are listed below:

When you use the serial terminal like "Arduino serial monitor" to set JDY-23 with AT commands, you must set "NL and CR", and the baud rate is set to 115200, or the JDY-23 module will not identify any AT command you send.

In this tutorial, we will introduce how to use the Ailia in python language to implement an OpenCat robot to imitate various human body movements.

To clone or download the code from the GitHub repository, you can clone the code with the following command:

1. Run on a regular computer (Mac/Linux)

1. It is recommended to install the IDE. For the specific installation method, please refer to the following link:

2. Open the Anaconda Prompt (Windows) or the Terminal (Linux / macOS) and enter the following commands to create and activate a virtual environment (the environment name is "venv", and can also be customized to other names): conda create --name venv conda activate venv

3. Follow to install the Ailia SDK, it will be used for pose detection. The guide mainly includes the following steps: download and install the ailia SDK and the related python library files. When downloading the Ailia SDK, you need to enter the correct email address to receive the download link address and license file. The free license is valid for only one month. The SDK is about 2GB, so it takes time to download. Move the downloaded license file (AILIA.lic) to the directory where bootstrap.py is located ({ailia sdk directory}/python), and then follow the steps to continue installing the Ailia SDK. cd {ailia sdk directory}/python python3 bootstrap.py pip3 install . Download the from this page () to the directory where bootstrap.py is located before running the following command: pip install -r requirements.txt. It may take 30 minutes.

4. Use the USB uploader or Bluetooth module to connect the robot and power it on. The computer needs to be connected to a camera device.

5. Run the following command to start the OpenCat Imitation program:

2. Run on the Jetson Nano 2GB Developer kit

You may want to run the demo on a Jetson Nano to experiment with some GPU features.

The developer kit uses a microSD card as a boot device and for main storage. It’s important to have a card that’s fast and large enough for your projects; the minimum requirement is a 32GB UHS-1 card. Many projects with Jetson Nano 2GB Developer Kit will utilize swap space on the MicroSD Card due to only 2GB physical memory. For this reason, we recommend 64GB or larger microSD cards. High-endurance microSD cards are also recommended.

1. Please refer to to record the system image file () into the microSD card and complete the system initialization.

2. Use a network cable to connect the Jetson Nano development board to a router or other computer hosts so that it can access the Internet.

3. Clone or download the code from , and install the Ailia SDK according to , the specific method is the same as the above step 3 in Run on the host computer, but NO need to execute the statement:

pip install -r requirements.txt

4. Install the relevant python library files using the following command：

5. Connect the camera and complete its configuration by referring to .

Please refer to the technical documentation to complete the setup if you use a USB camera to complete the setup.

To connect the USB uploader, you need to use the following command:

sudo usermod -a -G dialout $USER to increase user rights.

6. Start the program, please refer to step 4 and 5 of .

Now the OpenCat imitation program can run on the Jetson Nano development board. You can refer to other relevant technical documents to improve the program's performance, such as .

Update：

NyBoard V1_1 is a V1 refreshed version mainly focused on the shortage of the ATMEGA328P-MU in our supply chain.

1. Replace the ATMEGA328P-MU（QFN32=）with the ATMEGA328P-AU（TQFP32）

2. Removed 7 WS2812 LEDs to optimize the area.

3. A green LED is connected to the D10 port with PWM functions.

4. There's no changes of sockets and pin definitions from V1_0, the bootloader and the OpenCat sketchs is fully compatible.

Overview

NyBoard V1 is an upgraded version considering the users' feedback on NyBoard V0. It's compatible with previous versions, yet has some new design to make it easier to use.

• It still uses Atmel ATMega328P as the main chip but adopts 16MHz without accelerating it to 20MHz. Now the board is fully compatible with Arduino Uno, much easier for new users to Arduino.

• It keeps driving 16 PWM channels with PCA9685. The pin order is altered, but you don't even need to read the indexes on the board, because the pin mapping is handled within the software.

• Now the 6-axis motion sensor MPU6050 is designed on the PCB, rather than a stand-alone module soldered above the board. It supports a built-in DMP (Digital Motion Processor) to calculate the motion data, as well as providing raw data for your own fusion and filtering algorithms.

• It continues to use an 8KB onboard I2C EEPROM to save constants for skills.

• The power system is redesigned to provide a more stable supply. The structure for peripherals is also optimized.

• From Jan 1st, 2021, We start to include an official Bluetooth dongle for wirelessly uploading and communication. The default baud rate for all the communication ports is set to be 115200.

• The reset button is more accessible on the back of the board.

• We added 4 Grove socket to plug-and-play Seeed Studio's extensible modules. We still provide standard 2.54mm through-holes besides the socket.

• The socket for the battery is now anti-reverse.

Logic diagram of the controller

The configuration of NyBoard V1_0 is shown as below:

Introduction to the onboard components

Main controller

NyBoard V1_0 uses Atmel ATMega328P-AU, the same MCU of the Arduino Nano (UNO Compatible).

The ATMega328P works at 16MHz with a 5V supply. It has 2KB SRAM, 32KB Flash, and 1KB on-chip EEPROM. With the same bootloader of Arduino Uno, you can upload sketches through the serial port.

LED（NEW!)

The WS2812 serial RGB LEDs are replaced by a single green LED. You can easily use it with standard Arduino GPIO control commands.

I2C switch

The main chip runs at 5V, while the other peripherals run at a 3.3V logic level. We use PCA9306 to convert the I2C bus of ATMega328P to 3.3V. We also added an I2C switch on the bus. By dialing it to "Arduino" or "Raspberry Pi", you can change the I2C master of the onboard peripherals.

6-Axis IMU MPU6050

MPU6050 is widely used in many DIY projects to acquire the motion state of devices. It detects the 3 acceleration and 3 angular motion states. It also includes a DMP to calculate the state directly, without using the main controller's computational resources.

On NyBoard V1_0, its I2C address is 0x68. The interrupt pin is connected to the PD2 port of ATMega328P (or the D2 pin of Arduino Uno).

There are a lot of available MPU6050 libraries and we are using I2CDev/6050DMP. You can also use other versions:

PCA9685 and the PWM servo ports

PCA9685 fans out 16 PWM 12-bit channels with instructions from the I2C port. Its address is set to 0x40. There are 16 PWM indexes printed on the PCB, but you don't really need to read them because the pin-mapping is done in the software. The physical wiring pattern is the same as the previous boards. You do need to check the direction of the servo pins. Regular servos have 3 pins for PWM, power(2S), and ground (GND). The ground should connect to the black wire of the servo.

On NyBoard V1_0, the servos' power connects to the 2S Li-ion battery. We designed our servos to be compatible with 8.4V input. Regular servos usually run at 6V. You should not connect regular 9g servos like the SG90 to the board directly.

We use Adafruit PWM Servo Driver Library for PCA9685.

EEPROM

We save the motion skills with an 8KB onboard I2C EEPROM AT24C64. Its I2C address is 0x54. The lookup table of skills is saved in the 1KB on-chip EEPROM of ATMega328P. It uses <EEPROM.h>. You need to pay attention to their differences when developing new codes.

Passive buzzer

The buzzer is driven by PD5 (or the D5 of Arduino UNO). The current is amplified by 2N7002 MOS.

Infrared receiver

We use VS1838B as the Infrared receiver, connected to PD4 (or D4 on Arduino Uno). It's driven by the IRremote library of Arduino, the corresponding remote is encoded in NEC format. You may disable the other protocols in IRremote.h to save Flash (about 10%!)

Voltage detector

The two LEDs in the Petoi logo indicates the powering state of the board. The left eye is blue for the logic chips. The right eye is yellow for the servos' power. When NyBoard is connected to the battery, both LEDs should lit up. When NyBoard is powered by the USB downloader, only the blue LED will lit up.

There's an anti-reverse socket for the battery. The battery's output is connected to ADC7 (or A7 of Arduino Uno) and is not threaded to an open pin. ADC7 collects the voltage over a voltage divider. The actual voltage is approximately 2x of the reading. A safe range of battery voltage is below 10V.

You should charge the battery in time when the battery is lower than 7.4V.

Grove sockets

We adopted the Grove sockets for convenient plug-and-play connections. There are three types of socket:

Power system

The main chips are powered by a Low-dropout (LDO) linear regulator for noise removal and better stability. We use LM1117-5V and XC6206P-3.3V to power 5V and 3.3V chips. The 3.3V LDO is connected in serial after the 5V LDO for better efficiency.

There's a diode between the battery and LM1117-5V to prevent damage by the wrong connection. There's a self-recover fuse (6V 500mA) on the USB uploader to limit the current and protect the USB port.

The Raspberry Pi consumes much more power, so we choose TPS565201 DC-DC to provide a 5V 3A output. The peak output can be 5A and with high-temperature/current/voltage protection. It will cut off the power when the chip keeps outputting >4A and over 100 Celcius degrees until the temperature drops to normal.

The servos are powered by 2S Li-ion batteries directly. Pay attention not to short connect the power or any pins on the NyBoard.

There are two ways to play a melody with the robot:

1. Using the in Mind+.

2. Using the in Mind+, Arduino IDE, Python, and the Petoi mobile app.

1. Coding blocks for music in Mind+

You can use this coding block to make one tone.

There are several ways to join multiple tones together to make a melody:

1.1 A list comprises multiple "Tone + Duration" blocks connected by the "+" block.

1.2 A list in the format of pairs of Tone + Duration: [tone, duration, tone, duration...]

To better understand the format, you can continue reading the next section.

2. The for generating melody

2.1 Start Token

The melody starts with the letter 'b', indicating a buzzer command. (No quotation marks are needed in the final command).

2.2 Music Notes

Notes are represented by numbers, with 0 or -1 for silence. Use 1-35 for the best effect on a buzzer.

2.3 Duration

Durations are also numbers, indicating how many parts a whole second is divided into (e.g., 2 = 1/2 second). This plays a single middle C (C3 = 14) for 1/2 second with no delay:

The space between the starting 'b' and the first number can be omitted:

A note longer than 1 second can be represented by two notes:

2.4 Half-scale vs. Whole-scale

A difference of 1 in note number represents a half-scale tone (semitone), while a difference of 2 represents a whole-scale tone. You can define any note as the base (e.g., middle C3 = 14). This sets the reference point for your melody. So D3 will be 16, E3 will be 18, F3 will be 19, G will be 21, A will be 23, B will be 25, and C4 will be 26. C4 - C3 = 12. That's the so-called . You may write a map in the code for quick conversion.

2.5 Command Structure

2.5.1 In the serial monitor or the mobile app's customized button console:

You can define multiple note-duration pairs separated by spaces or commas. It's easier to read if you use spaces to separate the notes within a sentence and use commas to separate sentences.

For example:

2.5.2 In the Python code:

• Use brackets []to define a list. The numbers should all be separated by ','. The above example becomes:

or

• After playing the melody, you can add a number at the end to define an optional delay (in seconds).

Refer to the to send it to the robot using Python.

2.5.3 In the Mind+ coding blocks

Copy and paste the number part of the command, and separate each number with ',' as the example in section 1.

3. Example: Creating Twinkle, Twinkle, Little Star

3.1 Choose Your Base Tone:

In this example, we'll use C3 (base tone 14). But you can choose any note within the 5-30 range.

3.2 Plan Your Notes:

Write down the sequence of notes you want to play, considering half- and whole-tone jumps. Use numbers based on your chosen base tone (14). Include silent notes (0) for pauses.

3.3 Define Durations:

Decide how long each note should play. Use numbers to represent fractions of a second (e.g., 4 = 1/4 second).

3.4 Translate to Commands:

Command with the 'b' token

It can be used in Arduino IDE's serial monitor or the Petoi mobile app:

The mobile app also supports the binary format with the 'B' token:

B,14,4,14,4,21,4,21,4,23,4,23,4,21,2,0,4,19,4,19,4,18,4,18,4,16,4,16,4,14,2

3.5 The mind+ version

3.6 The Python version:

or

4. Experimenting

You can also test the following examples:

Complete Twinkle, Twinkle, Little Star

My Love by Westlife

A very long melody for testing on the BiBoard

Using other tools

Play around with tones and duration sequences to create your own melodies. For more complex pieces, there are online resources and software that can translate musical notation to this format. You may even write prompts to let AI generate a melody for you!

For example, using Gemini to give you a raw melody sequence to start with:

You may share your prompt, which works directly with our community, at .

Remember, this is just the beginning—have fun composing!

Overview

NyBoard V1 is an upgraded version considering the users' feedback on NyBoard V0. It's compatible with previous versions, yet has some new design to make it easier to use.

• It still uses Atmel ATMega328P as the main chip but adopts 16MHz without accelerating it to 20MHz. Now the board is fully compatible with Arduino Uno, much easier for new users to Arduino.

• It keeps driving 16 PWM channels with PCA9685. The pin order is altered, but you don't even need to read the indexes on the board, because the pin mapping is handled within the software.

• Now the 6-axis motion sensor MPU6050 is designed on the PCB, rather than a stand-alone module soldered above the board. It supports a built-in DMP (Digital Motion Processor) to calculate the motion data, as well as providing raw data for your own fusion and filtering algorithms.

• It continues to use an 8KB onboard I2C EEPROM to save constants for skills.

• The power system is redesigned to provide a more stable supply. The structure for peripherals is also optimized.

• From Jan 1st, 2021, We start to include an official Bluetooth dongle for wirelessly uploading and communication. The default baud rate for all the communication ports is set to be 115200.

• The reset button is more accessible on the back of the board.

• We added 4 Grove socket to plug-and-play Seeed Studio's extensible modules. We still provide standard 2.54mm through-holes besides the socket.

• We added 7 WS2812 RGB LEDs on the board as another form of output and status indicator.

• The socket for the battery is now anti-reverse.

Logic diagram of the controller

The configuration of NyBoard V1_0 is shown as below:

Introduction to the onboard components

Main controller

NyBoard V1_0 uses Atmel ATMega328P-MUR as the main controller. We adopted its smaller version of QFN32 for better layout, and it's near-identical to regular TQFP32.

ATMega328P works at 16MHz with a 5V supply. It has 2KB SRAM, 32KB Flash, and 1KB on-chip EEPROM. With the same bootloader of Arduino Uno, you can upload sketches through the serial port.

I2C switch

The main chip runs at 5V, while the other peripherals run at a 3.3V logic level. We use PCA9306 to convert the I2C bus of ATMega328P to 3.3V. We also added an I2C switch on the bus. By dialing it to "Arduino" or "Raspberry Pi", you can change the I2C master of the onboard peripherals.

6-Axis IMU MPU6050

MPU6050 is widely used in many DIY projects to acquire the motion state of devices. It detects the 3 acceleration and 3 angular motion states. It also includes a DMP to calculate the state directly, without using the main controller's computational resources.

On NyBoard V1_0, its I2C address is 0x68. The interrupt pin is connected to the PD2 port of ATMega328P (or the D2 pin of Arduino Uno).

There are a lot of available MPU6050 libraries and we are using I2CDev/6050DMP. You can also use other versions:

PCA9685 and the PWM servo ports

PCA9685 fans out 16 PWM 12-bit channels with instructions from the I2C port. Its address is set to 0x40. There are 16 PWM indexes printed on the PCB, but you don't really need to read them because the pin-mapping is done in the software. The physical wiring pattern is the same as the previous boards. You do need to check the direction of the servo pins. Regular servos have 3 pins for PWM, power(2S), and ground (GND). The ground should connect to the black wire of the servo.

On NyBoard V1_0, the servos' power connects to the 2S Li-ion battery. We designed our servos to be compatible with 8.4V input. Regular servos usually run at 6V. You should not connect regular 9g servos like the SG90 to the board directly.

We use Adafruit PWM Servo Driver Library for PCA9685.

EEPROM

We save the motion skills with an 8KB onboard I2C EEPROM AT24C64. Its I2C address is 0x54. The lookup table of skills is saved in the 1KB on-chip EEPROM of ATMega328P. It uses <EEPROM.h>. You need to pay attention to their differences when developing new codes.

Passive buzzer

The buzzer is driven by PD5 (or the D5 of Arduino UNO). The current is amplified by 2N7002 MOS.

Infrared receiver

We use VS1838B as the Infrared receiver, connected to PD4 (or D4 on Arduino Uno). It's driven by the IRremote library of Arduino, the corresponding remote is encoded in NEC format. You may disable the other protocols in IRremote.h to save Flash (about 10%!)

Voltage detector

The two LEDs in the Petoi logo indicates the powering state of the board. The left eye is blue for the logic chips. The right eye is yellow for the servos' power. When NyBoard is connected to the battery, both LEDs should lit up. When NyBoard is powered by the USB downloader, only the blue LED will lit up.

There's an anti-reverse socket for the battery. The battery's output is connected to ADC7 (or A7 of Arduino Uno) and is not threaded to an open pin. ADC7 collects the voltage over a voltage divider. The actual voltage is approximately 2x of the reading. A safe range of battery voltage is below 10V.

You should charge the battery in time when the battery is lower than 7.4V.

WS2812 RGB LED

We added 7 WS2812 RGB LEDs (or the NeoPixel) on the NyBoard. The pin number is D10. They are powered by the 5V DC-DC power chip for Raspberry Pi and are independent of the 5V network of ATMega328P. So you need to plug in the battery to power the LEDs.

Grove sockets

We adopted the Grove sockets for convenient plug-and-play connections. There are three types of socket:

Power system

The main chips are powered by a Low-dropout (LDO) linear regulators for noise removal and better stability. We use LM1117-5V and XC6206P-3.3V to power 5V and 3.3V chips. The 3.3V LDO is connected in serial after the 5V LDO for better efficiency.

There's a diode between the battery and LM1117-5V to prevent damage by the wrong connection. There's a self-recover fuse (6V 500mA) on the USB uploader to limit the current and protect the USB port.

The Raspberry Pi consumes much more power, so we choose TPS565201 DC-DC to provide a 5V 3A output. The peak output can be 5A and with high-temperature/current/voltage protection. It will cut off the power when the chip keeps outputting >4A and over 100 Celcius degrees until the temperature drops to normal. The WS2812 RGB LEDs are also powered by this DC-DC source.

The servos are powered by 2S Li-ion batteries directly. Pay attention not to short connect the power or any pins on the NyBoard.

Last updated: Jan 13, 2021

1. Function introduction

ESP-NOW is another wireless communication protocol developed by Espressif that enables multiple devices to communicate without or using Wi-Fi. This protocol is similar to the low-power 2.4GHz wireless connection commonly found in wireless mice—the devices are paired before they can communicate. After pairing, the connection between the devices is continuous, peer-to-peer, and does not require a handshake protocol. It is a fast communication technology with short data transmission and no connection, which allows low-power controllers to directly control all smart devices without connecting to a router. It is suitable for scenarios such as smart lights, remote control, and sensor data return.

After using ESP-NOW communication, if a certain device suddenly loses power, as long as it restarts, it will automatically connect to the corresponding node to resume communication.

The communication modes supported by ESP-NOW are as follows:

• one-to-one communication

• one-to-many communication

• many-to-one communication

• many-to-many communication

ESP-NOW supports the following features:

• Unicast packet encryption or unicast packet unencrypted communication;

• Mixed use of encrypted paired devices and non-encrypted paired devices;

• Can carry payload data up to 250 bytes;

• Support setting sending callback function to notify the application layer of frame sending failure or success.

At the same time, ESP-NOW also has some limitations:

• Broadcast packets are not supported temporarily;

• There are restrictions on encrypted paired devices

  • In Station mode，a maximum of 10 encrypted paired devices are supported;

  • In SoftAP or SoftAP + Station mixed mode, a maximum of 6 encrypted paired devices are supported;

  • The number of non-encrypted paired devices is supported, and the total number of encrypted devices does not exceed 20;

• Valid payloads are limited to 250 bytes.

Petoi group control can use the ESP-NOW communication function of the ESP8266.

2. Setup for ESP-NOW

2.1 Hardware setup

In this case, two Bittles (equipped with ESP8266) and one computer connected with ESP8266 are prepared.

See below for program uploading and MAC address acquisition of the module in the figure.

2.2 Software setup

Install Thonny on the computer to facilitate the debugging of MicroPython of the ESP8266 module. When using the ESP-NOW protocol, special MicroPython firmware is required (see ). Because the normal version of the 8266-MicroPython firmware will prompt that the library cannot be found.

Open Thonny and use the USB uploader to connect the ESP8266 module, enter in the shelll interface:

If there is an error prompt such as "cannot find espnow module", it means that there is a problem with the firmware uploading; if there is no prompt, it means that the firmware uploading is successful.

3. Code introduction

The group control code is divided into 3 parts:

• Query the MAC address of the module

• Transmitter program

• receiver program

3.1 Query the MAC address of the module

The MAC address is an address used to confirm the location of a network device, and is responsible for the second layer (data link layer) of the OSI network model. The MAC address is also called the physical address and the hardware address. It is burned into the non-volatile memory (such as EEPROM) of the network card when it is produced by the network equipment manufacturer.

The length of the MAC address is 48 bits (6 bytes), usually expressed as 12 hexadecimal numbers. The first 3 bytes represent the serial number of the network hardware manufacturer, which is assigned by IEEE (Institute of Electrical and Electronics Engineers), and the last 3 bytes represent the serial number of a certain network product (such as a network card) manufactured by the manufacturer. As long as you don't change your MAC address, the MAC address is unique in the world. Visually speaking, the MAC address is like the ID number on the ID card, which is unique.

The easiest way to use ESPNOW is to send it by MAC address. We use a small program to query the MAC address of the module.

After running in Thonny, print out the MAC address in the terminal. At this time, you can use a self-adhesive sticker to write the MAC address of the module and paste it on the module.

3.2 Transmitter program

The transmitter program consists of the following parts:

• Enable the WiFi function of the module

• Configure the ESP-NOW protocol and enable it

• Add a node (peer) that needs to communicate

• Send a message

The specific code is as follows:

3.3 Receiver program

The receiver program is mainly composed of the following parts:

• Enable the WiFi function of the module

• Configure the ESP-NOW protocol and enable it

• Add a node (peer) that needs to communicate

• Receive and decode the message, and send commands to NyBoard through the serial port

The specific code is as follows:

This code is encapsulated in a function named espnow_rx() for the convenience of automatically starting the program after power-on.

There are two ways to realize automatic startup after power-on:

• Rename the code file to main.py;

• Modify the boot.py ;

For beginners, we recommend the first method.

3.4 Communication-Command Converter

Writing the serial command conversion at the receiving end will make the program too complicated and difficult to maintain. We can create a new function in which to perform instruction conversion and output commands.

If you cannot upload sketches to the NyBoard (the "not in sync error") and verify that the serial connection is all good, the NyBoard's bootloader might be crashed during the last upload.

There could be several reasons why the NyBoard's bootloader crashes. Some of the common causes include:

1. Uploading the sketch at a high baud rate

2. Using a malfunctioning USB cable

3. Using a power source that is not sufficient

4. Using a low-quality or damaged Uno board

5. Disrupting the upload process by pressing the reset button or unplugging the board

6. Memory overflow

In the specific case of Petoi robots, the sketch size and errors in the code are major causes of the crashed bootloader. Uploading a sketch to the Uno replaces the existing bootloader code with the new sketch. If the sketch is too large to fit in the memory or if there are errors in the code causing memory overflow, the bootloader may corrupt.

Use the Simple Bootloader Resetter

From August 2023, we will ship a simple bootloader resetter with the NyBoard. If you got an earlier batch and need to reset the bootloader, please write to to request a free shipment.

Use Arduino UNO Board

1. Open the sketch ArduinoISP.ino.
2. Select the items in the menu bar Tools > Board (Arduino UNO) and Port that connect to the UNO board.
3. Upload the sketch ArduinoISP.ino to the UNO board.
4. Wire the UNO board with NyBoard.
5. Select the Arduino as ISP in the menu bar Tools>Programmer.
6. Click the menu Burn Bootloader.

Use USBtinyISP or USBasp

• USBtinyISP

Connect the USBtinyISP programmer and NyBoard. The pins connection map is as follows:

MI --> MISO V --> VCC

SC --> SCK MO --> MOSI

R --> Reset G --> GND

Connect the USBtinyISP programmer to the computer with a USB port. After installing the driver as follows:

The driver is as follows:

With NyBoard V1_*, you can simply choose Arduino Uno under the Tool menu of Arduino IDE, then burn the bootloader as follows:

• USBasp

Connect the USBasp programmer and NyBoard. The pins connection map is as follows:

MISO --> MISO VCC --> VCC

SCK --> SCK MOSI --> MOSI

Reset --> Reset GND --> GND

Connect the USBasp programmer to the computer with a USB port. Afer installing the driver as follows:

The driver installer is as follows:

With NyBoard V1_*, you can simply choose Arduino Uno under the Tool menu of Arduino IDE, then burn the bootloader as follows:

For details about how to use the USBasp programmer, you can refer to:

* Upload sketches using a Programmer

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 坐下
}

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

• 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

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.

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++

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.

1. Read the Quick Start Guide

The specific parameters of each functional module of BiBoard, please refer to of the BiBoard Quick Start Guide.

2. Set up BiBoard

2.1 Prepare the ESP32 development environment

For details, please refer to of the BiBoard Quick Start Guide.

2.2 Modify code file in the package

• sdkconfig.h

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

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 uses an ESP32 with a 16 M 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.

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

If 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 .

2.5 Download the OpenCatEsp32 package

• Download the ​OpenCatEsp32 repository from GitHub: .It’s better if 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.

• If you download the Zip file of the codes, you will get an OpenCatEsp32-main folder after unzipping. You need to rename it to OpenCatEsp32 before opening the OpenCatEsp32.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)

2.6 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 BiBoard.ino according to the device type.

Modify the motherboard model macro definition in BiBoard.ino according to .

After the modification is completed, you can click the upload button to upload BiBoard.ino, and the changes in the program will be automatically saved.

2.8 Open the serial monitor and do a factory reset (Optional)

If you want a factory reset, please connect the BiBoard and the computer via USB type-C data cable, and open the serial monitor. You can find the button either under Tools, or at the top-right corner of the Arduino IDE.

Input the serial command '!' and press Enter in the serial monitor to start over. You will see several questions:

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

Input 'Y' to the question, which means calibrating the MPU6050, i.e. the gyro/accelerometer sensor.

Input 'n' and press Enter to continue.

The details of serial port printing information are as follows：

After the IMU calibration is completed, every time the robot is powered on, it will enter the regular power-on program.

2.9 Power on

• long-press the button which is on the battery and boot up the robot with one side up, it will enter the calibration state automatically. The picture below shows the upper legs and lower legs installed after the robot enters the calibration state.

Please refer to and 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).

2.10 Standard mode and special modes

The default code runs the Standard mode (including the Voice command function). If you have some extensible modules, you may uncomment the 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.

3. Configuration with App

The BiBoard has built-in Bluetooth, and you can connect it with the new Android app:

You can check the update history and added features in ChangeLog.md (BiBoard\ChangeLog.md)

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
}