基于 STM32F103RCT6 单片机μC/OS-II 实现简易计算器设计简易计算器能够实现多个数字的加、减、乘、除等运算，能显示操作数、操作符和计算 结果，用C语言代码实现。

好的，我可以为你提供一个简单的基于 STM32F103RCT6 单片机μC/OS-II 实现简易计算器的代码实现。以下是代码：

#include <stdio.h>
#include <stdlib.h>
#include "stm32f10x.h"
#include "LCD.h"
#include "key.h"
#include "usart.h"
#include "os_cpu.h"
#include "os_cfg.h"
#include "ucos_ii.h"

#define TASK_STK_SIZE 512

static OS_STK StartTaskStk[TASK_STK_SIZE];
static OS_STK DispTaskStk[TASK_STK_SIZE];
static OS_STK KeyTaskStk[TASK_STK_SIZE];
static OS_STK CalcTaskStk[TASK_STK_SIZE];
static OS_STK UartTaskStk[TASK_STK_SIZE];

static void StartTask(void *pdata);
static void DispTask(void *pdata);
static void KeyTask(void *pdata);
static void CalcTask(void *pdata);
static void UartTask(void *pdata);

static OS_EVENT *DispQ;
static OS_EVENT *KeyQ;
static OS_EVENT *CalcQ;
static OS_EVENT *UartQ;

static char DispBuf[32];
static char KeyBuf[32];
static char CalcBuf[32];
static char UartBuf[32];

static char OpBuf[2];
static float NumBuf[2];
static float Result;

int main(void) {
    OSInit();

    DispQ = OSQCreate(&DispBuf[0], sizeof(DispBuf) / sizeof(DispBuf[0]));
    KeyQ = OSQCreate(&KeyBuf[0], sizeof(KeyBuf) / sizeof(KeyBuf[0]));
    CalcQ = OSQCreate(&CalcBuf[0], sizeof(CalcBuf) / sizeof(CalcBuf[0]));
    UartQ = OSQCreate(&UartBuf[0], sizeof(UartBuf) / sizeof(UartBuf[0]));

    OSStatInit();

    OSTaskCreate(StartTask, (void *)0, (OS_STK *)&StartTaskStk[TASK_STK_SIZE - 1], 0);
    OSTaskNameSet(0, "Start Task", NULL);

    OSStart();

    return 0;
}

static void StartTask(void *pdata) {
    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB, ENABLE);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    GPIO_Init(GPIOB, &GPIO_InitStructure);

    LCD_Init();

    KEY_Init();

    USART_Init();

    OSTaskCreate(DispTask, (void *)0, (OS_STK *)&DispTaskStk[TASK_STK_SIZE - 1], 1);
    OSTaskNameSet(1, "Display Task", NULL);

    OSTaskCreate(KeyTask, (void *)0, (OS_STK *)&KeyTaskStk[TASK_STK_SIZE - 1], 2);
    OSTaskNameSet(2, "Key Task", NULL);

    OSTaskCreate(CalcTask, (void *)0, (OS_STK *)&CalcTaskStk[TASK_STK_SIZE - 1], 3);
    OSTaskNameSet(3, "Calc Task", NULL);

    OSTaskCreate(UartTask, (void *)0, (OS_STK *)&UartTaskStk[TASK_STK_SIZE - 1], 4);
    OSTaskNameSet(4, "Uart Task", NULL);

    while (1) {
        OSTimeDlyHMSM(0, 0, 1, 0);
    }
}

static void DispTask(void *pdata) {
    char buf[32];
    float result;

    while (1) {
        if (OSQAccept(DispQ, buf, sizeof(buf))) {
            if (sscanf(buf, "%f", &result) == 1) {
                sprintf(buf, "%.1f", result);
            }

            LCD_DisplayString(0, buf);
        }

        OSTimeDly(1);
    }
}

static void KeyTask(void *pdata) {
    char buf[32];

    while (1) {
        if (KEY_Read() == KEY_UP) {
            sprintf(buf, "%.1f%c%.1f=", NumBuf[0], OpBuf[0], NumBuf[1]);
            OSQPost(CalcQ, buf);
        }

        OSTimeDly(1);
    }
}

static void CalcTask(void *pdata) {
    char buf[32];

    while (1) {
        if (OSQAccept(CalcQ, buf, sizeof(buf))) {
            if (sscanf(buf, "%.1f%c%.1f=", &NumBuf[0], &OpBuf[0], &NumBuf[1]) == 3) {
                switch (OpBuf[0]) {
                    case '+':
                        Result = NumBuf[0] + NumBuf[1];
                        break;
                    case '-':
                        Result = NumBuf[0] - NumBuf[1];
                        break;
                    case '*':
                        Result = NumBuf[0] * NumBuf[1];
                        break;
                    case '/':
                        Result = NumBuf[0] / NumBuf[1];
                        break;
                    default:
                        Result = 0;
                        break;
                }

                sprintf(buf, "%.1f", Result);
                OSQPost(DispQ, buf);

                sprintf(buf, "%.1f%c%.1f=%.1f", NumBuf[0], OpBuf[0], NumBuf[1], Result);
                OSQPost(UartQ, buf);
            }
        }

        OSTimeDly(1);
    }
}

static void UartTask(void *pdata) {
    char buf[32];

    while (1) {
        if (OSQAccept(UartQ, buf, sizeof(buf))) {
            USART_SendString(buf);
        }

        OSTimeDly(1);
    }
}

以上代码实现了基本的计算器功能，包括按键输入、数学运算和显示结果等。具体实现过程如下：

1. 在 `main()` 函数中，先初始化 μC/OS-II 嵌入式系统和相关的硬件模块。

2. 创建四个任务：显示任务、按键任务、运算任务和串口任务。其中，显示任务的优先级最低，按键任务的优先级次之，运算任务的优先级再次之，串口任务的优先级最高。

3. 在每个任务中，使用相应的套接字接收和发送消息。显示任务从显示队列中接收消息，按键任务从按键队列中接收消息，运算任务从计算队列中接收消息，串口任务从串口队列中接收消息。

4. 在按键任务中，检测到用户按下“=”键后，将当前的操作数和操作符发送到计算队列中。

5. 在计算任务中，从计算队列中接收消息，进行数学运算，并将结果发送到显示队列和串口队列中。

6. 在显示任务中，从显示队列中接收消息，将结果显示在屏幕上。

7. 在串口任务中，从串口队列中接收消息，将结果发送到串口上，实现与外部通信。

需要注意的是，以上代码仅为示例，具体实现方式可能因为硬件设计和需求不同而有所差异。