首页  思维导图  详情

ucos

2024-12-02 12:22:30   0  举报





AI智能生成

ucosI代码分析

UCOS功能分析

作者其他创作

大纲/内容

替换调度方式

变量描述： OSTCBCur ：是一个全局变量，它是一个指针，指向当前正在运行的任务的任务控制块（TCB）。 OSTCBList ：是一个全局变量，它定义了一个指向任务控制块（TCB）的指针，用于管理所有已创建的任务。 OSTCBStat ：是 TCB的一个重要成员，用于表示任务的当前状态。 OSTCBHighRdy ：是一个全局变量，它指向当前最高优先级且处于就绪状态的任务的任务控制块（TCB）。 // 轮询调度器的当前任务索引 static INT8 OSRdyIdx = 0; // 轮询调度器选择下一个任务 void OSSchedRoundRobin(void) {     OS_TCB *next_tcb;     OS_ENTER_CRITICAL();     next_tcb = OSTCBList;    // 假设OSTCBList按优先级排序     while (next_tcb != (OS_TCB *)0)     {         if (next_tcb->OSTCBStat == OS_STAT_RDY && next_tcb->OSTCBDly == 0)         {             OSTCBCur = next_tcb;             break;         }         next_tcb = next_tcb->OSTCBNext;         OSRdyIdx++;         if (OSRdyIdx >= OS_MAX_TASKS)         {             OSRdyIdx = 0; // 回到列表的开始         }     }     OS_EXIT_CRITICAL();     OSSched(); // 调用原有的调度函数进行上下文切换 } 功能描述： OSSchedRoundRobin 函数： 进入临界区：OS_ENTER_CRITICAL() 确保在调度过程中不会被中断 选择下一个任务：从任务列表 OSTCBList 开始遍历，查找下一个状态为就绪 (OS_STAT_RDY) 且没有延迟 (OSTCBDly == 0) 的任务 更新当前任务：一旦找到符合条件的任务，将其设置为当前任务 OSTCBCur 更新任务索引：如果当前任务是最后一个任务，OSRdyIdx 重置为 0，以便从列表的开始处继续轮询 退出临界区：OS_EXIT_CRITICAL() 结束临界区 调用原有调度函数：调用 OSSched() 执行上下文切换 轮询调度：轮询调度是一种简单的调度策略，它按照固定的顺序依次检查每个任务，给每个任务平等的执行机会。 时间片管理：在这个实现中，通过 OSTCBDly 字段间接管理。如果任务需要延迟，它的 OSTCBDly 会被设置为非零值，这样它就不会在下一次轮询中被选中。 任务选择：调度器选择下一个任务时，会跳过那些不在就绪状态或有延迟的任务。 循环索引：通过 OSRdyIdx 实现循环索引，确保即使在任务数量少于 OS_MAX_TASKS 时，调度器也能正确地循环遍历任务列表。 void OSStart(void) {     UBYTE x, y, p;     y = OSUnMapTbl[OSRdyGrp];     x = OSRdyTbl[y];     p = (y << 3) + OSUnMapTbl[x];     OSTCBHighRdy = OSTCBPrioTbl[p];     OSTCBCur = OSTCBHighRdy;     OSRunning = 1;     OSSchedRoundRobin(); // 使用轮询调度替换原有的调度 } 功能描述： OSStart 函数 初始化操作系统并启动轮询调度： 初始化任务索引和优先级：通过 OSUnMapTbl 和 OSRdyTbl 计算最高优先级的任务。 设置当前任务：将最高优先级的任务设置为当前任务 OSTCBCur。 标记操作系统为运行状态：OSRunning = 1。 启动轮询调度：调用 OSSchedRoundRobin() 开始轮询调度。 算法逻辑： 1.定义轮询调度器的当前任务索引：OSRdyIdx用于跟踪当前执行的任务。 2.实现轮询调度器选择下一个任务的函数：OSSchedRoundRobin()遍历任务列表，选择下一个就绪的任务。 3.修改OSStart()函数：在OSStart()中调用OSSchedRoundRobin()来初始化轮询调度。 4.实现时间片管理：为每个任务分配时间片，并在任务执行期间跟踪时间片。 5.实现上下文切换：在OSSched()中实现上下文切换的逻辑。

轮询调度（Polling Scheduling）是一种简单的任务调度策略，通常用于单核操作系统或嵌入式系统中。在轮询调度中，调度器按照固定的顺序（轮询顺序）依次检查每个任务，并为每个任务分配一段CPU时间。以下是轮询调度的一些关键特点： 顺序执行：调度器按照预定的顺序依次执行每个任务，每个任务轮流获得CPU时间。 时间片：在轮询调度中，每个任务通常被分配一个固定的时间片（时间量子），即每个任务在轮询周期中可以运行的时间长度。 循环检查：调度器会不断地循环检查任务列表，为每个任务提供执行机会。 上下文切换：当一个任务的时间片用完时，调度器会进行上下文切换，保存当前任务的状态，并恢复下一个任务的状态，然后继续执行下一个任务。 公平性：轮询调度确保每个任务都能获得CPU时间，因此它是一种公平的调度策略。 实时性：对于实时系统，轮询调度可以提供可预测的响应时间，因为每个任务都知道它将在下一个轮询周期中获得CPU时间。 简单性：轮询调度的实现相对简单，不需要复杂的调度算法。 局限性：       如果任务数量较多，每个任务获得的CPU时间可能会非常短，导致频繁的上下文切换，增加系统的开销。       对于计算密集型任务，轮询调度可能导致某些任务无法及时完成，因为它必须等待轮询周期再次到达。       轮询调度适用于任务数量较少、任务执行时间较短、对实时性要求不是特别高的系统。在更复杂的系统中，可能会采用优先级调度、时间片轮转调度或其他更高级的调度算法来提高系统的效率和响应性。

TEST1.C

void far Task(void *data)

setvect(0x08, (void interrupt (*)(void))OSTickISR); 作用：设置定时器中断服务 这行代码将中断向量0x08（通常是系统时钟中断） 设置为指向 OSTickISR 函数，是时钟节拍中断服务例程。 setvect 函数用于设置中断向量。

OSTimeDly(1); 作用：延时 OSTimeDly 函数使当前任务延时一个时钟节拍。

putch(*(char *)data); 作用：显示字符 putch 函数在光标当前位置显示一个字符。 这个字符是从传递给任务的 data 参数中获取的，data 被强制转换为 char 指针，然后解引用以获取字符。

gotoxy(rand() % 79 + 1, rand() % 25 + 1); 作用：随机定位光标 gotoxy 函数将屏幕光标移动到随机位置。 rand() % 79 + 1 和 rand() % 25 + 1 分别生成1到79和1到25之间的随机数，代表屏幕上的列和行。

if (kbhit()) {   setvect(0x08, OldTickISR);   exit(0); } 作用：检查键盘输入 如果检测到键盘输入（kbhit 函数返回非零值），则将中断向量0x08恢复为原来的中断服务例程（OldTickISR），然后退出任务（exit(0)）。

代码

void far Task(void *data) {     setvect(0x08, (void interrupt (*)(void))OSTickISR);     while (1) {         OSTimeDly(1);         gotoxy(rand() % 79 + 1, rand() % 25 + 1); putch(*(char *)data);         if (kbhit()) {             setvect(0x08, OldTickISR);             exit(0);         }     } }

void main(void)

UBYTE err; 声明了一个无符号字节类型的变量 err，用于存储函数返回的错误代码。

OSStart(); OSStart 函数启动操作系统的多任务处理。一旦调用此函数，操作系统将开始调度任务执行。

clrscr(); clrscr 函数用于清除屏幕，这是在控制台应用程序中常见的操作，用于清除之前的输出。

OldTickISR  = getvect(0x08); setvect( UCOS, (void interrupt (*)(void)) OSCtxSw ); setvect( 0xF2, OldTickISR ); 作用：获取和设置中断向量 getvect(0x08) 获取当前中断向量0x08（通常是时钟中断）的地址，并将其存储在 OldTickISR 变量中。 setvect(UCOS, (void interrupt (*)(void))OSCtxSw) 将中断向量 UCOS 设置为 OSCtxSw 函数，这是uCOS的上下文切换中断服务。 setvect(0xF2, OldTickISR) 将中断向量0xF2设置为原来的时钟中断服务例程，OldTickISR。

OSInit(&OSIdleTaskStk[STK_SIZE], OS_MAX_TASKS); OSInit 函数初始化操作系统，设置空闲任务的堆栈和最大任务数。

OSTaskCreate(Task, (void *)&Data1, (void *)&Stk1[STK_SIZE], 1); OSTaskCreate(Task, (void *)&Data2, (void *)&Stk2[STK_SIZE], 2); OSTaskCreate(Task, (void *)&Data3, (void *)&Stk3[STK_SIZE], 3); OSTaskCreate(Task, (void *)&Data4, (void *)&Stk4[STK_SIZE], 4); OSTaskCreate(Task, (void *)&Data5, (void *)&Stk5[STK_SIZE], 5); OSTaskCreate 函数创建新任务。 每个任务都使用相同的函数 Task，但传递不同的数据和堆栈。任务的优先级从1到5不同。

代码

void main(void) {     UBYTE err;     clrscr();     OldTickISR = getvect(0x08);     setvect(UCOS, (void interrupt (*)(void))OSCtxSw);     setvect(0xF2, OldTickISR);     OSInit(&OSIdleTaskStk[STK_SIZE], OS_MAX_TASKS);     OSTaskCreate(Task, (void *)&Data1, (void *)&Stk1[STK_SIZE], 1);     OSTaskCreate(Task, (void *)&Data2, (void *)&Stk2[STK_SIZE], 2);     OSTaskCreate(Task, (void *)&Data3, (void *)&Stk3[STK_SIZE], 3);     OSTaskCreate(Task, (void *)&Data4, (void *)&Stk4[STK_SIZE], 4);     OSTaskCreate(Task, (void *)&Data5, (void *)&Stk5[STK_SIZE], 5);     OSStart(); }

TEST2.C

void main(void)

这个主函数的流程是应用程序的启动流程，它展示了如何准备环境、初始化资源、创建任务，并最终启动多任务处理。展示了如何初始化操作系统、设置同步机制以及创建和启动多个任务。

OSInit(&OSIdleTaskStk[STK_SIZE], OS_MAX_TASKS); OSInit函数初始化操作系统，设置空闲任务的堆栈空间和最大任务数。

OSSemInit(&Sem, 1); OSMboxInit(&Mbox, (void *)0); OSQInit(&Q, &QData[0], Q_SIZE); OSSemInit(&Sem, 1); 初始化一个信号量Sem，初始计数设置为1。 OSMboxInit(&Mbox, (void *)0); 初始化一个邮箱Mbox，初始消息指针设置为NULL。 OSQInit(&Q, &QData[0], Q_SIZE); 初始化一个队列Q，指定队列的存储开始地址和大小。

OSTaskCreate(DispTask, (void *)0, (void *)&DispStk[STK_SIZE],   0); OSTaskCreate(KeyTask,  (void *)0, (void *)&KeyStk[STK_SIZE],    1); OSTaskCreate(Task1,    (void *)0, (void *)&Task1Stk[STK_SIZE], 10); OSTaskCreate(Task2,    (void *)0, (void *)&Task2Stk[STK_SIZE], 20); OSTaskCreate(Task3,    (void *)0, (void *)&Task3Stk[STK_SIZE], 30); OSTaskCreate函数用于创建新任务，每个任务都有自己的任务函数、传递给任务的数据、堆栈空间和优先级。 任务的优先级从0（最高）到30（最低）。

OSStart(); OSStart函数启动操作系统的多任务处理。

代码

void main(void) {     clrscr();     OldTickISR = getvect(0x08);     setvect(UCOS, (void interrupt (*)(void))OSCtxSw);     setvect(0xF2, OldTickISR);     OSInit(&OSIdleTaskStk[STK_SIZE], OS_MAX_TASKS);     OSSemInit(&Sem, 1);     OSMboxInit(&Mbox, (void *)0);     OSQInit(&Q, &QData[0], Q_SIZE);     OSTaskCreate(DispTask, (void *)0, (void *)&DispStk[STK_SIZE],   0);     OSTaskCreate(KeyTask,  (void *)0, (void *)&KeyStk[STK_SIZE],    1);     OSTaskCreate(Task1,    (void *)0, (void *)&Task1Stk[STK_SIZE], 10);     OSTaskCreate(Task2,    (void *)0, (void *)&Task2Stk[STK_SIZE], 20);     OSTaskCreate(Task3,    (void *)0, (void *)&Task3Stk[STK_SIZE], 30);     OSStart(); }

void far KeyTask(void *data)

setvect(0x08, (void interrupt (*)(void))OSTickISR); 这行代码将中断向量0x08（通常是系统时钟中断）设置为 OSTickISR 函数。

if (kbhit()) { kbhit 函数用于检查键盘是否有输入。如果返回非零值，表示有键盘输入。

switch (getch()) { getch 函数获取按下的字符，然后使用 switch 语句来处理不同的按键： 如果按下的是 '1'，则调用 OSMboxPost 函数向邮箱 Mbox 发送一个消息（(void *)1）。 如果按下的是 '2'，则调用 OSQPost 函数向队列 Q 发送一个消息（(void *)1）。 如果按下的是 'x' 或 'X'，则将中断向量0x08恢复为原来的中断服务例程（OldTickISR），然后退出任务（exit(0)）。

setvect(0x08, OldTickISR); exit(0); 当按下 'x' 或 'X' 时，这些行代码将中断向量恢复并退出任务，允许操作系统进行清理和资源回收。

这个任务的主要作用是监听键盘输入，并根据输入向邮箱或队列发送消息，或者在特定输入下退出任务。这是一个典型的实时操作系统中的任务，用于处理外部事件（如用户输入）并与其他系统组件（如同步机制）交互。

代码

void far KeyTask(void *data) {     UBYTE i;     setvect(0x08, (void interrupt (*)(void))OSTickISR);     while (1) {         OSTimeDly(1);         if (kbhit()) {             switch (getch()) {                 case '1': OSMboxPost(&Mbox, (void *)1);                           break;                 case '2': OSQPost(&Q, (void *)1);                           break;                 case 'x':                 case 'X': setvect(0x08, OldTickISR);                           exit(0);                           break;             }         }     } }

void far Task1(void *data)

这段代码定义了一个名为 Task1 的任务函数，它是用于从邮箱中接收消息，并更新一个计数器。

UBYTE err; 这行代码声明了一个无符号字节类型的变量 err，用于存储函数返回的错误代码。

OSMboxPend(&Mbox, 36, &err); OSMboxPend 函数使任务等待（挂起）直到从 Mbox 邮箱接收到消息。36 是超时时间（以时钟节拍为单位），&err 是用于存储操作结果的指针。如果邮箱在超时时间内变为非空，任务将接收消息并继续执行；如果超时时间到达而邮箱仍然为空，err 将被设置为 OS_TIMEOUT。

OSSemPend(&Sem, 0); OSSemPend 函数使任务等待信号量 Sem。0 表示任务将无限期等待信号量，直到它可用。如果信号量可用，任务将继续执行；如果信号量不可用，任务将被挂起，直到信号量被另一个任务释放。

Ctr1++; 简单地将全局计数器 Ctr1 增加1。这个计数器用于跟踪任务从邮箱接收消息的次数。

OSSemPost(&Sem); OSSemPost 函数释放（或信号）信号量 Sem，允许等待此信号量的其他任务继续执行。

代码

void far Task1(void *data) {     UBYTE err;     while (1) {         OSMboxPend(&Mbox, 36, &err);         OSSemPend(&Sem, 0);         Ctr1++;         OSSemPost(&Sem);     } }

void far Task2(void *data)

这个任务的主要作用是从队列接收消息，并在每次成功接收后更新计数器。它还展示了如何使用信号量来同步任务的执行。这种模式在需要协调多个任务访问共享资源或事件时非常有用。 Task2 与 Task1 类似，但它们从不同的同步机制（队列Q和邮箱Mbox）接收消息。

OSQPend(&Q, 72, &err); OSQPend 函数使任务等待（挂起）直到从 Q 队列接收到消息。72 是超时时间（以时钟节拍为单位），&err 是用于存储操作结果的指针。如果队列在超时时间内变为非空，任务将接收消息并继续执行；如果超时时间到达而队列仍然为空，err 将被设置为 OS_TIMEOUT。

OSSemPend(&Sem, 0); OSSemPend 函数使任务等待信号量 Sem。0 表示任务将无限期等待信号量，直到它可用。如果信号量可用，任务将继续执行；如果信号量不可用，任务将被挂起，直到信号量被另一个任务释放。

Ctr2++; 简单地将全局计数器 Ctr2 增加1。这个计数器用于跟踪任务从队列接收消息的次数。

OSSemPost(&Sem); OSSemPost 函数释放（或信号）信号量 Sem，允许等待此信号量的其他任务继续执行。

代码

void far Task2(void *data) {     UBYTE err;     while (1) {         OSQPend(&Q, 72, &err);         OSSemPend(&Sem, 0);         Ctr2++;         OSSemPost(&Sem);     } }

void far Task3(void *data)

这个任务的主要作用是模拟时钟的秒和分钟计数。 它通过延时和信号量同步来确保每次只更新一次计数器，并且更新操作是原子的，即不会被其他任务中断。 这种同步机制对于确保多个任务共享资源时数据的一致性非常重要。

OSTimeDly(18); OSTimeDly 函数使当前任务延时18个时钟节拍。一个时钟节拍通常是由系统的定时器中断生成的。 这里延时18个节拍意味着任务每18个时钟节拍执行一次循环体。

Sec++; 这行代码将全局秒计数器 Sec 增加1。

if (Sec > 59) {     Sec = 0;     Min++; } 如果秒计数器 Sec 超过59，这表示一分钟已经过去。因此，代码将 Sec 重置为0，并增加分钟计数器 Min。

OSSemPost(&Sem); OSSemPost 函数释放（或信号）信号量 Sem，允许等待此信号量的其他任务继续执行。

代码

void far Task3(void *data) {     while (1) {         OSTimeDly(18);         OSSemPend(&Sem, 0);         Sec++;         if (Sec > 59) {             Sec = 0;             Min++;         }         OSSemPost(&Sem);     } }

void far DispTask(void *data)

这个任务的主要作用是在屏幕上显示时钟和计数器的值，并且通过信号量 Sem 同步对共享资源的访问，以确保在显示时数据的一致性和准确性。

UWORD ctr1, ctr2; UBYTE min, sec; 声明了用于存储计数器和时钟值的变量。

OSTimeDly(6); OSTimeDly 函数使当前任务延时6个时钟节拍。 这允许其他任务有机会运行，而不是 DispTask 独占CPU。

OSSemPend(&Sem, 0); OSSemPend 函数使任务等待信号量 Sem。0 表示任务将无限期等待信号量，直到它可用。 这是为了确保在读取计数器和时钟值时不会被其他任务中断。

读取共享资源： ctr1 = Ctr1; ctr2 = Ctr2; min = Min; sec = Sec; 读取全局计数器 Ctr1 和 Ctr2，以及分钟和秒计数器 Min 和 Sec 的值。

OSSemPost(&Sem); OSSemPost 函数释放（或信号）信号量 Sem，允许等待此信号量的其他任务继续执行。

gotoxy(1, 9); printf("Clock = %02d:%02d", min, sec); gotoxy(1, 10); printf("Ctr1  =  %4d", ctr1); gotoxy(1, 11); printf("Ctr2  =  %4d", ctr2); 使用 gotoxy 函数将光标移动到屏幕上的特定位置，并使用 printf 函数打印时钟和计数器的值。 %02d 格式化字符串确保分钟和秒以两位数字显示。

代码

void far DispTask(void *data) {     UWORD ctr1, ctr2;     UBYTE min,  sec;     while (1) {         OSTimeDly(6);         OSSemPend(&Sem, 0);         ctr1 = Ctr1;         ctr2 = Ctr2;         min  = Min;         sec  = Sec;         OSSemPost(&Sem);         gotoxy(1, 9);         printf("Clock = %02d:%02d", min, sec);         gotoxy(1, 10);         printf("Ctr1  =  %4d", ctr1);         gotoxy(1, 11);         printf("Ctr2  =  %4d", ctr2);     } }

UCOS186C.C

UBYTE OSTaskCreate(void (far *task)(void *dptr), void  *data, void  *pstk, UBYTE  p)

这段代码是uCOS操作系统中用于创建新任务的函数 OSTaskCreate 的实现。 这个函数负责初始化一个新的任务控制块（TCB），设置任务的堆栈，并将其添加到就绪任务列表中。 实现创建新任务的关键部分，它负责设置任务的堆栈和TCB，并确保新任务能够被操作系统调度和执行。

1.函数声明： UBYTE OSTaskCreate(void (far *task)(void *dptr), void  *data, void  *pstk, UBYTE  p) 这个函数接受四个参数：任务函数的指针 task，传递给任务的数据 data，任务的堆栈指针 pstk，以及任务的优先级 p。函数返回一个无符号字节，表示创建任务的结果。

2.检查任务是否已存在： if (OSTCBPrioTbl[p] == (OS_TCB *)0) { 检查优先级为 p 的任务是否已经存在。 如果已经存在，则不创建新任务，并返回错误代码 OS_PRIO_EXIST。

3.获取空闲的任务控制块（TCB）： ptr = OSTCBGetFree(); OSTCBGetFree 函数从空闲TCB列表中获取一个空闲的TCB。

4.初始化TCB： ptr->OSTCBPrio = (UBYTE)p; ptr->OSTCBStat = OS_STAT_RDY; ptr->OSTCBDly = 0; 这些行代码初始化TCB的优先级、状态（就绪）和延迟时间（0）。

5.设置任务堆栈： stk = (UWORD *)pstk; *--stk = (UWORD)FP_OFF(data); *--stk = (UWORD)FP_SEG(task); *--stk = (UWORD)FP_OFF(task); *--stk = (UWORD)0x0200; // PSW = Int. En. *--stk = (UWORD)FP_SEG(task); *--stk = (UWORD)FP_OFF(task); *--stk = (UWORD)0x0000; // AX = 0 *--stk = (UWORD)0x0000; // CX = 0 *--stk = (UWORD)0x0000; // DX = 0 *--stk = (UWORD)0x0000; // BX = 0 *--stk = (UWORD)0x0000; // SP = 0 *--stk = (UWORD)0x0000; // BP = 0 *--stk = (UWORD)0x0000; // SI = 0 *--stk = (UWORD)0x0000; // DI = 0 *--stk = (UWORD)0x0000; // ES = 0 这些行代码设置任务的堆栈，包括数据段、代码段、程序状态字（PSW）、寄存器值等。 这是为任务切换时保存和恢复上下文做准备。

6.更新TCB和就绪任务列表： ptr->OSTCBStkPtr = (void *)stk; OSTCBPrioTbl[p] = ptr; 更新TCB的堆栈指针，并将TCB添加到优先级表中。

7.添加任务到就绪任务列表： OS_ENTER_CRITICAL(); ptr->OSTCBNext = OSTCBList; ptr->OSTCBPrev = (OS_TCB *)0; if (OSTCBList != (OS_TCB *)0) {     OSTCBList->OSTCBPrev = ptr; } OSTCBList = ptr; OSRdyGrp |= OSMapTbl[p >> 3]; OSRdyTbl[p >> 3] |= OSMapTbl[p & 0x07]; OS_EXIT_CRITICAL(); 将新任务添加到就绪任务列表中，并更新就绪任务组和表。

8.调度：  if (OSRunning) {     OSSched(); } 如果操作系统已经在运行，调用 OSSchedule 函数进行任务调度。

代码

#include "INCLUDES.H" #pragma  inline extern UBYTE    OSMapTbl[]; extern UBYTE    OSUnMapTbl[]; /* *********************************************************** *                    CREATE A TASK *********************************************************** */ UBYTE OSTaskCreate(void (far *task)(void *dptr), void  *data, void  *pstk, UBYTE  p) {     OS_TCB *ptr;     UWORD  *stk;     if (OSTCBPrioTbl[p] == (OS_TCB *)0) {                       /* Avoid creating task if already exist */         ptr              = OSTCBGetFree();         ptr->OSTCBPrio   = (UBYTE)p;         ptr->OSTCBStat   = OS_STAT_RDY;         ptr->OSTCBDly    = 0;         stk              = (UWORD *)pstk;                       /* 80186/80188 Small Model              */         *--stk           = (UWORD)FP_OFF(data);         *--stk           = (UWORD)FP_SEG(task);         *--stk           = (UWORD)FP_OFF(task);         *--stk           = (UWORD)0x0200;                       /* PSW = Int. En.                       */         *--stk           = (UWORD)FP_SEG(task);         *--stk           = (UWORD)FP_OFF(task);         *--stk           = (UWORD)0x0000;                       /* AX = 0                               */         *--stk           = (UWORD)0x0000;                       /* CX = 0                               */         *--stk           = (UWORD)0x0000;                       /* DX = 0                               */         *--stk           = (UWORD)0x0000;                       /* BX = 0                               */         *--stk           = (UWORD)0x0000;                       /* SP = 0                               */         *--stk           = (UWORD)0x0000;                       /* BP = 0                               */         *--stk           = (UWORD)0x0000;                       /* SI = 0                               */         *--stk           = (UWORD)0x0000;                       /* DI = 0                               */         *--stk           = (UWORD)0x0000;                       /* ES = 0                               */         ptr->OSTCBStkPtr = (void *)stk;                         /* Load SP in TCB                       */         OSTCBPrioTbl[p]  = ptr;         OS_ENTER_CRITICAL();         ptr->OSTCBNext        = OSTCBList;         ptr->OSTCBPrev        = (OS_TCB *)0;         if (OSTCBList != (OS_TCB *)0) {                         /* Rev. A, This line was missing        */             OSTCBList->OSTCBPrev = ptr;         }         OSTCBList             = ptr;         OSRdyGrp             |= OSMapTbl[p >> 3];         OSRdyTbl[p >> 3]     |= OSMapTbl[p & 0x07];         OS_EXIT_CRITICAL();         if (OSRunning) {             OSSched();         }         return (OS_NO_ERR);     } else {         return (OS_PRIO_EXIST);     } }

UCOS.C

核心部分，包含了操作系统的初始化、任务调度、同步机制（信号量、邮箱、队列）的实现。

UBYTE OSMboxInit(OS_MBOX *pmbox, void *msg); void *OSMboxPend(OS_MBOX *pmbox, UWORD timeout, UBYTE *err); UBYTE OSMboxPost(OS_MBOX *pmbox, void *msg); 这些函数用于初始化、等待和发送邮箱消息。

UBYTE OSQInit(OS_Q *pq, void **start, UBYTE size); void *OSQPend(OS_Q *pq, UWORD timeout, UBYTE *err); UBYTE OSQPost(OS_Q *pq, void *msg); 这些函数用于初始化、等待和发送队列消息。

UBYTE OSSemInit(OS_SEM *psem, WORD cnt); UBYTE OSSemPend(OS_SEM *psem, UWORD timeout); UBYTE OSSemPost(OS_SEM *psem); 这些函数用于初始化、等待和释放信号量。

TABLES

UBYTE const OSMapTbl[]   = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; UBYTE const OSUnMapTbl[] = {...}; OSMapTbl 和 OSUnMapTbl 是两个映射表，用于将优先级映射到就绪表和组中，以及反向映射。

OS_TCB     *OSTCBCur; OS_TCB     *OSTCBHighRdy; OS_TCB     *OSTCBList; OS_TCB     *OSTCBPrioTbl[64]; BOOLEAN     OSRunning; UBYTE       OSRdyGrp; UBYTE       OSRdyTbl[8]; UBYTE       OSLockNesting; UBYTE       OSIntNesting; OS_TCB     *OSTCBFreeList; 这些全局变量用于跟踪当前任务、就绪任务列表、任务优先级表、运行状态、就绪组和表、锁定嵌套和中断嵌套等。

void OSInit(void *idle_task_stk, UBYTE maxtasks) 初始化操作系统，包括设置全局变量、初始化任务控制块列表和空闲任务。

全局变量初始化： OSTCBCur = (OS_TCB *)0;     初始化当前任务指针为 NULL。 OSTCBList = (OS_TCB *)0;     初始化任务列表头指针为 NULL。 OSIntNesting = 0;     初始化中断嵌套层数为0。 OSLockNesting = 0;     初始化调度锁定嵌套层数为0。 OSRunning = 0;      初始化操作系统运行状态为0（停止状态）。 就绪表初始化： OSRdyGrp = 0; 初始化就绪组为0。 for (i = 0; i < 8; i++) { OSRdyTbl[i] = 0; } 初始化8个就绪表字节为0。 任务优先级表初始化： for (i = 0; i < 64; i++) { OSTCBPrioTbl[i] = (OS_TCB *)0; } 初始化64个任务优先级表项为 NULL。 任务控制块链表初始化： for (i = 0; i < (maxtasks - 1); i++) { OSTCBTbl[i].OSTCBNext = &OSTCBTbl[i+1]; } 将任务控制块数组链接成一个链表。 OSTCBTbl[maxtasks-1].OSTCBNext = (OS_TCB *)0; 将链表的最后一个节点的 OSTCBNext 设置为 NULL。 空闲任务控制块初始化： OSTCBFreeList = &OSTCBTbl[0]; 初始化空闲任务控制块列表头指针为任务控制块数组的第一个元素。 创建空闲任务： OSTaskCreate(OSTaskIdle, (void *)0, idle_task_stk, OS_LO_PRIO); 创建空闲任务，这是操作系统在没有其他任务运行时执行的任务。 这个初始化函数是操作系统启动前的重要步骤，它确保了操作系统的核心数据结构被正确设置，为后续的任务创建和调度提供了基础。在调用 OSInit 之后，操作系统才能开始调度任务执行。

static void  far   OSTaskIdle(void *data); 定义了空闲任务，这是一个空循环，用于在系统没有其他任务运行时占用CPU。

void OSStart(void) 启动多任务处理，选择最高优先级的任务开始执行。

1. 局部变量：     UBYTE x, y, p;：定义了三个无符号字节（UBYTE）类型的变量，用于存储中间计算结果。     这些变量在函数内部被用来遍历任务就绪表和优先级映射表。 2. 选择最高优先级的就绪任务： y = OSUnMapTbl[OSRdyGrp];：    从就绪组（OSRdyGrp）的映射表中获取一个索引值。就绪组是一个表示哪些优先级的任务组处于就绪状态的位图。 x = OSRdyTbl[y];：    使用这个索引值从就绪表中获取另一个索引值。就绪表是一个数组，每个元素指向一个包含特定优先级下就绪任务位图的表。 p = (y << 3) + OSUnMapTbl[x];：      通过一系列的计算，得到最高优先级就绪任务的优先级。这里 (y << 3) 是将就绪组的索引左移3位（因为每个就绪组包含8个优先级，所以左移3位相当于乘以8），然后加上从就绪表中获取的具体优先级的偏移量。 3. 设置当前任务和操作系统运行状态： OSTCBHighRdy = OSTCBPrioTbl[p];：     根据计算出的优先级，从优先级表中获取对应任务的任务控制块（TCB），并将其设置为最高优先级就绪任务的任务控制块。 OSTCBCur = OSTCBHighRdy;：     将当前任务（OSTCBCur）设置为最高优先级就绪任务。 OSRunning = 1;：     将操作系统运行状态（OSRunning）设置为1，表示操作系统已经开始运行。 4. 启动最高优先级就绪任务： OSStartHighRdy();：这个函数用于实际启动最高优先级就绪任务。 OSStart 函数通常只在操作系统初始化期间调用一次，以启动多任务环境。一旦调用 OSStart，控制权通常会转移到最高优先级就绪任务，并且只有在任务主动放弃CPU时，才会再次回到调度器。

void OSSched(void) 任务调度函数，选择最高优先级的任务执行，并进行上下文切换。

1. 函数定义：void OSSched(void) 是一个没有返回值和参数的函数，用于操作系统的调度逻辑。 2. 局部变量：     UBYTE x, y, p;  ：     定义了三个无符号字节（UBYTE）类型的变量，用于存储中间计算结果。 3. 进入临界区：     OS_ENTER_CRITICAL();     这条语句用于进入临界区，保证在执行调度逻辑时不会被其他中断或任务打断，以保证数据的一致性和完整性。 4. 检查锁定和中断嵌套级别：     if (OSLockNesting == 0 && OSIntNesting == 0)：     这个条件判断确保在没有任务锁定（OSLockNesting）和中断嵌套（OSIntNesting）的情况下才进行任务调度。这是为了避免在不应该调度的时候进行调度，比如在中断处理过程中或任务被锁定时。 5. 选择最高优先级的任务： y = OSUnMapTbl[OSRdyGrp];：          从就绪组（OSRdyGrp）的映射表中获取一个索引值。 x = OSRdyTbl[y];：                               使用这个索引值从就绪表中获取另一个索引值。 p = (y << 3) + OSUnMapTbl[x];：       通过一系列的计算，得到最高优先级任务的优先级。 OSTCBHighRdy = OSTCBPrioTbl[p];：根据计算出的优先级，从优先级表中获取对应任务的任务控制块（TCB）。 6. 任务切换： if (OSTCBHighRdy != OSTCBCur)：      如果最高优先级的任务不是当前正在执行的任务，则需要进行任务切换。 OS_TASK_SW();：                                  执行任务切换操作，切换到最高优先级的任务。 7. 退出临界区：OS_EXIT_CRITICAL();     退出临界区，允许其他中断或任务继续执行。

void OSIntEnter(void); void OSIntExit(void); 这些函数用于处理中断的进入和退出，确保在中断处理期间不进行任务调度。

1. 进入临界区： OS_ENTER_CRITICAL(); 这条语句用于进入临界区。 2. 增加中断嵌套计数器： OSIntNesting++; 这条语句将中断嵌套计数器（OSIntNesting）的值增加1。 中断嵌套计数器用于跟踪当前中断的嵌套级别。当操作系统在处理一个中断时，如果另一个中断发生，中断嵌套计数器就会增加，以确保在中断处理过程中不会进行任务调度（因为任务调度通常不应该在中断处理过程中进行）。 3. 退出临界区： OS_EXIT_CRITICAL(); 退出临界区后，其他任务或中断服务程序可以访问被保护的共享资源。

void OSTimeDly(UWORD ticks) 使当前任务延时指定的时钟节拍数。

1. 函数定义： void OSTimeDly(UWORD ticks) 是一个接受一个无符号字（UWORD）类型参数 ticks 的函数，该参数指定了任务延迟的时间片数。函数没有返回值。 2. 局部变量： UBYTE p;： 定义了一个无符号字节（UBYTE）类型的变量 p，用于存储当前任务的优先级。 3. 进入临界区： OS_ENTER_CRITICAL(); 这条语句用于进入临界区，以确保在修改任务就绪表和优先级表时不会被其他任务或中断打断。 4. 获取并修改当前任务的优先级： p = OSTCBCur->OSTCBPrio;： 从当前任务的任务控制块（TCB）中获取当前任务的优先级，并将其存储在变量 p 中。 if ((OSRdyTbl[p >> 3] &= ~OSMapTbl[p & 0x07]) == 0)： 这一行代码首先通过位运算获取当前优先级在就绪表中的位置，然后使用位与和位取反操作将该优先级对应的位清零（即从就绪表中移除当前任务）。如果清零后的就绪表项为0，表示该优先级下没有就绪任务。 OSRdyGrp &= ~OSMapTbl[p >> 3];： 如果当前优先级下没有就绪任务，则将从就绪组中对应的位也清零，表示该组中没有就绪任务。 5. 设置当前任务的延迟时间： OSTCBCur->OSTCBDly = ticks;： 将当前任务的延迟时间设置为参数 ticks 指定的值。 6. 退出临界区：OS_EXIT_CRITICAL();   7. 调用调度函数：OSSched(); 调用任务调度函数，以重新评估哪些任务是就绪的，并选择一个新的最高优先级就绪任务来执行。由于当前任务已经被挂起，因此调度函数可能会选择另一个任务来执行。

void OSTimeTick(void) 处理系统时钟滴答，更新任务的延时和就绪状态。

1. 局部变量： UBYTE p;：         定义了一个无符号字节（UBYTE）类型的变量 p，用于存储任务的优先级。 OS_TCB *ptcb;：定义了一个指向任务控制块（TCB）的指针 ptcb，用于遍历任务列表。 2. 遍历任务列表： ptcb = OSTCBList;：     将 ptcb 初始化为指向任务列表的起始位置。 while (ptcb->OSTCBPrio != OS_LO_PRIO)：  遍历任务列表，直到遇到最低优先级的任务（OS_LO_PRIO）。这里任务列表是按优先级顺序排列的，且最低优先级的任务作为列表的结束标志。 3. 处理每个任务的延迟： OS_ENTER_CRITICAL();：         进入临界区，以确保在修改任务就绪表和延迟时间时不会被其他任务或中断打断。 if (ptcb->OSTCBDly != 0)：     检查当前任务的延迟时间是否不为0。 if (--ptcb->OSTCBDly == 0)：如果延迟时间大于0，则将其减1，并检查是否减为0。                                                  如果延迟时间减为0，表示任务延迟到期。 p = ptcb->OSTCBPrio;：          获取当前任务的优先级。 OSRdyGrp |= OSMapTbl[p >> 3];：                将就绪组中对应的位设置为1，表示该组中有就绪任务。 OSRdyTbl[p >> 3] |= OSMapTbl[p & 0x07];：将就绪表中对应的位设置为1，表示该优先级下有就绪任务。 OS_EXIT_CRITICAL();：                                     退出临界区，允许其他任务或中断继续执行。 4. 移动到下一个任务： ptcb = ptcb->OSTCBNext;：     将 ptcb 更新为指向下一个任务的指针。

OS_TCB *OSTCBGetFree(void) 获取空闲TCB、更新空闲列表、分配TCB给任务、链接到已分配列表。

1. 函数定义：OS_TCB *OSTCBGetFree(void) 是一个返回 OS_TCB 类型指针的函数，该指针指向一个空闲的任务控制块。函数没有参数。 2. 局部变量： OS_TCB *ptcb;：定义了一个指向 OS_TCB 类型的指针 ptcb，用于存储从空闲列表中获取的 TCB 的地址。 3. 进入临界区： OS_ENTER_CRITICAL();：这条语句用于进入临界区，以确保在访问和修改 TCB 空闲列表时不会被其他任务或中断打断。临界区的实现可能依赖于禁用中断、使用锁或其他同步机制。 4. 获取空闲 TCB： ptcb = OSTCBFreeList;：将 ptcb 设置为指向当前空闲列表的起始 TCB（即 OSTCBFreeList 指向的 TCB）。 OSTCBFreeList = ptcb->OSTCBNext;：更新空闲列表的起始位置，使其指向下一个空闲的 TCB。这里 OSTCBNext 字段在 TCB 结构中用于链接空闲列表中的 TCB。 5. 退出临界区： OS_EXIT_CRITICAL();：这条语句用于退出临界区，允许其他任务或中断继续执行。 6. 返回空闲 TCB： return (ptcb);：返回指向获取的空闲 TCB 的指针。

void OSLock(void) 锁定任务调度，增加调度锁计数（原子性操作）。

增加嵌套锁定计数器： OSLockNesting++;：在临界区内，将 OSLockNesting 变量的值增加1。 这个变量用于跟踪锁的嵌套级别，即同一个任务或中断处理程序已经获取了多少次锁。

void OSLock(void) {     OS_ENTER_CRITICAL();     OSLockNesting++;     OS_EXIT_CRITICAL(); }

void OSUnlock(void) 解锁任务调度，允许任务调度器重新进行任务切换。

减少嵌套锁定计数器： OSLockNesting--;：在临界区内，将 OSLockNesting 变量的值减少1。 这个变量用于跟踪锁的嵌套级别，即同一个任务或中断处理程序已经释放了多少次锁。 如果 OSLockNesting 变为0，则表示所有通过 OSLock 获取的锁都已经被释放。 重新调度： OSSched();：在退出临界区后，调用 OSSched 函数来检查是否有更高优先级的任务已经就绪，并可能需要运行。如果系统处于多任务环境，OSSched 函数将确保任务调度器运行，并根据需要切换任务。

void OSUnlock(void) {     OS_ENTER_CRITICAL();     OSLockNesting--;     OS_EXIT_CRITICAL();     OSSched(); }

UBYTE OSChangePrio(UBYTE newp) 改变任务优先级。

UBYTE oldp;：用于存储当前任务的旧优先级。 1. if (OSTCBPrioTbl[newp] != (void *)0)： 检查优先级表（OSTCBPrioTbl）中是否已经存在一个任务具有指定的新优先级。 如果存在，则退出临界区并返回 OS_PRIO_EXIST。 2. 更改优先级： 如果新优先级未被占用，则继续执行以下步骤： oldp = OSTCBCur->OSTCBPrio;：      获取当前任务的旧优先级。 更新就绪表和就绪组，以反映当前任务从旧优先级到新优先级的移动。这包括清除旧优先级在就绪表和就绪组中的标记，并设置新优先级在就绪表和就绪组中的标记。 OSTCBCur->OSTCBPrio = newp;：     更改当前任务的优先级。 更新优先级表，将当前任务与新优先级关联，并清除旧优先级的关联。 3.重新调度： OSSched();：调用任务调度器以检查是否有更高优先级的任务已经就绪，并可能需要运行。 OSTCBCur  是一个指向当前正在运行的任务的任务控制块（TCB）的指针。 OSTCBPrioTbl  是一个数组，用于将优先级映射到对应的任务控制块。 OSRdyTbl 和 OSRdyGrp  分别表示就绪表和就绪组，它们用于跟踪哪些优先级的任务已经就绪。 OSMapTbl  是一个映射表，用于将优先级映射到就绪表和就绪组中的位。 OS_ENTER_CRITICAL 和 OS_EXIT_CRITICAL 的实现依赖于禁用中断、使用原子操作或获取互斥锁等同步机制。

UBYTE OSChangePrio(UBYTE newp) {     UBYTE oldp;     OS_ENTER_CRITICAL();     if (OSTCBPrioTbl[newp] != (void *)0)     {         OS_EXIT_CRITICAL();         return (OS_PRIO_EXIST);     }     else     {         oldp = OSTCBCur->OSTCBPrio;         if ((OSRdyTbl[oldp >> 3] &= ~OSMapTbl[oldp & 0x07]) == 0)         {             OSRdyGrp &= ~OSMapTbl[oldp >> 3];         }         OSRdyGrp |= OSMapTbl[newp >> 3];         OSRdyTbl[newp >> 3] |= OSMapTbl[newp & 0x07];         OSTCBCur->OSTCBPrio = newp;         OSTCBPrioTbl[newp] = OSTCBCur;         OSTCBPrioTbl[oldp] = (void *)0;         OS_EXIT_CRITICAL();         OSSched();         return (OS_NO_ERR);     } }

void OSTaskDelete(void) 删除一个任务。

1. 进入临界区： OS_ENTER_CRITICAL();：进入临界区以确保在删除任务时不会被其他任务或中断打断。 2. 获取当前任务的优先级： p = OSTCBCur->OSTCBPrio;：从当前任务的任务控制块（TCB）中获取优先级。 3. 从优先级表中删除任务： OSTCBPrioTbl[p] = (OS_TCB *)0;：将优先级表中的对应条目设置为空，表示该优先级不再与任何任务关联。 4. 更新就绪表和就绪组： 通过位操作清除当前任务在就绪表和就绪组中的标记。如果清除后对应的就绪表项为0，则还需要清除就绪组中的对应位。 5. 从任务链表中删除当前任务： 如果当前任务没有前一个任务（OSTCBCur->OSTCBPrev == (OS_TCB *)0），则它必须是任务链表的头节点。此时，将头节点更新为当前任务的下一个任务，并将下一个任务的 OSTCBPrev 设置为空。 如果当前任务有前一个任务，则需要更新前一个任务和下一个任务之间的链接，以绕过当前任务。 6. 将当前任务添加到空闲任务链表： 将当前任务的 OSTCBNext 指向当前的空闲任务链表头（OSTCBFreeList），然后将空闲任务链表头更新为当前任务。这样，当前任务就变成了可用的空闲任务，可以在将来被重新分配。 7. 退出临界区： OS_EXIT_CRITICAL();：退出临界区以允许其他任务或中断继续执行。 8. 重新调度： OSSched();：调用任务调度器以检查是否有其他任务已经就绪，并可以运行。由于当前任务已被删除，任务调度器将选择一个新的最高优先级的就绪任务来运行。

void OSTaskDelete(void) {     UBYTE p;     OS_ENTER_CRITICAL();     p = OSTCBCur->OSTCBPrio;     OSTCBPrioTbl[p] = (OS_TCB *)0;     if ((OSRdyTbl[p >> 3] &= ~OSMapTbl[p & 0x07]) == 0)     {         OSRdyGrp &= ~OSMapTbl[p >> 3];     }     if (OSTCBCur->OSTCBPrev == (OS_TCB *)0)     {         OSTCBCur->OSTCBNext->OSTCBPrev = (OS_TCB *)0;         OSTCBList = OSTCBCur->OSTCBNext; /* Rev. A, This line was missing   */     }     else     {         OSTCBCur->OSTCBPrev->OSTCBNext = OSTCBCur->OSTCBNext;         OSTCBCur->OSTCBNext->OSTCBPrev = OSTCBCur->OSTCBPrev;     }     OSTCBCur->OSTCBNext = OSTCBFreeList;     OSTCBFreeList = OSTCBCur;     OS_EXIT_CRITICAL();     OSSched(); }

UBYTE OSSemInit(OS_SEM *psem, WORD cnt) 初始化一个信号量的数据结构。

1. 检查初始计数： if (cnt >= 0)：检查提供的初始计数是否非负。如果是负数，则初始化失败。 2. 初始化信号量结构体： psem->OSSemCnt = cnt;：       将信号量的当前计数设置为提供的初始计数。 psem->OSSemGrp = 0x00;：    初始化信号量的就绪组为0。就绪组通常用于跟踪哪些任务或线程正在等待信号量。 psem->OSSemTbl[...] = 0x00;：初始化信号量的就绪表为0。就绪表是一个位数组，用于表示哪些任务或线程已经等待信号量。这里初始化了8个字节（64位）。 3. 返回结果： 如果初始计数非负且信号量成功初始化，则返回无错误代码（OS_NO_ERR）。 如果初始计数为负数，则返回信号量错误代码（OS_SEM_ERR）。 *在临界区的操作

UBYTE OSSemInit(OS_SEM *psem, WORD cnt) {     OS_ENTER_CRITICAL();     if (cnt >= 0)     {         psem->OSSemCnt = cnt;         psem->OSSemGrp = 0x00;         psem->OSSemTbl[0] = 0x00;         psem->OSSemTbl[1] = 0x00;         psem->OSSemTbl[2] = 0x00;         psem->OSSemTbl[3] = 0x00;         psem->OSSemTbl[4] = 0x00;         psem->OSSemTbl[5] = 0x00;         psem->OSSemTbl[6] = 0x00;         psem->OSSemTbl[7] = 0x00;         OS_EXIT_CRITICAL();         return (OS_NO_ERR);     }     else     {         OS_EXIT_CRITICAL();         return (OS_SEM_ERR);     } }

UBYTE OSSemPend(OS_SEM *psem, UWORD timeout) 等待（pend）一个信号量   wait()

1. 函数定义： UBYTE OSSemPend(OS_SEM *psem, UWORD timeout)： 函数返回一个 UBYTE 类型的错误代码，并接受一个指向信号量结构体的指针 psem 和一个超时时间 timeout作为参数。 2. 进入临界区： 3. 尝试获取信号量： if (psem->OSSemCnt-- > 0)： 如果信号量的当前计数大于0，则减少计数并立即返回无错误代码（OS_NO_ERR），表示成功获取信号量。 4. 任务挂起： 如果信号量的计数为0，则需要将当前任务挂起以等待信号量。 OSTCBCur->OSTCBStat |= OS_STAT_SEM;：设置当前任务的状态为等待信号量。 OSTCBCur->OSTCBDly = timeout;：设置当前任务的延迟（超时）时间。 5. 更新就绪表和就绪组： 通过位操作清除当前任务在就绪表和就绪组中的标记，并将其添加到信号量的等待表中。 6. 退出临界区并调度： OS_EXIT_CRITICAL();：退出临界区。 OSSched();：调用任务调度器以选择另一个就绪的任务来运行。由于当前任务被挂起，调度器将选择一个具有最高优先级的就绪任务。 7. 重新进入临界区并检查任务状态： OS_ENTER_CRITICAL();：重新进入临界区以检查当前任务的状态。 如果当前任务的状态仍然是等待信号量（OS_STAT_SEM），则检查是否发生了超时。 如果超时发生，则清除当前任务在信号量等待表中的标记，并将其状态设置为就绪（OS_STAT_RDY）。 返回超时错误代码（OS_TIMEOUT）。 如果当前任务的状态不再是等待信号量，这意味着它在等待期间被信号量唤醒（即信号量变得可用），因此可以退出临界区并返回无错误代码（OS_NO_ERR）。

UBYTE OSSemPend(OS_SEM *psem, UWORD timeout) {     UBYTE x, y, bitx, bity;     OS_ENTER_CRITICAL();     if (psem->OSSemCnt-- > 0)     {         OS_EXIT_CRITICAL();         return (OS_NO_ERR);     }     else     {         OSTCBCur->OSTCBStat |= OS_STAT_SEM;         OSTCBCur->OSTCBDly = timeout;         y = OSTCBCur->OSTCBPrio >> 3;         x = OSTCBCur->OSTCBPrio & 0x07;         bity = OSMapTbl[y];         bitx = OSMapTbl[x];         if ((OSRdyTbl[y] &= ~bitx) == 0)             OSRdyGrp &= ~bity;         psem->OSSemTbl[y] |= bitx;         psem->OSSemGrp |= bity;         OS_EXIT_CRITICAL();         OSSched();         OS_ENTER_CRITICAL();         if (OSTCBCur->OSTCBStat & OS_STAT_SEM)         {             if ((psem->OSSemTbl[y] &= ~bitx) == 0)             {                 psem->OSSemGrp &= ~bity;             }             OSTCBCur->OSTCBStat = OS_STAT_RDY;             OS_EXIT_CRITICAL();             return (OS_TIMEOUT);         }         else         {             OS_EXIT_CRITICAL();             return (OS_NO_ERR);         }     } }

UBYTE OSSemPost(OS_SEM *psem) 释放（post）一个信号量的函数   signal()

1. 函数定义： UBYTE OSSemPost(OS_SEM *psem)：函数返回一个 UBYTE 类型的错误代码，并接受一个指向信号量结构体的指针 psem 作为参数。 2. 进入临界区： OS_ENTER_CRITICAL();：进入临界区以确保在修改信号量状态和任务状态时不会被其他任务或中断打断。 3. 检查并更新信号量计数： if (psem->OSSemCnt < 32767)：首先检查信号量的当前计数是否小于32767（这是为了防止计数溢出）。 if (psem->OSSemCnt++ >= 0)：然后增加信号量的计数，并检查增加后的计数是否非负。这个条件始终为真，因为前面的检查确保了计数小于32767，所以增加1后不会变成负数。 **这里的条件判断似乎是多余的，因为无论计数是否非负，后续的代码都需要执行。 4. 处理等待的任务： 如果信号量的等待组（OSSemGrp）不为0，表示有任务在等待该信号量。 通过查找等待表和就绪组来确定哪个任务在等待信号量，并清除其在等待表中的标记。 如果清除标记后，该优先级的等待表为空，则还需要清除对应的就绪组标记。 通过计算得到等待任务的优先级，并将其从等待信号量状态更改为就绪状态，同时清除其延迟时间。 更新就绪组和就绪表，以反映任务现在已就绪。 5. 退出临界区并调度： OS_EXIT_CRITICAL();：退出临界区。 OSSched();：调用任务调度器以选择另一个就绪的任务来运行。由于可能有任务被唤醒，调度器将选择一个具有最高优先级的就绪任务。 6. 返回结果： 如果信号量计数成功增加且没有溢出，则返回无错误代码（OS_NO_ERR）。 如果信号量计数达到或超过32767，则返回信号量溢出错误代码（OS_SEM_OVF）。

UBYTE OSSemPost(OS_SEM *psem) {     UBYTE x, y, bitx, bity, p;     OS_ENTER_CRITICAL();     if (psem->OSSemCnt < 32767)     {         if (psem->OSSemCnt++ >= 0)         {             OS_EXIT_CRITICAL();         }         else         {             if (psem->OSSemGrp != 0)             { /* Rev. A, This line was missing   */                 y = OSUnMapTbl[psem->OSSemGrp];                 x = OSUnMapTbl[psem->OSSemTbl[y]];                 bity = OSMapTbl[y];                 bitx = OSMapTbl[x];                 if ((psem->OSSemTbl[y] &= ~bitx) == 0)                 {                     psem->OSSemGrp &= ~bity;                 }                 p = (y << 3) + x;                 OSTCBPrioTbl[p]->OSTCBDly = 0;                 OSTCBPrioTbl[p]->OSTCBStat &= ~OS_STAT_SEM;                 OSRdyGrp |= bity;                 OSRdyTbl[y] |= bitx;                 OS_EXIT_CRITICAL();                 OSSched();             }             else             {                 OS_EXIT_CRITICAL();             }         }         return (OS_NO_ERR);     }     else     {         OS_EXIT_CRITICAL();         return (OS_SEM_OVF);     } }

UBYTE OSMboxInit(OS_MBOX *pmbox, void *msg) 初始化一个邮箱。

初始化消息邮箱： pmbox->OSMboxMsg = msg;： 将传入的消息指针 msg 赋值给消息邮箱结构体的 OSMboxMsg 成员，这是邮箱当前存储的消息。 pmbox->OSMboxGrp = 0x00;： 将消息邮箱的就绪组（OSMboxGrp）初始化为0。就绪组是一个用于表示哪些优先级的任务在等待该消息邮箱的位掩码。 pmbox->OSMboxTbl[...] = 0x00;： 将消息邮箱的等待表（OSMboxTbl）的所有元素初始化为0。等待表是一个数组，用于记录哪些优先级的任务在等待该消息邮箱的具体位。 **消息邮箱通常用于在任务之间传递简单的数据或消息。与信号量不同，消息邮箱可以传递实际的数据内容，而不仅仅是信号或事件。

UBYTE OSMboxInit(OS_MBOX *pmbox, void *msg) {     OS_ENTER_CRITICAL();     pmbox->OSMboxMsg = msg;     pmbox->OSMboxGrp = 0x00;     pmbox->OSMboxTbl[0] = 0x00;     pmbox->OSMboxTbl[1] = 0x00;     pmbox->OSMboxTbl[2] = 0x00;     pmbox->OSMboxTbl[3] = 0x00;     pmbox->OSMboxTbl[4] = 0x00;     pmbox->OSMboxTbl[5] = 0x00;     pmbox->OSMboxTbl[6] = 0x00;     pmbox->OSMboxTbl[7] = 0x00;     OS_EXIT_CRITICAL();     return (OS_NO_ERR); }

void *OSMboxPend(OS_MBOX *pmbox, UWORD timeout, UBYTE *err) 从邮箱接收消息。

1. 函数定义： void *OSMboxPend(OS_MBOX *pmbox, UWORD timeout, UBYTE *err)： 函数返回一个指向消息的指针，并接受三个参数：一个指向消息邮箱结构体的指针 pmbox，一个超时值 timeout（以系统时钟滴答数表示），以及一个指向错误代码的指针 err。 2. 进入临界区： 3. 检查消息邮箱： 如果消息邮箱中有消息（pmbox->OSMboxMsg != (void *)0），则立即获取消息，将消息邮箱的消息指针设置为空，退出临界区，并返回无错误代码（OS_NO_ERR）。 4. 挂起当前任务： 如果消息邮箱中没有消息，则将当前任务的状态设置为等待消息（OS_STAT_MBOX），并设置超时值。 计算当前任务的优先级在就绪表和就绪组中的位置，并清除其在就绪表中的标记。如果清除后该优先级的就绪表为空，则还需要清除对应的就绪组标记。 将当前任务的优先级添加到消息邮箱的等待表中，并设置对应的就绪组标记。 5. 退出临界区并调度： OS_EXIT_CRITICAL();：退出临界区。 OSSched();：调用任务调度器以选择另一个就绪的任务来运行。由于当前任务被挂起等待消息，调度器将选择一个具有最高优先级的就绪任务。 6. 重新进入临界区并检查任务状态： OS_ENTER_CRITICAL();：  重新进入临界区以检查当前任务的状态。 如果当前任务仍然处于等待消息的状态（OSTCBCur->OSTCBStat & OS_STAT_MBOX），则表示超时发生或消息尚未到达。此时，清除任务在消息邮箱等待表中的标记，并根据需要清除就绪组标记。将任务状态设置为就绪（OS_STAT_RDY），返回空消息指针，并设置超时错误代码（OS_TIMEOUT）。 如果当前任务的状态不再是等待消息，则表示在调度期间有消息到达。此时，获取消息，将消息邮箱的消息指针设置为空，退出临界区，并返回无错误代码（OS_NO_ERR）。 7. 返回消息： 函数返回指向消息的指针（如果有消息到达）或空指针（如果超时发生）

void *OSMboxPend(OS_MBOX *pmbox, UWORD timeout, UBYTE *err) {     UBYTE x, y, bitx, bity;     void *msg;     OS_ENTER_CRITICAL();     if ((msg = pmbox->OSMboxMsg) != (void *)0)     {         pmbox->OSMboxMsg = (void *)0;         OS_EXIT_CRITICAL();         *err = OS_NO_ERR;     }     else     {         OSTCBCur->OSTCBStat |= OS_STAT_MBOX;         OSTCBCur->OSTCBDly = timeout;         y = OSTCBCur->OSTCBPrio >> 3;         x = OSTCBCur->OSTCBPrio & 0x07;         bity = OSMapTbl[y];         bitx = OSMapTbl[x];         if ((OSRdyTbl[y] &= ~bitx) == 0)         {             OSRdyGrp &= ~bity;         }         pmbox->OSMboxTbl[y] |= bitx;         pmbox->OSMboxGrp |= bity;         OS_EXIT_CRITICAL();         OSSched();         OS_ENTER_CRITICAL();         if (OSTCBCur->OSTCBStat & OS_STAT_MBOX)         {             if ((pmbox->OSMboxTbl[y] &= ~bitx) == 0)             {                 pmbox->OSMboxGrp &= ~bity;             }             OSTCBCur->OSTCBStat = OS_STAT_RDY;             msg = (void *)0;             OS_EXIT_CRITICAL();             *err = OS_TIMEOUT;         }         else         {             msg = pmbox->OSMboxMsg;             pmbox->OSMboxMsg = (void *)0;             OS_EXIT_CRITICAL();             *err = OS_NO_ERR;         }     }     return (msg); }

UBYTE OSMboxPost(OS_MBOX *pmbox, void *msg) 向消息邮箱发送消息。

1. 参数说明： OS_MBOX *pmbox：指向一个消息箱控制块的指针，该控制块包含了消息箱的状态信息和相关的消息。 void *msg：指向要发送到消息箱的消息的指针。 2. 函数开始： 使用 OS_ENTER_CRITICAL(); 进入临界区，保护共享资源免受并发访问的干扰。 3. 检查消息箱是否已满： 如果 pmbox->OSMboxMsg 不等于 (void *)0，即消息箱中已经有一个消息，则函数通过 OS_EXIT_CRITICAL(); 退出临界区，并返回 OS_MBOX_FULL 表示消息箱已满。 4.  存储消息： 如果消息箱为空，将 msg 赋值给 pmbox->OSMboxMsg，准备存储消息。 5. 处理消息箱关联的任务组：     如果 pmbox->OSMboxGrp 不为0，表示有任务组与这个消息箱关联。     使用 OSUnMapTbl 和 OSMapTbl 这两个映射表来转换任务组和任务表索引。     清除相应的位（bitx）在任务表（pmbox->OSMboxTbl[y]）中，如果这导致整个任务组的该任务表索引变为0，则也清除任务组中的相应位（bity）。     通过计算 p = (y << 3) + x;  来确定关联任务的优先级。     清除该任务的 OS_STAT_MBOX 状态位，表示消息已被处理。     将任务的延迟时间设置为0。     更新就绪组（OSRdyGrp）和任务表（OSRdyTbl[y]），使关联的任务变为就绪状态。 6. 调度： 调用 OSSched(); 进行任务调度，这可能会触发一次任务切换，以运行因接收到消息而变为就绪的任务。 7. 返回： 函数返回 OS_NO_ERR 表示消息已成功发送到消息箱。

UBYTE OSMboxPost(OS_MBOX *pmbox, void *msg) {     UBYTE x, y, bitx, bity, p;     OS_ENTER_CRITICAL();     if (pmbox->OSMboxMsg != (void *)0)     {         OS_EXIT_CRITICAL();         return (OS_MBOX_FULL);     }     else     {         pmbox->OSMboxMsg = msg;         if (pmbox->OSMboxGrp != 0)         { /* Rev. A, This line was missing   */             y = OSUnMapTbl[pmbox->OSMboxGrp];             x = OSUnMapTbl[pmbox->OSMboxTbl[y]];             bity = OSMapTbl[y];             bitx = OSMapTbl[x];             if ((pmbox->OSMboxTbl[y] &= ~bitx) == 0)             {                 pmbox->OSMboxGrp &= ~bity;             }             p = (y << 3) + x;             OSTCBPrioTbl[p]->OSTCBStat &= ~OS_STAT_MBOX;             OSTCBPrioTbl[p]->OSTCBDly = 0;             OSRdyGrp |= bity;             OSRdyTbl[y] |= bitx;             OS_EXIT_CRITICAL();             OSSched();         }         else         {             OS_EXIT_CRITICAL();         }         return (OS_NO_ERR);     } }

UBYTE OSQInit(OS_Q *pq, void **start, UBYTE size) 初始化一个消息队列。

1. 参数说明： OS_Q *pq：   指向队列控制块的指针，该控制块包含了队列的状态信息和指向队列存储空间的指针。 void **start：指向队列存储空间起始地址的指针的指针。这里使用指针的指针是因为队列的存储空间可能是一个动态分配的数组，而我们需要一个能够修改这个数组起始地址的指针（即，我们需要一个能够“指向指针”的指针，以便在函数内部改变它指向的地址）。然而，在实际应用中，这个参数通常被传递为一个已经分配好的数组的指针的地址，因此在这个函数内部，start 主要被用作一个普通的指针来访问队列的存储空间。 UBYTE size：队列能够存储的元素数量。 2. 函数开始： 使用 OS_ENTER_CRITICAL(); 进入临界区。 3. 初始化队列控制块： pq->OSQStart：设置为队列存储空间的起始地址（即 start 指向的地址）。 pq->OSQEnd：设置为队列存储空间的结束地址之后的一个位置（即 &start[size]，这里 start 被当作一个指向队列元素类型的指针来处理，因此 &start[size] 指向的是队列存储空间之后的第一个位置）。 pq->OSQIn 和 pq->OSQOut：都设置为队列存储空间的起始地址，表示队列为空，没有元素被加入，也没有元素被取出。 pq->OSQSize：设置为队列能够存储的元素数量。 pq->OSQEntries：设置为0，表示队列当前为空，没有存储任何元素。 pq->OSQGrp 和 pq->OSQTbl[0-7]：这些字段用于与队列相关联的任务组的就绪状态管理。在这个初始化函数中，它们都被设置为0，表示没有任务组与队列相关联。 4. 退出临界区： 使用 OS_EXIT_CRITICAL();  5. 返回： 函数返回 OS_NO_ERR，表示队列已成功初始化。

UBYTE OSQInit(OS_Q *pq, void **start, UBYTE size) {     OS_ENTER_CRITICAL();     pq->OSQStart = start;     pq->OSQEnd = &start[size];     pq->OSQIn = start;     pq->OSQOut = start;     pq->OSQSize = size;     pq->OSQEntries = 0;     pq->OSQGrp = 0x00;     pq->OSQTbl[0] = 0x00;     pq->OSQTbl[1] = 0x00;     pq->OSQTbl[2] = 0x00;     pq->OSQTbl[3] = 0x00;     pq->OSQTbl[4] = 0x00;     pq->OSQTbl[5] = 0x00;     pq->OSQTbl[6] = 0x00;     pq->OSQTbl[7] = 0x00;     OS_EXIT_CRITICAL();     return (OS_NO_ERR); }

void *OSQPend(OS_Q *pq, UWORD timeout, UBYTE *err) 从消息队列中等待（pend）消息的函数  wait()

进入临界区： 使用OS_ENTER_CRITICAL()。 检查队列是否为空：     如果pq->OSQEntries（队列中的消息数）不为0，则队列中有消息可用。     从pq->OSQOut（队列输出指针）指向的位置检索消息，并将其存储在局部变量msg中。     更新pq->OSQOut以指向下一个消息的位置。     如果pq->OSQOut等于pq->OSQEnd（队列末尾指针），则将其重置为pq->OSQStart（队列起始指针），实现队列的循环。     递减pq->OSQEntries以反映队列中消息数的减少。     退出临界区。     设置*err为OS_NO_ERR，表示没有错误发生。     返回检索到的消息。 队列为空时的处理：     将当前任务（OSTCBCur）的状态设置为等待队列（OS_STAT_Q）。     设置当前任务的延迟时间（OSTCBCur->OSTCBDly）为timeout。     计算当前任务优先级对应的就绪表和就绪组索引（y和x），并使用OSMapTbl找到对应的位掩码（bity和bitx）。     从全局就绪表（OSRdyTbl）和就绪组（OSRdyGrp）中移除当前任务。     将当前任务与队列相关联，通过修改pq->OSQTbl和pq->OSQGrp。     退出临界区。     调用OSSched()函数重新调度任务。     再次进入临界区以检查当前任务的状态。     如果当前任务仍然处于等待队列状态，表示超时发生。            从队列的等待表中移除当前任务。            将当前任务的状态设置为就绪（OS_STAT_RDY）。            将msg设置为NULL（(void *)0），表示没有检索到消息。            设置*err为OS_TIMEOUT，表示超时错误。            退出临界区并返回NULL。      如果当前任务不再处于等待队列状态，表示已经成功从队列中检索到消息。            重复之前的步骤来检索消息、更新指针和计数器。            设置*err为OS_NO_ERR。            退出临界区并返回检索到的消息。

void *OSQPend(OS_Q *pq, UWORD timeout, UBYTE *err) {     UBYTE x, y, bitx, bity;     void *msg;     OS_ENTER_CRITICAL();     if (pq->OSQEntries != 0)     {         msg = *pq->OSQOut++;         pq->OSQEntries--;         if (pq->OSQOut == pq->OSQEnd)         {             pq->OSQOut = pq->OSQStart;         }         OS_EXIT_CRITICAL();         *err = OS_NO_ERR;     }     else     {         OSTCBCur->OSTCBStat |= OS_STAT_Q;         OSTCBCur->OSTCBDly = timeout;         y = OSTCBCur->OSTCBPrio >> 3;         x = OSTCBCur->OSTCBPrio & 0x07;         bity = OSMapTbl[y];         bitx = OSMapTbl[x];         if ((OSRdyTbl[y] &= ~bitx) == 0)         {             OSRdyGrp &= ~bity;         }         pq->OSQTbl[y] |= bitx;         pq->OSQGrp |= bity;         OS_EXIT_CRITICAL();         OSSched();         OS_ENTER_CRITICAL();         if (OSTCBCur->OSTCBStat & OS_STAT_Q)         {             if ((pq->OSQTbl[y] &= ~bitx) == 0)             {                 pq->OSQGrp &= ~bity;             }             OSTCBCur->OSTCBStat = OS_STAT_RDY;             msg = (void *)0;             OS_EXIT_CRITICAL();             *err = OS_TIMEOUT;         }         else         {             msg = *pq->OSQOut++;             pq->OSQEntries--;             if (pq->OSQOut == pq->OSQEnd)             {                 pq->OSQOut = pq->OSQStart;             }             OS_EXIT_CRITICAL();             *err = OS_NO_ERR;         }     }     return (msg); }

UBYTE OSQPost(OS_Q *pq, void *msg) 向消息队列发送消息。

1. UBYTE OSQPost(OS_Q *pq, void *msg); UBYTE：一个无符号字节类型，通常用于表示小的整数值或状态码。 OS_Q *pq：指向队列控制块（Queue Control Block, QCB）的指针，该控制块包含了队列的状态信息和指针。 void *msg：指向要发送到队列的消息的指针。 2. 返回值 OS_NO_ERR：表示消息成功发送到队列。 OS_Q_FULL：表示队列已满，无法发送消息。 3. 函数执行流程 (1) 进入临界区： OS_ENTER_CRITICAL();保护队列的访问，防止并发操作导致的冲突。 (2) 检查队列是否已满： if (pq->OSQEntries >= pq->OSQSize) {     OS_EXIT_CRITICAL();     return (OS_Q_FULL); } 如果队列中的消息数（pq->OSQEntries）已经达到或超过了队列的容量（pq->OSQSize），则队列已满，函数将退出临界区并返回OS_Q_FULL。 (3)将消息发送到队列： *pq->OSQIn++ = msg; pq->OSQEntries++; if (pq->OSQIn == pq->OSQEnd) {     pq->OSQIn = pq->OSQStart; } 将消息msg存储在pq->OSQIn指向的位置，然后递增pq->OSQIn以指向下一个存储位置。如果pq->OSQIn达到了队列的末尾（pq->OSQEnd），则将其重置为队列的起始位置（pq->OSQStart），实现队列的环绕。 (4)处理与队列相关联的任务： 如果pq->OSQGrp不为0，表示有任务组与队列相关联。 通过OSUnMapTbl和OSMapTbl这两个映射表，找到与队列相关联的具体任务。 清除该任务在任务组中的等待队列标志位。 将该任务设置为就绪状态，并更新就绪组和就绪表。 (5)退出临界区： 在处理完与队列相关联的任务或队列为空（没有任务组与之关联）的情况下，退出临界区。 (6)返回成功： 函数返回OS_NO_ERR，表示消息成功发送到队列。

UBYTE OSQPost(OS_Q *pq, void *msg) {     UBYTE x, y, bitx, bity, p;     OS_ENTER_CRITICAL();     if (pq->OSQEntries >= pq->OSQSize)     {         OS_EXIT_CRITICAL();         return (OS_Q_FULL);     }     else     {         *pq->OSQIn++ = msg;         pq->OSQEntries++;         if (pq->OSQIn == pq->OSQEnd)         {             pq->OSQIn = pq->OSQStart;         }         if (pq->OSQGrp != 0)         { /* Rev. A, This line was missing   */             y = OSUnMapTbl[pq->OSQGrp];             x = OSUnMapTbl[pq->OSQTbl[y]];             bity = OSMapTbl[y];             bitx = OSMapTbl[x];             if ((pq->OSQTbl[y] &= ~bitx) == 0)             {                 pq->OSQGrp &= ~bity;             }             p = (y << 3) + x;             OSTCBPrioTbl[p]->OSTCBStat &= ~OS_STAT_Q;             OSTCBPrioTbl[p]->OSTCBDly = 0;             OSRdyGrp |= bity;             OSRdyTbl[y] |= bitx;             OS_EXIT_CRITICAL();             OSSched();         }         else         {             OS_EXIT_CRITICAL();         }         return (OS_NO_ERR);     } }

 收藏

立即使用

ucos

PO_aLGJzR

职业：暂无

去主页





0 条评论

下一页

为你推荐

查看更多



实时系统UCOS&FreeRTOS

毕业论文课题研究总路线