6. Python Project

6.1 MicroPython Development Environment Setup and Configuration

6.1.1 Programming Tool Installation and Overview

6.1.1.1 Firmware Flashing

Note

Before flashing the firmware, make sure to save the servo deviation values according to Read the Deviation Values in the PC Software.

1. Download 2. Software/5.ESP32S3 Firmware Flashing Tool/flash_download_tool_3.9.7_1. Then double-click flash_download_tool_3.9.7.exe to open the flash tool.

2. Select ESP32 for ChipType and Develop for WorkMode.

3. Power on miniHexa and connect it to the PC.

4. Select 2. Software/8.miniHexa Factory Firmware/MicroPython & Scratch Firmware/minihexa_20250929_0x000.bin and set the address to 0x0000. Select the correct serial port and baud rate. Click ERASE first, then click START to begin flashing. Wait until the process is complete.

5. After flashing is complete, restart the robot to return it to the initial position. Then follow 6.1.2 Deviation Calibration to write the deviation values.

6.1.1.2 Python Editor Overview and Usage

This section explains how to connect the Hiwonder Python Editor and use its main features. The software allows switching the language to English.

Note

If the editor cannot be opened, rename the editor folder to an English-only name such as Hiwonder.

The editor interface is divided into five areas as shown below:

The functions of each area are listed in the table below:

No.	Area	Function
1	Menu Bar	Includes File, Edit, View, Connect, Run, and Help.
2	Toolbar	Includes several common shortcut buttons. Their functions correspond to commands in the menu bar.
3	File List	Contains project files stored on the device and on the local PC. Folders and source code files can be viewed here.
4	Code Editor	Used to view and edit code.
5	Terminal	Displays message logs and debugging information. When no device is connected, only message logs are available.

Operation Guide

1. For the first import, left-click Local Project to open the file selection list. For later imports, right-click Local Project -> Switch Project Path.

2. Select 2. Software/4. Program Collection/5. Python Project, then click Select Folder.

3. The files in the folder are automatically added to the local project and can be viewed under Local Project.

Note

Importing a local project only imports files from the PC into the editor. It does not download them to the ESP32 controller board.

View Files and Programs

Double-click a program file in the file list to view the code. 02 Omnidirectional Movement Program/main.py is used here as an example:

After a program file is downloaded to the ESP32 controller board, double-click the file under Device to view it in the same way.

Code Writing and Saving

The code editor on the right side supports code creation, viewing, editing, modification, and saving. Read the following notes before writing code:

1. Files cannot be created directly under the Device tab. Changes to files under Device can be saved only through the download operation. For backup, copy the files to the local project first.

2. Do not modify action group files with the .rob extension in the editor. Unknown format errors may occur. Edit action group files in the PC software when needed.

3. Among the provided low-level program files, main.py is the main program of the device. All robot functions are launched through this file. Reset and power-on operations also depend on this file. If main.py stops responding, subsequent operations cannot continue. For safety, rename the program first if additional features need to be added. If main.py is changed to another name and the program becomes stuck during debugging, even when Ctrl+C and Ctrl+D both fail, reset the controller board, delete the program, and download the required program again.

Program Download and Execution

Program download is an interaction between the editor and the device. 02 Omnidirectional Movement Program/main.py is used here as an example:

1. Under the Local Project tab, select 02 Omnidirectional Movement Program/main.py. Click the toolbar icon to connect to the ESP32 controller board. Then click the toolbar icon or right-click the file and select Download and Run.

2. The terminal displays the download progress and completion status. Since Download and Run is used in the previous step, the running result can also be viewed there.

3. After the download is complete, the program appears in the file list under Device.

Note

• If the downloaded file is not named main.py, delete the original main.py and rename the downloaded file to main.py. Another option is to rename the file to main.py before downloading.

• “Download and Run” first resets the device, which means a restart, and then downloads and runs the program. This helps improve program stability.

• If the program does not need to run immediately, click the button or right-click the target file and select “Download”. Before running the program later, click the icon to reset the device first, then run the program.

Terminal Debugging

The terminal combines the message window and the debugging console. When no device is connected, the terminal can display messages only and cannot be used for editing or debugging. The message viewing function has already been shown in the previous steps. The following section focuses on debugging features.

1. The terminal supports code input. Enter print(123) in the terminal and press Enter. The result is shown below:

2. The terminal also supports automatic indentation. When a Python statement ends with a colon, such as if, for, or while, pressing Enter continues on the next line with the appropriate indentation. Press Backspace to remove one indentation level.

3. To copy and paste code, select the target code and right-click in the terminal.

Note

Press “Ctrl+E” to enter edit mode before pasting code. Otherwise, indentation errors may occur during debugging.

The image below shows the correct result after copy and paste. The indentation is correct.

The image below shows incorrect indentation:

To exit edit mode, press Ctrl+C. If an infinite loop is running, press Ctrl+C to interrupt it as well.

Note

“Ctrl+C” only interrupts a running program in the terminal. It does not copy text. “Ctrl+V” does not paste text in the terminal.

4. Use Tab to complete code when entering commands in the terminal. For example, enter os and press Tab. The result is shown below:

If two or more completions are available, the terminal lists all available options. If only one completion is available, the terminal completes it automatically. If no completion is available, no action is taken.

5. Use the Up Arrow and Down Arrow keys in the terminal to view previously entered commands and reduce repeated input.

For more commands and command descriptions, visit http://docs.micropython.org/en/latest/library/uos.html

6.1.2 Deviation Calibration

6.1.2.1 Read the Deviation Values in the PC Software

Downloading an Arduino program erases the MicroPython firmware on the ESP32. The original servo deviation values are cleared at the same time. Before programming a MicroPython project, open the PC software and save the servo deviation values.

1. Open 2. Software/3. PC Software Package/MiniHexa.exe. Connect miniHexa to the PC with a USB data cable. Then follow the steps shown below. Select the corresponding port. COM4 is used here as an example. Click Connect, then click Action Edit.

2. Click Read offset to read the servo deviation values.

Note

After the servo deviation values are read, take a screenshot to keep a backup and prevent data loss.

6.1.2.2 Write the Deviation Values

1. Open the Hiwonder Python Editor.

2. Open 02 Program Files/Deviation Writing Program/main.py, then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

3. Locate the code section that sets the deviation values:

# Set servo deviation values
robot.set_deviation(1 , 0)
robot.set_deviation(2 , 0)
robot.set_deviation(3 , 0)
robot.set_deviation(4 , 0)
robot.set_deviation(5 , 0)
robot.set_deviation(6 , 0)
robot.set_deviation(7 , 0)
robot.set_deviation(8 , 0)
robot.set_deviation(9 , 0)
robot.set_deviation(10 , 0)
robot.set_deviation(11 , 0)
robot.set_deviation(12 , 0)
robot.set_deviation(13 , 0)
robot.set_deviation(14 , 0)
robot.set_deviation(15 , 0)
robot.set_deviation(16 , 0)
robot.set_deviation(17 , 0)
robot.set_deviation(18 , 0)

4. Write the deviation data read in Read the Deviation Values in the PC Software into the code.

robot.set_deviation(1 , 24)
robot.set_deviation(2 , 28)
robot.set_deviation(3 , 9)
robot.set_deviation(4 , -20)
robot.set_deviation(5 , -13)
robot.set_deviation(6 , -13)
robot.set_deviation(7 , 0)
robot.set_deviation(8 , -7)
robot.set_deviation(9 , 14)
robot.set_deviation(10 , 21)
robot.set_deviation(11 , -11)
robot.set_deviation(12 , 16)
robot.set_deviation(13 , 21)
robot.set_deviation(14 , 31)
robot.set_deviation(15 , -5)
robot.set_deviation(16 , 0)
robot.set_deviation(17 , -33)
robot.set_deviation(18 , -9)

5. After setting the deviation values, connect miniHexa to the PC with a Type-C data cable. Click . After the connection is successful, the icon turns green . Then click to download the program to miniHexa.

Note

The deviation setting program needs to be downloaded and run on miniHexa only once. After that, the settings are stored in the miniHexa Arduino programming environment. No additional setup is required.

6.1.2.3 Read the Written Deviation Values

After the deviation values are written, click . The serial port continuously prints the stored servo deviation values.

6.2 Basic Motion Control

6.2.1 Kinematics and Gait Overview

6.2.1.1 Coordinate System Introduction

1. To control miniHexa, specify the contact point coordinates of the six legs. Inverse kinematics is then used to calculate the rotation angles of all servos, which controls the movement of miniHexa.

2. First establish the coordinate system of miniHexa. Use the center of the body as the origin 0, 0, 0. From the robot’s own perspective, the front is the positive Y-axis, the right side is the positive X-axis, and the upward direction is the positive Z-axis, as shown below:

3. When setting coordinates, only the X-axis, Y-axis, and Z-axis values of the six leg contact points need to be specified.

6.2.1.2 Gait Overview

1. Gait is a periodic summary of the walking characteristics of animals. In simple terms, it describes how an animal walks. Common gait patterns of hexapods include tripod gait and wave gait. Under all conditions, at least three legs must remain in contact with the ground to keep the system stable.

2. The table below lists several common terms used in gait descriptions:

Term	Description
Phase	The position in periodic motion. The most direct interpretation is angle.
Phase Difference	The lead or lag difference in motion between different legs.
Swing Phase	The leg is lifted and off the ground.
Stance Phase	The leg is in contact with the ground.
Cycle	During locomotion, the complete process from one touchdown of the foot to the next touchdown of the same foot is one cycle.
Gait Frequency	The number of gait cycles completed per unit time.
Step Length	The distance traveled by the foot endpoint from lift-off to touchdown within one cycle.
Stride Length	The distance traveled by the body within one cycle.
Duty Cycle	The ratio between the time a single leg stays in the stance phase and the gait cycle.

6.2.1.3 Tripod Gait Introduction

1. Tripod gait is a typical walking gait for hexapod robots. In six-legged insects, all six legs do not move forward at the same time. Instead, the three pairs of legs are divided into two groups and advance alternately in a triangular support structure. In simple terms, three legs move up and down alternately with the other three.

2. This triangular support structure keeps the body in a statically stable state.

3. Most hexapod robots currently use an insect-inspired structure. The six legs are distributed on both sides of the body. The front and rear legs on the left side together with the middle leg on the right side form one group. The front and rear legs on the right side together with the middle leg on the left side form the other group. These two groups form two triangular supports. Support and swing are achieved through the forward and backward swing of the thighs. This is the typical tripod gait walking method.

4. When the hexapod robot uses tripod gait, the two leg groups operate alternately. For clarity, the legs are numbered from the robot’s own perspective as shown below:

5. The diagram below is used to analyze tripod gait:

6. As shown on the right side of the figure, legs 2, 4, and 6 lift and swing forward. Legs 1, 3, and 5 support the body and keep the center of gravity at the intersection of the diagonals. At this time, legs 2, 4, and 6 are in the swing phase. Legs 1, 3, and 5 are in the stance phase.

7. Then all six legs touch the ground at the same time. Legs 1, 3, and 5 stay in place. Legs 2, 4, and 6 are farther forward. All legs are in the stance phase.

8. As shown on the left side of the figure, legs 1, 3, and 5 lift and swing forward. Legs 2, 4, and 6 support the body and keep the center of gravity at the intersection of the diagonals. At this time, legs 1, 3, and 5 are in the swing phase. Legs 2, 4, and 6 are in the stance phase.

9. Then all six legs touch the ground at the same time. Legs 2, 4, and 6 stay in place. Legs 1, 3, and 5 are farther forward. All legs are in the stance phase.

10. After these four actions are completed, the robot completes one full gait cycle.

6.2.1.4 Robot Motion Process Analysis

This section uses one leg as an example to explain the motion process from the standing standby stage to the final standing return stage after movement is completed. For ease of description, assume the robot is standing still and receives a command to move straight forward.

Initial Stage

1. Before the robot receives the motion command, observe the middle leg in the figure below. It is touching the ground.

2. After the robot receives the motion command, overall movement begins. When the observed leg is ready to move, it lifts upward to the position directly above, which is the initial position, as shown below.

Motion Stage

1. During the motion stage, the leg always starts moving from the initial position.

2. Based on the motion parameters, the robot controls the leg to swing forward or backward. In the assumed scenario, the robot moves forward, so the leg first swings forward from top to bottom until the toe touches the ground, as shown below.

3. After the toe touches the ground, the leg continues to swing backward. The resulting force drives the robot forward, as shown below.

4. Finally, the leg swings upward from bottom to top and returns to the initial position. This completes one full motion cycle of the leg. In the move function, which is used to control body movement, the movement step count step_num can be specified. The movement step count refers to how many cycles one leg completes, starting from the initial position, landing on the ground, and swinging back to the initial position.

Finishing Stage

1. After the leg completes the last swing, it enters the finishing stage. The motion still starts from the initial position.

2. As shown below, the leg drops to the ground and completes the final finishing movement.

6.2.1.5 Robot Kinematics Analysis

Because the overall motion of the robot involves the coupling of the gait algorithm and the inverse kinematics algorithm, analyzing the full system directly is relatively complex. Therefore, one leg is used here as an example so that the gait algorithm can be separated from the discussion and the kinematics can be analyzed directly.

Single-Leg Structural Modeling

1. The figure below shows the coordinate-system model of a single leg:

Note

• In the actual design, a metal plate is mounted at joint O3 at the end of the leg. Its width extends in the same direction as link r₂. Therefore, in the following calculations, that width is treated as the foot-end offset offset and is included as part of link r₂.

• In the D-H parameter table and in the forward and inverse kinematics derivations below, r₂ already includes the foot-end offset offset.

D-H Parameter Table

i	d	theta	r	alpha
1	0	0	2.85	90
2	0	0	5.2	0
3	0	0	7.2	0

Description of the four D-H parameters:

1. d is the offset of coordinate system a(i+1) relative to coordinate system a(i) along the Z(i) axis

2. theta is the angle between the X-axes of coordinate systems a(i) and a(i+1)

3. r is the mathematical length of the link

4. alpha is the angle from Z(i-1) to Z(i+1) after rotation around X(i)

Single-Leg Forward Kinematics Overview

1. Forward kinematics is a fundamental basis for trajectory planning in joint space and for robot control. For this robot, forward kinematics means calculating the foot-end coordinates from the rotation angles of the three servos on one leg.

2. The forward kinematics process is as follows: given the rotation angles of the three servos on one leg, determine the leg position and then calculate the corresponding foot-end coordinates.

Single-Leg Forward Kinematics Derivation

Known parameters: joint rotation angles Q₁, Q₂, and Q₃

Unknown parameters: the D-H parameter table and the foot-end coordinates p_x, p_y, and p_z

1. The transformation matrix expressions of each joint coordinate system are obtained as follows:

\[\begin{split} T_{2}^{1} = \begin{bmatrix} \cos(Q_{1}) & 0 & \sin(Q_{1}) & r_{1}\cos(Q_{1}) \\ \sin(Q_{1}) & 0 & - \cos(Q_{1}) & r_{1}\sin(Q_{1}) \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} \end{split}\]

\[\begin{split} T_{3}^{2} = \begin{bmatrix} \cos(Q_{2}) & - \sin(Q_{2}) & 0 & r_{2}\cos(Q_{2}) \\ \sin(Q_{2}) & \cos(Q_{2}) & 0 & r_{2}\sin(Q_{2}) \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} \end{split}\]

\[\begin{split} T_{4}^{3} = \begin{bmatrix} \cos(Q_{3}) & - \sin(Q_{3}) & 0 & r_{3}\cos(Q_{3}) \\ \sin(Q_{3}) & \cos(Q_{3}) & 0 & r_{3}\sin(Q_{3}) \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} \end{split}\]

2. By multiplying the matrices sequentially, the overall transformation matrix T¹₄ from the base coordinate system to the foot endpoint coordinate system can be obtained:

\[\begin{split} T_{2}^{1}T_{3}^{2}T_{4}^{3} = T_{4}^{1} = \begin{bmatrix} \cos(Q_{2} + Q_{3}) \cdot \cos(Q_{1}) & - \sin(Q_{2} + Q_{3}) \cdot \cos(Q_{1}) & \sin(Q_{1}) & px \\ \cos(Q_{2} + Q_{3}) \cdot \sin(Q_{1}) & - \sin(Q_{2} + Q_{3}) \cdot \sin(Q_{1}) & - \cos(Q_{1}) & py \\ \sin(Q_{2} + Q_{3}) & \cos(Q_{2} + Q_{3}) & 0 & pz \\ 0 & 0 & 0 & 1 \end{bmatrix} \end{split}\]

3. Here p_x, p_y, and p_z are the end-point coordinates, namely the foot-end coordinates. Their expressions are as follows:

\[\begin{split} \begin{matrix} px & = r_{1}\cos(Q_{1}) + r_{2}\cos(Q_{1})\cos(Q_{2}) + r_{3}\cos(Q_{1})\cos(Q_{2})\cos(Q_{3}) + r_{3}\cos(Q_{1})\sin(Q_{2})\sin(Q_{3}) \\ py & = r_{1}\sin(Q_{1}) + r_{2}\cos(Q_{2})\sin(Q_{1}) + r_{3}\cos(Q_{2})\cos(Q_{3})\sin(Q_{1}) - r_{3}\sin(Q_{1})\sin(Q_{2})\sin(Q_{3}) \\ pz & = r_{2}\sin(Q_{2}) + r_{3}\cos(Q_{2})\sin(Q_{3}) + r_{3}\cos(Q_{3})\sin(Q_{2}) \end{matrix} \end{split}\]

4. After further simplification:

\[ px = \cos(Q_{1}) \cdot (r_{1} + r_{3} \cdot \cos(Q_{2} + Q_{3}) + r_{2} \cdot \cos(Q_{2})) \]

\[ py = \sin(Q_{1}) \cdot (r_{1} + r_{3} \cdot \cos(Q_{2} + Q_{3}) + r_{2} \cdot \cos(Q_{2})) \]

\[ pz = r_{3} \cdot \sin(Q_{2} + Q_{3}) + r_{2} \cdot \sin(Q_{2}) \]

5. This yields the forward kinematics expressions that map servo rotation angles to foot-end coordinates.

Single-Leg Inverse Kinematics Overview

1. Inverse kinematics is a fundamental basis for trajectory planning based on the end effector and for robot control. For this robot, inverse kinematics means calculating the rotation angles of the three servos on one leg from the foot-end coordinates.

2. The inverse kinematics process is as follows: given the foot-end coordinates of one leg, determine the leg position and then solve for the corresponding servo rotation angles.

3. After the servo rotation angles are obtained, the corresponding values can be calculated to drive the servos directly and achieve robot motion control.

Single-Leg Inverse Kinematics Derivation

Known parameters: the D-H parameter table and the foot-end coordinates p_x, p_y, and p_z

Unknown parameters: joint rotation angles Q₁, Q₂, and Q₃

1. First, define a matrix that contains the known foot-end coordinates. It will later be multiplied by other matrices containing Q₁, Q₂, and Q₃ so that several expressions can be derived for further solving. From the forward kinematics derivation above, T¹₄ meets this requirement. Only the first three elements of the fourth column need to be considered here because they are known values:

\[\begin{split} T = T_{4}^{1} = \begin{bmatrix} ax & bx & cx & px \\ ay & by & cy & py \\ az & bz & cz & pz \\ 0 & 0 & 0 & 1 \end{bmatrix} \end{split}\]

2. Based on the expression of the transformation matrix:

\[ (T_{2}^{1})^{- 1} \cdot T = (T_{2}^{1})^{- 1} \cdot T_{2}^{1} \cdot T_{3}^{2} \cdot T_{4}^{3} = T_{3}^{2} \cdot T_{4}^{3} \]

3. Derive the expressions on both sides:

\[\begin{split} (T_{2}^{1})^{- 1} \cdot T = \begin{bmatrix} \cos(Q_{2} + Q_{3}) & - \sin(Q_{2} + Q_{3}) & 0 & px\cos(Q_{1}) - r_{1} + py\sin(Q_{1}) \\ \sin(Q_{2} + Q_{3}) & \cos(Q_{2} + Q_{3}) & 0 & pz \\ 0 & 0 & 1 & px\sin(Q_{1}) - py\cos(Q_{1}) \\ 0 & 0 & 0 & 1 \end{bmatrix} \end{split}\]

\[\begin{split} T_{3}^{2} \cdot T_{4}^{3} = \begin{bmatrix} \cos(Q_{2} + Q_{3}) & - \sin(Q_{2} + Q_{3}) & 0 & r_{3}\cos(Q_{2} + Q_{3}) + r_{2}\cos(Q_{2}) \\ \sin(Q_{2} + Q_{3}) & \cos(Q_{2} + Q_{3}) & 0 & r_{3}\sin(Q_{2} + Q_{3}) + r_{2}\sin(Q_{2}) \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} \end{split}\]

4. By equating the first three elements of the fourth column of these two matrices, three expressions are obtained:

(1-1)

\[ r_{3} \cdot \cos(Q_{2} + Q_{3}) = px \cdot \cos(Q_{1}) - r_{1} + py \cdot \sin(Q_{1}) - r_{2} \cdot \cos(Q_{2}) \]

(1-2)

\[ r_{3} \cdot \sin(Q_{2} + Q_{3}) = pz - r_{2} \cdot \sin(Q_{2}) \]

(1-3)

\[ px \cdot \sin(Q_{1}) - py \cdot \cos(Q_{1}) = 0 \]

5. Further derivation of equation (1-3) gives the expression for Q₁ in terms of p_x, p_y, and p_z:

\[ Q_{1} = \arctan\left( \frac{px}{py} \right) \]

6. By observing equations (1-1) and (1-2), it can be seen that the two expressions contain trigonometric functions of Q₂ and Q₂+Q₃. The next step is to simplify them using the identity sin²x + cos²x = 1. First, isolate the parts that are not trigonometric functions of Q₂ and Q₂+Q₃, and consolidate them into m₁ and m₂. Since Q₁ has already been obtained above, both m₁ and m₂ are known values.

\[ m_{1} = px \cdot \cos(Q_{1}) - r_{1} + py \cdot \sin(Q_{1}) \]

\[ m_{2} = pz \]

7. After simplification, equations (1-1) and (1-2) can be rewritten as:

(1-4)

\[ r_{3} \cdot \cos(Q_{2} + Q_{3}) = m_{1} - r_{2} \cdot \cos(Q_{2}) \]

(1-5)

\[ r_{3} \cdot \sin(Q_{2} + Q_{3}) = m_{2} - r_{2} \cdot \sin(Q_{2}) \]

8. Square both sides of equations (1-4) and (1-5), then add the left-hand sides and the right-hand sides respectively to obtain:

(1-6)

\[ {r_{3}}^{2} = {r_{2}}^{2} - 2 \cdot \cos(Q_{2}) \cdot r_{2} \cdot m_{1} - 2 \cdot \sin(Q_{2}) \cdot r_{2} \cdot m_{2} + {m_{1}}^{2} + {m_{2}}^{2} \]

9. Further consolidate parts of the expression above. From the following definitions, n₁, n₂, and n₃ are all known values:

\[ n_{1} = 2 \cdot r_{2} \cdot m_{1} \]

\[ n_{2} = 2 \cdot r_{2} \cdot m_{2} \]

\[ n_{3} = {r_{2}}^{2} + {m_{1}}^{2} + {m_{2}}^{2} - {r_{3}}^{2} \]

10. After further simplification of equation (1-6):

\[ n_{1} \cdot \cos(Q_{2}) + n_{2} \cdot \sin(Q_{2}) = n_{3} \]

11. Further derivation yields the expression for Q₂ in terms of p_x, p_y, and p_z:

\[ Q_{2} = \arctan\left( \frac{{n_{1}}^{2} + {n_{2}}^{2} - {n_{3}}^{2}}{n_{3}} \right) + \arctan\left( \frac{n_{2}}{n_{1}} \right) \]

12. Substitute the expression for Q₂ back into equation (1-4) or (1-5) to obtain the expression for Q₃:

\[ Q_{3} = \arctan\left( \frac{m_{2} - r_{2}\sin Q_{2}}{m_{1} - r_{2}\cos Q_{2}} \right) - Q_{2} \]

13. After consolidation, the inverse kinematics expressions for the joint rotation angles Q₁, Q₂, and Q₃ are listed again below:

\[ Q_{1} = \arctan\left( \frac{px}{py} \right) \]

\[ Q_{2} = \arctan\left( \frac{{n_{1}}^{2} + {n_{2}}^{2} - {n_{3}}^{2}}{n_{3}} \right) + \arctan\left( \frac{n_{2}}{n_{1}} \right) \]

\[ Q_{3} = \arctan\left( \frac{m_{2} - r_{2}\sin Q_{2}}{m_{1} - r_{2}\cos Q_{2}} \right) - Q_{2} \]

6.2.2 Omnidirectional Movement

6.2.2.1 Feature Overview

This section controls miniHexa to move in different directions.

6.2.2.2 Project Process

6.2.2.3 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open 02 Program Files/01 Omnidirectional Movement Program/main.py in the same path as this document.

3. After the file is opened, select the development board model shown below:

4. Click Tools in the menu bar and select the corresponding ESP32 development board configuration as shown below.

Note

Make sure to modify the development board configuration before program download.

5. Click Compile first, then click Upload. When the output panel at the bottom displays the success message, the program has been downloaded successfully.

6.2.2.4 Project Outcome

After power-on, the hexapod robot cycles through movement in ten directions: forward, forward-right, right, backward-right, backward, backward-left, left, forward-left, turn left in place, and turn right in place.

6.2.2.5 Program Analysis

1. Import the hiwonder_robot.h library file. This library contains the low-level control interfaces of the robot.

    #include "hiwonder_robot.h"

2. Initialize the miniHexa object and define the motion mode variable count. Then create the robot motion arrays vel, pos, and att, which represent velocity, position, and Euler angles.

    // Initialize miniHexa object
    Robot minihexa;
    
    // Define variable `count` to record the motion mode
    uint8_t count = 0;
    // Initialize motion state
    Velocity_t vel = {0.0f,0.0f,0.0f};
    Vector_t pos = {0.0f,0.0f,0.0f};
    Euler_t att = {0.0f,0.0f,0.0f};

3. In the setup() function, set the initial serial communication baud rate to 115200, then initialize the robot.

   void setup() {
     Serial.begin(115200);
     minihexa.begin();
   }

4. In the loop() main function, the ten different movement directions are executed cyclically according to the loop of variable count. By modifying the three parameters in vel, the direction of body movement can be changed. The first parameter of vel controls the left and right movement speed of the body along the X-axis. The second parameter controls the forward and backward movement speed of the body along the Y-axis. The third parameter controls the in-place rotation speed of the body around the Z-axis. After vel is passed into the move function, the robot starts moving according to the specified parameters. After 5.5 s, the next group of motion parameters is passed into the move function, and the robot switches to the next motion state.

    void loop() {
      switch(count) {
        case 0:// Forward
          count++;
          vel = {0.0f, 3.0f, 0.0f};
          break;
      
        case 1:// Forward-right
          count++;
          vel = {2.0f, 2.0f, 0.0f};
          break;

        case 2:// Move right
          count++;
          vel = {3.0f, 0.0f, 0.0f};
          break;

        case 3:// Backward-right
          count++;
          vel = {2.0f, -2.0f, 0.0f};
          break;

        case 4:// Backward
          count++;
          vel = {0.0f, -3.0f, 0.0f};
          break;

        case 5:// Backward-left
          count++;
          vel = {-2.0f, -2.0f, 0.0f};
          break;

        case 6:// Move left
          count++;
          vel = {-3.0f, 0.0f, 0.0};
          break;

        case 7:// Forward-left
          count++;
          vel = {-2.0f, 2.0f, 0.0f};
          break;

        case 8:// Turn left in place
          count++;
          vel = {0.0f, 0.0f, 2.0f};
          break;

        case 9:// Turn right in place
          count = 0;
          vel = {0.0f, 0.0f, -2.0f};
          break;
      }
      delay(5500);
      minihexa.move(&vel, &pos, &att, 1800, 3);
    }

5. case 0 is used here as an example. The movement direction of the body is mainly changed by modifying the parameters of vel. When the Y-axis speed is set to 3, the body moves forward.

    case 0:// Forward
      count++;
      vel = {0.0f, 3.0f, 0.0f};  // Set the Y-axis speed to 3 so the body moves forward
      break;

6. case 1 is used here as an example. Set the X-axis speed to 2 so the body translates to the right. Then add a Y-axis speed of 2 so the body moves forward. Under the combined effect of these two directions, the body moves toward the forward-right direction.

    case 1:// Forward-right
      count++;
      vel = {2.0f, 2.0f, 0.0f};  // X-axis speed 2 to the right and Y-axis speed 2 forward
      break;

7. case 8 is used here as an example. Set the Z-axis speed to 2.0f, and the body rotates to the left in place.

    case 8:// Turn left in place
      count++;
      vel = {0.0f, 0.0f, 2.0f};  // Z-axis speed 2 so the body turns left in place
      break;

6.2.3 Turn Left and Right

6.2.3.1 Feature Overview

This section controls miniHexa to perform left and right turning motion.

6.2.3.2 Project Process

6.2.3.3 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open 02 Program Files/02 Left and Right Turning Program/main.py in the same path as this document.

3. After the file is opened, select the development board model shown below:

4. Click Tools in the menu bar and select the corresponding ESP32 development board configuration as shown below.

Note

Make sure to modify the development board configuration before program download.

5. Click Compile first, then click Upload. When the output panel at the bottom displays the success message, the program has been downloaded successfully.

6.2.3.4 Project Outcome

After power-on, the hexapod robot repeatedly performs left and right arc turns.

6.2.3.5 Program Analysis

1. Import the hiwonder_robot.h library file. This library contains the low-level control interfaces of the robot.

    #include "hiwonder_robot.h"

2. Initialize the miniHexa object and create the robot motion arrays vel, pos, and att, which represent velocity, position, and Euler angles.

    // Initialize miniHexa object
    Robot minihexa;

    // Initialize motion state
    Velocity_t vel = {0.0f,0.0f,0.0f};
    Vector_t pos = {0.0f,0.0f,0.0f};
    Euler_t att = {0.0f,0.0f,0.0f};

3. In the setup() function, set the initial serial communication baud rate to 115200, then initialize the robot.

    void setup() {
      Serial.begin(115200);
      minihexa.begin();
    }

4. In the loop() main function, the robot repeatedly performs left and right turns by changing the vel array. First execute a left arc turn. Set the Y-axis speed in vel to 5 so the robot translates forward. Set the Z-axis speed to 0.2 so the robot rotates to the left. The combined effect of these two motions makes the robot turn left.

    void loop() {
        vel = {0.0f, 5.0f, 0.2f};// Left arc forward
        minihexa.move(&vel, &pos, &att);// Execute movement
        delay(5000);
    }

5. Set the Y-axis speed to 5 and the Z-axis speed to -0.2 to make the robot turn right.

        vel = {0.0f, 5.0f, -0.2f};// Right arc forward
        minihexa.move(&vel, &pos, &att);// Execute movement
        delay(5000);
    }

6.2.3.6 Feature Extension

This section uses changing the turning angle of miniHexa as an example to show how to modify the turning angle. Refer to the steps below:

1. Locate the turning code in the main function.

    void loop() {
        vel = {0.0f, 5.0f, 0.2f};// Left arc forward
        minihexa.move(&vel, &pos, &att);// Execute movement
        delay(5000);

        vel = {0.0f, 5.0f, -0.2f};// Right arc forward
        minihexa.move(&vel, &pos, &att);// Execute movement
        delay(5000);
    }

2. Modify the third value omega in vel. Here it is changed to 0.3f to increase the turning angle.

Note

The third omega value in vel should not be set too high. Otherwise, the effect of left rotation will greatly exceed the effect of forward translation, and the robot will behave more like it is rotating in place.

void loop() {
    vel = {0.0f, 5.0f, 0.3f};// Left arc forward with a larger turning angle
    minihexa.move(&vel, &pos, &att);// Execute movement
    delay(5000);

    vel = {0.0f, 5.0f, -0.3f};// Right arc forward with a larger turning angle
    minihexa.move(&vel, &pos, &att);// Execute movement
    delay(5000);
}

3. After the modification is completed, refer to 6.2.3.3 Program Download to run the program.

6.2.4 Speed Adjustment

6.2.4.1 Feature Overview

This section controls miniHexa to move at different speeds.

6.2.4.2 Project Process

6.2.4.3 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open 02 Program Files/03 Speed Adjustment Program/main.py in the same path as this document.

3. After the file is opened, select the development board model shown below:

4. Click Tools in the menu bar and select the corresponding ESP32 development board configuration as shown below.

Note

Make sure to modify the development board configuration before program download.

5. Click Compile first, then click Upload. When the output panel at the bottom displays the success message, the program has been downloaded successfully.

6.2.4.4 Project Outcome

After power-on, the hexapod robot repeatedly performs left rotation in place from slow to fast. The speed increases by 0.5 each time, from 0.5 to 2.0, then returns to 0.5 and repeats in sequence.

6.2.4.5 Program Analysis

1. Import the hiwonder_robot.h library file. This library contains the low-level control interfaces of the robot.

    #include "hiwonder_robot.h"

2. Initialize the miniHexa object, define the variable count, and create the robot motion arrays vel, pos, and att for velocity, position, and Euler angles.

    Robot minihexa;

    uint8_t count = 0;
    // Initialize robot motion
    Velocity_t vel = {0.0f,0.0f,0.0f};
    Vector_t pos = {0.0f,0.0f,0.0f};
    Euler_t att = {0.0f,0.0f,0.0f};

3. In the setup() function, set the initial serial communication baud rate to 115200, then initialize the robot.

    void setup() {
      Serial.begin(115200);
      minihexa.begin();
    }

4. In the loop() main function, four different movement speeds are executed cyclically according to the changing value of variable count.

    void loop() {
      switch(count) {
        case 0:// Slowest left turn in place
          count++;
          vel = {0.0f, 0.0f, 1.0f};
          delay(5000);
          break;
      
        case 1:// Slower left turn in place
          count++;
          vel = {0.0f, 0.0f, 1.5f};
          delay(5000);
          break;

        case 2:// Medium-speed left turn in place
          count++;
          vel = {0.0f, 0.0f, 2.0f};
          delay(5000);
          break;

        case 3:// High-speed left turn in place
          count = 0;
          vel = {0.0f, 0.0f, 2.5f};
          delay(5000);
          break;
      }

      minihexa.move(&vel, &pos, &att);// Execute movement
    }

5. In the switch statement, the rotation speed of miniHexa is changed by modifying the variable count and the vel array.

        case 0:// Slowest left turn in place
          count++;
          vel = {0.0f, 0.0f, 1.0f};  // Z-axis speed 1.0 for the slowest speed
          delay(5000);
          break;

6.2.5 Gait Parameter Adjustment

6.2.5.1 Feature Overview

This section modifies the gait parameters of miniHexa so the robot can move in different postures.

6.2.5.2 Project Process

6.2.5.3 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open 02 Program Files/04 Gait Parameter Adjustment Program/main.py in the same path as this document.

3. After the file is opened, select the development board model shown below:

4. Click Tools in the menu bar and select the corresponding ESP32 development board configuration as shown below.

Note

Make sure to modify the development board configuration before program download.

5. Click Compile first, then click Upload. When the output panel at the bottom displays the success message, the program has been downloaded successfully.

6.2.5.4 Project Outcome

After power-on, the hexapod robot repeatedly performs movement in six different gait modes.

6.2.5.5 Program Analysis

1. Import the hiwonder_robot.h library file. This library contains the low-level control interfaces of the robot.

    #include "hiwonder_robot.h"

2. Initialize the miniHexa object and define the variable count. Create step_num, which is the number of iterations in the motion discretization process, and move_time, which is the motion duration. Then create the robot motion arrays vel, pos, and att, which represent velocity, position, and Euler angles.

    // Initialize miniHexa object
    Robot minihexa;

    // Define motion mode variable `count`
    uint8_t count = 0;
    // Number of iterations in the discretized motion process, which is the foothold count
    int step_num = -1;
    // Initialize motion duration
    uint32_t move_time = 1000;
    // Leg lift height
    float leg_lift = 2.0f;
    // Initialize body motion
    Velocity_t vel = {0.0f,0.0f,0.0f};
    Vector_t pos = {0.0f,0.0f,0.0f};
    Euler_t att = {0.0f,0.0f,0.0f};

3. In the setup() function, set the initial serial communication baud rate to 115200, then initialize miniHexa.

    void setup() {
      Serial.begin(115200);
      minihexa.begin();
    }

4. In the loop() main function, six different gait modes are executed cyclically according to the changing value of variable count.

    void loop() {
      switch(count) {
        case 0:
          count++;
          vel = {0.0f, 2.0f, 0.0f};// Forward
          move_time = 600;// Define runtime
          step_num = 3;
          break;
      
        case 1:
          count++;
          vel = {0.0f, 2.0f, 0.0f};
          move_time = 1000;
          step_num = 2;
          break;

        case 2:
          count++;
          vel = {0.0f, -2.0f, 0.0f};
          move_time = 600;
          step_num = 3;
          break;

        case 3:
          count++;
          vel = {0.0f, -2.0f, 0.0f};
          move_time = 1000;
          step_num = 2;
          break;

        case 4:
          count++;
          vel = {0.0f, 0.0f, 2.0f};
          move_time = 600;
          step_num = 2;
          break;

        case 5:
          vel = {0.0f, 0.0f, -2.0f};
          move_time = 1000;
          step_num = -1;
          break;
      }

      minihexa.move(&vel, &pos, &att, move_time, step_num);
      delay(4000);
    }

5. The parameters that affect gait are move_time, which is the motion duration, and step_num, which is the foothold count. The robot gait can be changed by modifying these parameters. In case 0, the Y-axis speed in vel is set to 2.0, the motion duration is set to 600 ms, and the foothold count is 3. In this state, the robot moves forward along the positive Y-axis at a speed of 2.0. The motion lasts 600 ms and completes 3 footholds.

        case 0:
          count++;
          vel = {0.0f, 2.0f, 0.0f};// Forward
          move_time = 600;// Define runtime
          step_num = 3;
          break;

6. In case 5, the motion duration is set to 1000 ms and the foothold count is set to -1, which means continuous walking. In this state, the robot continuously performs the specified movement pattern for 1000 ms.

        case 5:
          vel = {0.0f, 0.0f, -2.0f};
          move_time = 1000;
          step_num = -1;
          break;

6.2.6 Posture Adjustment

6.2.6.1 Feature Overview

This section changes the motion posture of the hexapod robot by modifying posture parameters.

6.2.6.2 Project Process

6.2.6.3 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open 02 Program Files/05 Posture Adjustment Program/main.py in the same path as this document.

3. After the file is opened, select the development board model shown below:

4. Click Tools in the menu bar and select the corresponding ESP32 development board configuration as shown below.

Note

Make sure to modify the development board configuration before program download.

5. Click Compile first, then click Upload. When the output panel at the bottom displays the success message, the program has been downloaded successfully.

6.2.6.4 Project Outcome

After power-on, miniHexa repeatedly changes among 12 different postures.

6.2.6.5 Program Analysis

1. Import the hiwonder_robot.h library file. This library contains the low-level control interfaces of the robot.

    #include "hiwonder_robot.h"

2. Initialize the miniHexa object. Then initialize the variable count and create the robot motion arrays vel, pos, and att, which represent velocity, position, and Euler angles.

    Robot minihexa;

    uint8_t count = 0;
    Velocity_t vel = {0.0f,0.0f,0.0f};
    Vector_t pos = {0.0f,0.0f,0.0f};
    Euler_t att = {0.0f,0.0f,0.0f};

3. In the setup() function, set the initial serial communication baud rate to 115200, then initialize the robot.

    void setup() {
      Serial.begin(115200);
      minihexa.begin();
    }

4. In the loop() main function, twelve different posture movements are executed cyclically according to the changing value of variable count.

    void loop() {
      switch(count) {
        case 0:
          count++;
          pos = {3.0f, 0.0f, 0.0f};
          att = {0.0f, 0.0f, 0.0f};
          delay(1000);
          break;
      
        case 1:
          count++;
          pos = {0.0f, 3.0f, 0.0f};
          delay(1000);
          break;

        case 2:
          count++;
          pos = {-3.0f, 0.0f, 0.0f};
          delay(1000);
          break;

        case 3:
          count++;
          pos = {0.0f, -3.0f, 0.0f};
          delay(1000);
          break;

        case 4:
          count++;
          pos = {0.0f, 0.0f, 3.0f};
          delay(1000);
          break;

        case 5:
          count++;
          pos = {0.0f, -2.0f, -1.0f};
          delay(1000);
          break;

        case 6:
          count++;
          att = {8.0f, 0.0f, 0.0f};
          pos = {0.0f, 0.0f, 0.0f};
          delay(1000);
          break;

        case 7:
          count++;
          att = {-8.0f, 0.0f, 0.0};
          delay(1000);
          break;

        case 8:
          count++;
          att = {0.0f, 12.0f, 0.0f};
          delay(1000);
          break;

        case 9:
          count++;
          att = {0.0f, -12.0f, 0.0f};
          delay(1000);
          break;

        case 10:
          count++;
          att = {0.0f, 0.0f, 12.0f};
          delay(1000);
          break;
      
        case 11:
          count = 0;
          att = {0.0f, 0.0f, -12.0f};
          delay(1000);
          break;
      }

      minihexa.move(&vel, &pos, &att, 600);
    }

5. The three parameters in the pos center-of-gravity position array control posture translation of miniHexa along the X-axis, Y-axis, and Z-axis. The first parameter controls left and right translation of the body center of gravity along the X-axis. The second parameter controls forward and backward translation along the Y-axis. The third parameter controls the height of the body center of gravity along the Z-axis. Modify the corresponding parameter values to change the body posture.

        case 0:
          count++;
          pos = {3.0f, 0.0f, 0.0f};  // Shift the center of gravity 3.0 to the right along the X-axis
          att = {0.0f, 0.0f, 0.0f};
          delay(1000);
          break;
      
        case 1:
          count++;
          pos = {0.0f, 3.0f, 0.0f};  // Shift the center of gravity forward by 3.0 along the Y-axis
          delay(1000);
          break;

        case 4:
          count++;
          pos = {0.0f, 0.0f, 3.0f};  // Shift the center of gravity upward by 3.0 along the Z-axis
          delay(1000);
          break;

6. The three parameters in the att posture array control posture tilt of miniHexa around the X-axis, Y-axis, and Z-axis. The first parameter is the Euler angle around the X-axis, which controls pitch. The second parameter is the Euler angle around the Y-axis, which controls roll. The third parameter is the Euler angle around the Z-axis, which controls yaw. Modify the corresponding parameter values on each axis to change the body posture.

        case 6:
          count++;
          att = {8.0f, 0.0f, 0.0f};  // Pitch 8 degrees around the X-axis
          pos = {0.0f, 0.0f, 0.0f};
          delay(1000);
          break;
    
        case 8:
          count++;
          att = {0.0f, 12.0f, 0.0f};  // Roll 12 degrees around the Y-axis
          delay(1000);
          break;
    
        case 10:
          count++;
          att = {0.0f, 0.0f, 12.0f};  // Yaw 12 degrees around the Z-axis
          delay(1000);
          break;

6.3 Secondary Development Project

6.3.1 Action Group Introduction and Practice

6.3.1.1 Feature Overview

This section introduces the action groups in miniHexa and explains how to control an action group with a program.

An action group is a predefined sequence of movement steps. It allows the robot to complete a specific task according to the preset sequence, such as moving or dancing.

miniHexa includes 14 built-in action groups. These action groups can be called directly. The corresponding action group names are shown in the table below:

Action Group No.	Action
1	Counterclockwise Twist
2	Clockwise Twist
3	Wake Up
4	Wake-Up Run
5	Acting Cute
6	Obstacle Crossing
7	Battle 1
8	Battle 2
9	Left Foot Forward Kick
10	Left Foot Right Kick
11	Right Foot Forward Kick
12	Right Foot Left Kick
13	Door Push
14	Wave

6.3.1.2 Project Process

6.3.1.3 Action Group Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open the Hiwonder Python Editor.

3. Right-click Local Project -> Switch Project Path on the left side of the editor.

4. Select 2. Software/10. Action Group Files, then click Select Folder.

5. Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

6. Select all imported action group files. Right-click and select Download to download the action groups to miniHexa. Wait until the information panel below shows that all action groups have been downloaded successfully.

7. After the download is complete, click Device to confirm that the action groups have been downloaded to miniHexa.

6.3.1.4 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open the Hiwonder Python Editor.

3. Open 02 Program Files/01 Action Group Program/main.py, then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

4. Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

5. After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.3.1.5 Project Outcome

After power-on, miniHexa runs action group 5, which is Acting Cute.

6.3.1.6 Program Analysis

1. Import the libraries. The Hiwonder library is used for robot control. The time library is used for delay control.

import Hiwonder  # Import the Hiwonder robot control library
import time      # Import the time module for delay control

2. Create the robot object.

# Create robot object
robot = Hiwonder.Robot()

3. Call action_run(). Parameter 5 calls action group No. 5.

# Execute action group 5. Acting Cute
robot.action_run(5)
time.sleep(4)

4. Reset the robot to the initial state.

# Reset the robot to the initial state
robot.reset()

6.3.2 Intelligent Voice Control

6.3.2.1 Feature Overview

This section uses the sound sensor to detect sound intensity and controls robot movement based on the detected value.

6.3.2.2 Project Process

6.3.2.3 Module Description

The onboard sound sensor detects ambient sound intensity. The sound level can be obtained by reading the value on the ADC pin. Sound causes the microphone diaphragm to vibrate. This changes the capacitance and generates a corresponding small voltage change, which is then converted into an electrical signal for output.

6.3.2.4 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open the Hiwonder Python Editor.

3. Open 02 Intelligent Voice Control Program/main.py, then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

4. Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

5. After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.3.2.5 Project Outcome

After power-on, miniHexa moves into its initial standing pose and then continuously monitors ambient sound. When the detected sound value is greater than 20, miniHexa moves forward.

6.3.2.6 Program Analysis

1. Import the libraries. The Hiwonder library handles robot control, Hiwonder_DEV provides access to external sensors, and time is used for delays and timing.

import Hiwonder
import Hiwonder_DEV
import time

2. Create the robot object and the sound sensor object.

robot = Hiwonder.Robot()
sound = Hiwonder.Sound()

3. In the main loop, first read the sound value val detected by the sound module. Then check whether the value is greater than 20. If it is, execute forward movement.

while True:
  val = sound.read()
  if(val >20):
    robot.go([0.0, 2.0, 0.0] , 1 , 1000)
    time.sleep(1)
  time.sleep_ms(10)

6.3.3 Ultrasonic Distance Measurement

6.3.3.1 Feature Overview

This section uses the glowy ultrasonic module to detect distance and controls the RGB LED color of the module based on the measured distance.

6.3.3.2 Project Process

6.3.3.3 Module Description

The glowy ultrasonic module integrates an IIC Port. It supports reading the measured distance data from the ultrasonic sensor through the IIC protocol. Two RGB LEDs are integrated at the ultrasonic probe position. The brightness can be adjusted, and multiple colors can be displayed by changing and combining the R, G, and B channels.

During ranging, the module automatically sends eight 40 kHz square waves and then checks whether a return signal is received. If a signal is received, the module outputs a high level. The duration of the high level is the travel time of the ultrasonic signal from transmission to return.

Note

The glowy ultrasonic module is already connected to the onboard IIC Port at the factory. No additional wiring is required.

6.3.3.4 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open the Hiwonder Python Editor.

3. Open 03 Ultrasonic Distance Measurement Program/main.py, then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

4. Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

5. After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.3.3.5 Project Outcome

When an object moves close to the glowy ultrasonic module, the RGB LED color changes according to the detected distance:

• 0 < distance <= 8 changes to red.

• 8 < distance <= 18 changes to a red gradient.

• 18 < distance <= 32 changes to a blue gradient.

• 32 < distance <= 50 changes to a green gradient.

• distance > 50 changes to green.

6.3.3.6 Program Analysis

1. Import the libraries. The Hiwonder library handles robot control, Hiwonder_DEV provides access to external sensors, and time is used for delays and timing.

import Hiwonder
import Hiwonder_DEV
import time

2. Create the robot object and the ultrasonic sensor object.

# Create robot and ultrasonic sensor objects
robot = Hiwonder.Robot()
sonar = Hiwonder_DEV.DEV_SONAR()

3. Initialize the RGB LEDs to white.

# Initialize the RGB LEDs to white
sonar.setRGB(0, 255, 255, 255)  # Parameter 1 is the LED index. 0 means both LEDs
                                # Parameters 2 to 4 are the RGB values. 255,255,255 means white

4. Map the input value x linearly from the input range [in_min, in_max] to the output range [out_min, out_max].

def map_value(x, in_min, in_max, out_min, out_max):
    """Map a value from one range to another range"""
    return int((x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min)

5. In the while True main loop, read the distance detected by the glowy ultrasonic module. Then change the RGB color according to the measured distance and print the distance value through the serial port.

6. When 0 < distance <= 8, the RGB LEDs are set to red.

    # Set the RGB color according to the distance
    if distance > 0 and distance <= 8:
        # Breathing light mode in red. The actual breathing effect requires further implementation
        r, g, b = 255, 0, 0

7. When 8 < distance <= 18, the RGB LEDs display a red gradient.

    elif distance > 8 and distance <= 18:
        # Red gradient. Map the distance from 8-18 to 0-255
        s = map_value(distance, 8, 18, 0, 255)
        r, g, b = 255 - s, 0, 0

8. When 18 < distance <= 32, the RGB LEDs display a blue gradient.

    elif distance > 18 and distance <= 32:
        # Blue gradient. Map the distance from 18-32 to 0-255
        s = map_value(distance, 18, 32, 0, 255)
        r, g, b = 0, 0, s

9. When 32 < distance <= 50, the RGB LEDs display a green gradient.

    elif distance > 32 and distance <= 50:
        # Green gradient. Map the distance from 32-50 to 0-255
        s = map_value(distance, 32, 50, 0, 255)
        r, g, b = 0, s, 255 - s

10. When distance > 50, the RGB LEDs are set to green.

    else:  # distance > 500
        # Green
        r, g, b = 0, 255, 0

6.3.4 Automatic Obstacle Avoidance

6.3.4.1 Feature Overview

This section uses the ultrasonic sensor to detect distance and then performs obstacle avoidance based on the detected value.

6.3.4.2 Project Process

6.3.4.3 Module Description

The glowy ultrasonic module integrates an IIC Port. It supports reading the measured distance data from the ultrasonic sensor through the IIC protocol. Two RGB LEDs are integrated at the ultrasonic probe position. The brightness can be adjusted, and multiple colors can be displayed by changing and combining the R, G, and B channels.

During ranging, the module automatically sends eight 40 kHz square waves and then checks whether a return signal is received. If a signal is received, the module outputs a high level. The duration of the high level is the travel time of the ultrasonic signal from transmission to return.

Note

The glowy ultrasonic module is already connected to the onboard IIC Port at the factory. No additional wiring is required.

6.3.4.4 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open the Hiwonder Python Editor.

3. Open 04 Automatic Obstacle Avoidance/main.py, then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

4. Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

5. After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.3.4.5 Project Outcome

After power-on, the glowy ultrasonic module lights white. miniHexa detects the distance to an object with the ultrasonic sensor. When the distance is greater than 20, miniHexa moves forward and the RGB LEDs turn green. When the distance is less than 10, miniHexa moves backward and the RGB LEDs turn red. Otherwise, miniHexa rotates in place and the RGB LEDs turn blue.

6.3.4.6 Program Analysis

1. Import the libraries. The Hiwonder library is the robot control library. Hiwonder_DEV provides the external sensor interface. The time library is used for time-related operations.

import Hiwonder
import Hiwonder_DEV
import time

2. Create the robot object and the ultrasonic sensor object.

# Create robot and ultrasonic sensor objects
robot = Hiwonder.Robot()
sonar = Hiwonder_DEV.DEV_SONAR()

3. Initialize the RGB LEDs to white.

# Initialize the RGB LEDs to white
sonar.setRGB(0, 255, 255, 255)

4. Read the ultrasonic sensor distance.

    distance = sonar.getDistance()

5. When the distance is greater than 20, set the two RGB LEDs to green. At the same time, miniHexa moves forward.

    if distance > 20:
      sonar.setRGB(0,0,250,0)
      robot.go([0,2,0])

setRGB(0,0,250,0) is the function that sets the RGB LED color. The first parameter 0 means setting both RGB LEDs. 1 means setting the left LED. 2 means setting the right LED. The second parameter 0 is the R brightness value. The third parameter 250 is the G brightness value. The fourth parameter 0 is the B brightness value.

go([0,2,0]) is the motion control function of miniHexa. [0,2,0] represents the speeds along the x, y, and z axes.

6. When the distance is greater than 10 and less than or equal to 20, set the two RGB LEDs to blue. At the same time, miniHexa rotates in place for 4 steps.

    elif 20 >= distance > 10:
      sonar.setRGB(0,0,0,250)
      robot.go([0,0,1.8], 4,1000)
      time.sleep(4)

7. When the distance is less than 10, set the two RGB LEDs to red. At the same time, miniHexa moves backward for 4 steps.

    else:
      sonar.setRGB(0,250,0,0)
      robot.go([0,-2,0],4,800)

6.3.5 Automatic Following

6.3.5.1 Feature Overview

This section uses the glowy ultrasonic sensor to detect distance and then controls robot movement according to the detected distance.

6.3.5.2 Project Process

6.3.5.3 Module Description

The glowy ultrasonic module integrates an IIC Port. It supports reading the measured distance data from the ultrasonic sensor through the IIC protocol. Two RGB LEDs are integrated at the ultrasonic probe position. The brightness can be adjusted, and multiple colors can be displayed by changing and combining the R, G, and B channels.

During ranging, the module automatically sends eight 40 kHz square waves and then checks whether a return signal is received. If a signal is received, the module outputs a high level. The duration of the high level is the travel time of the ultrasonic signal from transmission to return.

Note

The glowy ultrasonic module is already connected to the onboard IIC Port at the factory. No additional wiring is required.

6.3.5.4 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open the Hiwonder Python Editor.

3. Open 05 Automatic Following Program/main.py, then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

4. Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

5. After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.3.5.5 Project Outcome

After power-on, the RGB LEDs on the glowy ultrasonic module light white. miniHexa detects the distance to an object with the ultrasonic sensor. When the distance is greater than 20, miniHexa moves forward and the RGB LEDs turn green. When the distance is less than 10, miniHexa moves backward and the RGB LEDs turn red. Otherwise, miniHexa stops and the RGB LEDs turn blue.

6.3.5.6 Program Analysis

1. Import the libraries. The Hiwonder library is the robot control library. Hiwonder_DEV provides the external sensor interface. The time library is used for time-related operations.

import Hiwonder
import Hiwonder_DEV
import time

2. Create the robot object and the ultrasonic sensor object.

robot = Hiwonder.Robot()
sonar = Hiwonder_DEV.DEV_SONAR()

3. Initialize the RGB LEDs to white.

# Initialize the RGB LEDs to white
sonar.setRGB(0, 255, 255, 255)

4. Read the ultrasonic sensor distance.

    distance = sonar.getDistance()

5. When the distance is greater than 20, miniHexa moves forward and the RGB LEDs turn green.

    if distance > 20:
      sonar.setRGB(0,0,250,0)
      robot.go([0,2,0])

setRGB(0,0,250,0) is the function that sets the RGB LED color. The first parameter 0 means setting both RGB LEDs. 1 means setting the left LED. 2 means setting the right LED. The second parameter 0 is the R brightness value. The third parameter 250 is the G brightness value. The fourth parameter 0 is the B brightness value.

go([0,2,0]) is the motion control function of miniHexa. [0,2,0] represents the speeds along the x, y, and z axes.

6. When the distance is less than 10, miniHexa moves backward and the RGB LEDs turn red.

    elif distance < 10:
      sonar.setRGB(0,250,0,0)
      robot.go([0,-2,0])

7. When neither of the above conditions is met, miniHexa stops and the RGB LEDs turn blue.

    else:
      sonar.setRGB(0,0,0,250)
      robot.go([0,0,0])

6.3.6 Self-Balancing

6.3.6.1 Feature Overview

This section uses the IMU sensor to detect the body tilt angle and then controls body balance based on the detected result.

6.3.6.2 Project Process

6.3.6.3 Module Description

This section uses the onboard QMI8658 motion sensor. This sensor is widely used in handheld game devices, 3D remote controllers, portable navigation devices, and similar products.

It integrates a 3-axis MEMS gyroscope, a 3-axis MEMS accelerometer, and an expandable digital motion processor DMP.

6.3.6.4 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open the Hiwonder Python Editor.

3. Open 06 Self-Balancing Program/main.py, then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

4. Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

5. After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.3.6.5 Project Outcome

miniHexa reads the real-time tilt value from the IMU sensor, performs compensation calculations, and maintains self-balance through inverse kinematics.

6.3.6.6 Program Analysis

1. Import the libraries. The Hiwonder library is the robot control library. The time library is used for time-related operations.

import Hiwonder
import time

2. Create the robot object and the IMU sensor object.

robot = Hiwonder.Robot()
imu = Hiwonder.IMU()

3. Enable the self-balancing function.

# Enable the self-balancing function
robot.homeostasis(True)

homeostasis() is the function that enables or disables self-balancing. True means enable. False means disable.

6.3.7 Dot Matrix Display

6.3.7.1 Feature Overview

This section uses the dot matrix module to display characters.

6.3.7.2 Project Process

6.3.7.3 Module Description

The LED dot matrix module is an LED matrix display module. It features high brightness, flicker-free display, and convenient wiring. It can display numbers, text, and patterns. The module is composed of two red 8x8 LED arrays. Control of the matrix display is achieved through the TM640B driver chip.

Module wiring: before running this program, connect the module to the IO interface on the miniHexa base board at IO32 and IO14, as shown below.

Installation method: install the dot matrix module on the miniHexa back plate.

6.3.7.4 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open the Hiwonder Python Editor.

3. Open 07 Dot Matrix Display Program/main.py, then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

4. Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

5. After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.3.7.5 Project Outcome

After power-on, the dot matrix module alternately displays abc and ABC.

6.3.7.6 Program Analysis

1. Import the libraries. The Hiwonder library handles robot control, Hiwonder_DEV provides access to external sensors, and time is used for delays and timing.

import Hiwonder
import Hiwonder_DEV
import time

2. Create the robot object and initialize the pins of the dot matrix module.

robot = Hiwonder.Robot()

led = Hiwonder_DEV.DEV_Digitaltube(32,14)

3. Call drawStr() to display abc and ABC on the dot matrix module.

while True:
  led.drawStr(0,1,"abc")
  time.sleep(2)
  led.drawStr(0,1,"ABC")
  time.sleep(2)

drawStr(0,1,"abc") is the function that displays a string.

0 is the number of offset rows.

1 is the number of offset columns.

"abc" is the string to display.

6.3.8 Ultrasonic Distance Measurement Display

6.3.8.1 Feature Overview

This section uses the dot matrix module to display in real time the distance detected by the ultrasonic distance measurement module and controls the RGB LED color of the glowy ultrasonic module.

6.3.8.2 Project Process

6.3.8.3 Module Description

1. Ultrasonic module

The module uses an IIC Port and can read the distance measured by the ultrasonic sensor through IIC communication. Two RGB LEDs are integrated at the ultrasonic probe position. The brightness can be adjusted, and multiple colors can be displayed by changing and combining the R, G, and B channels.

During ranging, the module automatically sends eight 40 kHz square waves and then checks whether a return signal is received. If a signal is received, the module outputs a high level. The duration of the high level is the travel time of the ultrasonic signal from transmission to return.

Note

The glowy ultrasonic module is already connected to the onboard IIC Port at the factory. No additional wiring is required.

2. Dot matrix module

The LED dot matrix module is an LED matrix display module. It features high brightness, flicker-free display, and convenient wiring. It can display numbers, text, and patterns. The module is composed of two red 8x8 LED arrays. Control of the matrix display is achieved through the TM640B driver chip.

Module wiring: before running this program, connect the module to the IO interface on the miniHexa base board at IO32 and IO33, as shown below.

Installation method: install the dot matrix module on the miniHexa back plate.

6.3.8.4 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open the Hiwonder Python Editor.

3. Open 08 Ultrasonic Distance Measurement and Displaying Program/main.py, then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

4. Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

5. After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.3.8.5 Project Outcome

When an object moves close to the glowy ultrasonic module, the dot matrix module displays the detected distance in real time, and the RGB LEDs on the glowy ultrasonic module change according to the detected distance.

6.3.8.6 Program Analysis

1. Import the libraries. The Hiwonder library is the robot control library. Hiwonder_DEV provides the external sensor interface. The time library is used for time-related operations.

import Hiwonder
import Hiwonder_DEV
import time

2. Create the robot object, initialize the pins of the dot matrix module, and create the ultrasonic sensor object.

robot = Hiwonder.Robot()

sonar = Hiwonder_DEV.DEV_SONAR()
led = Hiwonder_DEV.DEV_Digitaltube(32,33)

3. Read the ultrasonic sensor distance.

  distance = sonar.getDistance()

4. If distance is less than 500, keep the original value. Otherwise, set distance to 500. Then display the value on the dot matrix module.

  distance = distance if distance < 500 else 500
  led.showNum(distance)

6.3.9 Touch Control

6.3.9.1 Feature Overview

This section uses the touch sensor to control miniHexa movement.

6.3.9.2 Project Process

6.3.9.3 Module Description

The touch sensor is a capacitive touch sensor. It mainly detects the human body or metal through the gold-plated contact surface.

When there is no contact from a human body or metal, the signal terminal outputs a high level. When a human body or metal touches the metal surface, the signal terminal outputs a low level.

Module wiring: before running this program, connect the module to the IO interface on the miniHexa base board at IO14 and IO32, as shown below.

Installation method: install the touch module on the miniHexa back plate.

6.3.9.4 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open the Hiwonder Python Editor.

3. Open 09 Touch Control Program/main.py, then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

4. Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

5. After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.3.9.5 Project Outcome

Touch the metal surface on the touch sensor. miniHexa then moves forward at speed 1.

6.3.9.6 Program Analysis

1. Import the libraries. The Hiwonder library is the robot control library. Hiwonder_DEV provides the external sensor interface. The time library is used for time-related operations.

import Hiwonder
import Hiwonder_DEV
import time

2. Create the robot object and initialize the touch sensor pin.

robot = Hiwonder.Robot()
touch = Hiwonder_DEV.DEV_TOUCH(32)

3. When a touch is detected, miniHexa moves forward at speed 1.

while True:
  if touch.read() == True:
    robot.go([0,1,0],2,1000)
    time.sleep(2)

6.3.10 Infrared Obstacle Avoidance

6.3.10.1 Feature Overview

This section uses infrared obstacle avoidance sensors to detect obstacles and control robot movement.

6.3.10.2 Project Process

6.3.10.3 Module Description

The infrared obstacle avoidance sensor is used to detect whether there is an obstacle ahead. The sensor includes one infrared transmitter and one infrared receiver. Once the sensor encounters an obstacle, the infrared light is reflected back and received by the receiver.

Module wiring: before running this program, connect the module to the IO interfaces on the miniHexa base board at IO32, IO14, IO18, and IO19, as shown below.

Installation method: install the infrared obstacle avoidance sensors on the miniHexa back plate.

6.3.10.4 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open the Hiwonder Python Editor.

3. Open 10 Infrared Obstacle Avoidance Program/main.py, then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

4. Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

5. After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.3.10.5 Project Outcome

After power-on, miniHexa uses two infrared obstacle avoidance sensors to detect obstacles around the body. If no obstacle is detected, miniHexa moves forward. If one side detects an obstacle, miniHexa turns away from the obstacle. If both sides detect obstacles, miniHexa first moves backward and then rotates in place.

6.3.10.6 Program Analysis

1. Import the libraries. The Hiwonder library is the robot control library. Hiwonder_DEV provides the external sensor interface. The time library is used for time-related operations.

import Hiwonder
import Hiwonder_DEV
import time

2. Create the robot object and initialize the pins of the two infrared obstacle avoidance sensors.

robot = Hiwonder.Robot()
ir1 = Hiwonder_DEV.DEV_IR(32)
ir2 = Hiwonder_DEV.DEV_IR(18)

3. Read the states of the two sensors.

    ir1_state = ir1.read()
    ir2_state = ir2.read()

4. When both sensors detect obstacles, miniHexa first moves backward for 2 seconds and then rotates clockwise for 2 seconds.

    if ir1_state and ir2_state:  # Both sensors detect obstacles
        # Move backward for 2 seconds
        robot.go([0, -2, 0], 2, 800)
        time.sleep(2)
        
        # Rotate clockwise
        robot.go([0, 0, 2], 2, 800)
        time.sleep(2)

5. When only sensor 1 detects an obstacle, miniHexa rotates clockwise for 2 seconds.

    elif ir1_state and not ir2_state:  # Only sensor 1 detects an obstacle
        # Rotate clockwise
        robot.go([0, 0, 2], 2, 800)
        time.sleep(2)

6. When only sensor 2 detects an obstacle, miniHexa rotates counterclockwise for 2 seconds.

    elif not ir1_state and ir2_state:  # Only sensor 2 detects an obstacle
        # Rotate counterclockwise
        robot.go([0, 0, -2], 2, 800)
        time.sleep(2)

7. When neither sensor detects an obstacle, miniHexa keeps moving forward.

    else:  # Neither sensor detects an obstacle
        # Move forward continuously
        robot.go([0, 2, 0], -1, 800)

6.3.11 Intelligent Fall Prevention

6.3.11.1 Feature Overview

This section uses infrared obstacle avoidance sensors to detect an edge condition and controls robot movement to prevent a fall.

6.3.11.2 Project Process

6.3.11.3 Module Description

The infrared obstacle avoidance sensor is used to detect whether there is an obstacle ahead. The sensor includes one infrared transmitter and one infrared receiver. Once the sensor encounters an obstacle, the infrared light is reflected back and received by the receiver.

Module wiring: before running this program, connect the module to the IO interfaces on the miniHexa base board at IO32, IO14, IO18, and IO19, as shown below.

Installation method: install the infrared obstacle avoidance sensors on the front two legs of miniHexa.

6.3.11.4 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open the Hiwonder Python Editor.

3. Open 11 Intelligent Fall Prevention Program/main.py, then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

4. Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

5. After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.3.11.5 Project Outcome

miniHexa uses the infrared obstacle avoidance sensors to detect edges near its legs to prevent falls. When either sensor is triggered, miniHexa moves backward and then rotates to change direction. Otherwise, miniHexa moves forward continuously.

6.3.11.6 Program Analysis

1. Import the libraries. The Hiwonder library is the robot control library. Hiwonder_DEV provides the external sensor interface. The time library is used for time-related operations.

import Hiwonder
import Hiwonder_DEV
import time

2. Create the robot object and initialize the pins of the two infrared obstacle avoidance sensors.

robot = Hiwonder.Robot()
ir1 = Hiwonder_DEV.DEV_IR(32)
ir2 = Hiwonder_DEV.DEV_IR(18)

3. Read the states of the two sensors.

    ir1_state = ir1.read()
    ir2_state = ir2.read()

4. If either sensor is triggered, miniHexa moves backward and then rotates to change its movement direction.

    # If either sensor is triggered
    if ir1_state or ir2_state:
        # Move backward quickly
        robot.go([0, -3, 0], 3, 1000)
        time.sleep(3)
        
        # Rotate
        robot.go([0, 0, 2], 4, 1000)
        time.sleep(4)

5. If neither sensor is triggered, miniHexa moves forward.

    else:
        # Move forward continuously
        robot.go([0, 3, 0])

6.4 AI Vision Project

6.4.1 ESP32-S3 AI Vision Module Overview and Installation

6.4.1.1 Product Introduction

The ESP32-S3 AI vision module is a compact camera module that can operate as a standalone system.

The built-in camera captures images. The ESP32 microcontroller processes the image data and transmits it through the Wi-Fi module. The module also supports multiple communication protocols and low-power operation, so it is widely used in IoT applications.

6.4.1.2 Interface Description

Interface Name	Description
USB serial port	Serial communication and firmware flashing
Custom button	The button event can be customized in code
I2C Port	Interface for connecting to the controller for secondary development

6.4.1.3 Notes

1. If water ripples appear in the images captured by the vision module, this may be caused by the rated input current of the module being ≤ 2A. Check the current output of the power supply.

2. The default image transmission program is preloaded at the factory. Flash the corresponding program when a vision recognition function is required.

6.4.1.4 Module Wiring

Use a 4-pin cable to connect the module to any I2C Port highlighted in red on the servo controller.

6.4.2 Getting Started

6.4.2.1 Notes

1. If the captured image shows water ripple patterns, the input power supply may provide a rated current of 2A or less. Check the current output of the power supply.

2. The image transmission firmware is preloaded at the factory. It can be tested directly without reflashing. Flash another firmware when another function is required.

6.4.2.2 Device Connection

1. Connect the AI vision module to the PC with a Type-C cable. Check in Device Manager that the port is recognized correctly.

Note

If the device does not appear under Ports, the driver may not be installed on the PC. The installation package is available at 2. Software/7.CH34x Driver Tool/ch341ser.exe. Install the driver manually if needed.

2. Connect to the hotspot generated by the module: HW_ESP32S3CAM.

6.4.2.3 Image Transmission

Enter 192.168.5.1 in the browser address bar and press Enter. A phone browser or a PC browser can be used. A PC browser is used in the example below. In the page that opens, click to enter the camera image transmission interface.

6.4.3 Controller-Device Communication Principle and Coordinate System Description

6.4.3.1 Introduction

This section introduces how the ESP32S3 module, abbreviated below as ESP32S3, communicates with controllers such as Arduino and ESP32 boards. It explains how the ESP32S3 operates as a device and how the controller accesses ESP32S3 data and control functions.

In this chapter, the ESP32S3 always operates as a device. Information is transmitted through the I2C protocol.

6.4.3.2 Controller-Device Relationship

In a controller-device system, the ESP32S3 operates as the device. Other microcontrollers and similar devices operate as the controller.

Functions of the ESP32S3 as the device

1. Receive and parse the signals sent by the controller:

Wait for an I2C signal interrupt. If I2C data is received, call the corresponding function according to the register address contained in the received I2C data.

2. Process data and send feedback:

When the ESP32S3 receives a register read command, call the corresponding transmission function and send the recognized data to the controller.

When the ESP32S3 receives a register setting command, set the fill light brightness.

Functions of other devices as the controller

1. Send commands:

Send a data read request to the ESP32S3.

2. Coordinate control:

Manage the coordinated operation of the entire system. Ensure that communication and operation among the controller, the ESP32S3, and other devices connected to the controller remain conflict-free and stable.

3. Receive data:

When the controller reads data, receive the status information sent by the ESP32S3 after the read command is sent. Then parse the data packet and extract the useful information.

6.4.3.3 Device Address and Registers

When the ESP32S3 runs the face detection function:

Address	Function
0x52 device address	Communication address of the ESP32S3
0x01 register address	Read face data [int16_t x, y, w, h]. All data values are 0 when no face is detected

Note

In the face data, x, y, w, and h represent the face detection box marked in the original image. These values are the center point x coordinate, center point y coordinate, detection box width, and detection box height. The unit is pixels. See 6.4.3.4 Module Coordinate System Description for details about the pixel coordinate system used in this mode.

When the ESP32S3 runs the color recognition function:

Address	Function
0x52 device address	Communication address of the ESP32S3
0x00 register address	Read color 0 data. The returned data format is [int16_t x, y, w, h]. All data values are 0 when no target is detected
0x01 register address	Read color 1 data. The returned data format is [int16_t x, y, w, h]. All data values are 0 when no target is detected

Note

• In the color data, x, y, w, and h represent the color block detection box marked in the original image. These values are the center point x coordinate, center point y coordinate, detection box width, and detection box height. The unit is pixels. See 6.4.3.4 Module Coordinate System Description for details about the pixel coordinate system used in this mode.

• If multiple color blocks in the camera view match the preset color threshold, the module selects the two largest color blocks in the image and stores their detection box data in the 0x00 and 0x01 register spaces in sequence.

6.4.3.4 Module Coordinate System Description

This section briefly introduces the image coordinate systems used when the module runs different functions. Review this section before studying the example programs.

When the example programs are ported for secondary development, establish the mapping between the module image coordinate system and the real-world coordinate system according to this document.

Pay attention to the following two characteristics of the module image coordinate system:

1. The origin is at the upper-left corner of the screen, not at the center of the screen.

2. The Y-axis direction is opposite to the Y-axis direction in a standard Cartesian coordinate system.

Image Transmission Mode

Note

The image transmission mode uses a resolution of 320 x 240 to match the image data interface used by the mobile app.

Face Detection Mode

Note

To ensure smooth image performance, the face detection mode uses a tested resolution of 240 x 240.

Color Recognition Mode

Note

To ensure smooth image performance, the color recognition mode uses a tested resolution of 160 x 140.

6.4.3.5 Notes

The controller and the ESP32S3 can use different power supplies. The grounds must be connected together during wiring. Stable communication voltage levels depend on a common ground.

6.4.4 Color Recognition

6.4.4.1 Feature Overview

This section uses the ESP32-S3 AI vision module to detect red, green, and blue color blocks. The RGB LEDs on the glowy ultrasonic module then light up in the corresponding color.

6.4.4.2 Project Process

6.4.4.3 Module Description

1. ESP32-S3 AI vision module

This development board integrates an ESP32-S3 chip and a camera module. After it is installed on the carrier board, it communicates through an I2C Port and can read color and face-detection data through I2C communication.

Module wiring: as shown below, connect the module to any I2C Port highlighted in red on the servo controller before running this program.

2. Glowy ultrasonic module

The module uses an I2C Port and can read the distance measured by the ultrasonic sensor through I2C communication. Two RGB LEDs are integrated at the ultrasonic probe position. The brightness can be adjusted. Color changes and color mixing across the red channel R, green channel G, and blue channel B make full-color lighting effects possible.

Note

The glowy ultrasonic module is already connected to the onboard I2C Port at the factory. No additional wiring is required.

6.4.4.4 Program Download

1. Program download for the ESP32-S3 AI vision module

(1) Connect the ESP32-S3 AI vision module to a USB port on the PC with a Type-C cable.

(2) Open 03 Program Files/01 Color Recognition/ColorDetection/ColorDetection.ino.

(3) Select ESP32S3 Dev Module as the development board.

(4) Click Tools in the menu bar. Configure the ESP32S3 development board options as shown below.

Note

Modify the development board configuration before downloading the program to the AI vision module.

(5) Finally, click to download the code to the ESP32-S3 AI vision module. Wait until flashing is complete.

2. Program download for Python

(1) Connect miniHexa to the PC with a Type-C data cable.

(2) Open the Hiwonder Python Editor.

(3) Open 03 Program Files/01 Color Recognition/main.py. Then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

(4) Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

(5) After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.4.4.5 Project Outcome

When the AI vision module detects a red, green, or blue color block, the RGB LEDs on the glowy ultrasonic module light in the same color.

6.4.4.6 Program Analysis

1. Import the libraries. Hiwonder is the robot control library. Hiwonder_DEV provides the interface for external sensors. time is used for time-related operations.

import Hiwonder
import Hiwonder_DEV
import time

2. Create the robot object, the ultrasonic sensor object, and the ESP32-S3 AI vision module object.

robot = Hiwonder.Robot()
sonar = Hiwonder_DEV.DEV_SONAR()
cam = Hiwonder_DEV.DEV_ESP32S3Cam()

3. If red is detected, set the RGB LEDs on the ultrasonic module to red.

  rec = cam.read_color(1)
  if rec:
    print("red")
    sonar.setRGB(0,250,0,0)

4. If green is detected, set the RGB LEDs on the ultrasonic module to green.

  else:
    rec = cam.read_color(2)
    if rec:
      print("green")
      sonar.setRGB(0,0,250,0)

5. If blue is detected, set the RGB LEDs on the ultrasonic module to blue.

    else:
      rec = cam.read_color(3)
      if rec:
        print("blue")
        sonar.setRGB(0,250,0,0)

6.4.5 Color Tracking

6.4.5.1 Feature Overview

This section uses the ESP32-S3 AI vision module to detect a red block. The robot then rotates in place to follow the movement of the block.

6.4.5.2 Project Process

6.4.5.3 Module Description

1. ESP32-S3 AI vision module

This development board integrates an ESP32-S3 chip and a camera module. After it is installed on the carrier board, it communicates through an I2C Port and can read color and face-detection data through I2C communication.

Module wiring: as shown below, connect the module to any I2C Port highlighted in red on the servo controller before running this program.

2. Glowy ultrasonic module

The module uses an I2C Port and can read the distance measured by the ultrasonic sensor through I2C communication. Two RGB LEDs are integrated at the ultrasonic probe position. The brightness can be adjusted. Color changes and color mixing across the red channel R, green channel G, and blue channel B make full-color lighting effects possible.

Note

The glowy ultrasonic module is already connected to the onboard I2C Port at the factory. No additional wiring is required.

6.4.5.4 Program Download

1. Program download for the ESP32-S3 AI vision module

(1) Connect the ESP32-S3 AI vision module to a USB port on the PC with a Type-C cable.

(2) Open 03 Program Files/02 Color Tracking/ColorTracking/ColorTracking.ino.

(3) Select ESP32S3 Dev Module as the development board.

(4) Click Tools in the menu bar. Configure the ESP32S3 development board options as shown below.

Note

Modify the development board configuration before downloading the program to the AI vision module.

(5) Finally, click to download the code to the ESP32-S3 AI vision module. Wait until flashing is complete.

2. Program download for Python

(1) Connect miniHexa to the PC with a Type-C data cable.

(2) Open the Hiwonder Python Editor.

(3) Open 03 Program Files/02 Color Tracking/main.py. Then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

(4) Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

(5) After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.4.5.5 Project Outcome

When the AI vision module detects a red block, the robot stays in place and adjusts its posture so that the AI vision module continues to face the red block.

Note

A rotation limit is set in the program. The robot tracks the color block only within 20° clockwise or counterclockwise from its current heading.

6.4.5.6 Program Analysis

1. Import the libraries. Hiwonder is the robot control library. Hiwonder_DEV provides the interface for external sensors. time is used for time-related operations.

import Hiwonder
import Hiwonder_DEV
import time

2. Create the robot object, the ultrasonic sensor object, and the ESP32-S3 AI vision module object.

robot = Hiwonder.Robot()
sonar = Hiwonder_DEV.DEV_SONAR()
cam = Hiwonder_DEV.DEV_ESP32S3Cam()

3. fmap is a linear mapping function. It maps a value linearly from one range to another.

def fmap(x, in_min, in_max, out_min, out_max):
    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min

4. In the main loop, continuously read the color recognition result rec from the camera. If a target is detected and rec is valid, get the center point x coordinate from rec[0]. Then map the center point x coordinate from [0, 160] to [-1, 1] and add the mapped value to yaw. Limit yaw to the range [-20, 20]. Finally, set the robot body angle and change only the yaw angle. Then wait 0.05 seconds.

while True:
  rec = cam.read_color(1)
  if rec:
    center = int(rec[0])
    yaw += fmap(center , 0 , 160 , -1 , 1)
    yaw = 20 if yaw > 20 else (-20 if yaw < -20 else yaw)
    robot.set_body_angle([0,0,yaw],100)
  time.sleep(0.05)

6.4.6 Visual Line Following

6.4.6.1 Feature Overview

This section uses the ESP32-S3 AI vision module to detect a red line and control the robot to follow the line.

6.4.6.2 Project Process

6.4.6.3 Module Description

1. ESP32-S3 AI vision module

This development board integrates an ESP32-S3 chip and a camera module. After it is installed on the carrier board, it communicates through an I2C Port and can read color and face-detection data through I2C communication.

Module wiring: as shown below, connect the module to any I2C Port highlighted in red on the servo controller before running this program.

2. Glowy ultrasonic module

The module uses an I2C Port and can read the distance measured by the ultrasonic sensor through I2C communication. Two RGB LEDs are integrated at the ultrasonic probe position. The brightness can be adjusted. Color changes and color mixing across the red channel R, green channel G, and blue channel B make full-color lighting effects possible.

Note

The glowy ultrasonic module is already connected to the onboard I2C Port at the factory. No additional wiring is required.

6.4.6.4 Program Download

1. Program download for the ESP32-S3 AI vision module

(1) Connect the ESP32-S3 AI vision module to a USB port on the PC with a Type-C cable.

(2) Open 03 Program Files/03 Vision Line Following/LineFollowing/LineFollowing.ino.

(3) Select ESP32S3 Dev Module as the development board.

(4) Click Tools in the menu bar. Configure the ESP32S3 development board options as shown below.

Note

Modify the development board configuration before downloading the program to the AI vision module.

(5) Finally, click to download the code to the ESP32-S3 AI vision module. Wait until flashing is complete.

2. Program download for Python

(1) Connect miniHexa to the PC with a Type-C data cable.

(2) Open the Hiwonder Python Editor.

(3) Open 03 Program Files/03 Vision Line Following/main.py. Then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

(4) Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

(5) After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.4.6.5 Project Outcome

When the AI vision module detects a red line, the robot moves along the line.

6.4.6.6 Program Analysis

1. Import the libraries. Hiwonder is the robot control library. Hiwonder_DEV provides the interface for external sensors. time is used for time-related operations.

import Hiwonder
import Hiwonder_DEV
import time

2. Create the robot object and the ESP32-S3 AI vision module object.

robot = Hiwonder.Robot()
cam = Hiwonder_DEV.DEV_ESP32S3Cam()

3. If the x coordinate of the center point of the color region is greater than 120, move the robot toward the front right.

  if rec:
    if rec[0] > 120:
      robot.go([0,1,-0.1])

4. If the x coordinate of the center point of the color region is less than 40, move the robot toward the front left.

    elif rec[0] < 40:
      robot.go([0,1,0.1])

5. Otherwise, move the robot straight forward.

    else:
      robot.go([0,1,0])

6.4.7 Face Detection

6.4.7.1 Feature Overview

This section uses the ESP32-S3 AI vision module to detect faces. Once a face is detected, miniHexa performs a cute action.

6.4.7.2 Project Process

6.4.7.3 Module Description

1. ESP32-S3 AI vision module

This development board integrates an ESP32-S3 chip and a camera module. After it is installed on the carrier board, it communicates through an I2C Port and can read color and face-detection data through I2C communication.

Module wiring: as shown below, connect the module to any I2C Port highlighted in red on the servo controller before running this program.

2. Glowy ultrasonic module

The module uses an I2C Port and can read the distance measured by the ultrasonic sensor through I2C communication. Two RGB LEDs are integrated at the ultrasonic probe position. The brightness can be adjusted. Color changes and color mixing across the red channel R, green channel G, and blue channel B make full-color lighting effects possible.

Note

The glowy ultrasonic module is already connected to the onboard I2C Port at the factory. No additional wiring is required.

6.4.7.4 Program Download

1. Program download for the ESP32-S3 AI vision module

(1) Connect the ESP32-S3 AI vision module to a USB port on the PC with a Type-C cable.

(2) Open 03 Program Files/04 Face Recognition/FaceDetection/FaceDetection.ino.

(3) Select ESP32S3 Dev Module as the development board.

(4) Click Tools in the menu bar. Configure the ESP32S3 development board options as shown below.

Note

Modify the development board configuration before downloading the program to the AI vision module.

(5) Finally, click to download the code to the ESP32-S3 AI vision module. Wait until flashing is complete.

2. Program download for Python

(1) Connect miniHexa to the PC with a Type-C data cable.

(2) Open the Hiwonder Python Editor.

(3) Open 03 Program Files/04 Face Recognition/main.py. Then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

(4) Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

(5) After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.4.7.5 Project Outcome

When a face is detected, the robot pitches forward and backward twice within ±10° and then returns to a level posture.

6.4.7.6 Program Analysis

1. Import the libraries. Hiwonder is the robot control library. Hiwonder_DEV provides the interface for external sensors. time is used for time-related operations.

import Hiwonder
import Hiwonder_DEV
import time

2. Create the robot object and the ESP32-S3 AI vision module object.

robot = Hiwonder.Robot()
cam = Hiwonder_DEV.DEV_ESP32S3Cam()

3. Use read_face() to get the face data. If a face is detected, the function returns the face position array [x, y, w, h]. If no face is detected, the function returns None. Store the returned data in rec.

while True:
  rec = cam.read_face()

4. If face data is returned, control miniHexa to pitch forward and backward within ±10° and then return to a level posture.

  if rec:
    if rec[2] > 0:
      # Pitch +10 degrees
      robot.set_body_angle([0, 10, 0], 300)
      time.sleep_ms(300)
      # Pitch -10 degrees
      robot.set_body_angle([0, -10, 0], 300)
      time.sleep_ms(300)
      # Pitch +10 degrees
      robot.set_body_angle([0, 10, 0], 300)
      time.sleep_ms(300)
      # Pitch -10 degrees
      robot.set_body_angle([0, -10, 0], 300)
      time.sleep_ms(300)
      # Return to the level posture
      robot.set_body_angle([0, 0, 0], 300)
      time.sleep_ms(300)

set_body_angle() is the function that sets the body angle of miniHexa. Use set_body_angle([0, 10, 0], 300) as the example.

The first parameter [0, 10, 0] represents the body angles [roll, pitch, yaw]. The range is ±20°.

The second parameter 300 is the running time.

5. Call set_body_pose() to move miniHexa 2 cm to the right first and then 2 cm to the left. After this sequence is executed twice, return to the center position.

      # Move 2 cm to the right
      robot.set_body_pose([2.0, 0, 0], 200)
      time.sleep_ms(200)
      # Move 2 cm to the left
      robot.set_body_pose([-2.0, 0, 0], 200)
      time.sleep_ms(200)
      # Move 2 cm to the right
      robot.set_body_pose([2.0, 0, 0], 200)
      time.sleep_ms(200)
      # Move 2 cm to the left
      robot.set_body_pose([-2.0, 0, 0], 200)
      time.sleep_ms(200)
      # Return to the center position
      robot.set_body_pose([0, 0, 0], 200)
      time.sleep_ms(200)

set_body_pose() is the function that sets the x, y, and z offsets of the miniHexa body from the origin. Use set_body_pose([2.0, 0, 0], 200) as the example.

The first parameter [2.0, 0, 0] is the x, y, and z offset of the body center from the origin. The range is [-4.0f, 4.0f]. The unit is centimeters.

The second parameter 200 is the time used for each step.

6.5 AI Voice Project

6.5.1 Introduction and Installation of WonderEcho

6.5.1.1 Module Introduction

The integrated voice interaction module WonderEcho is built on the CI1302 chip for voice recognition and voice playback. It supports offline neural network acceleration and hardware acceleration for voice signal processing. The module uses deep noise reduction and neural network models to analyze voice input and generate recognition results.

The CI1302 chip integrates a Brain Neural Processing Unit, supports offline neural network acceleration and hardware acceleration for voice signal processing, and runs at up to 220MHz. It supports offline far-field voice recognition, includes 2MB of onboard FLASH storage, and can store up to 300 command words.

The module is easy to use and delivers strong voice recognition performance. It is widely used in smart home devices, conversational robots, educational robots, and in-vehicle dispatch terminals.

Working Principle

The module uses a wake-word activation mode. Speak the wake word first to activate the voice interaction module. Commands can be recognized only after activation.

English is the default recognition language. The default English wake word is Hello Hiwonder.

If no voice is recognized within 15 seconds, the module enters sleep mode. Wake the module again before the next use.

After the CI1302 chip recognizes a command word, it sends the corresponding instruction to the I2C chip and plays back the matching phrase. The I2C chip stores the received voice command and send it through the I2C device protocol. The supported command words are listed in 03 WonderEcho Firmware Flash Tutorial/Command Word and Playback Phrase Protocol List.

Notes

1. Use a 5V power supply. Incorrect voltage may damage the module.

2. Use the module in a quiet environment. Excessive background noise affects recognition performance.

3. Speak the command words clearly and loudly. Avoid speaking too quickly. A distance of less than 5 meters from the module is recommended.

6.5.1.2 Hardware Interface Description

No.	Hardware Name	Description
1	Speaker	Converts analog signals into sound
2	Microphone	Converts sound into analog signals
3	RST button	Reset button
4	Signal indicator blue LED	Stays on during operation. Flashes once when a command word is recognized
5	Power indicator red LED	Stays on when the power supply is normal
6	I2C Port	Works as an I2C device and is used for power supply and communication with the controller
7	Type-C Port	Used for power supply and CI1302 firmware updates
8	CI1302 chip	High-performance voice recognition chip that recognizes voice commands and outputs signals
9	I2C chip	Converts instructions from the voice recognition chip into I2C protocol commands
10	Audio amplifier chip	Converts digital signals into analog signals to drive the speaker

6.5.2 Introduction to the Voice Module Library Files

WonderEcho Code Blocks

1. Module initialization

Use the following code to initialize the module interface.

asr = Hiwonder_DEV.DEV_ASR()

2. Retrieve the command word ID

This code block retrieves the ID of the command word recognized by the module. The return value is an integer.

    result = asr.getResult()

3. Play back a specified entry by ID

This function requires two parameters. cmd is the type ID of the entry to be played back. 0xFF is the playback type and 0x00 is the command type. id is the ID of the entry to be played back. The module receives the data through the I2C protocol and actively plays back the specified entry.

asr.speak()

6.5.3 Voice Obstacle Alert

6.5.3.1 Feature Overview

This section uses the ultrasonic module to detect obstacles in front of the robot. When an obstacle is too close, the ultrasonic module and the voice interaction module provide a sound and light alert.

6.5.3.2 Project Process

6.5.3.3 Module Description

1. WonderEcho voice interaction module

The integrated voice interaction module WonderEcho is built on the CI1302 chip for voice recognition and voice playback. It supports offline neural network acceleration and hardware acceleration for voice signal processing. The module uses deep noise reduction and neural network models to analyze voice input and generate recognition results.

Module wiring: as shown below, connect the module to any I2C Port highlighted in red on the servo controller before running this program.

Installation: mount the voice interaction module on the rear panel of miniHexa.

2. Glowy ultrasonic module

The module uses an I2C communication interface and can read the distance measured by the ultrasonic sensor through I2C communication. Two RGB LEDs are integrated at the ultrasonic probe position. The brightness can be adjusted. Color changes and color mixing across the red channel R, green channel G, and blue channel B make full-color lighting effects possible.

Note

The glowy ultrasonic module is already connected to the onboard I2C Port at the factory. No additional wiring is required.

6.5.3.4 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open the Hiwonder Python Editor.

3. Open 02 Program Files/01 Voice Obstacle Alert Program/main.py. Then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

4. Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

5. After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.5.3.5 Project Outcome

When the glowy ultrasonic module detects no obstacle ahead or the obstacle is too far away, the module lights up green. When the obstacle is too close, the module lights up red and the voice interaction module plays back Obstacle ahead.

6.5.3.6 Program Analysis

1. Import the libraries. Hiwonder is the robot control library. Hiwonder_DEV provides the interface for external sensors. time is used for time-related operations.

import Hiwonder
import Hiwonder_DEV
import time

2. Create the robot object and initialize WonderEcho and the glowy ultrasonic module.

robot = Hiwonder.Robot()
sonar = Hiwonder_DEV.DEV_SONAR()
asr = Hiwonder_DEV.DEV_ASR()

3. Get the distance returned by the ultrasonic module.

while True:
    dis = sonar.getDistance()

4. If the distance is less than 15, set the RGB LEDs on the ultrasonic module to red. Then make the voice interaction module play back Obstacle ahead.

    if dis < 15:
      r, g, b = 255, 0, 0
      sonar.setRGB(0, r, g, b)
      asr.speak(asr.ASR_ANNOUNCER, 5)
      time.sleep(1.5)

5. If the distance is greater than or equal to 15, set the RGB LEDs on the ultrasonic module to green.

    else:
      r, g, b = 0, 255, 0
      sonar.setRGB(0, r, g, b)
    time.sleep_ms(100)

6.5.4 Human-Robot Interaction

6.5.4.1 Feature Overview

This section uses the voice interaction module to detect commands and respond with different actions.

6.5.4.2 Project Process

6.5.4.3 Preparation

1. Module installation

The integrated voice interaction module WonderEcho is built on the CI1302 chip for voice recognition and voice playback. It supports offline neural network acceleration and hardware acceleration for voice signal processing. The module uses deep noise reduction and neural network models to analyze voice input and generate recognition results.

Module wiring: as shown below, connect the module to any I2C Port highlighted in red on the servo controller before running this program.

Installation: mount the voice interaction module on the rear panel of miniHexa.

6.5.4.4 Action Group Download

Follow the instructions in 6.3 Secondary Development Project -> 6.3.1.3 Action Group Download to download the action groups to miniHexa.

6.5.4.5 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open the Hiwonder Python Editor.

3. Open 02 Program Files/02 Human-Robot Interaction Program/main.py. Then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

4. Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

5. After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.5.4.6 Project Outcome

When a specified command word is recognized, the robot executes the corresponding action group as a response. The mapping between the command word and the action group is as follows:

Spoken Command	Voice Module Response	Executed Action
Hello	Hi	Run Action Group 14
Introduce Yourself	Hello, i'm Hiwonder, and i can talk and dance.	Perform the cute action
Show a Skill	Watch closely	Run Action Group 7

6.5.4.7 Program Analysis

1. Import the libraries. Hiwonder is the robot control library. Hiwonder_DEV provides the interface for external sensors. time is used for time-related operations.

import Hiwonder
import Hiwonder_DEV
import time

2. Create the robot object and initialize WonderEcho and the glowy ultrasonic module.

robot = Hiwonder.Robot()
sonar = Hiwonder_DEV.DEV_SONAR()
asr = Hiwonder_DEV.DEV_ASR()

3. perform_dance() is the function that performs the cute action. It uses set_body_angle() and set_body_pose().

set_body_angle() is the function that sets the body angle. The first parameter is the body angle [roll, pitch, yaw]. The range is [-20.0, 20.0] degrees. The second parameter is the execution time and is optional.

set_body_pose() is the function that sets the x, y, and z offsets of the body from the origin. The first parameter is the x, y, and z offset of the body center from the origin. The range is [-4.0, 4.0]. The second parameter is the execution time for each step and is optional.

def perform_dance():
    global robot
    # Part 1: Pitch swing
    # Pitch +10 degrees, body leans forward
    robot.set_body_angle([0.0, 10.0, 0.0], 300)
    time.sleep_ms(600)  # Wait for the action to finish plus extra delay
    
    # Pitch -10 degrees, body leans backward
    robot.set_body_angle([0.0, -10.0, 0.0], 300)
    time.sleep_ms(600)
    
    # Pitch +10 degrees, body leans forward
    robot.set_body_angle([0.0, 10.0, 0.0], 300)
    time.sleep_ms(600)
    
    # Pitch -10 degrees, body leans backward
    robot.set_body_angle([0.0, -10.0, 0.0], 300)
    time.sleep_ms(600)
    
    # Return to the level posture
    robot.set_body_angle([0.0, 0.0, 0.0], 300)
    time.sleep_ms(600)
    
    # Part 2: Horizontal swing along the x-axis
    # Move 2 cm to the right
    robot.set_body_pose([2.0, 0.0, 0], 200)
    time.sleep_ms(400)
    
    # Move 2 cm to the left
    robot.set_body_pose([-2.0, 0.0, 0], 200)
    time.sleep_ms(400)
    
    # Move 2 cm to the right
    robot.set_body_pose([2.0, 0.0, 0], 200)
    time.sleep_ms(400)
    
    # Move 2 cm to the left
    robot.set_body_pose([-2.0, 0.0, 0], 200)
    time.sleep_ms(400)
    
    # Return to the center position
    robot.set_body_pose([0.0, 0.0, 0], 200)
    time.sleep_ms(400)

4. Get the ID corresponding to the recognized command word.

    result = asr.getResult()

5. When the recognized command word is Hello, run Action Group 14.

    if result == 26:
        # "Hello" recognized - run Action Group 14
        robot.action_group_run(14)

6. When the recognized command word is Introduce Yourself, perform the cute action.

    elif result == 27:
        # "Introduce Yourself" recognized - perform the cute action
        perform_dance()

7. When the recognized command word is Show a Skill, run Action Group 7.

    elif result == 28:
        # "Show a Skill" recognized - run Action Group 7
        robot.action_group_run(7)

6.5.5 Voice Control

6.5.5.1 Feature Overview

This section uses the voice interaction module to detect spoken commands and execute the corresponding movements.

6.5.5.2 Project Process

6.5.5.3 Module Description

The integrated voice interaction module WonderEcho is built on the CI1302 chip for voice recognition and voice playback. It supports offline neural network acceleration and hardware acceleration for voice signal processing. The module uses deep noise reduction and neural network models to analyze voice input and generate recognition results.

Module wiring: as shown below, connect the module to any I2C Port highlighted in red on the servo controller before running this program.

Installation: mount the voice interaction module on the rear panel of miniHexa.

6.5.5.4 Program Download

1. Connect miniHexa to the PC with a Type-C data cable.

2. Open the Hiwonder Python Editor.

3. Open 02 Program Files/03 Voice Control Program/main.py. Then drag it into the Hiwonder Python Editor. The drag operation takes effect only when the file is dropped inside the red box.

4. Click the connection icon in the menu bar . After the connection succeeds, the icon turns green .

5. After the connection succeeds, click the download icon in the menu bar to download the program to miniHexa. Wait until the information panel below shows that the download is complete.

6.5.5.5 Project Outcome

When a specified command word is recognized, the robot executes the corresponding movement as a response. The mapping between the command word and the movement is as follows:

Spoken Command	Voice Module Response	Executed Movement
Go straight	Going straight	Move forward continuously
Go backward	Going backward	Move backward continuously
Turn left	Turning left	Rotate counterclockwise continuously
Turn right	Turning right	Rotate clockwise continuously
Stop	Copy that	Stop moving
March	Copy that	Move forward two steps in the current heading

6.5.5.6 Program Analysis

1. Import the libraries. Hiwonder is the robot control library. Hiwonder_DEV provides the interface for external sensors. time is used for time-related operations.

import Hiwonder
import Hiwonder_DEV
import time

2. Create the robot object and initialize WonderEcho.

robot = Hiwonder.Robot()
asr = Hiwonder_DEV.DEV_ASR()

3. Define the command ID for each spoken command.

FORWARD_ID = 1      # "Go straight"
BACKWARD_ID = 2     # "Go backward"
LEFT_ID = 3         # "Turn left"
RIGHT_ID = 4        # "Turn right"
STOP_ID = 9         # "Stop"
WALK_ID = 29        # "March"

4. Get the ID corresponding to the recognized command word.

# Main loop
while True:
    # Run voice recognition
    result = asr.getResult()

5. If the recognized command word is Go straight, miniHexa moves forward.

    if result == FORWARD_ID:
        # Go straight
        robot.go([0.0, 2.0, 0.0])

6. If the recognized command word is Go backward, miniHexa moves backward.

    elif result == BACKWARD_ID:
        # Go backward
        robot.go([0.0, -2.0, 0.0])

7. If the recognized command word is Turn left, miniHexa turns left.

    elif result == LEFT_ID:
        # Turn left
        robot.go([0.0, 0.0, 2.0])

8. If the recognized command word is Turn right, miniHexa turns right.

    elif result == RIGHT_ID:
        # Turn right
        robot.go([0.0, 0.0, -2.0])

9. If the recognized command word is Stop, miniHexa stops moving.

    elif result == STOP_ID:
        # Stop
        robot.go([0.0, 0.0, 0.0])

10. If the recognized command word is March, miniHexa moves forward for two steps.

    elif result == WALK_ID:
        # "March" - move forward two steps
        robot.go([0.0, 2.0, 0.0],2)
        time.sleep(2)