A Simple and User-Friendly STM32 Embedded OS Kernel

Now, there are more and more embedded operating systems, such as the well-known uCOS, FreeRTOS, RT-Thread, etc. Each of these operating systems has its own characteristics:Which RTOS have you used in STM32 embedded development?

This article will introduce a simple and user-friendly embedded operating system kernel – KLite.

KLite Source Code

Source code link:https://gitee.com/kerndev/klite

The author of KLite is Jiang Xiaogang.

KLite Introduction

KLite is open-sourced under the MIT license. It is an entry-level small preemptive operating system kernel designed to be simple and easy to use, aiming to reduce the difficulty of learning embedded operating system programming and getting started.

With a simple API style, straightforward calling methods, and easy porting methods, it may be the simplest and most user-friendly embedded operating system kernel available today.

Supports priority preemption
Supports threads of the same priority
Supports thread synchronization and mutual exclusion
Supports dynamic memory management
Supports multiple compilers: GCC, IAR, MDK

KLite Porting

KLite has been adapted for ARM Cortex-M0/M3/M4, and if your CPU platform is based on the above platforms, such as STM32, GD32, NRF51, NRF52, Freescale K40, and other series of microcontrollers, you can directly use the precompiled library files for development.

You only need to modify a few simple functions in template.c to start programming. Otherwise, you may need to port the low-level assembly code for the CPU yourself.

KLite Usage

1. KLite Compilation

In the build directory, there are preset project files. Choose the compiler and target CPU platform you want to use. After compilation, a kernel.lib file will be generated. Copy kernel.lib, kernel.h, and template.c into your project source code. Using the lib file can reduce compilation time, but you can also choose to add all the source code to your project.

2. Modify template.c

Implement the two empty functions in template.c according to the programming manual of the target CPU.

void cpu_sys_init(void);

This function is called by kernel_init and provides an interface for the user to perform necessary preparations that must occur before system initialization, such as initializing the CPU clock and setting FLASH, etc.

void cpu_sys_idle(uint32_t time);

This function is called by kernel_idle and provides an interface for the user to implement system sleep, such as calling the WFI instruction or doing nothing.

void SysTick_Handler(void);

This function is the platform-specific tick clock interrupt function, which needs to call kernel_tick(n) in the tick clock interrupt, where n represents the milliseconds of one interrupt.

3. Add Initialization Code in the Main Function

The recommended way to write the main function is as follows:

// Just include this one header file
#include "kernel.h"
// Thread for initializing the application
void init(void *arg) {
}
// Idle thread, just call kernel_idle
void idle(void *arg) {
    kernel_idle();
}
// Entry point of the C program
void main(void) {
    static uint8_t heap[HEAP_SIZE];
    kernel_init((uint32_t)heap, HEAP_SIZE);
    thread_create(init, 0, 0);
    thread_create(idle, 0, 0);
    kernel_start();
}

Note:

kernel_init is used to initialize the kernel;
thread_create creates the main threads init and idle;
kernel_start is used to start the kernel;
init is a thread function where you implement your other initialization code.
For more function parameter descriptions, please refer to the API documentation.