WAVEGO Pro
| ||
Introduction
This is a bionic quadruped robot with 12 degrees of freedom, equipped with 12 2.3kg.cm high torque servos. It is structurally reliable and has flexible movements, integrating cameras, 9-axis motion trackers, RGB and other devices. It also opens up a cross-platform web application for controlling the robot, which can be accessed via a browser on a phone or computer. The ESP32 can be used as the lower computer for link inverse solution and gait generation, sharing computing power with the upper computer. Raspberry Pi can also be installed as the upper computer for high-order decision-making operations.
Features
- 12 degrees of freedom (DOF), with more flexible and diverse movements.
- Multi-link leg structure + inverse kinematics algorithm, increasing the effective torque of the servo.
- ICM20948 9-axis motion tracker with self-balancing mode available.
- 2.3kg.cm high-torque servo, with a locked rotor torque of up to 5.2kg.cm, offering better expandability.
- It is composed of 5052 aluminum alloy and PA12 nylon parts. There are 40 sets of bearings used for all joints of the whole body, and the structure is firm and reliable.
- Integrated with various interactive devices, including a 0.96inch OLED screen, two RGB-LED indicators, and an active buzzer, etc.
- The demo is developed using Arduino IDE, and there is no need to manually configure the compilation environment. The ESP32 will automatically establish a WIFI hotspot when it is turned on, you can use a mobile phone (Android/iOS) or a computer (Linux/Windows/Mac). Only a browser based on Chromium is required, and there is no need to download an app.
- With a charging port and an automatic download circuit, you can use it while charging.
- Onboard two series 18650 batteries, 5200mAh, larger output current, and more powerful servo.
- Integrated with a lithium battery protection circuit, featuring protection against overcharging, overdischarging, overcurrent, and short circuits.
- Onboard INA219 acquisition chip, convenient for real-time monitoring of battery voltage and charging current.
- 2*5P expansion ports are reserved for the remaining IO and serial ports of the ESP32, with functions including RGB expansion, RX0, TX0, G21, G15, G12, 3V3, 5V, GND. This can be used for communication with a host computer or to connect to other devices.
- The Raspberry Pi can be installed as the upper computer to communicate with the lower computer through the serial port. The ESP32, as the lower computer, can share a lot of computing power for link inverse solution and gait generation, leaving more resources for Raspberry Pi to develop advanced functions.
- The Raspberry Pi kit comes with a cooling fan and an ultra-wide-angle lens. The Raspberry Pi demo includes a web application based on Flask-Streaming that can use OpenCV-based features such as face recognition/color tracking/motion detection.
- All code is open source and rich development documentation and tutorials are provided.
Product Usage
First Use
- After power-on, connect your phone or computer to the robot's Wi-Fi: WAVEGO, password 12345678. Open Google Chrome and enter 192.168.4.1 in the address bar to access the web interface. You can now use the Web buttons to control the robot or send JSON commands via the Web interface.
Lower Computer Web Usage
- Use the directional buttons to control the robot's movement. The buttons STEADY START and STEADY STOP below the directional buttons toggle the robot's self‑balancing mode.
- Staylow button controls the robot's crouch and stand actions; HandShake button makes the robot perform a handshake; Jump button makes the robot jump.
- In the FEEDBACK INFORMATION window, you can send JSON commands to the robot. Below the input box are specific JSON commands; detailed explanations of JSON commands are available in the JSON Command Set.
- This web application is completely open-source. You can modify its interface and functionality by editing the WebPage.h file in the open-source example.
JSON Usage Tutorial
What is JSON?
JSON (JavaScript Object Notation) is a lightweight data interchange format commonly used for transmitting and storing data between different systems. JSON originated from JavaScript but has become a language-independent data format, so it can be used and parsed in various programming languages.
Below is an example of a JSON command for controlling the robot's forward and lateral movements:
{"T":111,"FB":1,"LR":1}
Explanation of this command:
"T" represents the command type, defined in the lower-level program's header file json_cmd.h. "111" corresponds to the command CMD_BASIC_MOVE.
We will detail the usage and precautions of each command in the following JSON Command Set. Once you have a basic understanding of each function, you can refer to the JSON command set to improve secondary development efficiency.
Why Use JSON Commands to Interact with the Robot?
Given the abundant onboard resources of the robot's driver board, rich example functionalities, and the need to conveniently support upper computers for more extensive and flexible control, we use JSON command communication for interaction. Similarly, you can perform secondary development based on this existing framework to tailor the robot's functions to your specific needs.
Communication Methods Supporting JSON Commands
The robot supports multiple methods for JSON command interaction. Wired communication can use the RX/TX pins for serial communication, or connect via USB through the Type‑C port. Wireless communication can use HTTP requests. You can use the examples below to send corresponding JSON commands using different methods to control various robot functions.
1. Serial/USB Communication
Features: Wired connection, default baud rate @115200, bidirectional communication, stable, low latency;
Purpose: Convenient for controlling the robot with upper computers like PC, Raspberry Pi, etc.
Connection Methods:
- Connect the robot's 40PIN UART interface to a Raspberry Pi.
- Connect the lower driver board's USB interface to the upper computer using a USB cable
Python demo: Serial_simple_ctrl.zip. The specific example content is as follows:
import serial
import argparse
import threading
def read_serial():
while True:
data = ser.readline().decode('utf-8')
if data:
print(f"Received: {data}", end='')
def main():
global ser
parser = argparse.ArgumentParser(description='Serial JSON Communication')
parser.add_argument('port', type=str, help='Serial port name (e.g., COM1 or /dev/ttyUSB0)')
args = parser.parse_args()
ser = serial.Serial(args.port, baudrate=115200, dsrdtr=None)
ser.setRTS(False)
ser.setDTR(False)
serial_recv_thread = threading.Thread(target=read_serial)
serial_recv_thread.daemon = True
serial_recv_thread.start()
try:
while True:
command = input("")
ser.write(command.encode() + b'\n')
except KeyboardInterrupt:
pass
finally:
ser.close()
if __name__ == "__main__":
main()
Use the following command to run the serial communication program, and be sure to add the port number to which the robot is connected. Replace COM20 with the actual serial port device name that appears after connecting the robot. If you are using a Raspberry Pi, change it to the corresponding port name.
python serial_simple_ctrl.py COM20
After running, you can send JSON format commands and receive robot feedback in this interface to communicate with the robot.
2. HTTP Request Communication
HTTP (Hypertext Transfer Protocol) is a protocol used for data communication on the Web.
Features: Wireless communication based on the Wi-Fi module, using a request-response model, is flexible and simple.
Python demo: Download the HTTP request communication demo http_simple_ctrl.py. The specific content is as follows:
import requests
import argparse
def main():
parser = argparse.ArgumentParser(description='Http JSON Communication')
parser.add_argument('ip', type=str, help='IP address: 192.168.10.104')
args = parser.parse_args()
ip_addr = args.ip
try:
while True:
command = input("input your json cmd: ")
url = "http://" + ip_addr + "/js?json=" + command
response = requests.get(url)
content = response.text
print(content)
except KeyboardInterrupt:
pass
if __name__ == "__main__":
main()
Before running, you need to confirm the robot's IP address, which depends on its Wi-Fi mode.
- If the robot's Wi-Fi is only in AP mode, the IP address is 192.168.4.1.
- If the robot's Wi-Fi is in STA mode, you can obtain its IP address from the ST line on the OLED screen.
Use the following command to run the HTTP request communication program. Replace the IP address in the command with your robot's IP address.
python http_simple_ctrl.py 192.168.4.1
Note: Regardless of the mode, the robot and the device running this script must be on the same local network.
JSON Command Set
Vector Control – CMD_BASIC_MOVE
{"T":111,"FB":1,"LR":1}
- FB is forward/backward, LR is left/right strafe. The speed range is -1 to +1. Positive values mean forward, negative values mean backward.
- It is recommended to use this command for controlling the product.
Move to Mid Position – CMD_JOINT_MIDDLE
{"T":101}
- All joints move to the mid position (511).
Torque Lock Control – CMD_RELEASE_TORQUEE
{"T":102}
- Release torque lock on all joints. This command is only applicable in assembly mode (when G15 pin is connected to 3.3V to enter assembly mode).
Servo Control – CMD_SINGLE_SERVO_CTRL
{"T":103,"id":21,"goal":511,"time":0,"spd":0}
- id: Servo identifier number. The ID numbers for each joint are different. Refer to the product assembly tutorial for the specific distribution.
- goal: Target position of the servo.
- time: Time required to move from the current position to the target position; takes effect when speed is 0.
- spd: Speed at which to move from the current position to the target position.
- This command is only applicable in assembly mode (when G15 pin is connected to 3.3V).
- After assembly, each joint is constrained by the mechanical structure, so it is not recommended to use this command for motion control. It is better to use the vector control commands for operation.
Get Zero Position – CMD_GET_JOINTS_ZERO
{"T":104}
- Get the pos values of the robot's zero positions.
Set Zero Position - CMD_SET_JOINTS_ZERO
{"T":105,"set":[511,511,511,511,511,511,511,511,511,511,511,511]}
- Set the zero positions of the robot's joints.
Get Current Servo Positions - CMD_GET_CURRENT_POS
{"T":106}
- Get the current pos values of all joint servos.
Set Current Position as Zero Position - CMD_SET_CURRENT_POS_ZERO
{"T":107}
- Set the current pos values of all joints as the zero positions.
WAVEGO Tutorial Catalog
Resources
Robot Diagram
Open Source Resources
Raspberry Pi Learning Resources
Development Resources
FAQ
It uses 2 18650-type batteries, which are 18mm in length and 65mm in length. The nominal voltage of a single cell is generally 3.7V, and the fully charged voltage is generally 4.2V.
The default account for Raspberry Pi system: ws; password: ws
Question: 3. It prompts to enter the password, but I cannot enter the password, or receive an error?
Linux systems do not print the input content when entering passwords, which means blind typing is required. Just type "raspberry" directly with the keyboard and press Enter.
If the servo does not turn as specified in the tutorial, check if the servo is installed correctly. In assembly mode, the white arm should be installed at a 45-degree angle.
It is normal. Due to the color change of RGB-LED lights, RGB-LED will now appear green when entering assembly mode.
When entering the web interface for calibration, there is no need to keep the G12 and 3V3 shorted in assembly mode.
Please note that the browser must be Google Chrome or Microsoft Edge. When adjusting PWM, a single click is a fine-tuning and the change is subtle; multiple clicks will be more noticeable. If it cannot be adjusted, it may also be that there was a mistake when installing the servo, back to Q5.
If an error occurs when running setup. py, please check if the source or network issues are causing the download to fail. After installation, please enter the Python environment by inputting python3 in the terminal and then input import cv2 to check for any error reports If no errors are reported, the installation is successful. If there are error reports, you can run setup.py multiple times or directly use the installed image.
First, check if the Raspberry Pi is occupying the serial port of the lower computer. If the lower computer is connected to the Raspberry Pi, disconnect it and then re-upload the demo again. If the demo fails to download automatically, enter the download mode manually. After compiling the demo, press and hold the boot button while uploading it and release the boot button during the RST button press. If the problem cannot be solved, please return it for repair.
Please check the configuration you set when flashing the image. For more information, please refer to the product installation tutorial on the WAVEGO Raspberry Pi Wiki page. If you still cannot flash the image successfully, please help the customer flash the image through remote login.
The battery life of WAVEGO Pro depends on various factors such as usage and environment. In general, a single charge can support continuous use for 1 to 2 hours, and for continuous high-intensity operation, it can last 20-30 minutes. However, the specific usage time will vary depending on usage (such as different power settings, different wavelengths) and working environment (such as temperature, and humidity).
Support
Technical Support
If you need technical support or have any feedback/review, please click the Submit Now button to submit a ticket, Our support team will check and reply to you within 1 to 2 working days. Please be patient as we make every effort to help you to resolve the issue.
Working Time: 9 AM - 6 PM GMT+8 (Monday to Friday)