一步步学习操作系统（1）——参照ucos，在STM32上实现一个简单的多任务

1、OSInit(); 

2、OSTaskCreate(Task1, (void*)0, (OS_STK*)&Task1Stk[TASK_STACK_SIZE-1]);

3、OSTaskCreate(Task2, (void*)0, (OS_STK*)&Task2Stk[TASK_STACK_SIZE-1]);

4、OSTaskCreate(Task3, (void*)0, (OS_STK*)&Task3Stk[TASK_STACK_SIZE-1]);

5、SysTickInit(5);

6、LedInit();

7、OSStart();

#include "include.h"    

extern OS_TCB OSTCBTbl[OS_MAX_TASKS]; // (OS Task Control Block Table)

extern OS_STK TASK_IDLE_STK[TASK_STACK_SIZE]; //("TaskIdle" Stack)

extern OS_TCB *OSTCBCur; // Pointer to the current running task(OS Task Control Block Current)

extern OS_TCB *OSTCBNext; // Pointer to the next running task(OS Task Control Block Next)

extern INT8U OSTaskNext; // Index of the next task

extern INT32U TaskTickLeft; // Refer to the time ticks left for the current task

extern INT32U TimeMS;       // For system time record                             

extern INT32U TaskTimeSlice; // For system time record



OS_STK Task1Stk[TASK_STACK_SIZE]; // initialize stack for task1

OS_STK Task2Stk[TASK_STACK_SIZE]; // initialize stack for task2

OS_STK Task3Stk[TASK_STACK_SIZE]; // initialize stack for task3



void Task1(void *p_arg); // flip the led1 every 0.5s

void Task2(void *p_arg); // flip the led2 every 1.0s

void Task3(void *p_arg); // do nothing



int main(void)

{

    

    

    OSInit();  // OS initialization

    OSTaskCreate(Task1, (void*)0, (OS_STK*)&Task1Stk[TASK_STACK_SIZE-1]); // create task 1

    OSTaskCreate(Task2, (void*)0, (OS_STK*)&Task2Stk[TASK_STACK_SIZE-1]); // create task 2

    OSTaskCreate(Task3, (void*)0, (OS_STK*)&Task3Stk[TASK_STACK_SIZE-1]); // create task 3

    SysTickInit(5); // configure the SysTick as 5ms

    LedInit(); // leds initialization

    OSStart(); // start os!

    

    return 0; // never come here

}



void Task1(void *p_arg)

{

    while(1) {

        delayMs(100); // delay 100 * 5ms = 0.5s

        LED1TURN(); // flip the switch of led1

    }

}

void Task2(void *p_arg)

{

    while(1) {

        delayMs(200); // delay 200 * 5ms = 1.0s

        LED2TURN(); // flip the switch of led2 

    }

}



void Task3(void *p_arg)

{

    while(1) {

    }

}

#ifndef INCLUDE_H

#define INCLUDE_H



#include <stdlib.h>

#include "myos.h"

#include "stm32f10x.h" //stm32官方头文件



#endif

#ifndef MYOS_H

#define MYOS_H

#include "stm32f10x.h"



/**********CPU DEPENDENT************/

#define TASK_TIME_SLICE     5             // 5ms for every task to run every time



typedef unsigned char  INT8U;             // Unsigned  8 bit quantity  

typedef unsigned short INT16U;            // Unsigned 16 bit quantity 

typedef unsigned int   INT32U;            // Unsigned 32 bit quantity



typedef unsigned int   OS_STK;            // Each stack entry is 32-bit wide(OS Stack)



// assembling functions

void OS_ENTER_CRITICAL(void);             // Enter Critical area, that is to disable interruptions

void OS_EXIT_CRITICAL(void);              // Exit Critical area, that is to enable interruptions

void OSCtxSw(void);                       // Task Switching Function(OS Context Switch)

void OSStart(void);



OS_STK* OSTaskStkInit(void (*task)(void *p_arg), // task function

              void *p_arg,                       // (pointer of arguments)

                OS_STK *p_tos);                  // (pointer to the top of stack)

/**********CPU INDEPENDENT************/



#define OS_MAX_TASKS    16



#define TASK_STATE_CREATING     0

#define TASK_STATE_RUNNING    1

#define TASK_STATE_PAUSING    2



#define TASK_STACK_SIZE     64

              

#define LED1TURN() (GPIOA->ODR ^= 1<<8)  // reverse the voltage of LED1 !!!HARDWARE RELATED

#define LED2TURN() (GPIOD->ODR ^= 1<<2)  // reverse the voltage of LED2 !!!HARDWARE RELATED





typedef struct os_tcb {

    OS_STK    *OSTCBStkPtr;     // (OS Task Control Block Stack Pointer)

    INT8U     OSTCBStat;        // (OS Task Control Block Status)

} OS_TCB;                       // (OS Task Control Block)



void OSInit(void);              // (OS Initialization)

void LedInit(void);

45 void OS_TaskIdle(void *p_arg);

void OSInitTaskIdle(void);                      // (OS Initialization of "TaskIdle")

void OSTaskCreate(void (*task)(void *p_arg),    // task function

          　　　　 void *p_arg,      　　　　　　  // (pointer of arguments)

                  OS_STK *p_tos); 　　　　　　　　// (pointer to the top of stack)

void OSTCBSet(OS_TCB *p_tcb, OS_STK *p_tos, INT8U task_state);





void SysTickInit(INT8U Nms);                    // (System Tick Initialization)

void SysTick_Handler(void); 　　　　　　　　　　   // The interrupt function 



INT32U GetTime(void);

void delayMs(volatile INT32U ms); 　　　　　　　　// The argument can't be too large



#endif

IMPORT     OSTCBCur

    IMPORT    OSTCBNext

    

    EXPORT    OS_ENTER_CRITICAL

    EXPORT    OS_EXIT_CRITICAL

    EXPORT    OSStart

    EXPORT    PendSV_Handler

    EXPORT    OSCtxSw

    

NVIC_INT_CTRL    EQU            0xE000ED04    ; Address of NVIC Interruptions Control Register

NVIC_PENDSVSET   EQU            0x10000000    ; Enable PendSV

NVIC_SYSPRI14    EQU         0xE000ED22  ; System priority register (priority 14).

NVIC_PENDSV_PRI  EQU         0xFF        ; PendSV priority value (lowest).

    

    PRESERVE8 ; align 8



    AREA    |.text|, CODE, READONLY 

    THUMB 



;/******************OS_ENTER_CRITICAL************/

OS_ENTER_CRITICAL

    CPSID    I    ; Enable interruptions(Change Processor States: Interrupts Disable)

    BX    LR    ; Return



;/******************OS_EXIT_CRITICAL************/

OS_EXIT_CRITICAL

    CPSIE    I    ; Disable interruptions

    BX    LR     ; Return



;/******************OSStart************/

OSStart

    ; disable interruptions

    CPSID    I                            ; OS_ENTER_CRITICAL();

    ; initialize PendSV

    ; Set the PendSV exception priority

    LDR     R0, =NVIC_SYSPRI14            ; R0 = NVIC_SYSPRI14;

    LDR     R1, =NVIC_PENDSV_PRI          ; R1 = NVIC_PENDSV_PRI;

    STRB    R1, [R0]                      ; *R0 = R1;

    

    ; initialize PSP as 0

    ; MOV    R4, #0

    LDR R4,  =0x0                            ; R4 = 0;

    MSR    PSP, R4                           ; PSP = R4;

    

    ; trigger PendSV

    LDR    R4, =NVIC_INT_CTRL              ; R4 = NVIC_INT_CTRL;

    LDR    R5, =NVIC_PENDSVSET             ; R5 = NVIC_PENDSVSET;

    STR    R5, [R4]                        ; *R4 = R5;

    

    ; enable interruptions

    CPSIE    I                            ; OS_EXIT_CRITICAL();



; should never get here

; a endless loop

OSStartHang                                    

    B    OSStartHang



;/******************PendSV_Handler************/

PendSV_Handler

    CPSID    I                            ; OS_ENTER_CRITICAL();

    ; judge if PSP is 0 which means the task is first invoked

    MRS     R0, PSP                            ; R0 = PSP;

    CBZ     R0, PendSV_Handler_NoSave          ; if(R0 == 0) goto PendSV_Handler_NoSave;

    

    ;     R12, R3, R2, R1

    SUB     R0, R0, #0x20            ; R0 = R0 - 0x20;

    

    ; store R4 

    STR     R4 , [R0]                ; *R0 = R4;

    ADD     R0, R0, #0x4             ; R0 = R0 + 0x4;

    ; store R5 

    STR     R5 , [R0]                ; *R0 = R5;

    ADD     R0, R0, #0x4             ; R0 = R0 + 0x4;

    ; store R6 

    STR     R6 , [R0]                ; *R0 = R6;

    ADD     R0, R0, #0x4             ; R0 = R0 + 0x4;

    ; store R7 

    STR     R7 , [R0]                ; *R0 = R7;

    ADD     R0, R0, #0x4             ; R0 = R0 + 0x4;

    ; store R8 

    STR     R8 , [R0]                ; *R0 = R8;

    ADD     R0, R0, #0x4             ; R0 = R0 + 0x4;

    ; store R9

    STR     R9, [R0]                ; *R0 = R4;

    ADD     R0, R0, #0x4            ; R0 = R0 + 0x4;

    ; store R10 

    STR     R10, [R0]               ; *R0 = R10;

    ADD     R0, R0, #0x4            ; R0 = R0 + 0x4;

    ; store R11 

    STR     R11, [R0]               ; *R0 = R11;

    ADD     R0, R0, #0x4            ; R0 = R0 + 0x4;



    SUB     R0, R0, #0x20           ; R0 = R0 - 0x20;

    

    ; easy method

    ;SUB     R0, R0, #0x20

    ;STM     R0, {R4-R11}

    

    LDR     R1, =OSTCBCur            ; R1 = OSTCBCur;

    LDR     R1, [R1]                 ; R1 = *R1;(R1 = OSTCBCur->OSTCBStkPtr)

    STR     R0, [R1]                 ; *R1 = R0;(*(OSTCBCur->OSTCBStkPrt) = R0)



PendSV_Handler_NoSave

    LDR     R0, =OSTCBCur           ; R0 = OSTCBCur;

    LDR     R1, =OSTCBNext          ; R1 = OSTCBNext;

    LDR     R2, [R1]                ; R2 = OSTCBNext->OSTCBStkPtr;

    STR     R2, [R0]                ; *R0 = R2;(OSTCBCur->OSTCBStkPtr = OSTCBNext->OSTCBStkPtr)

    

    LDR     R0, [R2]                 ; R0 = *R2;(R0 = OSTCBNext->OSTCBStkPtr)

    ; LDM     R0, {R4-R11}

    ; load R4 

    LDR     R4, [R0]                 ; R4 = *R0;(R4 = *(OSTCBNext->OSTCBStkPtr))

    ADD     R0, R0, #0x4             ; R0 = R0 + 0x4;(OSTCBNext->OSTCBStkPtr++)

    ; load R5 

    LDR     R5, [R0]                 ; R5 = *R0;(R5 = *(OSTCBNext->OSTCBStkPtr))

    ADD     R0, R0, #0x4             ; R0 = R0 + 0x4;(OSTCBNext->OSTCBStkPtr++)

    ; load R6

    LDR     R6, [R0]                 ; R6 = *R0;(R6 = *(OSTCBNext->OSTCBStkPtr))

    ADD     R0, R0, #0x4             ; R0 = R0 + 0x4;(OSTCBNext->OSTCBStkPtr++)

    ; load R7 

    LDR     R7 , [R0]                ; R7 = *R0;(R7 = *(OSTCBNext->OSTCBStkPtr))

    ADD     R0, R0, #0x4             ; R0 = R0 + 0x4;(OSTCBNext->OSTCBStkPtr++)

    ; load R8 

    LDR     R8 , [R0]                ; R8 = *R0;(R8 = *(OSTCBNext->OSTCBStkPtr))

    ADD     R0, R0, #0x4             ; R0 = R0 + 0x4;(OSTCBNext->OSTCBStkPtr++)

    ; load R9 

    LDR     R9 , [R0]                ; R9 = *R0;(R9 = *(OSTCBNext->OSTCBStkPtr))

    ADD     R0, R0, #0x4             ; R0 = R0 + 0x4;(OSTCBNext->OSTCBStkPtr++)

    ; load R10 

    LDR     R10 , [R0]               ; R10 = *R0;(R10 = *(OSTCBNext->OSTCBStkPtr))

    ADD     R0, R0, #0x4             ; R0 = R0 + 0x4;(OSTCBNext->OSTCBStkPtr++)

    ; load R11 

    LDR     R11 , [R0]               ; R11 = *R0;(R11 = *(OSTCBNext->OSTCBStkPtr))

    ADD     R0, R0, #0x4             ; R0 = R0 + 0x4;(OSTCBNext->OSTCBStkPtr++)

    

    MSR     PSP, R0                 ; PSP = R0;(PSP = OSTCBNext->OSTCBStkPtr)

    ; P42

    ; P139 (key word: EXC_RETURN)

    ; use PSP

    ORR     LR, LR, #0x04           ; LR = LR | 0x04;

    CPSIE     I                     ; OS_EXIT_CRITICAL();

    BX    LR                        ; return;



OSCtxSw ;OS context switch

    PUSH    {R4, R5}                

    LDR     R4, =NVIC_INT_CTRL       ; R4 = NVIC_INT_CTRL

    LDR     R5, =NVIC_PENDSVSET      ; R5 = NVIC_PENDSVSET

    STR     R5, [R4]                 ; *R4 = R5

    POP     {R4, R5}

    BX     LR                        ; return;

    

    align 4

    end

#include "myos.h"

#include "stm32f10x.h"





OS_TCB OSTCBTbl[OS_MAX_TASKS]; // (OS Task Control Block Table)

OS_STK TASK_IDLE_STK[TASK_STACK_SIZE]; //("TaskIdle" Stack)

OS_TCB *OSTCBCur; // Pointer to the current running task(OS Task Control Block Current)

OS_TCB *OSTCBNext; // Pointer to the next running task(OS Task Control Block Next)

INT8U OSTaskNext; // Index of the next task

INT32U TaskTickLeft; // Refer to the time ticks left for the current task

INT32U TimeMS;

INT32U TaskTimeSlice;

char * Systick_priority = (char *)0xe000ed23;

// Initialize the stack of a task, it is of much relationship with the specific CPU

OS_STK* OSTaskStkInit(void (*task)(void *p_arg),

          void *p_arg,

          OS_STK *p_tos)

{

    OS_STK *stk;

    stk = p_tos;



    *(stk)    = (INT32U)0x01000000L;             // xPSR                                               

    *(--stk)  = (INT32U)task;                    // Entry Point  



    // Don't be serious with the value below. They are of random

    *(--stk)  = (INT32U)0xFFFFFFFEL;             // R14 (LR) 

    *(--stk)  = (INT32U)0x12121212L;             // R12                                                

    *(--stk)  = (INT32U)0x03030303L;             // R3                                                 

    *(--stk)  = (INT32U)0x02020202L;             // R2                                                 

    *(--stk)  = (INT32U)0x01010101L;             // R1                                                 



    // pointer of the argument

    *(--stk)  = (INT32U)p_arg;                   // R0



    // Don't be serious with the value below. They are of random

    *(--stk)  = (INT32U)0x11111111L;             // R11 

    *(--stk)  = (INT32U)0x10101010L;             // R10 

    *(--stk)  = (INT32U)0x09090909L;             // R9  

    *(--stk)  = (INT32U)0x08080808L;             // R8  

    *(--stk)  = (INT32U)0x07070707L;             // R7  

    *(--stk)  = (INT32U)0x06060606L;             // R6  

    *(--stk)  = (INT32U)0x05050505L;             // R5  

    *(--stk)  = (INT32U)0x04040404L;             // R4  

    return stk;

}



// Only to initialize the Task Control Block Table

void OSInit(void)

{

    INT8U i;

    OS_ENTER_CRITICAL();

    for(i = 0; i < OS_MAX_TASKS; i++) {

        OSTCBTbl[i].OSTCBStkPtr = (OS_STK*)0;

        OSTCBTbl[i].OSTCBStat = TASK_STATE_CREATING;

    }

    OSInitTaskIdle();

    OSTCBCur = &OSTCBTbl[0];

    OSTCBNext = &OSTCBTbl[0];

    OS_EXIT_CRITICAL();

}



void OSInitTaskIdle(void)

{

    OS_ENTER_CRITICAL();

    OSTCBTbl[0].OSTCBStkPtr = OSTaskStkInit(OS_TaskIdle, (void *)0, (OS_STK*)&TASK_IDLE_STK[TASK_STACK_SIZE - 1]);

    OSTCBTbl[0].OSTCBStat = TASK_STATE_RUNNING;

    OS_EXIT_CRITICAL();

}



void OSTaskCreate(void (*task)(void *p_arg), 

          void *p_arg, 

          OS_STK *p_tos)

{

    OS_STK * tmp;

    INT8U i = 1;

    OS_ENTER_CRITICAL();

    while(OSTCBTbl[i].OSTCBStkPtr != (OS_STK*)0) {

        i++;

    }

    tmp = OSTaskStkInit(task, p_arg, p_tos);

    OSTCBSet(&OSTCBTbl[i], tmp, TASK_STATE_CREATING);

    OS_EXIT_CRITICAL();

}



void OSTCBSet(OS_TCB *p_tcb, OS_STK *p_tos, INT8U task_state)

{

    p_tcb->OSTCBStkPtr = p_tos;

    p_tcb->OSTCBStat = task_state;

}



void OS_TaskIdle(void *p_arg)

{

    p_arg = p_arg; // No use of p_arg, only for avoiding "warning" here.

    for(;;) {

        // OS_ENTER_CRITICAL();

        // Nothing to do

        // OS_EXIT_CRITICAL();

    }

}



// void SysTick_Handler(void)

// {

//     // OS_ENTER_CRITICAL();

//     // OS_EXIT_CRITICAL();

// }

void SysTick_Handler(void)

{

    OS_ENTER_CRITICAL();

    if((--TaskTimeSlice) == 0){

        TaskTimeSlice = TASK_TIME_SLICE;

        OSTCBCur = OSTCBNext;

        OSCtxSw();

        OSTaskNext++;

        while(OSTCBTbl[OSTaskNext].OSTCBStkPtr == (OS_STK*)0) { 

            OSTaskNext++;

            if(OSTaskNext >= OS_MAX_TASKS) {

                OSTaskNext = 0;

            }

        }

        OSTCBNext = &OSTCBTbl[OSTaskNext];

        TaskTimeSlice = TASK_TIME_SLICE;

    }

    TimeMS++;

    OS_EXIT_CRITICAL();

}



void SysTickInit(INT8U Nms)

{

    

    OS_ENTER_CRITICAL();

    

    TimeMS = 0;

    TaskTimeSlice = TASK_TIME_SLICE;                             



    SysTick->LOAD  = 1000 * Nms - 1; 

    *Systick_priority = 0x00;

    SysTick->VAL   = 0;  

    SysTick->CTRL = 0x3;

    OS_EXIT_CRITICAL();

}



INT32U GetTime(void)

{

    return TimeMS;

}



void delayMs(volatile INT32U ms)

{

    INT32U tmp;

    tmp = GetTime() + ms;

    while(1){

        if(tmp < GetTime()) break;

    }

}



void LedInit(void)

{

    RCC->APB2ENR |= 1<<2;

    RCC->APB2ENR |= 1<<5;

    //GPIOE->CRH&=0X0000FFFF;  

    //GPIOE->CRH|=0X33330000;

    

    GPIOA->CRH &= 0xfffffff0;

    GPIOA->CRH |= 0x00000003;

    //GPIOA->ODR &= 0xfffffeff;

    GPIOA->ODR |= 1<<8;



    GPIOD->CRL &= 0xfffff0ff;

    GPIOD->CRL |= 0x00000300;

    //GPIOD->ODR &= 0xfffffffd;    

    GPIOD->ODR |= 1<<2;

    

    //LED1TURN();

    LED2TURN();

    

}

void OSInit(void)

{

    INT8U i;

    OS_ENTER_CRITICAL();

    for(i = 0; i < OS_MAX_TASKS; i++) {

        OSTCBTbl[i].OSTCBStkPtr = (OS_STK*)0;

        OSTCBTbl[i].OSTCBStat = TASK_STATE_CREATING;

    }

    OSInitTaskIdle();

    OSTCBCur = &OSTCBTbl[0];

    OSTCBNext = &OSTCBTbl[0];

    OS_EXIT_CRITICAL();

}

void OSTaskCreate(void (*task)(void *p_arg), 

void *p_arg, 

OS_STK *p_tos)

{

OS_STK * tmp;

INT8U i = 1;

OS_ENTER_CRITICAL();

while(OSTCBTbl[i].OSTCBStkPtr != (OS_STK*)0) {

i++;

}

tmp = OSTaskStkInit(task, p_arg, p_tos);

OSTCBSet(&OSTCBTbl[i], tmp, TASK_STATE_CREATING);

OS_EXIT_CRITICAL();

}

OS_STK* OSTaskStkInit(void (*task)(void *p_arg),

          void *p_arg,

          OS_STK *p_tos)

{

    OS_STK *stk;

    stk = p_tos;



    *(stk)    = (INT32U)0x01000000L;             // xPSR                                               

    *(--stk)  = (INT32U)task;                    // Entry Point  



    // Don't be serious with the value below. They are of random

    *(--stk)  = (INT32U)0xFFFFFFFEL;             // R14 (LR) 

    *(--stk)  = (INT32U)0x12121212L;             // R12                                                

    *(--stk)  = (INT32U)0x03030303L;             // R3                                                 

    *(--stk)  = (INT32U)0x02020202L;             // R2                                                 

    *(--stk)  = (INT32U)0x01010101L;             // R1                                                 



    // pointer of the argument

    *(--stk)  = (INT32U)p_arg;                   // R0



    // Don't be serious with the value below. They are of random

    *(--stk)  = (INT32U)0x11111111L;             // R11 

    *(--stk)  = (INT32U)0x10101010L;             // R10 

    *(--stk)  = (INT32U)0x09090909L;             // R9  

    *(--stk)  = (INT32U)0x08080808L;             // R8  

    *(--stk)  = (INT32U)0x07070707L;             // R7  

    *(--stk)  = (INT32U)0x06060606L;             // R6  

    *(--stk)  = (INT32U)0x05050505L;             // R5  

    *(--stk)  = (INT32U)0x04040404L;             // R4  

    return stk;

}