Posts on Mortal

Claude Code 安装与 DeepSeek API 接入教程

Sat, 28 Feb 2026 00:00:00 +0000

前言

Claude Code 是 Anthropic 推出的命令行 AI 编程助手，配合 DeepSeek V4 模型可以大幅降低使用成本。本教程记录 Windows 平台下从零安装到成功使用的全过程。

一、环境准备

1.1 所需软件

软件	用途	下载地址
Node.js	Claude Code 运行环境	nodejs.org → 点击 Releases 下载 Windows 版本
cc-switch	API 代理切换工具，用于接入 DeepSeek	GitHub 搜索 `cc-switch`，下载 Windows 版本
Git	版本管理（Claude Code 依赖）	git-scm.com

1.2 配置 npm 国内镜像

由于 npm 默认源在国内访问较慢，先切换到国内镜像：

1

npm config set registry https://registry.npmmirror.com/

1.3 验证安装

安装完上述软件后，在终端中分别执行以下命令，确认均有版本号输出：

1
2
3


node -v # 应输出 v20.x 或更高
npm -v # 应输出 10.x 或更高
git -v # 应输出 git version 2.x

二、安装 Claude Code

2.1 全局安装

打开终端（CMD 或 PowerShell），执行：

1

npm install -g @anthropic-ai/claude-code

2.2 验证安装

1

claude --version

有版本号输出即表示安装成功。

2.3 跳过登录验证

Claude Code 默认要求登录 Anthropic 账号。我们通过 DeepSeek API 接入，不需要登录，直接修改配置文件跳过：

打开文件资源管理器，在地址栏输入 %USERPROFILE% 回车
找到 .claude 文件夹（注意：是 .claude 文件夹，不是 claude.json）
进入 .claude 文件夹，找到 claude.json 文件
在文件末尾添加 "hasCompletedOnboarding": true

关键修正：很多教程误写成"claude.json 文件夹"，实际上是用户目录下的 .claude 文件夹，里面有 claude.json 配置文件。

修改后的 claude.json 示例：

1
2
3


{
 "hasCompletedOnboarding": true
}

三、接入 DeepSeek API

3.1 注册并获取 API Key

访问 DeepSeek 开放平台注册账号。
进入 API Keys 页面，点击 创建 API Key
为 Key 命名（如 claude-code），创建后立即复制保存——关闭弹窗后将无法再次查看

确保账户内有一定余额（最低充值通常 ¥10 即可使用很久）。

3.2 配置 cc-switch

cc-switch 是一个开源的 API 代理工具，负责将 Claude Code 的 Anthropic API 请求转发到 DeepSeek 的 API 端点。

下载并启动 cc-switch（Windows 版本）
点击添加按钮
选择 DeepSeek 作为后端
填入之前复制的 API Key
将所有模型名称修改为：deepseek-v4-pro[1m]

为什么用 cc-switch？ Claude Code 默认调用 Anthropic 官方 API，费用较高。cc-switch 在本地拦截请求并转发到 DeepSeek，让你用 DeepSeek 的价格享受 Claude Code 的交互体验。

四、验证使用

打开终端，输入 claude 启动
首次启动会要求选择工作目录，选择你常用的代码目录即可
进入对话后，询问：“你是什么模型？”
若回答为 deepseek-v4-pro[1m]，说明接入成功

1
2
3
4
5


# 启动 Claude Code
claude

# 进入后在对话中输入
你是什么模型？

五、常见问题

问题	可能原因	解决方案
`claude` 命令不存在	npm 全局安装路径未加入 PATH	将 `%APPDATA%\npm` 加入系统环境变量
cc-switch 连接失败	API Key 无效或余额不足	检查 DeepSeek 平台的 API Key 状态和余额
模型回答不是 DeepSeek	cc-switch 未正确拦截	检查 cc-switch 是否在运行，模型名是否配置正确
安装卡在 `npm install`	npm 源连接慢	确认已切换国内镜像源

总结

整个流程概括为四步：

装环境 — Node.js + Git + cc-switch
装 Claude Code — npm install -g + 跳过登录
接 API — DeepSeek 注册 + cc-switch 配置
验证 — 启动对话，确认模型正确

配置完成后即可在终端内享受 AI 辅助编程，使用体验与官方 Claude Code 一致，但成本仅为 DeepSeek API 的调用费用。

ESP32学习

Sat, 28 Feb 2026 00:00:00 +0000

1.基础配置

配置芯片：

Serial Flasher config -配置封装外flash
ESP PSRAM -配置封装没PSRAM
ESP System Setting -ESP32系统配置(主频)
FreeRTOS -配置时钟节拍

2.常用函数

函数名	功能说明	关键参数 / 注意点
`gpio_config(&gpio_config_t config)`	一站式配置 GPIO（模式 / 上下拉 / 中断）	结构体参数： `pin_bit_mask`：引脚掩码（如`1ULL<<GPIO_NUM_2`） `mode`：`GPIO_MODE_INPUT/OUTPUT` `pull_up_en`：`GPIO_PULLUP_ENABLE/DISABLE`
`gpio_set_level(gpio_num_t pin, uint32_t level)`	设置 GPIO 输出电平（0/1）	无需手动使能时钟，直接调用
`gpio_get_level(gpio_num_t pin)`	读取 GPIO 输入电平
`gpio_install_isr_service(0)`	安装 GPIO 中断服务	全局中断初始化，仅需调用一次
`gpio_isr_handler_add(pin, isr_handler, arg)`	绑定 GPIO 中断处理函数	中断函数需为`void isr_handler(void* arg)`
FreeRTOS 任务管理
`xTaskCreate(task_func, name, stack_size, arg, prio, handle)`	创建任务	`stack_size`：ESP32 建议≥2048 字节 `prio`：优先级（0~31，数值越高优先级越高）
`vTaskDelete(TaskHandle_t handle)`	删除任务	`NULL`表示删除当前任务
`xQueueCreate(length, item_size)`	创建队列（任务间通信）	`length`：队列长度 `item_size`：单个数据字节数
`xQueueSend(queue, &data, timeout)`	发送数据到队列	`timeout`：超时时间（pdMS_TO_TICKS (100)）
`xQueueReceive(queue, &data, timeout)`	从队列接收数据	-
`xSemaphoreCreateBinary()`	创建二值信号量	-
`xSemaphoreGive(sem)`	释放信号量	-
`xSemaphoreTake(sem, timeout)`	获取信号量	-
UART 串口函数
`uart_param_config(uart_num_t uart, &uart_config_t)`	配置串口参数	结构体参数： `baud_rate`：波特率（115200） `data_bits`：`UART_DATA_8_BITS` `parity`：`UART_PARITY_DISABLE`
`uart_set_pin(uart_num, tx, rx, rts, cts)`	映射串口引脚	ESP32 支持任意 GPIO 映射（如 UART0_TX=GPIO16）
`uart_driver_install(uart_num, rx_buf_size, tx_buf_size, 0, NULL, 0)`	安装串口驱动	`rx_buf_size`：接收缓冲区大小（如 1024）
`uart_write_bytes(uart_num, data, len)`	发送字节数据	阻塞式发送
`uart_read_bytes(uart_num, buf, len, timeout)`	读取字节数据	`timeout`：超时时间（pdMS_TO_TICKS (100)）
RMT 外设函数
`rmt_new_tx_channel(&tx_chan_config, &rmt_chan)`	创建 RMT TX 通道	结构体参数： `gpio_num`：输出引脚 `resolution_hz`：时钟分辨率（如 10MHz）
`rmt_new_copy_encoder(&config, &encoder)`	创建 copy 编码器（ESP-IDF v5.1+）	替代弃用的`rmt_new_encoder`
`rmt_transmit(chan, encoder, data, len, &tx_config)`	发送 RMT 符号数据	-
`rmt_enable(rmt_chan)`	启用 RMT 通道	-
ADC 模拟采集函数
`adc_oneshot_new_unit(&adc_config, &adc_unit)`	创建 ADC 单元	ESP32-C6 仅支持 ADC1（GPIO0~6）
`adc_oneshot_config_channel(adc_unit, chan, &config)`	配置 ADC 通道	结构体参数： `atten`：衰减系数（如`ADC_ATTEN_DB_11`，测量 0~3.3V） `bitwidth`：`ADC_BITWIDTH_12`
`adc_oneshot_read(adc_unit, chan, &raw_data)`	读取 ADC 原始值	原始值范围：0~4095（12 位）
Wi-Fi 核心函数
`esp_wifi_init(&wifi_init_config_t)`	初始化 Wi-Fi 驱动	-
`esp_wifi_set_mode(WIFI_MODE_STA/AP)`	设置 Wi-Fi 模式（STA/AP）	STA：连接路由器；AP：自建热点
`esp_wifi_set_config(interface, &wifi_config)`	设置 Wi-Fi 参数	STA 模式：配置 SSID / 密码 `wifi_config.sta.ssid`：路由器名称 `wifi_config.sta.password`：密码
`esp_wifi_start()`	启动 Wi-Fi	-
`esp_wifi_connect()`	STA 模式连接路由器	-

2.模块代码

2.1 WIFi

连wifi四步走

初始化 nvs_flash_init esp_netif_init //初始化nvs和网络接口 esp_event_loop_create_default //创建事件循环 esp_netif_create_default_wifi_sta //创建wifi statin模式
使用esp_event_handler_instance_register注册wifi和ip事件
wifi配置与启动 esp_wifi_init
esp_wifi_set_mode esp_wifi_set_config esp_wifi_start esp_wifi_connect

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142


#include <stdio.h>

#include "freertos/FreeRTOS.h"

#include "freertos/task.h"

#include "freertos/event_groups.h"

#include "driver/gpio.h"

#include "esp_log.h"

#include "freertos/queue.h"

#include <string.h>

#include <stdint.h>


#include "esp_wifi.h"

#include "esp_event.h"

#include "nvs_flash.h"



// 1. 定义你的 Wi-Fi 信息

#define EXAMPLE_ESP_WIFI_SSID      "esp"

#define EXAMPLE_ESP_WIFI_PASS      "12345678"



// 2. 事件处理函数

static void event_handler(void* arg, esp_event_base_t event_base,

                                int32_t event_id, void* event_data)

{

    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {

        esp_wifi_connect(); // 启动后开始连接

    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {

        esp_wifi_connect(); // 断开后尝试重连

        ESP_LOGI("WIFI", "重连中...");

    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {

        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;

        ESP_LOGI("WIFI", "成功获取IP: " IPSTR, IP2STR(&event->ip_info.ip));

        // 这里可以给你的 Task 发送信号，告诉它“可以开始发网络数据了”

    }

}



// 3. 封装好的 Wi-Fi 初始化函数

void wifi_init_sta(void)

{

    ESP_ERROR_CHECK(esp_netif_init());

    ESP_ERROR_CHECK(esp_event_loop_create_default());

    esp_netif_create_default_wifi_sta();



    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();

    ESP_ERROR_CHECK(esp_wifi_init(&cfg));



    // 注册事件处理

    esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL, NULL);

    esp_event_handler_instance_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &event_handler, NULL, NULL);



    wifi_config_t wifi_config = {

        .sta = {

            .ssid = EXAMPLE_ESP_WIFI_SSID,

            .password = EXAMPLE_ESP_WIFI_PASS,

        },

    };

    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA) );

    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config) );

    ESP_ERROR_CHECK(esp_wifi_start() );

}



void app_main(void)

{

    // A. 必须初始化 NVS

    esp_err_t ret = nvs_flash_init();

    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {

      ESP_ERROR_CHECK(nvs_flash_erase());

      ret = nvs_flash_init();

    }

    ESP_ERROR_CHECK(ret);



    // B. 启动 Wi-Fi

    wifi_init_sta();

}

2.2 lwip TCP

填写服务器信息
- struct sockaddr_in 名称;
创建socket
- socket( ); 失败时返回 -1
- 参数：地址(ipv4 ipv6) 套接字类型(SOCK_STREAM: TCP 协议；UDP 用 SOCK_DGRAM) 协议类型(IPPROTO_IP: IP ; IPPROTO_TCP :TCP)
拨号连接(此时连接成功)
- connect() 成功时返回0
发送和接收数据
- send(); 失败时返回-1 说明发送失败
- recv(); 失败时返回-1 说明接收失败；返回0说明服务器关闭；大于0则接收成功
最后需要关闭socket释放资源

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145


void Tcp_Client(void *pvparam)

{

    // 1. 等待 Wi-Fi 获取 IP 的信号

    xEventGroupWaitBits(WIFI_READY, WIFIREADY_BIT, pdFALSE, pdTRUE, portMAX_DELAY);

    ESP_LOGI("TCP", "Wi-Fi 已就绪，准备连接电脑...");



    char *tradata = "MYTCP Send";

    char recbufer[100];



    //填写服务器信息

    struct  sockaddr_in sockaddr;

    sockaddr.sin_addr.s_addr = inet_addr("192.168.1.18");

    sockaddr.sin_family = AF_INET;//ipv4 AF_INET6(ipv6)

    sockaddr.sin_port = htons(8080); //必须使用htons做字节序转换



    while (1)

    {

        //创建socket

        int sock = socket(AF_INET,SOCK_STREAM,IPPROTO_IP);//地址(ipv4 ipv6) 套接字类型(SOCK_STREAM: TCP 协议；UDP 用 SOCK_DGRAM) 协议类型(IPPROTO_IP: IP ; IPPROTO_TCP :TCP)

        if(sock < 0)

        {

            ESP_LOGW("TCP","SOCK创建失败");

            vTaskDelay(pdMS_TO_TICKS(20));

            continue;

        }



        //拨号连接

        int res = connect(sock,(struct sockaddr *)&sockaddr,sizeof(sockaddr));

        if(res != 0)

        {

            ESP_LOGW("TCP","拨号连接失败");

            close(sock);//必须释放sock否则会泄露文件句柄

            vTaskDelay(pdMS_TO_TICKS(2000));

            continue;

        }



        ESP_LOGW("TCP","端口连接成功%s %d","192.168.1.18",8080);



        while (1)

        {

            //发送数据

            int write = send(sock,tradata,strlen(tradata),0);//最后一位默认是0

            if(write < 0)

            {

                ESP_LOGW("TCP","数据发送失败");

                vTaskDelay(pdMS_TO_TICKS(2000));

                break;

            }



            //接收数据

            int receive = recv(sock,recbufer,sizeof(recbufer) - 1,0);

            if(receive < 0)

            {

                ESP_LOGW("TCP","数据接收失败");

                vTaskDelay(pdMS_TO_TICKS(2000));

                break;

            }else if(receive == 0){

                ESP_LOGW("TCP","服务器关闭");

                vTaskDelay(pdMS_TO_TICKS(2000));

                break;

            }else{

                 recbufer[receive] = 0;//末尾补0，来作为字符串结尾

                ESP_LOGW("TCP","%s",recbufer);

            }

            vTaskDelay(pdMS_TO_TICKS(2000));

        }



        if(sock != -1){

            close(sock);

            vTaskDelay(pdMS_TO_TICKS(2000));

        }

    }

}

2.3

freertos学习

Sat, 28 Feb 2026 00:00:00 +0000

1.基本概念

一、内核（Kernel）

管理所有任务、分配 CPU 资源、处理中断、提供系统 API（如任务创建 / 延时 / 队列）

可以实现抢占式，configUSE_PREEMPTION=1 开启
可裁剪通过 FreeRTOSConfig.h 宏定义开启/关闭，适配不同的mcu

二、任务（Task）

RTOS中最小执行单元，对应独立的、无限循环的C函数，实现一个具体的业务功能

1
2
3
4
5
6
7


void vTaskUART(void *pvParameters)
{
 for(;;)
 {

 }
}

多状态切换：任务在运行过程中会被内核切换为不同状态，核心状态有 4 种

运行态：当前正在占用 CPU 执行的任务（同一时间只有一个任务处于运行态）；
就绪态：任务已准备好执行，等待 CPU 资源（如你的串口任务被唤醒后，进入就绪态立即抢占 CPU）；
阻塞态：任务因等待某个事件而暂停（如vTaskDelay延时、xQueueReceive等待队列数据），不占用 CPU；
挂起态：任务被手动挂起（vTaskSuspend），需手动恢复（vTaskResume），同样不占用 CPU。

三、任务控制块（TCB - Task Control Block）

为每个任务分配一个结构体，存储任务的核心信息，内核通过操作TCB来管理任务(创建、调度、切换、删除)

1
2
3
4
5
6


typedef struct tskTaskControlBlock {
 StackType_t *pxTopOfStack; // 任务栈的栈顶指针（核心，任务切换的关键）
 ListItem_t xStateListItem; // 任务状态链表项（用于将任务加入就绪/阻塞/挂起链表） UBaseType_t uxPriority; // 任务的优先级（0~configMAX_PRIORITIES-1）
 char pcTaskName[ configMAX_TASK_NAME_LEN ]; // 任务名称（如你的"LED_Task"）
 // 其他：栈大小、任务编号、队列/信号量等待信息等
} tskTCB;

核心作用

存储任务状态：通过xStateListItem将任务挂载到内核的就绪链表 / 阻塞链表 / 挂起链表，调度器只需遍历链表即可找到待执行的任务；
记录运行环境：pxTopOfStack保存任务栈的栈顶地址，任务切换的核心就是保存 / 恢复栈顶指针（CPU 的寄存器值会压入任务栈，栈顶指针记录压栈位置）；
标识任务属性：优先级、任务名称、栈大小等，为调度器的调度决策提供依据。

四：栈（STACK）

为每一个任务分配独立的RAM空间，存储局部变量、CPU寄存器值、函数调用返回地址

实现任务切换：这是栈最核心的作用！当高优先级任务抢占低优先级任务时，内核会将当前 CPU 的所有寄存器值（如 PC、R0-R15）压入被抢占任务的栈中，并将栈顶指针更新到 TCB 的pxTopOfStack；当被抢占任务再次执行时，内核会从栈中恢复所有寄存器值，让任务从被打断的位置继续执行，实现 “无缝切换”。

五、优先级（Priority）

FreeRTOS 优先级的核心规则

抢占式调度核心：当一个高优先级任务进入就绪态时，调度器会立即暂停当前正在执行的低优先级任务，将 CPU 切换给高优先级任务（这就是你代码中串口任务能打断数据处理 / LED 任务的根本原因）；
同优先级任务调度：若多个任务优先级相同，FreeRTOS 会采用时间片轮转调度（需开启configUSE_TIME_SLICING=1），每个任务分配固定的 CPU 时间片，轮流执行；
优先级范围：由FreeRTOSConfig.h的configMAX_PRIORITIES定义，建议按实际需求配置（无需配置过大，否则会占用更多内核 RAM）；
空闲任务优先级：FreeRTOS 会自动创建一个空闲任务（idle task），优先级为 0（最低），当系统中所有任务都处于阻塞 / 挂起态时，调度器会执行空闲任务（防止 CPU 空转）。

六、调度器（scheduler）

根据任务的优先级和TCB状态来决定哪个任务获得CPU执行权

调度器的类型（FreeRTOS 支持）

抢占式调度器：configUSE_PREEMPTION=1开启，是嵌入式实时开发的主流选择，高优先级任务可随时抢占低优先级任务，保证实时性；
协作式调度器：configUSE_PREEMPTION=0开启，任务不会被主动抢占，需任务主动调用taskYIELD()让出 CPU，实时性差，适合对实时性要求低的场景。

2. 常用函数

函数名	参数
`xTaskCreate()`	`xTaskCreate(Func, "name", stack, pvParameters, priority, Handle);`
`vTaskStartScheduler`	`vTaskStartScheduler()`
`vTaskDelete`	`vTaskDelete(Handle)`
`vTaskSuspend`	`vTaskSuspend(Handle)`
`vTaskResume`	`vTaskResume(Handle)`
`xTaskGetHandle`	`xTaskGetHandle(name)`

`vTaskDelay()`	`vTaskDelay(pdMS_TO_TICKS(time));`
`vTaskDelayUntil()`	`vTaskDelayUntil(&pretime,delaytime);`

`xQueueCreate()` 队列创建	`xADCQueue = xQueueCreate(10, sizeof(float));`
`xQueueSend()` 队列发送	`xQueueSend(xADCQueue,&voltage,pdMS_TO_TICKS(50))`
`xQueueReceive()` 队列接收	`xQueueReceive(xADCQueue,&voltage,portMAX_DELAY)`
`uxQueueMessagesWaiting()` 队列数目查询	`uxQueueMessagesWaiting(adc_voltage_queue)`

`xSemaphoreCreateBinary` 二值信号量	`xBinarySemaphore = xSemaphoreCreateBinary();` 必须手动调用Give函数启用
`xSemaphoreCreateCounting` 计数信号量
`xSemaphoreTake` 获取令牌，获取后从1-0	`xSemaphoreTake(句柄,portMAX_DELAY)`
`xSemaphoreGive` 释放令牌，成功后获取后从0-1	`xSemaphoreGive(xBinarySemaphore);//释放`
`xSemaphoreGiveFromISR` 中断释放令牌

`xSemaphoreCreateMutex` 创建互斥量(获取和释放同上)	`xSemaphoreCreateMutex` 避免优先级反转，自动启用需要手动释放

`xQueueSendFromISR()` 中断中队列入队
`xSemaphoreGiveFromISR()` 中断中释放信号量 / 互斥量
`portYIELD_FROM_ISR()` 中断中触发任务调度

`xEventGroupCreate()` 创建事件组
`xEventGroupSetBits()` 设置事件位
`xEventGroupWaitBits()` 等待事件位
`xEventGroupClearBits` 清除事件位
`xTimerCreate()` 创建定时器	`xTimerCreate( "名称", 定时时长, pdTRUE,pvTimerID 回调函数 ;`
`xTimerStart()` 启动定时器	`xTimerStart(名称, 0);` 第二位0表示立即开始
`xTimerStop()` 停止定时器
`xTimerReset()` 重置定时器

`vApplicationStackOverflowHook()` 栈溢出钩子函数
`portYIELD_FROM_ISR` 中断中唤醒高优先级任务	一般用于中断处理后加上 xHigherPriorityTaskWoken
`uxTaskGetStackHighWaterMark` 空闲任务剩余栈大小
`xTaskGetTickCount` 获取当前tick数

3.标准流程

中断里在执行完代码后立即按照任务优先级执行：

1
2
3
4
5
6


 // 典型用法
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 // 初始化为“未唤醒高优先级任务”
 // 在ISR中释放信号量，函数会修改 xHigherPriorityTaskWoken 的值 xSemaphoreGiveFromISR(Handle, &xHigherPriorityTaskWoken);
 // 根据标记判断是否需要立即切换任务
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);

4.工程步骤

划分任务（按功能 + 优先级）→ 确定同步 / 通信方式 → 分配栈大小和优先级 → 编写业务逻辑 → 调试排错。

整理FreeRTOS 核心知识框架：

plaintext

1
2
3
4
5


FreeRTOS核心
├─ 任务管理：创建/删除/挂起/恢复 + 调度器（抢占式/时间片）
├─ 通信同步：队列（数据传输）、信号量（同步/计数）、互斥量（互斥+优先级继承）、事件组（多条件同步）
├─ 时间管理：vTaskDelay()/vTaskDelayUntil()、软件定时器
└─ 中断管理：FROM_ISR API、中断优先级配置、portYIELD_FROM_ISR()

freertos源码学习

Sat, 28 Feb 2026 00:00:00 +0000

1.列表(list.c)

Linux基础

Sat, 28 Feb 2026 00:00:00 +0000

1.基础

Linux 的一切都从 根目录 / 开始。

/home/你的用户名：这是你的“家”，你所有的代码、文档都应该放在这里。
/bin 和 /usr/bin：存放常用命令（如 ls, cp）。
/dev：嵌入式重点！ 所有的硬件设备（串口、LCD、SD卡）在 Linux 里都是一个文件，存放在这里。

命令	用途	简而言之
pwd	我在哪？	显示当前文件夹路径
ls	这有什么？	查看当前文件夹下所有文件
cd	去哪？	cd..回到上一层，cd~回到根目录
mkdir	创建文件夹	mkdir text_folder 创建目录
rm	删除	rm 文件名(删了就真没了)

Python

Sat, 28 Feb 2026 00:00:00 +0000

数据结构与算法c

Sat, 28 Feb 2026 00:00:00 +0000

stm32 通信协议

Fri, 27 Feb 2026 00:00:00 +0000