GO-M8010-6 Motor V1.2 Use Manual

GO-M8010-6 Motor Use Manual

Add content here

Product Usage Precautions

The maximum allowable voltage for the GO-8010-6 motor is DC-30V. Be sure to follow relevant safety regulations during operation.
When in use, pay attention to controlling the motor parameters. Do not allow the output torque to become too large or install high-inertia loads at the motor end.
Before use, check whether the motor is functioning properly and whether it is stalled. If any abnormality is found, replace it promptly.
During operation, pay attention to the motor temperature. Do not touch the motor surface with your hands to avoid burns.
When installing or removing the mechanical structure at the output end, be sure to disconnect the motor power supply.

1. Motor Overview

The stator of a permanent magnet synchronous motor (PMSM) consists of a three-phase symmetrical sinusoidal winding, with permanent magnets mounted on the rotor. It is known that in a fixed magnetic field, a permanent magnet will rotate and align itself parallel to the direction of the magnetic field. A typical example is a compass needle in the Earth's magnetic field, which rotates to point toward the geomagnetic North-South direction. Similarly, if this fixed magnetic field begins to rotate, the permanent magnet will also rotate, attempting to stay aligned with the direction of the magnetic field as closely as possible. In this way, by rotating the magnetic field, we can position the permanent magnet at a desired angle.

At the same time, the torque generated by the permanent magnet in the magnetic field is related to the angle between the magnet and the magnetic field direction. Therefore, the torque generated by the permanent magnet can also be controlled by adjusting the angle between the magnetic field and the magnet.

From the perspective of motor control, by regulating the magnitude and switching of the voltages applied to the three stator windings, we can control both the angular position and the output torque of the rotor. This control method is known as Field-Oriented Control (FOC) of permanent magnet synchronous motors.

2. Introduction to FOC

FOC control offers many unique advantages that allow us to achieve "pixel-level" control of permanent magnet synchronous motors, enabling capabilities beyond traditional motor control methods:

Maintains precise control at low speeds;
Achieves smooth motor reversing;
Supports three closed-loop control modes: torque, speed, and position;
PMSM with FOC control operates with low noise.

As described in the Permanent Magnet Synchronous Motor Overview section, the foundation of FOC control is the rotating magnetic field. In the magnetic field vector diagram shown in Figure 1, the three coils a, b, c of the motor stator generate magnetic fields Ba, Bb, Bc in three directions, which together synthesize the overall magnetic field B within the motor. Based on the current angular position and angular velocity of the permanent magnet rotor, the desired output torque, and the sampled currents from the three coils a, b, c, the FOC controller calculates the switching states and durations of the voltages applied to the three coils. These voltages are then controlled via MOSFETs to achieve the desired switching patterns. In this way, the desired magnetic field B is synthesized, driving the motor rotor to move in the desired manner.

Figure 1: Magnetic Field Vector of FOC

3. Motor Hardware and Encoder Overview

The core components of a robotic joint motor are the motor driver board, stator, rotor, and planetary gearbox. Since motors are suitable for high-speed, low-torque operation, while our robots require low-speed, high-torque output, the motor rotor must be decelerated through a gearbox before delivering torque.

An encoder is a sensor used to measure rotational angle. Encoders are available in various types, including incremental encoders, multi-turn absolute position encoders, and single-turn absolute position encoders. Here, we will only discuss in detail the single-turn absolute position encoder as used in practical joint motor applications.

The single-turn absolute position encoder of a joint motor is mounted on the motor rotor. A single-turn absolute position encoder (hereinafter referred to as the encoder) can be thought of as a "clock face." Every time we look at a clock, we can read the current date and time, for example, April 1st, 23:00. If two hours pass, the clock passes 24:00 on April 1st, the date increments by one day to April 2nd, and the time restarts from 00:00, becoming April 2nd, 01:00. For convenience in calculating elapsed time, we could also say it is April 1st, 25:00. Although 25:00 exceeds the 24-hour range of a single day, this effectively means that the date has increased by one day.

The same principle applies to the single-turn absolute position encoder. Each time the system is powered on, the rotor may be at any arbitrary position, and the encoder reports the angular position of the rotor (a value between 0 and 2𝜋). If the rotor rotates past the 2𝜋 angular position, the encoder also records that the number of full turns has increased by one, thereby outputting an angular position that exceeds the 0 to 2𝜋 range. It may seem that the encoder can output angular positions beyond a single full turn — so why is it called a "single-turn" absolute position encoder? The reason is that this type of encoder cannot store the number of accumulated turns after power-off. The following example illustrates this point.

Assume that the current angular position output by the encoder is 2.3𝜋. This means that since power-on, the encoder has passed 2𝜋, the turn count has increased from 0 to 1, and the encoder is currently at the position 0.3𝜋. If we now power off the encoder without moving it, and then power it on again, the encoder will output an angular position of 0.3𝜋. Because the turn count resets to 0 after power-off, the encoder only outputs the current position of 0.3𝜋.

4. Hybrid Control of the Motor

As a highly integrated power unit, the joint motor has its underlying control algorithm encapsulated internally. As a user, you only need to send relevant commands to the joint motor, and the motor will complete all tasks from receiving the command to outputting joint torque.

For the underlying control algorithm of the motor, the sole control objective is the output torque. However, for robots, we typically need to set the position, velocity, and torque for each joint. This requires hybrid control of the joint motor.

The joint motor from Unitree Robotics includes the following five control commands:

Feedforward torque: 𝜏𝑓𝑓;
Desired angular position: 𝑝𝑑𝑒𝑠;
Desired angular velocity: 𝜔𝑑𝑒𝑠;
Position stiffness: 𝑘𝑝;
Velocity stiffness (damping): 𝑘𝑑.

In the hybrid control of the joint motor, a PD controller is used to feed back the position error of the motor into the torque output:

$\tau = \tau_{ff} + k_p \times (p_{\text{des}} - p) + k_d \times (\omega_{\text{des}} - \omega)$

where 𝜏 is the output torque of the motor rotor of the joint motor, 𝑝 is the current angular position of the motor rotor, and 𝜔 is the angular velocity of the motor rotor. In practical use of the joint motor, care should be taken to convert between the control target quantities at the motor output end and the commands sent to the motor rotor.

5. Motor Wiring Connection

We use RS-485 as the physical layer. The so-called physical layer refers to the physical phenomena used to represent and transmit information. In fact, RS-485 can be considered equivalent to a half-duplex serial port (UART).

RS-485 uses the potential difference between two wires to transmit digital levels. Typically, both wires are twisted pairs of equal length. When external interference exists, it generates noise on both wires simultaneously. After the differential signal is transmitted to the motor, it is processed by a differential operational amplifier, which subtracts the input differential levels to recover the original signal before sending it to the serial port. This gives the communication high immunity to interference.

RS-485 signal states
Signal	Mark (logic 1)	Space (logic 0)
A	Low	High
B	High	Low

Table: Relationship Between Differential Levels and Logic Levels

Because RS-485 data lines consist of only two wires for transmitting two differential signals representing a single level, only one direction of communication can occur on the line at any given time. This is why RS-485 is a half-duplex communication protocol. In contrast, RS-422 uses four data lines for full-duplex differential transmission. However, using RS-485 greatly simplifies cabling, improves hardware communication reliability, and reduces costs.

Typically, half-duplex communication requires a master device (host computer) to control the communication rhythm. The motion control commands sent by the host contain the target motor ID information. When each motor receives a motion control command, it checks whether the ID information matches. The motor with the matching ID will send its internal data back to the host, thus completing one communication cycle.

The N6014B-12.6 motor supports a maximum of 15 motors on a single bus (IDs 0 to 14). Motors with the same ID are not allowed on the bus; otherwise, communication on the entire bus will be abnormal. Please refer to section 6.2 for motor ID configuration.

To send motion control commands to the joint motors manufactured by Yushu Technology, the commands need to be transmitted via a serial port. The motors communicate with the host computer through an RS-485 interface, with a fixed baud rate of 4 Mbps. For user convenience, a USB to RS-485 adapter will be provided.

Figure 2 Motor Wiring Connection

As shown in Figure 2. The interface provided to the user uses a C (XT30(2+2) cable) connected to B (XT30(2+2) adapter board), and is connected to A (RS-485 to USB module) via D (GH1.25-3 cable), which is then connected to the computer.

When controlling the motor with your own computer, in order to send commands from the host computer to the motor, the RS-485 interface needs to be connected to the host computer via a USB-to-RS-485 adapter. After connecting the 24V DC power supply, the motor’s green indicator light will start blinking, indicating that the motor is powered on.

💡

Note:Please check the power supply before powering on. Do not allow the power supply voltage to exceed 30V, and verify that the power supply has sufficient current capacity.

6. Motor configuration

6.1 Check the serial port name

When the USB-to-RS-485 adapter is connected to the host computer, the host computer assigns a serial port name to it. In Linux systems, this serial port name typically starts with "ttyUSB", while in Windows systems, the serial port name usually begins with "COM".

In Linux systems, all external devices exist in the form of files. The USB-to-RS-485 adapter can also be regarded as a "file" located in the /dev directory. Open any terminal window (the shortcut key in Ubuntu is Ctrl+Alt+t), and run the following command:

cd /dev
ls | grep ttyUSB

The cd /dev command switches the current folder to /dev, and the ls | grep ttyUSB command displays all files in the current folder whose filenames contain "ttyUSB". The | symbol is located above the Enter key on the keyboard; you can type the "|" character by holding down the Shift key and pressing the key above Enter. After running the above commands, you will obtain the serial port name currently connected to the host computer. For example, as shown in Figure 3, the serial port name currently connected to the host computer is ttyUSB0. Considering the folder path where the serial port is located, its full serial port name is /dev/ttyUSB0.

Figure 3: Viewing the serial port name in the Ubuntu system

💡

Note:The serial port number (index) corresponds to the order in which the devices are connected, which is very helpful when connecting multiple devices.

6.2 Obtain the Motor Toolbox

After decompressing the Unitree MotorTools toolbox and entering the bin folder, you will see several executable programs. These provide some common tools for modifying the motors.

At this point, connect the motor's XT30 2+2 interface to the motor, connect the USB-to-RS-485 adapter to the computer, and power on the motor. The next step is to begin configuring the motor.

💡

Note:When using the Unitree MotorTools, please ensure that there is only one motor on the RS-485 bus and that no other host devices are active (sending data to the bus).

6.3 Check the motor ID

To view and modify the motor ID, you need to switch the motor to factory mode. Before switching, please ensure that all motors have stopped running and that the host computer is no longer sending motion control commands to the motors.

sudo ./swboot /dev/ttyUSB

Wait a moment. After entering factory mode, the green indicator light on the back of the motor will flash rapidly three times per second. At this point, the terminal will display all motors that have entered factory mode.

Under normal circumstances, the printed list will not contain motors with an ID greater than 15. If this occurs, please power cycle the motor and try again.

If there is a motor with ID 15, it indicates that the motor has not yet been assigned an ID. You can refer to Section 6.4 for configuration.

6.4 Change the motor ID

To modify the motor ID, you need to use the changeid command. The usage is as follows:

changeid [serial port] [original ID] [new ID]

changeid /dev/ttyUSB0 0 1 : Set motor ID 0 to ID 1

Before switching, please ensure that all motors have stopped running and that the host computer is no longer sending motion control commands to the motors.

Example: Change all motors with ID 15 on the bus to ID 0

sudo ./changed /dev/ttyUSB0 15 0

6.5 Motor firmware upgrade

The Go-M8010-6 motor supports firmware upgrades, making it convenient to improve motor performance and apply security fixes in the future. You can download the firmware file provided by Yushu Technology to the motor using the unisp tool. To upgrade the motor firmware, you need to use the unisp command. The usage is as follows:

unisp [serial port] [.bin firmware file] [target motor ID]

unisp /dev/ttyUSB0 ./GoM80106_v1.0.bin 0

💡

Note:Please do not download firmware of unknown origin to the motor. This is an extremely dangerous action.

The risks include, but are not limited to, bricking the motor, unexpected personal injury, burning out the motor, and voiding the warranty.

6.6 Switch back to motor mode

Viewing and modifying the motor ID will switch the motor to factory mode. If you do not manually switch it back to motor mode, the motor will still enter factory mode even after a power cycle.

When in factory mode, the green indicator light on the back of the motor will flash rapidly three times per second.

At this point, use the command ./swmotor to switch back to motor mode. The usage is as follows:

swmotor [serial port]

swmotor /dev/ttyUSB0

This will switch all motors on the RS-485 bus to motor mode, and the motors will then be able to receive motion control commands.

💡

Note:A motor without firmware will not be started, and this will be displayed on the terminal.

7. Motor control

The SDK currently supports the following platforms and systems:

Linux systems on x86/x64 platforms
Linux systems on ARM64 platforms

UnitreeMotorSDK download link: https://dev-motor.unitree.com/sdkUse/?highlight=ARM

For each supported platform, C++ code examples are provided. Users can control the motor simply by following the examples. Below, we demonstrate how to control the motor.

7.1 C++ example trial run

Below, we will try to get the motor running.

First, open the main.cpp file in the src folder. The first step is to modify the serial port name. If you are running the program on only one system, simply change the serial port name for that system:

SerialPort _ioPort("/dev/ttyUSB0");

Next, declare the commands to be sent to the motor and the status to be received from the motor:

MotorCmd cmd;
MotorData data;

Among them, cmd is the control command packet sent to the motor, both of which are structures of type MotorCmd. A structure is a data packet that contains multiple different types of data. We will soon demonstrate operations on the structure. Similarly, data is the packet that receives motor status information, and it is a structure of type MotorData. For the specific contents of these two structures, please refer to the include/unitreeMotor/unitreeMotor.h file, which will not be repeated here.

Next, we modify cmd. First, let's explain the data contained in the MotorCmd type structure:

Id: The ID of the target motor for the current control command.
mode: The operating mode of the target motor.

0: Stop
1: FOC (Field-Oriented Control)
2: Motor calibration

T: Feedforward torque τff
W: Desired angular velocity ωdes
Pos: Desired angular position pdes
K_P: Position stiffness kp
K_W: Velocity stiffness (damping) kd

When the value of mode is 0, the following five control parameters have no effect. When the value of mode is 2, it indicates motor calibration. In this example, we set the value of mode to 1. Here, we make the motor rotate at a constant speed. The complete code is as follows:

cmd.motorType = MotorType::Go2;
cmd.id = 0;
cmd.mode = 1;
cmd.K_P = 0;
cmd.W = 6.28*6.33;
cmd.K_W = 0.02;
cmd.T = 0.0;
_ioPort.sendRecv(&cmd,&data);

Now we can send commands to the motor. The control command is sent to the motor via the sendRecv(&cmd, &data) function of the _ioPort object, which simultaneously receives the motor's current status information.

💡

Note:One important thing to note here is that the commands sent to the motor are all directed to the motor rotor before the reducer, i.e., Shaft 1 in Figure 5, rather than the output shaft after the reduction, i.e., Shaft 2. Therefore, during actual control, you must take the motor's reduction ratio into consideration. For the GO-8010-6 motor, the reduction ratio is 6.33.

7.2 Position mode

In position mode, the output shaft of the motor will stabilize at a fixed position. For example, if we want the motor output end to be fixed at a position of 3.14 radians, the control parameters can be set as follows:

cmd.T = 0.0;
cmd.W = 0.0;
cmd.Pos = 3.14*6.33;
cmd.K_P = 0.02;
cmd.K_W = 0.0;

In the above parameter settings, set T and W to 0, and the configuration becomes PD control for Pos. Here, K_P is the proportional coefficient, K_W is the derivative coefficient, and 6.33 is the reduction ratio.

After making the above modifications, recompile and run the relevant executable file. From the status returned by the motor, it can be seen that the position of the motor rotor stabilizes at 3.14 × 6.33 radians, meaning the motor output end is fixed at 3.14 radians. It can be understood that if there is a large gap between the target position and the current position, the torque ττ generated by the motor will also be large, resulting in a large current. If the power supply providing power to the motor has a low output current limit, power supply protection may be triggered, causing the motor to stop rotating.

In this case, it is necessary to consider slowly varying cmd.Pos to avoid generating an instantaneous extremely large torque.

7.3 Velocity mode

In velocity mode, the output shaft of the motor will stabilize at a constant speed. To stabilize the motor output shaft speed at 6.28 rad/s:

cmd.T = 0.0;
cmd.W = 6.28*6.33;
cmd.Pos = 0.0;
cmd K_P = 0.0;
cmd.K_W = 0.02;

In velocity mode, T and K_P must be 0, which forms P control for W. Here, K_W is the proportional coefficient for velocity.

7.4 Damping mode

Damping mode is a special type of velocity mode. When we set W = 0.0, the motor will maintain a shaft speed of zero. When an external force rotates the shaft, the motor generates a resistive torque. This torque acts in the opposite direction of the rotation, and its magnitude is proportional to the rotational speed. When the external force stops, the motor comes to rest at its current position. Because this behavior is similar to that of a linear damper, it is called damping mode.

cmd.T = 0.0;
cmd.W = 0.0;
cmd.Pos = 0.0;
cmd K_P = 0.0;
cmd.K_W = 0.02;

7.5 Torque mode

In torque mode, the motor will continuously output a constant torque. However, when the motor is running without a load, if a large target torque is given, the motor will keep accelerating until it reaches its maximum speed, and even then, the target torque may not be achieved.

Below is a relatively safe parameter configuration for torque mode under no-load conditions:

cmd.T = 0.05;
cmd.W = 0.0;
cmd.Pos = 0.0;
cmd.K_P = 0.0;
cmd.K_W = 0.0;

Under these parameters, you can observe the motor gradually accelerating under a constant torque. Due to slight differences between individual motors, if the motor does not rotate smoothly, you can moderately increase the value of T or give it a gentle push by hand.

7.6 Zero-torque mode

Zero-torque mode is a special type of torque mode. When we modify the command to the following settings, the motor will maintain zero torque on the shaft:

cmd.T = 0.0;
cmd.W = 0.0;
cmd.Pos = 0.0;
cmd.K_P = 0.0;
cmd.K_W = 0.0;

At this point, the motor is not stopped; rather, it actively generates torque to counteract its own friction torque. In zero-torque mode, when you try to rotate the output shaft, you will feel that the resistance of the output shaft is significantly lower than when the motor is powered off.

7.7 Force-position hybrid mode

In practical quadruped robot control, the motion controller typically sends feedforward torque τff, desired position pdes, and desired angular velocity ωdes to the joints simultaneously. This is known as force-position hybrid control — the most frequently used control mode in the real-world applications we will cover later.

8. Porting to other host computer platforms

Considering that some users may use special host computer platforms to control the motor, we will also explain how to write your own motor control program here. Using the methods described in this section, readers can send control commands to the motor and receive motor status on any platform that meets the hardware requirements.

8.1 Communication configuration

The GO-M8010-6 motor uses serial communication with the RS-485 standard and a baud rate of 4.0 Mbps. The serial port configuration is 8 data bits, no parity, and 1 stop bit. It should be noted that in order to increase the communication frequency of the motor, we use a very high baud rate of 4.0 Mbps. Users need to verify whether their hardware supports such a high baud rate.

If your hardware cannot support this baud rate, you can use the USB-to-RS-485 module provided by Unitree.

8.2 Motor motion control command format

It is a 16-byte message. If no command is sent to the motor, the motor will not return any status. The format for sending commands to the motor is shown in Table 1, and the format for the motor's returned status is shown in Table 2. These two tables detail the meaning of each byte in the transmitted and received messages. Below, we will explain some of the details.

First, consider bytes 11 and 12 in the command sent to the motor. These two bytes represent the motor feedforward torque τff. Obviously, the feedforward torque τff is a floating-point number (float type), which normally occupies 4 bytes. To save communication bandwidth, we use 2 bytes to represent the floating-point number. The method we use involves shift operations, but the specific principles will not be explained here. From an application perspective, readers can think of it as multiplying the feedforward torque by 256 and then assigning the result to a 2-byte signed short int (i.e., a signed short integer). During this assignment, rounding is forced. This allows us to send the feedforward torque τff using only two bytes. When the motor receives this data, it simply divides by 256 to obtain the feedforward torque value. Although this operation results in some loss of precision, it is sufficient for practical applications.

Another point to note is that a 2-byte variable has 16 bits in total, of which 1 bit is used to represent the sign (the sign bit), leaving only 15 bits to represent the magnitude of the value. This means that the value of T in the command cannot exceed $2^{15}$ . Considering that we multiplied the original torque value τff by 256, its absolute value has an upper limit:

$|\tau_{ff}| < \frac{2^{15}}{256} = 128$

It should also be noted that due to the forced rounding during the assignment process, the larger the value of τff, the lower the decimal precision retained. In Table 1, the description of the variable T refers to the "X 256 times" scaling mentioned above, and the same applies to the scaling descriptions for other variables.

Furthermore, for the 2-byte torque variable, the low byte comes first (byte 13), followed by the high byte (byte 14). At the end of both the command and the returned status, we can see a 2-byte CRC_CCITT checksum. Before sending a command, we calculate the CRC checksum of the command bytes and send it together with the command to the motor.

After receiving the command, the motor calculates the post-transmission CRC checksum based on the received command. If no errors occur during data transmission, the pre-transmission CRC checksum will equal the post-transmission CRC checksum. If a data error occurs during transmission, the post-transmission CRC checksum will not match the pre-transmission CRC checksum, allowing the motor to detect data corruption and helping us avoid erroneous data. Readers can directly refer to the source code of the crc_ccitt function in the Linux kernel for further details.

Table 1: Host-side control protocol

type	bit	Symbol	Description	Value
Header (2Byte)	0-15 (2Byte)	HEAD	Packet header	0xFE 0xEE
Mode Setting (1Byte)	16-19 [4bit]	ID	Target motor ID	0,1,2,3 ... 13,14 15: Broadcast to all motors (no return value on bus at this time)
	20-22 [3bit]	STATUS	Motor operating mode	0: Locked (Default) 1: FOC closed-loop 2: Encoder calibration (wait 5s, no packets may be sent to the motor during this time) 3-7: Reserved
	23 [1bit]	Reserved
Control Parameters (12Byte)	24-39(2Byte)	𝜏𝑠𝑒𝑡	Desired motor torque	$𝜏_{𝑓𝑓} = 0.75 (𝑁. 𝑚)$ $𝜏_{𝑠𝑒𝑡} = 𝜏_{𝑓𝑓} \times 256 = 192$ $\|𝑇_{𝑓𝑓}\| ≤ 127.99(𝑁. m)$
	40-55(2Byte)	𝜔𝑠𝑒𝑡	Desired motor velocity	$ω_{des} = 3.14159 (rad/s)$ $ω_{set} = \frac {ω_{des}}{2π} ∗ 256 = 128$ note: 2π/s = 6.28rad/s = 60RPM $\|ω_{des}\| ≤ 804.0 (rad/s)$
	56-87(4Byte)	𝜃𝑠𝑒𝑡	Desired motor output position (multi-turn accumulated)	$θ_{des} = 90° = \frac π 2= 1.57 (rad)$ $θ_{set} = \frac {θ_{des}}{2π} ∗ 32768 = 8187$ note: 2π = 360° = 6.2831rad $\|𝜃_{des}\| ≤ 411774 rad(≈ 65535 rad)$
	88-103(2Byte)	𝐾𝑝𝑜𝑠	Motor stiffness coefficient / Position error proportional gain	$K_{p} = 0.2$ $K_{pos} = K_p \times 1280 = 128$ note:0 ≤ Kw ≤ 25.599
	104-119(2Byte)	𝐾𝑠𝑝𝑑	Motor damping coefficient / Velocity error proportional gain	$K_{w} = 0.2$ $K_{spd} = K_w \times 1280 = 256$ note: 0 ≤ Kw ≤ 25.599
Checksum (2Byte)	120-135(2Byte）	CRC16	CRC16 checksum result	Result of CRC16_CCITT polynomial calculation on data bits 0-119
Sum	17 Byte

💡

Note:To ensure proper calibration, after switching to the encoder calibration mode, you need to wait 5 seconds before establishing communication (during this period, no data packets should be sent to the motor; otherwise, calibration will fail).

Table 2 – Feedback Data from Motor Side

type	bit	Symbol	Description	Value
Header (2Byte)	0-15 (2Byte)	HEAD	Packet header	0xFD 0xEE Note: This is different from the packet header coming from the host direction.
Mode Setting (1Byte)	16-19 [4bit]	ID	Target motor ID	0,1,2,3 ... 13,14 15: Reserved
	20-22 [3bit]	STATUS	Motor operating mode	0: Locked (Default) 1: FOC closed-loop 2: Encoder Calibration 3-7: Reserved
	23 [1bit]	Reserved
Feedback Data (11 bytes)	24-39(2Byte)	$𝜏_{fbk}$	Actual Joint Output Torque	$𝜏(𝑁. 𝑚) = \frac {𝜏_{𝑓𝑏k}}{256}$
	40-55(2Byte)	$𝜔_{fbk}$	Actual Joint Output Velocity	$𝜔(𝑟𝑎𝑑/𝑠) = \frac {𝜔_{𝑓𝑏𝑘}}{256} ∗ 2π$
	56-87(4Byte)	$𝜃_{fbk}$	Actual Joint Output Position (Multi-turn Accumulated)	$𝜃(𝑟𝑎𝑑) = \frac {𝜃_{𝑓𝑏𝑘}}{32768} ∗ 2π$
	88-95(1Byte)	TEMP	Motor Temperature	Unit: degrees Celsius (int8_t), -128 to 127°C. Temperature protection is triggered at 90°C, and the motor must be power-cycled (power off and on again) before it can be controlled again.
	96-98[3bit]	MERROR	Motor Error Indicator	0. Normal 1. Overheat 2. Overcurrent 3. Overvoltage 4. Encoder fault 5–7. Reserved
	99-110 [12bit]	FORCE	Foot-end Force	12-bit raw data (0–4095). Physical quantity unit/range — to be confirmed.
	111 [1bit]
Checksum (2Byte)	112-127(2Byte）	CRC16	CRC16 checksum result	Result of CRC16_CCITT polynomial calculation on data bits 0-111
Sum	16 Byte

💡

All data types in the communication protocol are integers. Please refer to the "bit" field description in the table above for specific sizes. Ensure that the control host processor platform is in little-endian (LSB) mode.

💡

Unless otherwise specified, all parameters in the table refer to the motor rotor side of the joint motor, not the output side. The gear reduction ratio from the rotor to the output end of the Go-M8010-6 motor is 6.33.

← Previous

Add link here