Throughout my years of teaching engineering students, I have observed a persistent gap between theoretical knowledge and the hands-on skills required to succeed in the rapidly evolving robotics industry. The field of humanoid robot development is particularly demanding, because it brings together mechanics, electronics, control science, computer science, communications, materials science, and many other disciplines. In this article, I describe my experience and reflections on reforming the practical training course for humanoid robots through an industry–university cooperation model. The goal is to improve students’ practical abilities and innovation capacity while meeting the needs of a technology-driven society.
A humanoid robot, by definition, resembles the human body in shape and motion. It can walk, grasp, gesture, interact, and even express emotions. Because of these capabilities, humanoid robots are increasingly used in healthcare, nursing, domestic services, education, entertainment, agriculture, and disaster response. The market potential is enormous, and consequently there is a growing demand for professionals who not only understand the underlying algorithms but also know how to deploy, maintain, and innovate with humanoid robot systems. My teaching reform focuses on the biped humanoid robot as a platform for integrating multidisciplinary knowledge and cultivating real-world engineering skills.
The reform was initiated under the umbrella of an industry–university collaborative education project. Our college partnered with a robotics company to jointly design a practical training course for humanoid robots. We aimed to replace the traditional lecture-oriented approach with a project-driven, competition-inspired, and team-based learning environment. The core philosophy is to place the student at the center, guide rather than dominate, and let the physical humanoid robot act as an interactive learning partner. In the following sections, I share the details of this reform, including cooperation model innovation, content organization, teaching methods, assessment redesign, and a concrete case study.
Motivation for the Course Reform
Before the reform, many of our engineering courses were heavily focused on theoretical foundations. Students told me that they could recite the equations of kinematics and dynamics, but they could not implement a simple walking gait on a real robot. They lacked confidence in using development tools, reading sensor data, or debugging embedded code. At the same time, our students had received vocational training earlier in their education, so they possessed decent manual dexterity and a practical orientation. They were eager to work with tangible systems rather than only abstract mathematical derivations.
Surveys conducted in my department showed that over 70% of students wanted more laboratory hours and more opportunities to build complete robotic systems. Employers visiting our campus repeatedly expressed the same message: they value graduates who can integrate hardware and software, work in teams, and solve open-ended problems. The humanoid robot course was therefore designed to address these needs directly.
The course is offered to students majoring in software engineering, communication engineering, computer science, and related fields. It presumes basic programming knowledge and some familiarity with operating systems. Since humanoid robot development spans many layers from the microcontroller to the high-level vision processing, the course bridges the gap between low-level control and high-level intelligence.
Innovation in Cooperation Model
The first major innovation is the way we cooperate with industry. Instead of a one-way donation of equipment or a simple guest lecture, we established a co-creation mechanism. The company provides not only the latest biped humanoid robotics platforms but also technical engineers who help define the curriculum, provide training for our faculty, and update the teaching content with cutting-edge industrial practices.
Our college, in turn, contributes pedagogical expertise, teaching infrastructure, and the capacity to evaluate learning outcomes. We jointly developed a set of learning objectives that reflect both academic rigor and industrial relevance. The cooperation model can be summarized in a comparative table.
| Dimension | Traditional Model | Our Reformed Model |
|---|---|---|
| Role of industry | Provides donations or internships | Co-designs curriculum and content |
| Role of university | Defines curriculum independently | Co-creates with industry partners |
| Equipment | Generic lab equipment | Latest biped humanoid robot platforms |
| Teaching approach | Lecture-first | Project-first, theory integrated |
| Assessment | Written exams | Team competition + technical report + presentation |
| Outcome focus | Knowledge recall | Application, synthesis, evaluation |
This cooperation model is deeply aligned with the national strategy for industry–university collaborative education. It emphasizes mutual benefit: the company gains access to talented young people and can influence their skills; the university gains access to advanced technology and real-world problem scenarios. I have found that this reciprocity is essential for the sustainability of the cooperation.
To make the dual-benefit explicit, we defined a cooperation effectiveness indicator. Let $R$ denote the relevance score of course content to industrial practice, $S$ the satisfaction score of students, and $F$ the faculty development score (all measured on a 100-point scale). The cooperation performance index $C_{pi}$ can be expressed as
$$
C_{pi} = w_1 R + w_2 S + w_3 F,
$$
where $w_1$, $w_2$ and $w_3$ are weights such that $w_1 + w_2 + w_3 = 1$. In my course, I set $w_1 = 0.4$, $w_2 = 0.3$, and $w_3 = 0.3$, because relevance to industry is the top priority.
Innovation in Course Content Organization
The second innovation lies in how we organize the course content. Rather than following a single linear textbook, we divide the course into modular thematic units. This modular structure allows students to build knowledge gradually while seeing how each module connects to a complete humanoid robot system. The whole course is segmented into three broad parts: the application part, the technology part, and the intelligence part.
| Part | Content Area | Key Topics | Approximate Hours |
|---|---|---|---|
| Application | Introduction and use | History of humanoid robots, market trends, system architecture, safe operation | 6 |
| Technology | Hardware and software | Mechanical structure, sensors, actuators, embedded control, Linux, Python | 12 |
| Intelligence | Perception and autonomy | Vision processing, speech interaction, path planning, reinforcement learning basics | 12 |
| Project | Comprehensive practice | Team competition, robot programming, debugging, demonstration | 2 weeks |
The application part begins with a total overview. I deliberately avoid diving into equations on the first day. Instead, I show videos of humanoid robots walking, dancing, playing soccer, and assisting in hospitals. I bring a physical robot to the classroom and let students press buttons, watch its movements, and ask questions. This activity sparks curiosity and helps them identify their interests.
In the technology part, students learn the core subsystems of a humanoid robot. For example, the walking mechanism is an excellent example of multi-body dynamics. The inverted pendulum model is often used to simplify the gait analysis. The equation of motion for a linear inverted pendulum with mass $m$, center-of-mass height $h$, and horizontal position $x$ can be written as
$$
\ddot{x} = \frac{g}{h} x + \frac{u}{m h},
$$
where $u$ is the horizontal control force and $g$ is the gravitational acceleration. Students do not need to derive this equation fully, but they must understand its implications for balance control. Such mathematical tools are introduced just-in-time, not as a disconnected theory.
For the intelligence part, students use Python and OpenCV to process camera images. A classic exercise is to detect a colored ball or an ArUco marker. The visual detection pipeline can be expressed as a series of transformations from the image coordinate frame to the robot coordinate frame. If a point has pixel coordinates $(u, v)$ and depth $d$, the 3D position in the camera frame is
$$
\begin{bmatrix}
X_c \\ Y_c \\ Z_c
\end{bmatrix}
=
d \cdot
\begin{bmatrix}
(u – c_x)/f_x \\
(v – c_y)/f_y \\
1
\end{bmatrix},
$$
where $f_x$ and $f_y$ are the focal lengths and $(c_x, c_y)$ is the principal point. Once students understand this mapping, they can command the humanoid robot to approach a ball or kick it into a goal. Being able to see the direct consequence of their code immediately is what makes the course magical.
Innovation in Teaching Methodology
The third innovation is the shift from didactic instruction to guided, discussion-based learning. I call this the “coach rather than lecturer” philosophy. In the reformed classroom, the teacher does not stand in front of the blackboard for the entire session. Instead, each class session is structured around a short demonstration, followed by group challenges and peer discussions.
Students are divided into small teams of three or four members, based on their interests and complementary skills. Each team selects a particular type of humanoid robot or a particular research direction, such as walking control, obstacle avoidance, or human-robot interaction. I help each team formulate a learning plan and recommend reference materials, laboratory guides, and online resources. The students are then expected to conduct self-learning outside of the classroom. The in-class time is reserved for discussion, troubleshooting, and deeper exploration.
To make this work, I introduced a semi-flipped classroom structure. Before each weekly meeting, the team must complete a small programming assignment or a sensor calibration task. During the meeting, each team presents their findings, the obstacles they encountered, and the solution they developed. This process mirrors real engineering practice, where collaboration and communication are as important as technical expertise.
One of my favorite activities is the “gait debugging circle.” After the students load a basic walking program onto a biped humanoid robot, the robot often falls or walks awkwardly. Each team must observe the failures, hypothesize the causes, and adjust parameters such as step length, step height, or hip offset. The iterative learning cycle can be modeled as
$$
\text{Learning gain} = \sum_{i=1}^{n} \left( \frac{\text{Problem understanding}_i}{\text{Time spent}_i} \right),
$$
where $i$ indexes each debugging iteration. This formula is not meant to be quantitative, but it illustrates the importance of rapid prototyping and reflection.
Another valuable method is the use of multimedia and physical robots in parallel. Theoretical explanations are accompanied by short video clips, simulation software, and real robot demonstrations. I have noticed that students learn faster when they can see the direct relationship between lines of code and the movement of the humanoid robot’s joints. For example, when teaching joint control, I show how a sinusoidal reference trajectory $\theta_r(t)$ for a joint can be expressed as
$$
\theta_r(t) = A \sin(2\pi f t) + \theta_{\text{offset}},
$$
where $A$ is the amplitude, $f$ is the frequency, and $\theta_{\text{offset}}$ is the neutral position. The students immediately see how changing $A$ changes the walking stride.
Innovation in Assessment Methods
The fourth innovation is the redesign of assessment. Traditional exams cannot capture whether a student can actually make a humanoid robot perform a task. Therefore, I replaced the final written exam with a comprehensive team competition and technical report. The competition requires each team to demonstrate a set of skills on the physical robot, such as walking through a gate, climbing stairs, kicking a ball, or performing a choreographed dance. Each student must also present their individual contribution to the team project and answer questions from the instructor and the industry partner.
The overall grade is calculated both individually and as a team. The team performance score $T$ is based on the competition results, while individual scores $I_j$ are based on the presentation, the report section, and peer review. Let $G_j$ be the final grade for student $j$. One possible formula is
$$
G_j = 0.5 \times T + 0.3 \times I_j + 0.2 \times R_j,
$$
where $R_j$ is the quality of the individual technical report section assigned to that student. All scores are normalized to 100 points. This assessment scheme reduces free-riding because the individual score is partly determined by peer evaluation and the instructor’s direct questioning.
To make the grading more transparent, I use a rubric with five performance levels for each criterion. The rubric covers correctness, creativity, collaboration, communication, and completeness. Table 5 shows an example of the rubric applied to the competition execution.
| Criterion | Excellent (90–100) | Good (75–89) | Satisfactory (60–74) | Needs improvement (0–59) |
|---|---|---|---|---|
| Task completion | All tasks completed missed | Most tasks completed | Some tasks completed | Few tasks completed |
| Innovation | Novel solution beyond requirements | Some creative elements | Standard solution | No evidence of innovation |
| Technical quality | Robust, efficient code | Occasional crashes but works | Struggles to run reliably | Non-functional |
| Teamwork | Clear role distribution, mutual support | Most members active | Some members passive | Poor coordination |
After the course, the best teams are selected to participate in national or international robot competitions. This “competition as extension” approach has proven extremely effective. Students train harder, because they have a real audience, and they learn to deal with time pressure and unexpected hardware failures. I have seen shy students become confident leaders during these competitions.
Case Study: Aelos Practical Training with AirTag
To illustrate the concrete implementation of my reformed course, I present a case study based on a practical training module called “Aelos Training with AirTag.” This module uses a small biped humanoid robot and follows a six-step learning path. The detailed teaching plan is shown below.
| Step | Content | Detailed requirements | Hours |
|---|---|---|---|
| 1 | Robot operation basics | (1) Learn the primary parameters of the robot. (2) Understand the hardware structure. (3) Use the desktop software to adjust and run predefined actions. | 2 |
| 2 | Raspberry Pi development environment | (1) Flash the system image. (2) Learn Linux operating system essentials. (3) Install remote connection software. (4) Set up the software development environment. | 2 |
| 3 | Python programming basics | (1) Variables and operations. (2) Conditionals. (3) Loops. (4) Functions and objects. (5) Installing and using third-party libraries. | 2 |
| 4 | Controlling the robot with Python | (1) Understand the basic logic of Lua programs on the microcontroller. (2) Learn communication interfaces between Python and the robot. (3) Run existing action examples and write simple Python programs to control robot movement. | 2 |
| 5 | Introduction to vision processing | (1) Access the robot camera and read camera data with Python. (2) Use OpenCV methods to recognize colors and shapes. (3) Learn how to detect ArUco markers. | 2 |
| 6 | Comprehensive practice and challenge | (1) Within a specified timeframe, perform a complete robot dance synchronized with music. (2) The competition area is 3 m × 3.5 m. The robot must complete the following tasks: ① walk straight through a horizontal bar without touching it; ② walk straight over a bridge with length 60 cm, width 30 cm, and QR-code markers at both ends; ③ pass through the center of a gate with height 62 cm, width 30 cm, frame thickness 3 cm, and a QR-code marker near the frame; ④ walk upright up a staircase with three steps, each 3 cm high, 40 cm wide, and 15 cm long, with a QR-code marker at the first step; ⑤ kick a golf ball into a hole with diameter 10 cm, marked with a QR-code near the hole, with the ball placed 50 cm from the hole. The robot may make multiple attempts. After finishing, the robot executes a “bow” action, indicating that the project is complete. | 2 weeks |
In step 4, students often encounter the challenge of mapping Python data to low-level joint commands. The serial communication protocol between the Raspberry Pi and the robot’s microcontroller can be abstracted as a command frame
$$
\text{Frame} = [\text{Header} \;|\; \text{ID} \;|\; \text{Length} \;|\; \text{Data} \;|\; \text{Checksum}].
$$
The robot receives a frame containing the desired joint angles, for example $\theta_1, \theta_2, \ldots, \theta_n$. The microcontroller maps these angles to pulse-width modulation signals. If the communication is incorrect, the robot may freeze or move erratically. Students learn to use a logic analyzer or to print debugging messages in Python to verify the integrity of the frame.
In step 5, the visual recognition part is particularly engaging. Using OpenCV, students first convert the camera image to the HSV color space to detect a green ball. The code snippet can be written in Python as follows:
import cv2
import numpy as np
cap = cv2.VideoCapture(0)
while True:
ret, frame = cap.read()
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
lower = np.array([35, 50, 50])
upper = np.array([85, 255, 255])
mask = cv2.inRange(hsv, lower, upper)
contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
for c in contours:
area = cv2.contourArea(c)
if area > 1000:
x, y, w, h = cv2.boundingRect(c)
center = (int(x + w/2), int(y + h/2))
cv2.circle(frame, center, 5, (0, 0, 255), -1)
cv2.imshow('frame', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()I do not require every student to write every line from memory, but they must be able to modify the parameters and explain the logic. The most rewarding moment is when the humanoid robot successfully detects the ball, turns toward it, and kicks it into the hole. Students scream and high-five each other. This emotional engagement is what drives deep learning.
For the dance challenge, students need to synchronize the robot’s motions with music. They break the music into segments and design action sequences for each beat. This task combines creativity, rhythm, and programming. One team even implemented a simple beat detection algorithm that annotated the energy envelope of a song. The instantaneous energy $E(t)$ can be approximated as
$$
E(t) \approx \sum_{k=0}^{N-1} |x(t-k)|^2,
$$
where $x(n)$ is the audio signal. If the energy exceeds a threshold, the robot triggers the next dance move. This is a wonderful example of humanoid robot integration with digital signal processing.
Challenges and Solutions
Of course, the reform was not without challenges. The first obstacle was the cost of humanoid robot platforms. Biped humanoid robots with high-degree-of-freedom (DOF) joint control are expensive. To address this, we developed a two-tier strategy: each team has access to one physical robot for the final weeks, while during the earlier stages, a software simulator is used. The simulator supports the same programming interface as the physical robot, so students can develop and test code virtually before transferring it to the real hardware.
The second challenge was faculty readiness. Not all teachers are familiar with the Linux environment, Python, OpenCV, or ROS. I organized a series of faculty training workshops delivered by the industry partner’s engineers. I also encouraged team teaching, where a veteran professor and a young faculty member co-teach a session. The learning curve is steep, but the reward is high.
The third challenge was evaluation fairness. In team projects, some students may rely on others. To mitigate this, I introduced individual checkpoints throughout the project. Each student must present their own code and explain the source code line by line. I also used peer evaluation, where each team member rates every other member on a scale from 1 to 5. The peer score $P_j$ for student $j$ is computed as
$$
P_j = \frac{1}{m-1} \sum_{k=1, k\neq j}^{m} r_{kj},
$$
where $m$ is the number of team members and $r_{kj}$ is the rating given by member $k$ to member $j$. This score contributes to the individual component $I_j$ in the final grade formula.
The fourth challenge was keeping the course content up to date. Humanoid robot technology advances rapidly. I solve this by making the course content modular and by inviting industry engineers to share their latest research or product updates once a month. The students have direct access to real-world cases, such as how a humanoid robot maintains balance using a gyroscope and accelerometer.
One important theoretical aspect is the balance control of a biped humanoid robot. A simplified model is the inverted pendulum. The linearized state-space representation around the upright position is
$$
\begin{bmatrix}
\dot{x} \\ \ddot{x}
\end{bmatrix}
=
\begin{bmatrix}
0 & 1 \\
\frac{g}{h} & 0
\end{bmatrix}
\begin{bmatrix}
x \\ \dot{x}
\end{bmatrix}
+
\begin{bmatrix}
0 \\
\frac{1}{m h}
\end{bmatrix}
u.
$$
I explain this equation not as abstract math but as a tool for tuning a PID controller. The control law is
$$
u(t) = K_p e(t) + K_i \int_{0}^{t} e(\tau) d\tau + K_d \frac{d e(t)}{dt},
$$
where $e(t)$ is the tilt angle error. In the lab, students adjust $K_p$, $K_i$, and $K_d$ on a simulated inertia wheel pendulum before applying the strategy to the humanoid robot. They observe how a high $K_p$ makes the robot rigid but shaky, while a high $K_d$ damps the oscillations but may amplify noise. This hands-on tuning experience is far more effective than rote memorization of the formula.
Another challenge is accommodating students with different skill levels. Some incoming students have never touched Python; others have been coding for years. I use differentiated tasks. The basic tasks must be completed by everyone, while advanced tasks offer extra credit. For example, in the vision module, the basic task is to detect a colored ball. The advanced task is to estimate the ball’s distance from the camera using its known diameter and the pinhole model. The distance $Z$ is given by
$$
Z = \frac{f \cdot D_{\text{real}}}{D_{\text{pixel}}},
$$
where $f$ is the focal length in pixels, $D_{\text{real}}$ is the real diameter, and $D_{\text{pixel}}$ is the diameter measured in the image. Advanced students can then program the humanoid robot to stop at a fixed distance from the ball before kicking it.
Evidence of Success
After two full teaching cycles, I gathered both quantitative and qualitative evidence of success. The average final project score increased by 15% compared with the previous traditional exam-based offering. Student attendance in the optional lab hours increased from 50% to 92%. More importantly, students began to stay after class to continue debugging their humanoid robots, even when no extra credit was offered.
I collected pre-course and post-course self-assessments from students regarding their confidence in humanoid robot-related skills. The results are summarized in the following table.
| Skill area | Pre-course average (out of 5) | Post-course average (out of 5) | Improvement (%) |
|---|---|---|---|
| Programming with Python | 2.1 | 4.2 | 100% |
| Using Linux commands | 1.9 | 3.8 | 100% |
| Understanding robot kinematics | 2.0 | 4.0 | 100% |
| Visual servoing / OpenCV | 1.5 | 3.9 | 160% |
| Debugging embedded systems | 1.8 | 3.9 | 117% |
| Team-based project management | 2.3 | 4.4 | 91% |
The improvement percentage is computed as
$$
\Delta = \frac{M_{\text{post}} – M_{\text{pre}}}{M_{\text{pre}}} \times 100\%.
$$
Clearly, the most significant gain was in visual servoing, which is also the most challenging topic. This suggests that the hands-on humanoid robot context strongly enhances the learning of abstract computer vision concepts.
Furthermore, students in the reformed course won prizes in several robot competitions. One team developed an innovative humanoid robot routine that could autonomously detect a table and perform a pick-and-place task. Another team used a humanoid robot to simulate a rehabilitation exercise for elderly people, which sparked interest from a local hospital. These achievements demonstrate not only technical ability but also social awareness and creativity.
Reflection and Future Directions
Reflecting on the entire experience, I strongly believe that the humanoid robot training course is not merely about teaching robotics; it is about transforming the way students approach engineering. They learn to embrace failure, because debugging a falling robot is inevitable. They learn to communicate, because a humanoid robot project cannot be completed alone. They learn to explore, because new libraries and sensors appear constantly. And they learn to innovate, because the ultimate goal is not to reproduce a fixed solution but to create something meaningful.
However, I also realize that there is room for improvement. In future iterations, I plan to incorporate more artificial intelligence techniques, such as deep reinforcement learning, into the course. The state-of-the-art biped humanoid robot control increasingly relies on trained policies that map sensory inputs to joint commands. A simplified policy gradient objective can be written as
$$
\nabla_\theta J(\theta) = \mathbb{E}_{\tau \sim \pi_\theta}
\left[ \sum_{t=0}^{T} \nabla_\theta \log \pi_\theta(a_t|s_t) R(\tau) \right],
$$
where $\pi_\theta$ is the policy, $s_t$ and $a_t$ are the state and action at time $t$, and $R(\tau)$ is the cumulative reward for a trajectory. Although this formula is too advanced for most undergraduate students, I can demystify it by using simulations and pre-trained models. Students can observe how a virtual humanoid robot learns to walk from scratch, starting with random flailing and gradually improving.
Another direction is to integrate digital twin technology. Each physical humanoid robot is coupled with a digital twin in a virtual environment. Students can simulate an action in the digital twin, verify its safety, and then deploy it on the physical robot. This reduces hardware wear and allows faster experimentation. The digital twin also makes it easier to teach concepts like torque limits and joint velocity constraints.
Finally, I want to expand the industry–university cooperation to include more companies and research institutes. The humanoid robot ecosystem consists not only of robot manufacturers but also sensor suppliers, AI algorithm providers, and application integrators. By inviting engineers from various stakeholders to share their perspectives, students will gain a richer understanding of the humanoid robot industry and their possible career paths.
In conclusion, the reform of the humanoid robot training course has been a rewarding journey. Through cooperation model innovation, content organization, teaching methods, and assessment reform, I have seen students grow from passive listeners into active creators. The physical humanoid robot, with all its mechanical and computational complexity, becomes the perfect catalyst for multidisciplinary learning. As the humanoid robot field continues to expand, I am committed to continuously improving this course so that our graduates can meet the demands of the future and even shape it.