The development and control of joint mechanisms constitute a fundamental research area in the field of bionic robotics. Multi-legged bionic robots, which mimic the locomotion of biological organisms, offer significant advantages in traversing rough, unstructured terrain. The functionality and dexterity of these bionic robots are directly dependent on the performance and precise control of their individual joints. Each joint represents a degree of freedom, and coordinated control across multiple joints enables complex, adaptive movement. This article explores, from a first-person implementation perspective, the design and realization of a control algorithm for a single joint in a miniature bionic robot system. The focus is on a practical, microcontroller-based approach using a stepper motor as the joint actuator, providing a foundational building block for more sophisticated multi-legged bionic robot platforms.
The core mechanical unit for a joint in our miniature bionic robot is constructed using a stepper motor. In this model, one link (Link 1) is fixed directly to the motor’s rotating shaft, while a second link (Link 2) is attached to the motor’s stationary body (stator). This arrangement creates a simple revolute joint where Link 1 can rotate relative to Link 2 within a single plane when the motor is actuated. By assembling multiple such units with appropriate linkages, one can construct the leg mechanisms for a multi-legged bionic robot. The choice of stepper motor determines the joint’s torque and resolution; for lightweight, slow-moving prototypes, a small, low-cost stepper like the 28BYJ-48 is sufficient.
The hardware system for controlling the bionic robot’s joint is centered on an STC89C52 microcontroller (MCU), an 8-bit controller based on the MCS-51 architecture. This MCU is responsible for executing the control algorithm and generating the precise pulse sequences required to drive the stepper motor. The stepper motor used is a unipolar, 5-phase type (28BYJ-48). As the MCU’s GPIO pins cannot source sufficient current to drive the motor coils directly, a driver IC is essential. The ULN2003, a high-voltage, high-current Darlington transistor array, is employed for this purpose. Each of its seven channels can sink up to 500mA, making it ideal for driving the stepper motor coils.
The connection schematic is straightforward: The lower four bits of the MCU’s Port 2 (P2.0 to P2.3) are connected to the inputs of four channels on the ULN2003 (In1 to In4). The corresponding outputs of the ULN2003 are connected to the four phases (A, B, C, D) of the stepper motor. A common ground connects the motor’s power supply and the logic circuit. The table below summarizes the key hardware components and their roles in the bionic robot joint system.
| Component | Model/Specification | Role in Bionic Robot Joint |
|---|---|---|
| Microcontroller (MCU) | STC89C52 (MCS-51 Core) | Central processing unit; executes control algorithm and generates pulse sequences. |
| Actuator | 28BYJ-48 Unipolar Stepper Motor (5V) | Provides precise angular displacement; forms the core of the mechanical joint. |
| Driver IC | ULN2003 Darlington Array | Amplifies the MCU’s low-current signals to drive the high-current motor coils. |
| Power Supply | 5V DC Regulated | Powers both the logic circuit (MCU) and the actuator (motor via driver). |
The control algorithm is the intelligence behind the bionic robot’s joint movement. Its primary function is to translate high-level commands (like “extend” or “retract”) into the correct sequence of electrical pulses sent to the stepper motor driver, thereby controlling the joint’s angular position. The algorithm is designed to be modular and parameter-driven for flexibility. It operates based on several key parameters and mathematical relationships.
First, we define the fundamental parameter of the stepper motor: the number of steps required for one full 360-degree rotation of the motor’s output shaft, denoted as **M**. This is not the motor’s full-step count but the effective count after considering the gear reduction inside motors like the 28BYJ-48. For our setup, $$ M = 4100 $$ steps/revolution. The angular displacement per step, or step angle $\theta_s$, is therefore:
$$ \theta_s = \frac{360^{\circ}}{M} $$
This high resolution allows for fine control of the bionic robot’s joint position.
The core algorithm function, which we can call `joint_control()`, takes the following input parameters and returns the updated joint position:
- command (cmd): An integer specifying the desired action (e.g., 1=Stop/Idle, 2=Extend/Joint Open, 3=Retract/Joint Close).
- current_position (p): The current step count position of the joint.
- home_offset (p0): A calibration offset that defines the “zero” or home position of the joint in the bionic robot’s mechanical frame.
- delay_time (t): A timing parameter that controls the delay between step pulses, effectively setting the joint’s rotational speed.
The algorithm’s logic flow and calculations are as follows:
- Position Calculation: The absolute step position within the motor’s range is calculated by adding the home offset to the logical position: $$ P_{absolute} = p + p_0 $$
- Command Processing:
- If `cmd == 1`: Set target $P_{target} = P_{absolute}$ (no movement).
- If `cmd == 2`: Set target $P_{target} = P_{absolute} + 1$ (move one step forward/extend).
- If `cmd == 3`: Set target $P_{target} = P_{absolute} – 1$ (move one step backward/retract).
- Pulse Generation: The MCU outputs the appropriate 4-bit control pattern to its port based on $(P_{target} \mod 8)$. For a unipolar stepper driven in 8-step (half-step) mode, a cyclic sequence of 8 patterns is used to ensure smooth rotation. A delay of `t` microseconds is introduced after setting the pattern to control speed.
- Boundary Enforcement: To prevent the bionic robot’s joint from exceeding its mechanical limits (wiring strain, physical stops), the calculated $P_{target}$ is constrained:
$$ p_0 \leq P_{target} \leq (p_0 + M – 1) $$
After enforcement, the logical position `p` is updated for the next cycle: $$ p = P_{target} – p_0 $$
The algorithm’s logic is concisely summarized in the following truth table/state transition table:
| Current State (cmd) | Input Command (new_cmd) | Action | Next Logical Position (p) | Boundary Condition |
|---|---|---|---|---|
| Any | 1 (Stop) | Maintain current output pattern; no step change. | p (unchanged) | N/A |
| Any | 2 (Extend) | Output next pattern in sequence; increment step. | p + 1 | If (p+1) >= M, then p = M-1 |
| Any | 3 (Retract) | Output previous pattern in sequence; decrement step. | p – 1 | If (p-1) < 0, then p = 0 |
The software implementation for the bionic robot joint is written in C for the KEIL µVision development environment. The code is structured into header files for definitions and the main application file. Key components include the step pattern array, the fundamental delay function, the core algorithm function, and the main control loop.
The 8-step control sequence for smooth half-step operation is stored in an array:
unsigned char step_sequence[8] = {0x08, 0x0C, 0x04, 0x06, 0x02, 0x03, 0x01, 0x09}; // Active-low for P2.0-P2.3
A precise delay function is crucial for speed control. The following function generates a delay in multiples of 50 microseconds for an 11.0592 MHz crystal:
void delay_50us(unsigned int n) {
unsigned char i, j;
do {
j = 134;
do {
while (--j);
} while (--i);
} while (--n);
}
The core control algorithm is implemented as a function `int step_joint(int cmd, int pos, int home, int spd)`.
#define MOTOR_STEPS_PER_REV 4100 // M
int step_joint(int cmd, int pos, int home, int spd) {
int absolute_pos;
// 1. Calculate absolute motor step position
absolute_pos = pos + home;
// 2. Process command to determine target absolute position
switch(cmd) {
case 1: // STOP
// target = absolute_pos (no change)
break;
case 2: // EXTEND
absolute_pos++;
break;
case 3: // RETRACT
absolute_pos--;
break;
default:
// Invalid command, treat as stop
break;
}
// 3. Enforce mechanical boundaries for the bionic robot joint
if (absolute_pos > (home + MOTOR_STEPS_PER_REV - 1)) {
absolute_pos = home + MOTOR_STEPS_PER_REV - 1;
}
if (absolute_pos < home) {
absolute_pos = home;
}
// 4. Output the corresponding control pattern to the motor driver
// Clear lower 4 bits of Port 2, then set them according to the sequence.
P2 = (P2 & 0xF0) | step_sequence[absolute_pos % 8];
// 5. Implement speed control via delay
delay_50us(spd);
// 6. Return the new logical position to the caller
return (absolute_pos - home);
}
The main application loop for the bionic robot’s control system continuously polls input sources (such as tactile switches or commands from a higher-level gait controller) and calls the `step_joint()` function accordingly.
void main(void) {
int joint_command = 1; // Start in STOP state
int joint_position = 0;
int joint_speed = 100; // Determines motion speed (larger = slower)
const int joint_home_offset = 2000; // Calibrated zero position
// Configure I/O pins if needed
// ...
while(1) { // Superloop architecture
// Read from sensors or communication module to determine command
// Example: Reading from push buttons
if (extend_button_pressed) {
joint_command = 2;
} else if (retract_button_pressed) {
joint_command = 3;
} else {
joint_command = 1; // Stop if no button is pressed
}
// Optional: Read from a potentiometer or serial command to set speed
// joint_speed = read_speed_potentiometer();
// Execute the joint control algorithm for one step
joint_position = step_joint(joint_command,
joint_position,
joint_home_offset,
joint_speed);
// The function updates the physical joint and returns its new position.
}
}
The table below summarizes the key functions and variables in the software implementation for the bionic robot joint controller.
| Element Name | Type | Description |
|---|---|---|
| `step_sequence[8]` | Array | Pre-computed byte patterns for 8-step (half-step) motor control. |
| `MOTOR_STEPS_PER_REV` | Macro Constant | The number of steps (M) for one full motor revolution (4100). |
| `delay_50us(n)` | Function | Creates a delay of n * 50 microseconds for timing control. |
| `step_joint(cmd, pos, home, spd)` | Function | Core control algorithm. Manages position, boundaries, and pulse output. |
| `joint_position` | Variable | Stores the current logical step position of the bionic robot’s joint (0 to M-1). |
| `joint_home_offset` | Constant/Variable | Calibration offset mapping logical zero to a specific motor step. |
| `joint_speed` | Variable | Parameter ‘spd’ passed to `step_joint()`; controls the delay between steps. |
The proposed control algorithm and hardware setup were rigorously tested on a physical joint model for the bionic robot. The experimental platform consisted of the STC89C52 MCU board, a ULN2003 driver module, and a 28BYJ-48 stepper motor forming the joint. Tests were conducted to validate functionality, correctness, and limitations.
1. Basic Motion Tests: The joint was commanded to perform discrete operations: extension, retraction, speed variation (by changing the `spd` parameter), and pause. The joint reliably responded to each command, moving in discrete angular increments. The motion was observed to be smooth in half-step mode, and the joint could rotate nearly 360 degrees, closely mimicking the revolute motion of a biological joint. This confirmed the basic correctness of the algorithm in translating digital commands into physical motion for the bionic robot.
2. Boundary Enforcement Test: The joint was commanded to extend continuously. Upon reaching the software limit (defined by `M` and `home_offset`), the position variable saturated, and the motor ceased stepping, despite ongoing “extend” commands. This prevented potential damage from over-rotation, proving the safety and practicality of the algorithm’s constraint logic.
3. Feasibility for Prototyping: The entire system demonstrated the feasibility of using low-cost, readily available components (8-bit MCU, simple driver IC, inexpensive stepper motor) to create a controllable joint for a miniature bionic robot. The modularity of the `step_joint()` function allows it to be replicated for multiple joints, with each instance maintaining its own position state.
4. Performance Limitations Identified: Testing revealed inherent limitations of the chosen actuator for a dynamic bionic robot. The 28BYJ-48 motor, while precise, is relatively slow and has low torque. The relationship between speed (`spd`), step delay, and achievable rotational velocity $\omega$ is given by:
$$ \omega = \frac{\theta_s}{t_{step}} = \frac{360^{\circ} / M}{\text{spd} \times 50 \mu s} $$
For example, with `spd=100`, $$ \omega \approx \frac{0.088^{\circ}}{5 ms} \approx 17.6^{\circ}/s $$. This results in slow limb movement. Furthermore, the torque is insufficient for lifting significant payloads or performing rapid accelerations. These observations are critical for bionic robot design: higher-performance applications require more powerful motors (like NEMA steppers or servos) and correspondingly robust drivers (like specialized stepper drivers or H-bridges), though the fundamental control algorithm structure remains largely applicable.
5. Educational Utility: Beyond direct application in a bionic robot, this platform serves as an excellent educational tool. The direct correlation between the software parameters (command, position, speed), the algorithm’s execution, and the immediate physical response of the joint model allows students to concretely understand the principles of digital motion control in embedded systems and robotics.
The exploration and implementation detailed in this article successfully demonstrate a complete, functional control solution for a single joint in a bionic robot. By integrating an STC89C52 microcontroller, a ULN2003 driver, and a stepper motor, we constructed a hardware platform capable of precise angular positioning. The developed control algorithm, characterized by its parameter-driven design incorporating command processing, step sequencing, speed control, and boundary enforcement, was proven to be correct, practical, and feasible for prototype-grade bionic robots.
The significance of this work lies in its provision of a concrete theoretical and practical foundation. The mathematical models for step resolution and speed, the structured software architecture, and the empirical test results collectively form a reproducible blueprint. This blueprint can be directly used to construct the joints for slow-moving, lightweight multi-legged bionic robots for research or educational purposes.
For future development of more capable bionic robots, the path forward involves scaling the core concepts presented here. The control algorithm’s state machine logic is portable to more powerful microcontrollers (e.g., ARM Cortex-M series). The stepper motor can be replaced with higher-torque variants or even DC brushless motors, requiring more advanced drivers but benefiting from the same fundamental positional control philosophy. Integrating feedback from sensors like encoders or potentiometers would transform the open-loop system into a closed-loop one, enhancing accuracy and reliability under load—a critical step for autonomous bionic robots operating in real-world environments. Thus, this implementation serves as a vital foundational step in the broader journey of designing and deploying sophisticated, agile, and intelligent bionic robot systems.