robowalker_train: a RoboMaster control curriculum in Chinese

A team's teaching notes, published as a syllabus

The repository is the training notes of the RoboWalker team at the University of Science and Technology of China, for the RoboMaster competition, and it comes from the team's electrical control group. The description in the repository metadata says exactly that.

The stated purpose is worth quoting in substance, because it explains the shape of the whole thing. The course is for electrical control teaching, it contains a number of large and small technical points, and it is meant to let a team that is just starting get up to speed quickly, and to let a team whose research and knowledge transfer is hard and whose technical accumulation is thin avoid some of the wasted effort.

That is a curriculum, not a library. The top-level listing confirms it: 01_electrical/ for the first volume, 02_electrical_plus/ for the advanced one, robowalker_train_slides/ for the slide decks, markdown.assets/ for the images the documents embed, and readme.md at the root, which is the table of contents. The primary language is recorded as C, which fits the subject matter, and the licence field is empty with no licence file in the listing, so the terms for reuse are unstated.

The last push was on 2026-09-17, the repository is not archived, and it publishes no GitHub releases, which is what you would expect from a set of course notes rather than a package.

Three mirrors, because of how the hosting worked out

The overview section is where the practical information lives, and it is the part to read first if you are a newcomer.

There are three mirrors of the same content, and the README explains why. The code and related files are identical across them, and you are advised to pick according to your network conditions. The Gitee copy has a capacity limit, and since this repository is relatively large, the project was moved to GitHub and to the University of Science and Technology of China's internal GitLab on 2023-08-24. The original Gitee link still works, but it is not kept up to date.

So there are two current copies, at git.ustc.edu.cn/yssickjgd/robowalker_train and at github.com/yssickjgd/robowalker_train, and one stale one.

The supporting files are scattered across a similar set of places, and each has its own footnote. There is a matching set of teaching videos in a playlist on Bilibili, an environment configuration installer package on the author's own home page at the university, and the slide decks on the university's cloud drive, which are there because the old Rec netdisk stopped being maintained and the old link will stop working.

That is a slightly awkward arrangement for a reader outside China, and it is worth knowing before you start: the code, the slides, the videos and the toolchain are four separate downloads from four different hosts, and the slides are the one that has already moved once.

The first volume, chapter by chapter

The table of contents is the clearest description of the contents, and the eight chapters follow the order in which a robot actually has to be built.

The first chapter is an introduction to electrical control, with a side piece on how to ask questions well, which is a surprisingly valuable thing to teach a new team. The second is STM32CubeMX basics, covering environment setup, GPIO output voltage, external interrupts, timer interrupts with homework, UART communication, a PWM breathing light and measuring voltage with the ADC.

The third is motor control, and it is the longest chapter. It starts with C++ as applied to this work, then CAN communication, the CAN interface and a first pass at controlling a DJI RM motor, UART and serial plotting, serial plotting with motor feedback, the PID algorithm, a PID interface and motor closed-loop control, multi-loop PID across the motor interface, dynamic targets with feedforward PID, multi-motor control, and two side chapters on the Damiao motor and on advanced DJI motor control with the accumulation of related libraries.

The fourth is tooling, covering Markdown, the basics of Git, setting up CLion, gcc with Make and CMake, an aside on pulling in the arm_math.h maths library, where to get the official software and documentation, and how to debug.

The fifth is the chassis, seventeen topics from the DR16 and DT7 remote modules through kinematics and dynamics, Euler angles and rotation matrices, force compensation, power control lookahead, a motor power model, power control strategy, a ramp planner in the algorithm layer, small-gimbal travel, follow travel, Mecanum and omni-wheel adaptation, steering wheel adaptation, the operating logic, the watchdog in the driver layer, and a side chapter on buffered energy power control without power feedback.

The sixth is the gimbal, the seventh the booster with its finite state machine, jam handling and heat control, and the eighth the referee system, covering the protocol, the user agreement parsing, double buffering and packet-sticking handling, three side chapters on networking basics and two on checksums and CRC.

The second volume: observers, LQR, IMU fusion and everything else

The advanced volume is where a team that has already built one robot goes next.

It opens with a Damiao board and the H7 series, covering USB in general, USB virtual serial ports, the Vofa+ plotting tool, FD-CAN communication, using RM motors with the board, SPI with WS2812 custom lights, OSPI with the W25Q64 storage chip, and a closing look at the future of embedded work.

Then the observer chapter, which is the most academic part: an introduction to observers, the Luenberger observer, the Kalman filter from a matrix analysis foundation, from a probability and statistics foundation, and then its use to improve motor feedback speed, the principles section, the extended Kalman filter, and a long run of side chapters on signal preprocessing, frequency-selective filtering, its signal systems and frequency domain foundations, its use for motor current, and its principles.

The IMU chapter covers the IMU in general, a supplement on Euler angles and rotation matrices, the axis-angle method and rotation vectors, quaternions and rotation matrices, six-axis IMU attitude solving, the interface and the read and write scheduler, calibration, an EKF implementation of six-axis attitude solving, the adaptation algorithm and a summary.

The controller chapter revisits PID, then introduces LQR with system modelling, applies it to a two-axis gimbal, and closes with the principles. The wheel-legged robot chapter has the overview, the kinematics and dynamics model, the LQR controller construction and the adaptation algorithm. Then supercapacitors, with the communication interface, strategy and power control adaptation, the auto-aiming system with its interface, strategy and gimbal control adaptation, navigation with the same three-part structure, and finally a chapter on working as a team, covering setting up a team, what the mechanical, hardware, vision and media groups each do, and seven side chapters on motor selection, Solidworks modelling, a 3D printer, PCB design, graphic design, technical review and streaming.

That last chapter is the one that makes this a team document rather than an engineering one, and it is also the one a reader outside a competition will find least useful.

Two toolchains, chosen on purpose

The tutorials use two development environments, and the README explains the split rather than just listing it.

The Keil environment is the simpler one and easy for a beginner to get going with. Its setup teaching sits in the electrical introduction and the STM32CubeMX basics chapter, and because the second and third chapters, the STM32 basics and the motor control, are the more basic parts of the course, they are developed in that environment.

The CLion environment needs much more manual configuration, and the README says that if you want to understand the configuration process fully you need some C and ARM development background. In exchange it has better functionality, smarter code completion than Keil, and multithreaded compilation that makes compiling considerably faster. The setup chapter is in the development tools section, and from the fourth chapter onwards, which is where the whole infantry robot is developed, the tutorials use this environment.

So the switch happens at a deliberate point. The reader learns the peripherals and the first motor loop in a tool that does not get in the way, and then moves to a tool they will keep using for the rest of the project, with the cost of learning it paid once in the middle rather than at the start.

Both environments have complete setup videos, and the README notes that since most schools do not teach gcc and related build knowledge in detail, the author also explains the principles of compilation rather than only giving the commands.

Test, think, iterate, and a refusal to tune parameters blindly

The section on what makes the tutorial different is where the author's teaching philosophy is stated, and it is the part most worth reading even if you never build the robot.

The stated aim is to combine theory with practice and to get to the essence, which the README ties to the university's motto of blending theory and practice. Every engineering section has a review of the background knowledge first, with the theory as a lead-in, and it tries to avoid hard and blind parameter tuning, preferring to get better control through modelling.

The concrete examples show what that means. In the motor control chapter the author starts from the principles of CAN communication, then teaches the PID algorithm, and only then moves to open-loop control, angular velocity closed loop, angle loop double closed loop and feedforward control, each building on the last. In the chassis chapter the reader learns the principles of rotation matrices, and the power control section revisits the Taylor expansion.

The three processes of test, think and iterate are then worked through as examples. In the chassis chapter, the drift of the small-gimbal travel leads to the introduction of chassis angular rate feedforward. In the gimbal chapter, the symptom of slow motor response is analysed to the conclusion that the gimbal angular rate feedback is imprecise, and the fix is to use the gyroscope for that feedback instead, and the observation that the gimbal moves with the chassis small-gimbal and over bumps leads to the concept of gimbal self-stabilisation.

That last one is the clearest statement of the method: a bad user experience becomes a requirement, and the requirement becomes a new algorithm.

What the repository is, and what it is not

It is worth being clear about the boundaries, because a repository like this can be mistaken for something it is not.

It is not a code library. The source that the documents describe is distributed separately, as the code download in the overview section, and the repository itself holds documentation, images and the slide decks. The listing has no source directory and no build system.

It is not a competition entry either. It is teaching notes for a team, and the README presents it as something a new team should work through, with a stated aim of saving the newcomers of teams with less accumulated experience from repeating other people's mistakes.

It is a document with a very specific pedagogical contract, and that contract shows in the structure. The README promises that only C language basics are needed to start, that any other prerequisite knowledge is introduced as needed, that C++ is brought in for the motor control part, that Markdown is explained in detail because it is used constantly from the chassis chapter onwards, that gcc and build principles are explained because most courses do not cover them, and that Euler angles and rotation matrices are explained because the mathematics involved in coordinate transforms is beyond what most robot builders have studied.

Each major section ends with a summary and acknowledgements, and the side chapters, marked as extras, are where the author puts content that is either a digression or a piece of experience he thinks the reader will want later. Yellow highlighting marks content that has been updated.

So the honest way to use it is as a reading list with a defined order, and to read the theory sections before the code sections, which is the opposite of how most people approach a technical repository and probably the reason the author wrote the introduction himself.

Editorial conclusion

Adopt robowalker_train as a reading list if you are building a RoboMaster robot and want a syllabus that connects the peripheral, the driver and the control theory in one sequence, because that ordering is the thing the course is actually organised around and it is the ordering most self-taught robot builders lack. Do not adopt it as a code base, because the repository is documentation and slides rather than a library, and do not expect the code to drop into your project, since the source of the code is a separate download and the environment installer is a package hosted on the author's personal page. Before you follow it, pick the mirror to work from, because the Gitee copy is not being updated, and check the licence question, because the repository carries no licence statement and the content is the team's own training documentation.

Frequently asked questions

Official sources

1. Issues
2. README
3. yssickjgd/robowalker_train on GitHub