Arduino FOC Gait Control and Balance Control for Three-Legged Robots

在这里插入图片描述

Arduino is an open-source electronic prototyping platform that allows you to create a variety of interactive projects using simple hardware and software.At the heart of Arduino is a microcontroller board that can be used to connect to a variety of sensors, actuators, displays, and other external devices through a series of pins.Programming for Arduino is based on the C/C++ language, and you can use the Arduino IDE (Integrated Development Environment) to write, compile, and upload code to the Arduino board.Arduino also has a rich library and community that you can utilize to extend the functionality of Arduino and learn about Arduino.

Arduino features:
1, open source: Arduino's hardware and software are open source, you can freely modify, copy and share them.
2, easy to use: Arduino hardware and software are designed for beginners and non-professionals, you can easily get started and use them.
3, cheap: Arduino's hardware and software are very economical, you can realize your ideas at a very low cost.
4, diverse: Arduino has a variety of models and versions, you can choose the right Arduino board according to your needs and preferences.
5、Innovation: Arduino allows you to express your creativity and imagination electronically, and you can use Arduino to make all kinds of interesting and useful projects, such as robots, smart homes, art installations and so on.

在这里插入图片描述
Arduino FOC (Field Oriented Control) is an advanced motor control technology that allows preciseControl motorsof torque and speed. This control technique is particularly suitable for brushless DC motors (BLDC) and stepper motors. Implementing FOC on the Arduino platform provides smooth operation and a high degree of torque, speed, and position control, and it achieves high-efficiency, high-precision, and low-noise operation by accurately controlling the motor's current and voltage.

Key features.
1、High-performance motor control: FOC is an advanced motor control algorithm that can accurately control PMSM (Permanent Magnet)synchronous motor) and BLDC (Brushless DC) motors for smooth speed and torque output.
2、Closed-loop control architecture: FOC adopts closed-loop feedback control, by detecting the position and speed data of the motor, it adjusts the output voltage and current in real time to ensure that the motor action is in line with expectations.
3, modular design: Arduino FOC library adopts modular design, including motor modeling, speed/position/current control loop, PWM generation and other sub-modules, users can flexibly combine and use according to their needs.
4, strong portability: Arduino FOC can be ported to a variety of hardware platforms, such as Arduino, ESP32,STM32with Raspberry Pi and others for motor systems with power ranging from a few tens of watts to a few kilowatts.
5, automatic identification of parameters: FOC library with automatic identification of motor parameters, can greatly simplify the motor control system debugging process.

Application Scenario.
1、Industrial automation: In the field of factory robots, conveyor belts, CNC machining equipment, etc., Arduino FOC can provide high-performance motor control solutions.
2, electric vehicles: electric bicycles, electric cars, electric forklifts and other on-board motor drive system, you can use Arduino FOC for precise control.
3, household appliances: in electric fans, washing machines, air conditioning and other household appliances, Arduino FOC can realize delicate motor speed and torque control.
4, model airplanes and drones: model airplanes, drones and other areas that require high motor control performance, Arduino FOC can provide high-precision motor drive.
5, robotics: industrial robots, service robots, bionic robots and other areas of strict requirements for motor control performance, Arduino FOC is a good choice.

Matters requiring attention.
1, hardware requirements: Arduino FOC has certain requirements on the performance of the controller (such as CPU frequency, RAM / ROM capacity, etc.), you need to choose the appropriate hardware platform.
2, debugging complexity: FOC algorithm involves motor modeling, coordinate transformation, PI regulator and many other aspects of the debugging and tuning process is relatively complex, requiring a certain degree of expertise.
3, noise suppression: motor drive circuit is prone to noise interference, need to take reasonable shielding and filtering measures to ensure signal quality.
4, safety protection: motor drive system may produce overcurrent, overvoltage and other faults, need to be equipped with reliable protection circuit to ensure personal and equipment safety.
5、system integration: When integrating an Arduino FOC into a complete motor drive system, all aspects of mechanical, electrical, and control coordination need to be considered.

Overall, Arduino FOC is a powerful and high-performance motor control solution for industrial automation, electric vehicles, household appliances and many other fields. However, careful consideration is needed in hardware selection, algorithm debugging, noise suppression and safety protection to ensure stable and reliable operation of the system.

Appendix: Series Catalog
1, Arduino FOC features, scenes and use matters
/WZhYL
2、Arduino FOC simple FOC library - cross-platform brushless DC and stepper motor FOC implementation
/p9ADE
3、Arduino FOC of brushless DC motor speed control
/gZ7CY
4、Arduino FOC stepper motor position control
/VYbIb
5、Arduino FOC of brushless DC motor current control
/wWGVu
6, Arduino FOC of SimpleFOC library main functions
/S26MC
7, Arduino FOC of ArduinoFOC library core functions
/3VLzF
8、Arduino FOC Sensor Calibration
/NS3TR
9、Arduino FOC SimpleFOCShield v2.0.4 Brushless Motor Driver Board
/g9mP7
10、Arduino FOC of AS5600 angle reading
/dmI6F
11、Arduino FOC of FOC algorithm
/ENxc0
12、Arduino FOC's SimpleFOC library adapts the motor program.
/QdH6k

在这里插入图片描述
1. Main features.
Based on advanced inverse kinematics algorithms, it can quickly calculate the angle of each joint required to realize the target position.
A dynamic planning method is used to optimize the gait trajectory and achieve smooth and continuous gait motion.
It incorporates attitude estimation and center of gravity position control to actively maintain the dynamic balance of the robot.
The algorithm is real-time and can adapt to the complex and changing terrain environment.

2、Application Scenarios.
Three-legged robots: Utilizing the feature of independent driving of three legs to realize omnidirectional movement and attitude adjustment.
Outdoor Inspection Robot: With powerful balance control, it can walk stably in complex terrain.
Disaster-response robots: can enter confined and hazardous environments to perform tasks through autonomous balancing and adaptive gait.
Entertainment/educational robots: lively and interesting gait and balancing movements that attract attention.

3. Matters requiring attention.
Inverse kinematics computation and dynamic planning algorithms have high complexity and require high performance of MCU, which need to be weighed against the selection of appropriate Arduino boards.
Accurate attitude estimation and measurement of the center of gravity position are critical and require optimization of the sensor layout and calibration process.
Gait trajectory generation and balancing control parameters require extensive debugging and testing to adapt to different environments.
The three-legged mechanism itself is affected by mechanical properties and may have its own stability problems, which need to be carefully analyzed.
Overall system integration involves mechanical, electronic, control and other fields, and requires interdisciplinary cooperation.

In conclusion, Arduino FOC provides powerful gait control and balance control functions for three-legged robots, and shows a broad prospect in many application scenarios. However, in the specific implementation, we need to pay attention to the complexity of the algorithm, sensor accuracy, parameter tuning and other factors in order to maximize its potential.

在这里插入图片描述
1. Gait control for three-legged robots.

#include <>
#include <>

// Motor settings
BLDCMotor motor1(14, 15, 16);
BLDCMotor motor2(17, 18, 19);
BLDCMotor motor3(20, 21, 22);

void setup() {
  // Initialize the motor
  motor1.linkCommandToMotor(2);
  motor2.linkCommandToMotor(3);
  motor3.linkCommandToMotor(4);
  
  // Configure motor parameters
  motor1.configure(pole_pairs, voltage_limit, current_limit);
  motor2.configure(pole_pairs, voltage_limit, current_limit);
  motor3.configure(pole_pairs, voltage_limit, current_limit);
  
  // Initialize the FOC controller
  motor1.initFOC();
  motor2.initFOC();
  motor3.initFOC();
}

void loop() {
  // Read gait commands
  float step_command1 = get_step_command_1();
  float step_command2 = get_step_command_2();
  float step_command3 = get_step_command_3();
  
  // Perform gait control
  motor1.move(step_command1);
  motor2.move(step_command2);
  motor3.move(step_command3);
  
  // Other control logic
  // ...
}

Key Points to Read.
Use the SimpleFOC library to initialize the three motors and configure their motor parameters.
In the loop() function, the gait commands of the three motors are read and the motor control is executed by the move() function.
You need to implement the get_step_command_1(), get_step_command_2() and get_step_command_3() functions to generate the appropriate gait commands based on the gait algorithm.

2. Balance control of three-legged robots.

#include <>
#include <>
#include <Adafruit_MPU6050.h>

// Motor settings
BLDCMotor motor1(14, 15, 16);
BLDCMotor motor2(17, 18, 19);
BLDCMotor motor3(20, 21, 22);

// IMU settings
Adafruit_MPU6050 mpu;

void setup() {
  // Initialize the motor
  motor1.linkCommandToMotor(2);
  motor2.linkCommandToMotor(3);
  motor3.linkCommandToMotor(4);
  
  // Configure motor parameters
  motor1.configure(pole_pairs, voltage_limit, current_limit);
  motor2.configure(pole_pairs, voltage_limit, current_limit);
  motor3.configure(pole_pairs, voltage_limit, current_limit);
  
  // Initialize the FOC controller
  motor1.initFOC();
  motor2.initFOC();
  motor3.initFOC();
  
  // Initialize the IMU
  mpu.begin();
}

void loop() {
  // Read IMU data
  sensors_event_t a, g, temp;
  mpu.getEvent(&a, &g, &temp);
  
  // Calculate balance control commands
  float balance_command1 = calculate_balance_command_1(a.acceleration.x, a.acceleration.y, a.acceleration.z);
  float balance_command2 = calculate_balance_command_2(a.acceleration.x, a.acceleration.y, a.acceleration.z);
  float balance_command3 = calculate_balance_command_3(a.acceleration.x, a.acceleration.y, a.acceleration.z);
  
  // Perform balance control
  motor1.move(balance_command1);
  motor2.move(balance_command2);
  motor3.move(balance_command3);
  
  // Other control logic
  // ...
}

Key Points to Read.
Use the Adafruit_MPU6050 library to initialize the IMU sensor for acquiring 3-axis acceleration data.
In the loop() function, the IMU data is read and the balance control commands for the three motors are calculated according to the balance control algorithm.
You need to implement the calculate_balance_command_1(), calculate_balance_command_2(), and calculate_balance_command_3() functions to generate the appropriate balance control commands based on the balance control algorithm.

3. Mixed Gait and Balance Control.

#include <>
#include <>
#include <Adafruit_MPU6050.h>

// Motor settings
BLDCMotor motor1(14, 15, 16);
BLDCMotor motor2(17, 18, 19);
BLDCMotor motor3(20, 21, 22);

// IMU settings
Adafruit_MPU6050 mpu;

void setup() {
  // Initialize the motor
  motor1.linkCommandToMotor(2);
  motor2.linkCommandToMotor(3);
  motor3.linkCommandToMotor(4);
  
  // Configure motor parameters
  motor1.configure(pole_pairs, voltage_limit, current_limit);
  motor2.configure(pole_pairs, voltage_limit, current_limit);
  motor3.configure(pole_pairs, voltage_limit, current_limit);
  
  // Initialize the FOC controller
  motor1.initFOC();
  motor2.initFOC();
  motor3.initFOC();
  
  // Initialize the IMU
  mpu.begin();
}

void loop() {
  // Read gait commands
  float step_command1 = get_step_command_1();
  float step_command2 = get_step_command_2();
  float step_command3 = get_step_command_3();
  
  // Read IMU data
  sensors_event_t a, g, temp;
  mpu.getEvent(&a, &g, &temp);
  
  // Calculate balance control commands
  float balance_command1 = calculate_balance_command_1(a.acceleration.x, a.acceleration.y, a.acceleration.z);
  float balance_command2 = calculate_balance_command_2(a.acceleration.x, a.acceleration.y, a.acceleration.z);
  float balance_command3 = calculate_balance_command_3(a.acceleration.x, a.acceleration.y, a.acceleration.z);
  
  // Hybrid gait and balance control commands
  float final_command1 = step_command1 + balance_command1;
  float final_command2 = step_command2 + balance_command2;
  float final_command3 = step_command3 + balance_command3;
  
  // Perform mixing control
  motor1.move(final_command1);
  motor2.move(final_command2);
  motor3.move(final_command3);
  
  // Other control logic
  // ...
}

Key Points to Read.
The program implements both gait control and balance control and mixes the control commands of both in a weighted manner.
In loop() function, first read the gait command and IMU data, then calculate the balance control command, and finally add the two control commands to get the final control command.
You need to implement the get_step_command_1(), get_step_command_2(), get_step_command_3(), calculate_balance_command_1(), calculate_balance_command_2() and calculate_balance_command_1(), calculate_balance_command_2(), and calculate_balance_command_3() functions to generate the corresponding gait commands and balance control commands.

在这里插入图片描述
4. Gait control of a three-legged robot

#include <>

// Motor parameters
BLDCMotor motor1 = BLDCMotor(7, 6, 5, 4, 3, 2);
BLDCDriver6PWM driver1 = BLDCDriver6PWM(9, 10, 11, 12, 13, 8);
BLDCMotor motor2 = BLDCMotor(14, 15, 16, 17, 18, 19);
BLDCDriver6PWM driver2 = BLDCDriver6PWM(20, 21, 22, 23, 24, 25);
BLDCMotor motor3 = BLDCMotor(26, 27, 28, 29, 30, 31);
BLDCDriver6PWM driver3 = BLDCDriver6PWM(32, 33, 34, 35, 36, 37);

// Gait parameters
float step_height = 0.2; // Step length
float step_period = 1.0; // Step frequency
float current_time = 0.0;

void setup() {
  // Motor initialization
  motor1.linkDriver(&driver1);
  motor2.linkDriver(&driver2);
  motor3.linkDriver(&driver3);
  motor1.init();
  motor2.init();
  motor3.init();
  motor1.initFOC();
  motor2.initFOC();
  motor3.initFOC();

  // Set motor speed and acceleration
  motor1.velControlSettings(10.0, 20.0);
  motor2.velControlSettings(10.0, 20.0);
  motor3.velControlSettings(10.0, 20.0);
}

void loop() {
  // Calculate the current time
  current_time += 0.01;

  // Calculate the target angle for each motor
  float motor1_target = step_height * sin(2 * PI * current_time / step_period);
  float motor2_target = step_height * sin(2 * PI * current_time / step_period + 2 * PI / 3);
  float motor3_target = step_height * sin(2 * PI * current_time / step_period + 4 * PI / 3);

  // Setting the motor target position
  motor1.move(motor1_target);
  motor2.move(motor2_target);
  motor3.move(motor3_target);

  // Perform FOC control
  motor1.loopFOC();
  motor2.loopFOC();
  motor3.loopFOC();

  // delayed for a short period of time
  delay(10);
}

Key Points to Read.
The program uses the Arduino FOC library to control three motors and realize the gait control of the three-legged robot.
The target angle of each motor is calculated by setting the step_height and step_period.
The target angle is passed to the motor controller, which performs FOC control to make the motor move according to the designed gait.
Appropriate delay through the delay () function, so that the motor movement is smooth.

5. Balance control of a three-legged robot

#include <>
#include <>

// Motor parameters
BLDCMotor motor1 = BLDCMotor(7, 6, 5, 4, 3, 2);
BLDCDriver6PWM driver1 = BLDCDriver6PWM(9, 10, 11, 12, 13, 8);
BLDCMotor motor2 = BLDCMotor(14, 15, 16, 17, 18, 19);
BLDCDriver6PWM driver2 = BLDCDriver6PWM(20, 21, 22, 23, 24, 25);
BLDCMotor motor3 = BLDCMotor(26, 27, 28, 29, 30, 31);
BLDCDriver6PWM driver3 = BLDCDriver6PWM(32, 33, 34, 35, 36, 37);

// IMU sensors
MPU6050 imu;
float target_roll = 0.0;
float target_pitch = 0.0;

void setup() {
  // Motor initialization
  motor1.linkDriver(&driver1);
  motor2.linkDriver(&driver2);
  motor3.linkDriver(&driver3);
  motor1.init();
  motor2.init();
  motor3.init();
  motor1.initFOC();
  motor2.initFOC();
  motor3.initFOC();

  // IMU initialization
  imu.begin();

  // Set motor speed and acceleration
  motor1.velControlSettings(10.0, 20.0);
  motor2.velControlSettings(10.0, 20.0);
  motor3.velControlSettings(10.0, 20.0);
}

void loop() {
  // Read IMU data
  imu.update();
  float current_roll = imu.getAngleX();
  float current_pitch = imu.getAngleY();

  // Calculate the target angle
  target_roll = 0.0; // Stay still
  target_pitch = 0.0; // Stay still

  // Calculate the target angle for each motor
  float motor1_target = target_roll + target_pitch;
  float motor2_target = target_roll - 0.5 * target_pitch;
  float motor3_target = target_roll - 0.5 * target_pitch;

  // Setting the motor target position
  motor1.move(motor1_target);
  motor2.move(motor2_target);
  motor3.move(motor3_target);

  // Perform FOC control
  motor1.loopFOC();
  motor2.loopFOC();
  motor3.loopFOC();

  // delayed for a short period of time
  delay(10);
}

Key Points to Read.
The program uses the Arduino FOC library to control three motors and realize the balance control of the three-legged robot.
The current tilt angle (roll and pitch) of the robot is obtained via the MPU6050 IMU sensor.
The target angle for each motor is calculated based on the target angles (target_roll and target_pitch) and the current angle.
The target angle is transmitted to the motor controller, and the FOC control is executed to make the motor move according to the designed angle and realize the balance of the robot.
Appropriate delay through the delay () function, so that the motor movement is smooth.

6. Combining gait and balance for three-legged robot control

#include <>
#include <>

// Motor parameters
BLDCMotor motor1 = BLDCMotor(7, 6, 5, 4, 3, 2);
BLDCDriver6PWM driver1 = BLDCDriver6PWM(9, 10, 11, 12, 13, 8);
BLDCMotor motor2 = BLDCMotor(14, 15, 16, 17, 18, 19);
BLDCDriver6PWM driver2 = BLDCDriver6PWM(20, 21, 22, 23, 24, 25);
BLDCMotor motor3 = BLDCMotor(26, 27, 28, 29, 30, 31);
BLDCDriver6PWM driver3 = BLDCDriver6PWM(32, 33, 34, 35, 36, 37);

// IMU sensors
MPU6050 imu;
float step_height = 0.2;
float step_period = 1.0;
float current_time = 0.0;
float target_roll = 0.0;
float target_pitch = 0.0;

void setup() {
  // Motor initialization
  motor1.linkDriver(&driver1);
  motor2.linkDriver(&driver2);
  motor3.linkDriver(&driver3);
  motor1.init();
  motor2.init();
  motor3.init();
  motor1.initFOC();
  motor2.initFOC();
  motor3.initFOC();

  // IMU initialization
  imu.begin();

  // Set motor speed and acceleration
  motor1.velControlSettings(10.0, 20.0);
  motor2.velControlSettings(10.0, 20.0);
  motor3.velControlSettings(10.0, 20.0);
}

void loop() {
  // Calculate the current time
  current_time += 0.01;

  // Read IMU data
  imu.update();
  float current_roll = imu.getAngleX();
  float current_pitch = imu.getAngleY();

  // Calculate the target angle
  target_roll = 0.0; // Stay still
  target_pitch = 0.0; // Stay still

  // Calculate the target angle for each motor
  float motor1_target = step_height * sin(2 * PI * current_time / step_period) + target_roll + target_pitch;
  float motor2_target = step_height * sin(2 * PI * current_time / step_period + 2 * PI / 3) + target_roll - 0.5 * target_pitch;
  float motor3_target = step_height * sin(2 * PI * current_time / step_period + 4 * PI / 3) + target_roll - 0.5 * target_pitch;

  // Setting the motor target position
  motor1.move(motor1_target);
  motor2.move(motor2_target);
  motor3.move(motor3_target);

  // Perform FOC control
  motor1.loopFOC();
  motor2.loopFOC();
  motor3.loopFOC();

  // delayed for a short period of time
  delay(10);
}

Key Points to Read.
The program combines gait control and balance control to realize the integrated control of a three-legged robot.
By setting the step_height and step_period, the gait target angle of each motor is calculated.
The current tilt angle (roll and pitch) of the robot is obtained by the MPU6050 IMU sensor and the target angle is calculated.
The final target angle for each motor is obtained by adding the gait target angle and the balance target angle.
The target angle is passed to the motor controller, and the FOC control is executed to make the motor move according to the designed angle to realize the gait and balance of the robot.
Appropriate delay through the delay () function, so that the motor movement is smooth.

Note that the above examples are just for expansion of ideas and are for reference only. They may be buggy, inapplicable, or fail to compile. Your hardware platform, usage scenario and Arduino version may affect the choice of usage. When actually programming, you have to adjust it according to your hardware configuration, usage scenario and specific needs, and actually test it several times. You also need to connect the hardware correctly and understand the specifications and characteristics of the sensors and devices you use. For code that involves hardware operation, you have to confirm the correctness and safety of pins, levels, and other parameters before use.

在这里插入图片描述