单片机串口发送当前CPU的使用率

单片机通常不具备直接获取CPU使用率的功能，因为它们的资源有限，且大多数单片机并不支持操作系统来实时监控CPU负载。如果你是在嵌入式系统环境下工作，并且你的单片机具备一定的通信能力，比如通过UART（通用异步收发传输）连接到PC或其他设备，你可以设计一个方案：

1. **模拟计算**：如果CPU占用率不是关键需求，你可以编写一段简单的程序，定时运行并计算CPU占用率的“近似值”。这可能基于特定时间段内的任务处理次数或者周期内中断计数。

2. **外部测量**：如果硬件允许，可以考虑外接专门用于测量CPU使用率的模块，如一些高级传感器或者附加的专用芯片。

当你有了一个估算值后，将其转换成ASCII字符或者其他易于发送的数据格式，然后通过串口发送出去。例如，你可以将百分比值编码为几个二进制位或字符串。

**示例发送过程：**

// 假设有一个模拟计算得到的CPU使用率（假设为25%）
const cpuUsage = 25;
char data[8]; // 一个足够大的数组存储数值和分隔符

sprintf(data, "%d%%", cpuUsage); // 将数值转换为字符串

while (Serial.available() > 0) {} // 等待串口缓冲区空闲
Serial.write(data, strlen(data)); // 发送数据

相关问题

STM32F103写出电脑串口发送指令“1111”， 单片机串口发送当前所有任务状态; 电脑串口发送指令“2222”，单片机串口发送当前CPU的使用率;

在STM32F103单片机上实现通过串口按照指令发送相应信息，需要一些步骤：

1. **初始化串口通信**：首先，你需要配置STM32F103的串口，比如USART1或USART2，设置波特率、数据位、停止位以及校验模式。

// 初始化USART1
void USART_Init(void) {
   GPIO_InitTypeDef GPIO_InitStructure;
   USART_InitTypeDef USART_InitStructure;

   // ... (配置GPIO用于TX/RX引脚)
   
   USART_InitStructure.USART_BaudRate = 9600; // 设置串口速率
   USART_InitStructure.USART_WordLength = USART_WordLength_8b;
   USART_InitStructure.USART_StopBits = USART_StopBits_1;
   USART_InitStructure.USART_Parity = USART_Parity_No;
   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
   USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;

   HAL_UART_Init(&huart1); // 使用HAL库初始化串口
}

2. **处理命令解析**：在接收函数中，你可以读取串口接收到的数据，然后解析指令。例如，可以使用while循环比较接收到的每个字符是否匹配"1111"或"2222"。

void USART_CmdHandler(uint8_t *cmd) {
    if (!strcmp((char*)cmd, "1111")) {
        // 发送任务状态
        // ... (编写发送任务状态的函数并调用)
    } else if (!strcmp((char*)cmd, "2222")) {
        // 获取CPU使用率
        float cpuUsage = GetCPUUsage();
        // 将浮点数转换成字符串并发送
        char usageStr[10];
        sprintf(usageStr, "%f", cpuUsage);
        // ... (发送字符串到串口)
    }
}

3. **发送数据**：完成指令对应的计算后，将结果转化为适当的字符串，再通过`HAL_UART_Transmit`函数发送。

void SendTaskStatusOrCPUUsage(float usage) {
    char data[10];
    sprintf(data, "%g", usage);
    HAL_UART_Transmit(&huart1, (uint8_t*)data, strlen(data), HAL_MAX_DELAY);
}

记得在主循环中不断轮询串口接收，并调用相应的函数处理命令。

基于freertos用C语言写出电脑串口发送指令”1111”, 单片机串口发送当前所有任务状态； 电脑串口发送指令”2222”,单片机串口发送当前CPU的使用率；

以下是基于FreeRTOS使用C语言编写的单片机代码：

#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "timers.h"
#include "stdio.h"

#define UART_TX_PIN 1 //假设串口TX引脚为1
#define UART_RX_PIN 2 //假设串口RX引脚为2
#define BAUD_RATE 9600 //波特率为9600

//任务状态枚举类型
typedef enum
{
    RUNNING,
    BLOCKED,
    SUSPENDED,
    READY,
    DELETED
} task_status_t;

//任务信息结构体
typedef struct
{
    char task_name[20];
    task_status_t task_status;
    uint32_t stack_size;
    uint32_t stack_used;
} task_info_t;

//串口初始化函数
void uart_init(void)
{
    //在这里进行串口初始化的操作，包括引脚设置、波特率设置等
}

//发送任务状态到串口
void send_task_status(void)
{
    const char *status_str[] = {"RUNNING", "BLOCKED", "SUSPENDED", "READY", "DELETED"};
    task_info_t task_info;
    task_status_t task_status;
    TaskHandle_t task_handle = NULL;
    UBaseType_t task_num = uxTaskGetNumberOfTasks();
    uint32_t i;

    printf("Current Task Status:\r\n");

    for (i = 0; i < task_num; i++)
    {
        task_handle = (TaskHandle_t)uxTaskGetTaskHandle(i);
        if (task_handle != NULL)
        {
            task_info.stack_size = uxTaskGetStackHighWaterMark(task_handle);
            task_info.stack_used = uxTaskGetStackHighWaterMark(task_handle);
            task_info.task_status = eTaskGetState(task_handle);
            vTaskGetInfo(task_handle, &task_info, pdTRUE, eInvalid);
            printf("Task Name: %s, Status: %s, Stack Size: %u bytes, Stack Used: %u bytes\r\n",
                   task_info.task_name, status_str[task_info.task_status], task_info.stack_size, task_info.stack_used);
        }
    }
}

//计算CPU使用率
void calculate_cpu_usage(TimerHandle_t xTimer)
{
    static uint32_t prev_tick_count = 0;
    uint32_t current_tick_count = xTaskGetTickCount();
    uint32_t tick_diff = current_tick_count - prev_tick_count;
    uint32_t cpu_usage = 0;

    prev_tick_count = current_tick_count;

    //计算CPU使用率
    cpu_usage = (tick_diff * 100) / ((uint32_t)configTICK_RATE_HZ);

    printf("Current CPU Usage: %u%%\r\n", cpu_usage);
}

//串口接收中断处理函数
void uart_rx_isr(void)
{
    char recv_char;
    static char recv_buf[5] = {0};
    static uint8_t recv_index = 0;

    //从串口接收字符
    recv_char = uart_receive_char();

    //判断是否接收到了"1111"指令
    if (recv_char == '1')
    {
        recv_buf[recv_index++] = recv_char;
        if (recv_index == 4 && strcmp(recv_buf, "1111") == 0)
        {
            //发送当前所有任务状态
            send_task_status();
        }
    }
    else
    {
        recv_index = 0;
    }

    //判断是否接收到了"2222"指令
    if (recv_char == '2')
    {
        recv_buf[recv_index++] = recv_char;
        if (recv_index == 4 && strcmp(recv_buf, "2222") == 0)
        {
            //启动定时器计算CPU使用率
            xTimerStartFromISR(xTimer, NULL);
        }
    }
    else
    {
        recv_index = 0;
    }
}

int main(void)
{
    //初始化串口
    uart_init();

    //创建定时器
    TimerHandle_t cpu_usage_timer = xTimerCreate("CPU Usage Timer", pdMS_TO_TICKS(1000), pdTRUE, NULL, calculate_cpu_usage);

    //启动调度器
    vTaskStartScheduler();

    //定时器销毁
    xTimerDelete(cpu_usage_timer, 0);

    return 0;
}

在上面的代码中，我们首先定义了一个枚举类型`task_status_t`，用于表示任务的状态。然后定义了一个`task_info_t`结构体，用于记录任务的一些信息，包括任务名、任务状态、堆栈大小和已用堆栈大小。在`send_task_status()`函数中，我们通过调用FreeRTOS提供的API，获取当前所有任务的信息，并发送到串口。在`calculate_cpu_usage()`函数中，我们使用定时器来计算CPU使用率，具体实现是记录当前和上一次调用该函数时的时间戳，然后计算两个时间戳之间的差值，再根据差值和FreeRTOS提供的`configTICK_RATE_HZ`宏定义来计算CPU使用率。在`uart_rx_isr()`函数中，我们检测串口接收到的数据是否为字符串"1111"或"2222"，如果是，则执行相应的操作，即发送当前所有任务状态或启动计算CPU使用率的定时器。