Posts on Aobara的Blog

Elysia Js Note

Tue, 10 Mar 2026 00:00:00 +0000

路由

常用

import { Elysia } from 'elysia'

new Elysia()
    .all('/', 'hi')
    .listen(3000)


import { Elysia } from 'elysia'

const app = new Elysia()
    .get('/get', 'hello')
    .post('/post', 'hi')
    .route('M-SEARCH', '/m-search', 'connect') 
    .listen(3000)

分组路由

import { Elysia } from 'elysia'

new Elysia()
    .group('/user', (app) =>
        app
            .post('/sign-in', 'Sign in')
            .post('/sign-up', 'Sign up')
            .post('/profile', 'Profile')
    )
    .listen(3000)

前缀

import { Elysia } from 'elysia'

const users = new Elysia({ prefix: '/user' })
    .post('/sign-in', 'Sign in')
    .post('/sign-up', 'Sign up')
    .post('/profile', 'Profile')

new Elysia()
    .use(users)
    .get('/', 'hello world')
    .listen(3000)

生命周期

Interger with OpenAPI

export const sensorRoutes = new Elysia({ prefix: '/v1/sensors' })
    .use(mqttPlugin)
    .guard({
        headers: t.Object({
            authorization: t.String({ error: '需要 API Key' })
        }),
        detail: { tags: ['Sensors'] }
    }, (app) => app
        .onBeforeHandle(({ headers }) => {
            if (!headers.authorization.startsWith('iiot_')) {
                throw new Error('Unauthorized Device');
            }
        })
        .post('/publish', ({ body, mqtt }) => {
            const topic = `sensors/${body.deviceId}/data`;
            mqtt.publish(topic, JSON.stringify(body.payload));
            return { status: 'published', topic };
        }, {
            body: t.Object({
                deviceId: t.String(),
                payload: t.Object({
                    temp: t.Number(),
                    humidity: t.Number()
                })
            }),
            response: t.Object({
                status: t.String(),
                topic: t.String()
            }),

            // 这里
            detail: { summary: '推送传感器数据到 MQTT 总线' }
        })
    );

summary
summary: '上传传感器数据（显示在标题）'

description
description: '该接口用于将设备采集的温湿度通过 MQTT 转发...'

tags
tags: ['设备管理', '传感器数据']

security
security: [{ BearerAuth: [] }]

Lua 学习笔记

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

Lua 速查表（Lua 5.5）

一、基础语法

1. 变量

默认全局变量
local 定义局部变量
支持多重赋值
赋值本质是值拷贝（table/function 是引用）

易混淆点：

未声明直接赋值就是全局变量
nil 会删除 table 键
多重赋值是先整体计算右边，再统一赋值

示例：

local a = 10
b = 20
a, b = b, a
print(a, b)

2. 数据类型

nil
boolean
number（整数和浮点统一）
string
table
function
thread
userdata

易混淆点：

Lua 只有一种 number 类型
只有 false 和 nil 为假

示例：

1
2

local x = 1
print(type(x))

二、运算符

1. 算术

+ - * /
// 整除
% 取模
^ 幂运算

易混淆点：

/ 永远是浮点除
// 才是整除

1
2

print(5/2)
print(5//2)

2. 比较

==
~=
< > <= >=

易混淆点：

table 比较的是地址
字符串可比较大小（字典序）

`1`	`print({} == {})`

3. 逻辑

and
or
not

特点：返回操作数本身，不是布尔值

易混淆点：

a or b 常用于默认值
0 在 Lua 中为真

1
2

print(nil or 5)
print(0 and 10)

三、控制结构

1. if

必须写 then
以 end 结束

易混淆点：

不存在 else if，必须 elseif

local n = 5
if n > 3 then
    print("ok")
end

2. 循环

while

local i = 1
while i <= 3 do
    print(i)
    i = i + 1
end

repeat

至少执行一次

local i = 1
repeat
    print(i)
    i = i + 1
until i > 3

for 数值循环

起始，终止，步长

易混淆点：

步长默认 1
上限包含

1
2
3

for i = 1, 3 do
    print(i)
end

for 泛型循环

常用 pairs、ipairs

易混淆点：

ipairs 遇到 nil 停止
pairs 无序

local t = {10,20}
for i,v in ipairs(t) do
    print(i,v)
end

四、函数

1. 基础定义

函数是一等公民

function add(a,b)
    return a+b
end
print(add(1,2))

2. 局部函数

local function f()
    return 1
end
print(f())

3. 可变参数

...
select

易混淆点：

# {...} 可能受 nil 影响

function test(...)
    print(select("#",...))
end
test(1,2,3)

4. 多返回值

默认只返回第一个
放在表达式最后才展开

易混淆点：

位置不同结果不同

function f()
    return 1,2
end

print(f())
print((f()))

五、Table

Lua 核心结构

1. 创建

1
2
3

local t = {}
local t2 = {1,2,3}
local t3 = {name="lua"}

2. 数组与字典混合

1
2

local t = {1,2,a=3}
print(t[1], t.a)

易混淆点：

数组从 1 开始
长度 # 不可靠（有洞时）

3. 删除元素

1
2
3

local t = {1,2,3}
t[2] = nil
print(#t)

4. table库

table.insert
table.remove
table.sort
table.concat

1
2
3

local t = {3,1,2}
table.sort(t)
print(table.concat(t,","))

六、字符串

不可变

常用函数

string.sub
string.find
string.match
string.gsub
string.format

易混淆点：

Lua 使用模式匹配，不是完整正则
. 在模式里代表任意字符

1
2

local s = "abc123"
print(string.match(s,"%d+"))

七、错误处理

error

`1`	`error("fail")`

pcall

捕获错误

local ok,err = pcall(function()
    error("bad")
end)
print(ok,err)

易混淆点：

pcall 返回 true/false + 返回值

八、元表

Lua 面向对象和运算符重载核心

常见元方法

__index
__newindex
__add
__tostring
__call

__index 示例

local mt = {
    __index = function(t,k)
        return "default"
    end
}

local t = setmetatable({},mt)
print(t.a)

易混淆点：

__index 可是 table 或 function
只在访问不存在键时触发

九、简单面向对象

local Person = {}
Person.__index = Person

function Person:new(name)
    local obj = setmetatable({},self)
    obj.name = name
    return obj
end

function Person:say()
    print(self.name)
end

local p = Person:new("Tom")
p:say()

易混淆点：

: 会自动传 self
. 不会传 self

十、协程

轻量级线程

常用函数

coroutine.create
coroutine.resume
coroutine.yield
coroutine.status
coroutine.wrap

示例：

local co = coroutine.create(function()
    coroutine.yield(1)
    return 2
end)

print(coroutine.resume(co))
print(coroutine.resume(co))

易混淆点：

resume 返回是否成功 + 返回值
yield 只能在协程中调用

十一、模块

require

自动缓存
只加载一次

`1`	`local m = require("mymodule")`

易混淆点：

require 返回模块 return 的值
模块本质就是返回 table

十二、重要语义总结

变量默认全局
table 是引用类型
函数是值
数组从 1 开始
and/or 返回操作数
只有 nil 和 false 为假
# 对非连续数组不可靠
多返回值只有在最后位置展开
: 等价于 obj.method(obj, ...)

LVGL 学习笔记

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

[]https://www.cnblogs.com/lj15941314/p/17207869.html()

概念

对象(lv_obj_t)

LVGL的三层屏幕

1
2
3

lv_scr_act(void);   // 活动屏幕 disp->act_scr
lv_layer_top (void);    // 顶层       disp->top_layer
lv_layer_sys (void);    // 系统层   disp->sys_layer

基础操作

//-----宽高
设置宽度：lv_obj_set_width(obj, new_width);
设置高度：lv_obj_set_height(obj, new_height);

同时设置宽度、高度：lv_obj_set_size(obj, new_ width, new_ height);


获取宽度：lv_obj_get_width(obj);
获取高度：lv_obj_get_height(obj);

//-----位置
设置x轴方向的坐标位置：lv_obj_set_x(obj, new_x);
设置y轴方向的坐标位置：lv_obj_set_y(obj, new_y);

同时设置x、y坐标位置：lv_obj_set_pos(obj, new_x, new_y);  // position

获取x轴坐标位置：lv_obj_get_x(obj);
获取y轴坐标位置：lv_obj_get_y(obj);

屏幕的原点：左上方，x为横轴，y为竖轴

对齐方式

盒子模型

边界(bounding)：元素的宽度/高度围起来的区域(整个盒子)。
边框(border)：边框有大小和颜色等属性(相当于盒子的厚度和它的颜色)。
填充(padding)：对象两侧与其子对象之间的空间(盒子的填充物)。
内容(content)：如果边界框按边框宽度和填充的大小缩小，则显示其大小的内容区域(盒子实际装东西的区域)。
轮廓(outline) ：LVGL中没有外边距(margin)的概念(盒子之间的距离)，确认代之的是轮廓(outline)。它是绘制于元素(盒子)周围的一条线，它不占据空间，位于边框边缘的外围，可起到突出元素(盒子)的作用。  例如：在浏览器里，当鼠标点击或使用Tab键让一个选项或者一个图片获得焦点的时候，这个元素就会多了一个轮廓框围绕 。

标签(lv_label)

lv_obj_t * label = lv_label_create(parent);


直接设置要显示的文本：lv_label_set_text(label, "New text");
格式化给定要显示的文本：lv_label_set_text_fmt(label, “%s: %d”, “Value”, 15);
文本不存储在动态内存中，而是直接使用给定的缓冲区：lv_label_set_text_static(label, "New text");
在label换行，像printf函数那样使用 \n 即可：lv_label_set_text(label, " line1\nline2\n\nline4 ");

LV_LABEL_LONG_WRAP 如果有多个换行，并且如果高度为LV_SIZE_CONTENT，那么高度会根据文本换行被自动扩展；否则文本将被剪掉。(默认设置)
LV_LABEL_LONG_DOT 如果文本太长，就保持大小并在末尾写3个点。
LV_LABEL_LONG_SCROLL 如果文本比标签宽(太长)，则可以水平来回滚动显示它。如果它很高(多个\n换行)，可以垂直滚动。只滚动一个方向，水平滚动的优先级更高。LV_LABEL_LONG_SCROLL_CIRCULAR 如果文本比标签宽，则水平滚动它。如果它更高，就垂直滚动。只滚动一个方向，水平滚动的优先级更高。
LV_LABEL_LONG_CLIP 剪掉超出标签范围外的文本部分。
可以使用 lv_label_set_long_mode(label, LV_LABEL_LONG_...) 指定模式。

Label默认不接收输入事件，如果想设置输入类型的样式或者事件会无法生效，需要打开 LV_OBJ_FLAG_CLICKABLE，示例：lv_obj_add_flag(label, LV_OBJ_FLAG_CLICKABLE); // 使输入设备可点击对象

按钮(lv_btn)

1
2

lv_obj_t * btn = lv_btn_create(parent);
lv_obj_add_flag(btn, LV_OBJ_FLAG_CHECKABLE);

与按键相关的Group Events

开关(lv_switch)

lv_obj_t * sw = lv_switch_create(parent);

Part

LV_PART_MAIN 背景。修改其 padding 会让下面的(指示器)在相应方向上的大小发生变化。
LV_PART_INDICATOR 显示开关状态的指示器。
LV_PART_KNOB 在指标左侧或右侧的旋钮。默认情况下，旋钮是圆形的，边长等于滑块的较小边。可以修改 padding 值使旋钮变大，填充值可以是不对称的。

Usage

lv_obj_add_event_cb(switch, event_handler, LV_EVENT_VALUE_CHANGED, NULL);

当开关被打开时，开关的状态会变为 LV_STATE_CHECKED 。我们可以通过下面这两个接口获取开关当前的状态：
    lv_obj_has_state(switch, LV_STATE_CHECKED); // 返回 bool 类型， 开-1 ； 关-2
    lv_obj_get_state(switch); // 返回枚举类型： LV_STATE_...
一般我们通过触摸或按键控制让开关 打开/关闭，还可以通过下面这个接口来主动 打开/关闭：
    lv_obj_add_state(switch, LV_STATE_CHECKED); // 开
    lv_obj_clear_state(switch, LV_STATE_CHECKED); // 关
可以通过下面的接口让按钮处于不可更改状态：
    lv_obj_add_state(sw, LV_STATE_DISABLED); // 当前状态是关，并且不可更改
    lv_obj_add_state(sw, LV_STATE_CHECKED | LV_STATE_DISABLED); // 当前状态是开，并且不可更改
让按钮恢复可以更改的状态，只要将 LV_STATE_DISABLED 清除即可：
    lv_obj_clear_state(switch, LV_STATE_ DISABLED); // 清除禁用状态，按钮可正常使用

Style

Style Docs docs 样式存储在 lv_style_t 变量，样式变量应该是静态、全局或动态分配的
注意需要及时清空 Style 样式以免造成内存的无效占用

static lv_style_t static_style;
void static_style_demo(void) {
    lv_style_init(&static_style);
    lv_style_set_bg_color(&static_style, lv_color_hex(0xff0000));
    lv_style_set_border_width(&static_style, 2);

    lv_obj_t * btn = lv_btn_create(lv_scr_act());
    lv_obj_add_style(btn, &static_style, LV_STATE_DEFAULT);
}
void dynamic_style_demo(void) {
    lv_obj_t * btn = lv_btn_create(lv_scr_act());

    // 方式1：临时创建样式
    lv_style_t dynamic_style;
    lv_style_init(&dynamic_style);
    lv_style_set_bg_color(&dynamic_style, lv_color_hex(0x00ff00));
    lv_obj_add_style(btn, &dynamic_style, LV_STATE_DEFAULT);

    // 方式2：LVGL 8.3+ 链式API
    lv_obj_add_style(btn, 
        lv_style_builder_create()
        ->bg_color(lv_color_hex(0x0000ff))
        ->border_radius(8)
        ->build(), 
        LV_STATE_PRESSED
    );
}

样式状态

LV_STATE_DEFAULT (0x0000) 正常，释放状态
LV_STATE_CHECKED (0x0001) 切换或检查状态
LV_STATE_FOCUSED (0x0002) 通过键盘或编码器聚焦或通过触摸板/鼠标点击
LV_STATE_FOCUS_KEY (0x0004) 通过键盘或编码器聚焦，但不通过触摸板/鼠标聚焦
LV_STATE_EDITED (0x0008) 由编码器编辑
LV_STATE_HOVERED (0x0010) 鼠标悬停（现在不支持）
LV_STATE_PRESSED (0x0020) 被按下
LV_STATE_SCROLLED (0x0040) 正在滚动
LV_STATE_DISABLED (0x0080) 禁用状态
LV_STATE_USER_1 (0x1000) 自定义状态
LV_STATE_USER_2 (0x2000) 自定义状态
LV_STATE_USER_3 (0x4000) 自定义状态
LV_STATE_USER_4 (0x8000) 自定义状态


LV_PART_MAIN 类似矩形的背景
LV_PART_SCROLLBAR 滚动条
LV_PART_INDICATOR 指标，例如用于滑块、条、开关或复选框的勾选框
LV_PART_KNOB 像手柄一样可以抓取调整值
LV_PART_SELECTED 表示当前选择的选项或部分
LV_PART_ITEMS 如果小部件具有多个相似元素（例如表格单元格）
LV_PART_TICKS 刻度上的刻度，例如对于图表或仪表
LV_PART_CURSOR 标记一个特定的地方，例如文本区域或图表的光标
LV_PART_CUSTOM_FIRST 可以从这里添加自定义部件。

Exmaple

void slider_state_parts_demo(void) {
    lv_obj_t * slider = lv_slider_create(lv_scr_act());
    lv_obj_set_size(slider, 200, 30);
    lv_obj_align(slider, LV_ALIGN_CENTER, 0, 0);

    lv_style_t knob_pressed_style;
    lv_style_init(&knob_pressed_style);
    lv_style_set_bg_color(&knob_pressed_style, lv_color_hex(0xFF5722));
    lv_style_set_shadow_width(&knob_pressed_style, 6);

    lv_obj_add_style(slider, 
                     &knob_pressed_style, 
                     LV_PART_INDICATOR | LV_STATE_PRESSED);

    lv_style_t fill_default_style;
    lv_style_init(&fill_default_style);
    lv_style_set_bg_color(&fill_default_style, lv_color_hex(0x4CAF50));

    lv_obj_add_style(slider, 
                     &fill_default_style, 
                     LV_PART_FILL | LV_STATE_DEFAULT);
}

过渡

void lv_example_style_10(void)
{
    static const lv_style_prop_t props[] = {LV_STYLE_BG_COLOR, LV_STYLE_BORDER_COLOR, LV_STYLE_BORDER_WIDTH, 0};

    /* A default transition
     * Make it fast (100ms) and start with some delay (200 ms)*/
    static lv_style_transition_dsc_t trans_def;
    lv_style_transition_dsc_init(&trans_def, props, lv_anim_path_linear, 100, 200, NULL);

    /* A special transition when going to pressed state
     * Make it slow (500 ms) but start  without delay*/
    static lv_style_transition_dsc_t trans_pr;
    lv_style_transition_dsc_init(&trans_pr, props, lv_anim_path_linear, 500, 0, NULL);

    static lv_style_t style_def;
    lv_style_init(&style_def);
    lv_style_set_transition(&style_def, &trans_def);

    static lv_style_t style_pr;
    lv_style_init(&style_pr);
    lv_style_set_bg_color(&style_pr, lv_palette_main(LV_PALETTE_RED));
    lv_style_set_border_width(&style_pr, 6);
    lv_style_set_border_color(&style_pr, lv_palette_darken(LV_PALETTE_RED, 3));
    lv_style_set_transition(&style_pr, &trans_pr);

    /*Create an object with the new style_pr*/
    lv_obj_t * obj = lv_obj_create(lv_scr_act());
    lv_obj_add_style(obj, &style_def, 0);
    lv_obj_add_style(obj, &style_pr, LV_STATE_PRESSED);

    lv_obj_center(obj);
}

主题

Events

docs

lv_obj_add_event_cb(btn, event_cb, LV_EVENT_CLICKED, NULL);

uint32_t btn_id = 0;
lv_event_send(mbox, LV_EVENT_VALUE_CHANGED, &btn_id);

LV_EVENT_PRESSED 对象已被按下

LV_EVENT_PRESSING 对象被按下（按下时连续调用）

LV_EVENT_PRESS_LOST 对象仍被按下，但光标/手指已滑离对象

LV_EVENT_SHORT_CLICKED 对象被按下一小段时间，然后释放它。如果滚动则不会调用。

LV_EVENT_LONG_PRESSED 对象已按下输入设备驱动程序中指定的至少 long_press_time。如果滚动则不会调用。

LV_EVENT_LONG_PRESSED_REPEAT 在每个 long_press_repeat_time 毫秒的 long_press_time 之后调用。如果滚动则不会调用。

LV_EVENT_CLICKED 如果对象没有滚动，则在释放时调用（无论是否长按）

LV_EVENT_RELEASED 在对象被释放后的每种情况下调用

LV_EVENT_SCROLL_BEGIN 开始滚动。事件参数是 NULL 或 lv_anim_t *，如果需要，可以修改滚动动画描述符。

LV_EVENT_SCROLL_END 滚动结束。

LV_EVENT_SCROLL 对象被滚动

LV_EVENT_GESTURE 检测到手势。使用 lv_indev_get_gesture_dir(lv_indev_get_act()); 获取手势

LV_EVENT_KEY 一个密钥被发送到对象。使用 lv_indev_get_key(lv_indev_get_act()); 获取密钥

LV_EVENT_FOCUSED 对象被聚焦

LV_EVENT_DEFOCUSED 对象散焦

LV_EVENT_LEAVE 对象散焦但仍被选中

LV_EVENT_HIT_TEST 执行高级命中测试。使用 lv_hit_test_info_t * a = lv_event_get_hit_test_info(e) 并检查 a->point 是否可以点击对象。如果没有则 a->res = false

Event bubbling（事件冒泡）

如果启用了 lv_obj_add_flag(obj, LV_OBJ_FLAG_EVENT_BUBBLE)，所有事件也将发送到对象的父级。如果父级也启用了LV_OBJ_FLAG_EVENT_BUBBLE，则事件也将发送到其父级，依此类推。

static void event_cb(lv_event_t * e)
{
    /*The original target of the event. Can be the buttons or the container*/
    lv_obj_t * target = lv_event_get_target(e);

    /*The current target is always the container as the event is added to it*/
    lv_obj_t * cont = lv_event_get_current_target(e);

    /*If container was clicked do nothing*/
    if(target == cont) return;

    /*Make the clicked buttons red*/
    lv_obj_set_style_bg_color(target, lv_palette_main(LV_PALETTE_RED), 0);
}

/**
 * Demonstrate event bubbling
 */
void lv_example_event_3(void)
{

    lv_obj_t * cont = lv_obj_create(lv_scr_act());
    lv_obj_set_size(cont, 290, 200);
    lv_obj_center(cont);
    lv_obj_set_flex_flow(cont, LV_FLEX_FLOW_ROW_WRAP);

    uint32_t i;
    for(i = 0; i < 30; i++) {
        lv_obj_t * btn = lv_btn_create(cont);
        lv_obj_set_size(btn, 80, 50);
        lv_obj_add_flag(btn, LV_OBJ_FLAG_EVENT_BUBBLE);

        lv_obj_t * label = lv_label_create(btn);
        lv_label_set_text_fmt(label, "%"LV_PRIu32, i);
        lv_obj_center(label);
    }

    lv_obj_add_event_cb(cont, event_cb, LV_EVENT_CLICKED, NULL);
}

#endif

Custom events（自定义事件）

任何自定义事件代码都可以通过 uint32_t MY_EVENT_1 = lv_event_register_id(); 注册
并且可以使用 lv_event_send(obj, MY_EVENT_1, &some_data) 发送到任何对象

Refresh event（刷新事件）

LV_EVENT_REFRESH 是一个特殊事件，因为它被设计为用户使用它来通知对象刷新自身。一些例子：

通知标签根据一个或多个变量（例如当前时间）刷新其文本
当语言改变时刷新标签
如果满足某些条件（例如输入正确的 PIN），则启用按钮
如果超出限制，则向/从对象添加/删除样式等

MISC

自定义字体

自带字体：LV_FONT_SIMSUN_16_CJK

转换

字体转换器

常用字体范围

详情见

基础 ASCII: 0x20-0x7F
拉丁扩展：0x80-0xFF
中文字符：0x20-0x7F,0x4E00-0x9FFF
FontAwesome 图标:0xf000-0xf2e0

使用

// 主文件中添加宏
LV_FONT_DECLARE(chili_14);

void setup_style() {
    static lv_style_t style;
    lv_style_init(&style);
    lv_style_set_text_font(&style, &chili_14); 
}

图标的使用

1
2
3

lv_label_set_text(my_label, LV_SYMBOL_OK);  // 直接显示图标
lv_label_set_text(my_label, LV_SYMBOL_OK “Apply”);   // 图标与字符串一起使用
lv_label_set_text(my_label, LV_SYMBOL_OK LV_SYMBOL_WIFI LV_SYMBOL_PLAY); // 多个图标一起使用

DrawAPI

i18n

docs
trans
exmaple:

#include "../../lv_examples.h"

#if LV_USE_TRANSLATION && LV_USE_DROPDOWN && LV_USE_LABEL && LV_BUILD_EXAMPLES

/* Arrays are defined `const` to place them in program space instead of RAM. */
static const char * const tags[] = {"tiger", "lion", "rabbit", "elephant", NULL};
static const char * const languages[] = {"English", "Deutsch", "Español", NULL};

static void add_static_translations(void)
{
    static const char * const translations[] = {
        "The Tiger",    "Der Tiger",     "El Tigre",
        "The Lion",     "Der Löwe",      "El León",
        "The Rabbit",   "Das Kaninchen", "El Conejo",
        "The Elephant", "Der Elefant",   "El Elefante",
    };

    lv_translation_add_static(languages, tags, translations);
}

static void on_language_change(lv_event_t * e)
{
    lv_obj_t * label      = lv_event_get_target_obj(e);
    const char * tag      = (const char *) lv_event_get_user_data(e);
    /* You can get the new language with `lv_event_get_param`*/
    const char * language = (const char *) lv_event_get_param(e);
    LV_UNUSED(language);

    lv_label_set_text(label, lv_tr(tag));
}

static void language_change_cb(lv_event_t * e)
{
    static char selected_lang[20];

    lv_obj_t * dropdown = lv_event_get_target_obj(e);
    lv_dropdown_get_selected_str(dropdown, selected_lang, sizeof(selected_lang));
    lv_translation_set_language(selected_lang);
}

/**
 * Change label text when the translation language changes
 */
void lv_example_translation_2(void)
{
    lv_obj_set_flex_flow(lv_screen_active(), LV_FLEX_FLOW_COLUMN);
    lv_obj_set_flex_align(lv_screen_active(), LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);

    add_static_translations();
    const size_t tag_count = sizeof(tags) / sizeof(tags[0]) - 1;
    const size_t lang_count = sizeof(languages) / sizeof(languages[0]) - 1;

    /* Create a dropdown to be able to select the language */
    lv_obj_t * language_dropdown = lv_dropdown_create(lv_screen_active());
    lv_dropdown_clear_options(language_dropdown);

    for(size_t i = 0; i < lang_count; ++i) {
        lv_dropdown_add_option(language_dropdown, languages[i], i);
    }

    lv_obj_add_event_cb(language_dropdown, language_change_cb, LV_EVENT_VALUE_CHANGED, NULL);

    /* Create a label for each tag */
    for(size_t i = 0; i < tag_count; ++i) {
        lv_obj_t * label = lv_label_create(lv_screen_active());

        /* Bind to the language change event so that we can change the label when the language changes */
        lv_obj_add_event_cb(label, on_language_change, LV_EVENT_TRANSLATION_LANGUAGE_CHANGED, (void *)tags[i]);
    }

    lv_translation_set_language("English");
}

#endif /*LV_USE_TRANSLATION && LV_USE_DROPDOWN && LV_USE_LABEL && LV_BUILD_EXAMPLES*/

BouffaloSDK笔记

Sat, 24 Jan 2026 00:00:00 +0000

BouffaloSDK 使用指南
 SDK Doxygen Docs 野火lwip开发文档

SDK 安装

Win

官方的SDK我不知道为什么无法编译，使用 VeriMake 的可以正常使用

`1`	`git clone https://gitee.com/verimaker/bouffalo_sdk_vmg0.git`

配置环境变量

将SDK目录下的make、ninja、gcc添加到环境变量中,放最下面即可

Check

1
2

make -v
riscv64-unknown-elf-gcc -v

编译

## chip_name 为芯片型号，可以填写 bl702、bl616、bl808、bl606p, board_name 为开发板名称，详见 bsp/board 目录
 cd examples/helloworld
 make CHIP=chip_name BOARD=board_name

 # 使用 ninja 编译 
 make ninja CHIP=chip_name BOARD=board_name

烧录

1
2

cd examples/helloworld
make flash CHIP=chip_name COMX=port_name ## port_name 为串口号名称

常用命令

# 查看所有命令
help
# 连接wifi
wifi_sta_connet "ssid" "pswd"
ping www.baidu.com
# 可以查看ip地址
wifi_sta_info

添加新的工程

引脚定义

芯片定义

M0Pdock定义

GPIO20:MIC_IN

例程

uart(printf)

点开helloworld工程

1
2

make BOARD=m0pdock
make flash COMX=COM17

将UART0（TX:IO21;RX:IO22）连接电脑，可以看到打印信息，推荐使用的xshell软件进行连接，因为官方这个串口log库实现了彩色打印。 注意：set(CONFIG_BFLOG 0)时才能在串口看到打印信息，这有点反直觉，其实是0时将调试信息打印到环形缓冲区，方便调试器查看，1时使用串口发送

常用

1
2

#include "bflb_mtimer.h"
bflb_mtimer_delay_ms(1000);

DMA LLI

static void dma0_ch0_isr(void *arg);

static void adc_init(void)
{
    struct bflb_adc_channel_s chan[] = {
        { .pos_chan = ADC_CHANNEL_0,
          .neg_chan = ADC_CHANNEL_GND },
        { .pos_chan = ADC_CHANNEL_3,
          .neg_chan = ADC_CHANNEL_GND },
    };

    adc = bflb_device_get_by_name("adc");

    /**
     *  adc clock = XCLK / 2 / 20 / 64(14B) = 15.625K
     */
    struct bflb_adc_config_s cfg;
    cfg.clk_div = ADC_CLK_DIV_20;
    cfg.scan_conv_mode = true;
    cfg.continuous_conv_mode = true;
    cfg.differential_mode = false;
    cfg.resolution = ADC_RESOLUTION_14B;
    cfg.vref = ADC_VREF_2P0V;

    bflb_adc_init(adc, &cfg);
    bflb_adc_channel_config(adc, chan, sizeof(chan) / sizeof(chan[0]));
    bflb_adc_link_rxdma(adc, true);

    struct bflb_device_s *dma0_ch0;
    dma0_ch0 = bflb_device_get_by_name("dma0_ch0");

    struct bflb_dma_channel_config_s config;

    config.direction = DMA_PERIPH_TO_MEMORY;
    config.src_req = DMA_REQUEST_ADC;
    config.dst_req = DMA_REQUEST_NONE;
    config.src_addr_inc = DMA_ADDR_INCREMENT_DISABLE;
    config.dst_addr_inc = DMA_ADDR_INCREMENT_ENABLE;
    config.src_burst_count = DMA_BURST_INCR1;
    config.dst_burst_count = DMA_BURST_INCR1;
    config.src_width = DMA_DATA_WIDTH_32BIT;
    config.dst_width = DMA_DATA_WIDTH_32BIT;
    bflb_dma_channel_init(dma0_ch0, &config);

    bflb_dma_channel_irq_attach(dma0_ch0, dma0_ch0_isr, NULL);

    static struct bflb_dma_channel_lli_pool_s lli[20]; /* max trasnfer size 4064 * 20 */
    static struct bflb_dma_channel_lli_transfer_s transfers[2];

    transfers[0].src_addr = (uint32_t)DMA_ADDR_ADC_RDR;
    transfers[0].dst_addr = (uint32_t)adc_raw_data[0];
    transfers[0].nbytes = sizeof(adc_raw_data[0]);

    transfers[1].src_addr = (uint32_t)DMA_ADDR_ADC_RDR;
    transfers[1].dst_addr = (uint32_t)adc_raw_data[1];
    transfers[1].nbytes = sizeof(adc_raw_data[1]);

    int used_count = bflb_dma_channel_lli_reload(dma0_ch0, lli, 20, transfers, 2);
    bflb_dma_channel_lli_link_head(dma0_ch0, lli, used_count);
    bflb_dma_channel_start(dma0_ch0);

    // bflb_adc_start_conversion(adc);

    bflb_adc_stop_conversion(adc);
}

L1 cache

`1`	`#include "bflb_l1c.h"`

Keras 笔记

Sat, 24 Jan 2026 00:00:00 +0000

参考:

TensorFlow

嵌入式笔记00

Sat, 24 Jan 2026 00:00:00 +0000

FileSystem

FATFS

选择格式化的文件系统类型

FAT12: 主要用于极小容量的介质（小于 2MB）
FAT16：32MB 到 2GB 之间的介质（适合较小的 SD 卡或 SPI Flash）
FAT32：适用于 512MB 到 2TB 的容量
exFAT：专门为大容量闪存设计（通常 > 32GB）需要使能FF_FS_EXFAT

配置文件

FF_CODE_PAGE: 配置代码页（CN:936,US:437）
FF_LFN_UNICODE
FF_USE_LFN：长文件名支持
FF_FS_REENTRANT：文件可重入（线程安全），允许重写ff与互斥相关的函数
FF_FS_NORTC：是否使用默认日期，允许重写并从RTC时钟读取当前日期

代码

FRESULT f_open(FIL *fp, const TCHAR *path, BYTE mode);                               /* Open or create a file */
FRESULT f_close(FIL *fp);                                                            /* Close an open file object */
FRESULT f_read(FIL *fp, void *buff, UINT btr, UINT *br);                             /* Read data from the file */
FRESULT f_write(FIL *fp, const void *buff, UINT btw, UINT *bw);                      /* Write data to the file */
FRESULT f_lseek(FIL *fp, FSIZE_t ofs);                                               /* Move file pointer of the file object */
FRESULT f_truncate(FIL *fp);                                                         /* Truncate the file */
FRESULT f_sync(FIL *fp);                                                             /* Flush cached data of the writing file */
FRESULT f_opendir(DIR *dp, const TCHAR *path);                                       /* Open a directory */
FRESULT f_closedir(DIR *dp);                                                         /* Close an open directory */
FRESULT f_readdir(DIR *dp, FILINFO *fno);                                            /* Read a directory item */
FRESULT f_findfirst(DIR *dp, FILINFO *fno, const TCHAR *path, const TCHAR *pattern); /* Find first file */
FRESULT f_findnext(DIR *dp, FILINFO *fno);                                           /* Find next file */
FRESULT f_mkdir(const TCHAR *path);                                                  /* Create a sub directory */
FRESULT f_unlink(const TCHAR *path);                                                 /* Delete an existing file or directory */
FRESULT f_rename(const TCHAR *path_old, const TCHAR *path_new);                      /* Rename/Move a file or directory */
FRESULT f_stat(const TCHAR *path, FILINFO *fno);                                     /* Get file status */
FRESULT f_chmod(const TCHAR *path, BYTE attr, BYTE mask);                            /* Change attribute of a file/dir */
FRESULT f_utime(const TCHAR *path, const FILINFO *fno);                              /* Change timestamp of a file/dir */
FRESULT f_chdir(const TCHAR *path);                                                  /* Change current directory */
FRESULT f_chdrive(const TCHAR *path);                                                /* Change current drive */
FRESULT f_getcwd(TCHAR *buff, UINT len);                                             /* Get current directory */
FRESULT f_getfree(const TCHAR *path, DWORD *nclst, FATFS **fatfs);                   /* Get number of free clusters on the drive */
FRESULT f_getlabel(const TCHAR *path, TCHAR *label, DWORD *vsn);                     /* Get volume label */
FRESULT f_setlabel(const TCHAR *label);                                              /* Set volume label */
FRESULT f_forward(FIL *fp, UINT (*func)(const BYTE *, UINT), UINT btf, UINT *bf);    /* Forward data to the stream */
FRESULT f_expand(FIL *fp, FSIZE_t fsz, BYTE opt);                                    /* Allocate a contiguous block to the file */
FRESULT f_mount(FATFS *fs, const TCHAR *path, BYTE opt);                             /* Mount/Unmount a logical drive */
FRESULT f_mkfs(const TCHAR *path, const MKFS_PARM *opt, void *work, UINT len);       /* Create a FAT volume */
FRESULT f_fdisk(BYTE pdrv, const LBA_t ptbl[], void *work);                          /* Divide a physical drive into some partitions */
FRESULT f_setcp(WORD cp);                                                            /* Set current code page */
int f_putc(TCHAR c, FIL *fp);                                                        /* Put a character to the file */
int f_puts(const TCHAR *str, FIL *cp);                                               /* Put a string to the file */
int f_printf(FIL *fp, const TCHAR *str, ...);                                        /* Put a formatted string to the file */
TCHAR *f_gets(TCHAR *buff, int len, FIL *fp);                                        /* Get a string from the file */

类型

存储类型

typedef unsigned int UINT;  /* int must be 16-bit or 32-bit */
typedef unsigned char BYTE; /* char must be 8-bit */
typedef uint16_t WORD;      /* 16-bit unsigned integer */
typedef uint32_t DWORD;     /* 32-bit unsigned integer */
typedef uint64_t QWORD;     /* 64-bit unsigned integer */
typedef WORD WCHAR;         /* UTF-16 character type */

FRESULT

typedef enum {
    FR_OK = 0,              /* (0) Succeeded */
    FR_DISK_ERR,            /* (1) A hard error occurred in the low level disk I/O layer */
    FR_INT_ERR,             /* (2) Assertion failed */
    FR_NOT_READY,           /* (3) The physical drive cannot work */
    FR_NO_FILE,             /* (4) Could not find the file */
    FR_NO_PATH,             /* (5) Could not find the path */
    FR_INVALID_NAME,        /* (6) The path name format is invalid */
    FR_DENIED,              /* (7) Access denied due to prohibited access or directory full */
    FR_EXIST,               /* (8) Access denied due to prohibited access */
    FR_INVALID_OBJECT,      /* (9) The file/directory object is invalid */
    FR_WRITE_PROTECTED,     /* (10) The physical drive is write protected */
    FR_INVALID_DRIVE,       /* (11) The logical drive number is invalid */
    FR_NOT_ENABLED,         /* (12) The volume has no work area */
    FR_NO_FILESYSTEM,       /* (13) There is no valid FAT volume */
    FR_MKFS_ABORTED,        /* (14) The f_mkfs() aborted due to any problem */
    FR_TIMEOUT,             /* (15) Could not get a grant to access the volume within defined period */
    FR_LOCKED,              /* (16) The operation is rejected according to the file sharing policy */
    FR_NOT_ENOUGH_CORE,     /* (17) LFN working buffer could not be allocated */
    FR_TOO_MANY_OPEN_FILES, /* (18) Number of open files > FF_FS_LOCK */
    FR_INVALID_PARAMETER    /* (19) Given parameter is invalid */
} FRESULT;

FILE Access

#define FA_READ          0x01
#define FA_WRITE         0x02
#define FA_OPEN_EXISTING 0x00
#define FA_CREATE_NEW    0x04
#define FA_CREATE_ALWAYS 0x08
#define FA_OPEN_ALWAYS   0x10
#define FA_OPEN_APPEND   0x30

exmaple

FIL fnew;
FRESULT res; 
UINT fnum;
char write_buf[] = "Hello! This is FatFs test.";
char read_buf[64];

// 1. 写文件测试
res = f_open(&fnew, "/sd/test.txt", FA_CREATE_ALWAYS | FA_WRITE);
if (res == FR_OK) {
    f_write(&fnew, write_buf, sizeof(write_buf), &fnum);
    f_close(&fnew);
    LOG_I("Test file written successfully!\r\n");
}

// 2. 读文件测试
res = f_open(&fnew, "/sd/test.txt", FA_READ);
if (res == FR_OK) {
    f_read(&fnew, read_buf, sizeof(read_buf), &fnum);
    LOG_I("Read content: %s\r\n", read_buf);
    f_close(&fnew);
}

FATFS fs;
__attribute((aligned(8))) static uint32_t workbuf[4096];

MKFS_PARM fs_para = {
    .fmt = FM_FAT32,     /* Format option (FM_FAT, FM_FAT32, FM_EXFAT and FM_SFD) */
    .n_fat = 1,          /* Number of FATs */
    .align = 0,          /* Data area alignment (sector) */
    .n_root = 1,         /* Number of root directory entries */
    .au_size = 512 * 32, /* Cluster size (byte) */
};

void filesystem_init(void)
{
    FRESULT ret;

    board_sdh_gpio_init();

    fatfs_sdh_driver_register();

    ret = f_mount(&fs, "/sd", 1);

    if (ret == FR_NO_FILESYSTEM) {
        LOG_W("No filesystem yet, try to be formatted...\r\n");

        ret = f_mkfs("/sd", &fs_para, workbuf, sizeof(workbuf));

        if (ret != FR_OK) {
            LOG_F("fail to make filesystem %d\r\n", ret);
            _CALL_ERROR();
        }

        if (ret == FR_OK) {
            LOG_I("done with formatting.\r\n");
            LOG_I("first start to unmount.\r\n");
            ret = f_mount(NULL, "/sd", 1);
            LOG_I("then start to remount.\r\n");
        }
    } else if (ret != FR_OK) {
        LOG_F("fail to mount filesystem,error= %d\r\n", ret);
       LOG_F("SD card might fail to initialise.\r\n");
        _CALL_ERROR();
    } else {
        LOG_D("Succeed to mount filesystem\r\n");
    }

    if (ret == FR_OK) {
        LOG_I("FileSystem cluster size:%d-sectors (%d-Byte)\r\n", fs.csize, fs.csize * 512);
    }
}

Connective

传统蓝牙

A2DP(高级音频分发协议)

HFP / HSP(语音电话)

BLE

简单理解

广播：灯不停发送广播包。
发现：手机扫描到了灯的 MAC 地址和 UUID。
连接：手机发起连接请求，双方握手。
发现服务 (Discovery)：手机问灯：“你支持哪些 Service？” 灯回答：“我有一个 UUID 为 0xFF01 的灯控服务。”
找到特征值：手机继续问：“这个服务里有什么？” 灯回答：“有一个 UUID 为 0xFF02 的开关特征值，支持 Write。”
数据交互：
- 手机控制灯：手机向 0xFF02 写入 0x01（开灯）。
- 灯告知手机状态：如果灯有关机按键，按下去后，灯通过 0xFF03 特征值发送 Notify 给手机，手机收到 0x00。

关键层

GAP (Generic Access Profile)：决定设备如何打广告、如何被发现、如何建立连接。
GATT (Generic Attribute Profile)：连接后的数据传输框架（Server/Client 模式）。
ATT (Attribute Protocol)：GATT 的底层支撑，定义了数据操作（Read/Write/Notify）。

代码

zigbee

matter

Thread

迪文屏笔记

Wed, 21 Jan 2026 00:00:00 +0000

前言

学习串口屏，不过还不是很习惯51的开发

概念

变量地址：存放字符串这种,要大于0x0FFF,因为他被系统变量占用
描述指针：style 使用UART2发送以下协议可以修改对应数据

准备前操作

图片等素材以数字+英文或中文或是数字.jpg，第一张图片以数字00开头（只有背景图片所在的icl文件需要按这样命令），图片素材的分辨率需要与屏幕大小保持一致（学校的是800x480）
超长图标以1000开头，不超过1023

软件内步骤

添加图片素材

工程制作完步骤

保存工程，生成工程
使用首页的ICL工具将图片都转为ICL格式，命名为32背景文件，介绍一下13号文件触摸功能，14号显示文件，22号为初始配置文件，这些文件需要下载

烧录

sd卡

FAT32 新建DWIN_SET文件夹，将32号文件，13号文件，14号文件，22号文件放到文件夹内即可下载。 可以不用删除其他文件

组件介绍

常用控件

变量图标显示：根据变量显示对应图片，按照上限值与下限值连续的,如果变量超范围则不显示图标（可用于按下按钮）
动画图标显示：初始值为1时动画开始播放
图片动画：任意大小，在初始页面与结束页面都放上同样属性的页面即可
图标旋转：顺时针
位变量图标：0-1，按位存储，可以将一排按键用一个字节存取
艺术字图标
图标叠加：显示jpeg,在22号文件中，注意软件中的是以字节位单位，hex editor是字为单位，1字等于2字节

触控控件

按键返回：点击后修改变量地址的值
增量调节：一定范围内进行++与–操作，上限为1时可以当翻转使用
数据返回模式0x01时间VP1S上的字节数据传给VP1T指向的数据（用于操控系统变量）

1
2

xdata定义时不要管初值
在sys_init后定义

组态键盘

定义按键定义，定义字符图标设置
根据ASCII码表定义（注意：光标0xFF,确认0xF1,删除:0xF2,退出0xF0）

实用系统变量

C51学习笔记

Tue, 20 Jan 2026 00:00:00 +0000

前期

新建工程

keil
create new uVision project
AT89C52
创建main.c 模板文件：

#include <REGX52.H>

sbit LCD_RW=P2^5;
sbit LCD_EN=P2^7;

unsigned char Sec=55,Min=59,Hour=23;

void fuc(unsigned char cmd)
{

}

void main()
{
	while(1)
	{
	}
}

下载

打开 stc-isp
选择对应芯片型号
下载

stc-isp 的工具

软件延迟计算器

定时器计算器

中断

外设

硬件定时器

串口

void UART_SendByte(unsigned char Byte)
{
	SBUF=Byte;
	while(TI==0);
	TI=0;
}

//串口中断函数模板
void UART_Routine() interrupt 4
{
	if(RI==1)					//如果接收标志位为1，接收到了数据
	{
		P2=~SBUF;				//读取数据，取反后输出到LED
		UART_SendByte(SBUF);	//将受到的数据发回串口
		RI=0;					//接收标志位清0
	}
}

IIC(软件实现)

上升沿，高位先行

void AT24C02_WriteByte(unsigned char WordAddress,Data)
{
	I2C_Start();
	I2C_SendByte(AT24C02_ADDRESS);
	I2C_ReceiveAck();
	I2C_SendByte(WordAddress);
	I2C_ReceiveAck();
	I2C_SendByte(Data);
	I2C_ReceiveAck();
	I2C_Stop();
}

unsigned char AT24C02_ReadByte(unsigned char WordAddress)
{
	unsigned char Data;
	I2C_Start();
	I2C_SendByte(AT24C02_ADDRESS);
	I2C_ReceiveAck();
	I2C_SendByte(WordAddress);
	I2C_ReceiveAck();
	I2C_Start();
	I2C_SendByte(AT24C02_ADDRESS|0x01);
	I2C_ReceiveAck();
	Data=I2C_ReceiveByte();
	I2C_SendAck(1);
	I2C_Stop();
	return Data;
}

#include <REGX52.H>

sbit I2C_SCL=P2^1;
sbit I2C_SDA=P2^0;

/**
  * @brief  I2C开始
  * @param  无
  * @retval 无
  */
void I2C_Start(void)
{
	I2C_SDA=1;
	I2C_SCL=1;
	I2C_SDA=0;
	I2C_SCL=0;
}

/**
  * @brief  I2C停止
  * @param  无
  * @retval 无
  */
void I2C_Stop(void)
{
	I2C_SDA=0;
	I2C_SCL=1;
	I2C_SDA=1;
}

/**
  * @brief  I2C发送一个字节
  * @param  Byte 要发送的字节
  * @retval 无
  */
void I2C_SendByte(unsigned char Byte)
{
	unsigned char i;
	for(i=0;i<8;i++)
	{
		I2C_SDA=Byte&(0x80>>i);
		I2C_SCL=1;
		I2C_SCL=0;
	}
}

/**
  * @brief  I2C接收一个字节
  * @param  无
  * @retval 接收到的一个字节数据
  */
unsigned char I2C_ReceiveByte(void)
{
	unsigned char i,Byte=0x00;
	I2C_SDA=1;
	for(i=0;i<8;i++)
	{
		I2C_SCL=1;
		if(I2C_SDA){Byte|=(0x80>>i);}
		I2C_SCL=0;
	}
	return Byte;
}

/**
  * @brief  I2C发送应答
  * @param  AckBit 应答位，0为应答，1为非应答
  * @retval 无
  */
void I2C_SendAck(unsigned char AckBit)
{
	I2C_SDA=AckBit;
	I2C_SCL=1;
	I2C_SCL=0;
}

/**
  * @brief  I2C接收应答位
  * @param  无
  * @retval 接收到的应答位，0为应答，1为非应答
  */
unsigned char I2C_ReceiveAck(void)
{
	unsigned char AckBit;
	I2C_SDA=1;
	I2C_SCL=1;
	AckBit=I2C_SDA;
	I2C_SCL=0;
	return AckBit;
}

不是很重要的芯片

DS1302 (RTC时钟)

上升沿往芯片写数据，下降沿读取芯片寄存器，低位先行

unsigned char DS1302_ReadByte(unsigned char Command)
{
	unsigned char i,Data=0x00;
	Command|=0x01;	//将指令转换为读指令
	DS1302_CE=1;
	for(i=0;i<8;i++)
	{
		DS1302_IO=Command&(0x01<<i);
		DS1302_SCLK=0;
		DS1302_SCLK=1;
	}
	for(i=0;i<8;i++)
	{
		DS1302_SCLK=1;
		DS1302_SCLK=0;
		if(DS1302_IO){Data|=(0x01<<i);}
	}
	DS1302_CE=0;
	DS1302_IO=0;	//读取后将IO设置为0，否则读出的数据会出错
	return Data;
}

uint8_t decToBcd(uint8_t decimal) {
    if (decimal > 99) {
        return 0xFF; // 或者可以触发错误处理
    }
    uint8_t tens = decimal / 10;
    uint8_t ones = decimal % 10;
    return (tens << 4) | ones; // 高 4 位放十位，低 4 位放个位
}

Expo笔记

Sun, 04 Jan 2026 00:00:00 +0000

常见命令

新建工程

npx create-expo-app@latest

//创建babel.config.js
npx expo customize babel.config.js

//启动服务器
npx expo start
//预编译
npx expo prebuild
//本地编译原生安卓应用
npx expo run:android
npx expo run:ios
//安装新的库
npx expo install package-name

错误检查

`1`	`npx expo-doctor`

前面的知识

存储数据

Expo SecureStore

`1`	`npx expo install expo-secure-store`

// utils/secureStore.ts
import * as SecureStore from 'expo-secure-store';

// 可选：定义密钥常量，避免魔法字符串
export const SECURE_STORE_KEYS = {
  ACCESS_TOKEN: 'ACCESS_TOKEN',
  REFRESH_TOKEN: 'REFRESH_TOKEN',
  USER_ID: 'USER_ID',
} as const;

/**
 * 安全存储 - 设置值
 * @param key 存储键（建议使用 SECURE_STORE_KEYS 中的常量）
 * @param value 要存储的字符串值
 * @returns Promise<boolean> 是否成功
 */
export const setSecureItem = async (key: string, value: string): Promise<boolean> => {
  try {
    await SecureStore.setItemAsync(key, value, {
      // 可选：指定加密选项（默认已足够安全）
      keychainAccessible: SecureStore.ALWAYS_THIS_DEVICE_ONLY, // iOS: 仅当前设备，不解锁也能访问（根据需求调整）
      keychainService: 'com.yourcompany.yourapp.securestore', // iOS: 自定义服务名（可选）
    });
    return true;
  } catch (error) {
    console.error(`[SecureStore] Failed to set item "${key}":`, error);
    return false;
  }
};

/**
 * 安全存储 - 获取值
 * @param key 存储键
 * @returns Promise<string | null> 成功返回字符串，失败或不存在返回 null
 */
export const getSecureItem = async (key: string): Promise<string | null> => {
  try {
    const value = await SecureStore.getItemAsync(key);
    return value; // 若不存在，返回 null
  } catch (error) {
    console.error(`[SecureStore] Failed to get item "${key}":`, error);
    return null;
  }
};

/**
 * 安全存储 - 删除值
 * @param key 存储键
 * @returns Promise<boolean> 是否成功
 */
export const deleteSecureItem = async (key: string): Promise<boolean> => {
  try {
    await SecureStore.deleteItemAsync(key);
    return true;
  } catch (error) {
    console.error(`[SecureStore] Failed to delete item "${key}":`, error);
    return false;
  }
};

/**
 * 安全存储 - 清除所有（谨慎使用！仅用于登出等场景）
 * 注意：只会清除当前应用写入的项
 */
export const clearSecureStore = async (): Promise<boolean> => {
  try {
    // Expo SecureStore 没有直接提供 clearAll，需逐个删除
    // 建议：维护一个你使用的 key 列表
    const keys = Object.values(SECURE_STORE_KEYS);
    await Promise.all(keys.map(key => SecureStore.deleteItemAsync(key)));
    return true;
  } catch (error) {
    console.error('[SecureStore] Failed to clear all items:', error);
    return false;
  }
};

Expo SQLite

Expo FileSystem

`1`	`npx expo install expo-file-system`

import * as DocumentPicker from 'expo-document-picker';

const pickAndSlice = async () => {
  // 1. 用户选择文件
  const result = await DocumentPicker.getDocumentAsync({
    type: '*/*',
  });

  if (result.canceled) return;

  const file = result.assets[0];

  // 2. 分片：取前 512 字节，并显式指定类型
  const headerChunk = file.slice(0, 512, 'application/octet-stream');

  // 3. 读取分片内容（例如检查文件头）
  const reader = new FileReader();
  reader.onload = (e) => {
    const arrayBuffer = e.target?.result as ArrayBuffer;
    const view = new Uint8Array(arrayBuffer);
    console.log('File header bytes:', view.slice(0, 10)); // 打印前10字节
  };
  reader.readAsArrayBuffer(headerChunk);
};

页面导航（Expo Router）

app
    -(root_group_name)
        index.tsx
        [productId].tsx
        _layout.tsx
    - child_page
        index.tsx
        [params].tsx

pre

`1`	`npx expo install expo-router react-native-safe-area-context react-native-screens expo-linking expo-constants expo-status-bar`

使用动态路由

传递参数

<Link href="/users?limit=20">View users</Link>

<View>
  <Link
    href="/user/bacon">
    View user (id inline)
  </Link>
  <Link
    href={{
      pathname: '/user/[id]',
      params: { id: 'bacon' }
    }}
  >
    View user (id in params in href)
  </Link>
  <Pressable
    onPress={() =>
      router.navigate({
        pathname: '/user/[id]',
        params: { id: 'bacon' }
      })
    }
  >
    <Text>View user (imperative)</Text>
  </Pressable>
</View>

// 在不重新进入页面的情况下更新页面参数
<Pressable onPress={() => router.setParams({ limit: 50 })}>
  <Text>View more users</Text>
</Pressable>

接收参数

import { useLocalSearchParams } from 'expo-router';
import { View, Text } from 'react-native';

export default function Users() {
  const { id, limit } = useLocalSearchParams();

  return (
    <View>
      <Text>User ID: {id}</Text>
      <Text>Limit: {limit}</Text>
    </View>
  );
}

Deep links

Stack

手动编写

// app/_layout.tsx
import { Stack } from 'expo-router';

export default function Layout() {
  return (
    <Stack>
      <Stack.Screen name="index" options={{ title: '首页' }} />
      <Stack.Screen name="profile" options={{ title: '个人资料' }} />
      <Stack.Screen
        name="settings"
        options={{
          title: '设置',
          headerStyle: { backgroundColor: '#f0f0f0' },
          headerTintColor: '#000',
        }}
      />
      <Stack.Screen name="[productId]" options={{ headerShown: false }} />
    </Stack>
  );
}

自动

`1`	`<Stack screenOptions={{ headerShown: false }} />`

Tabs

// app/(tabs)/_layout.tsx
import { Tabs } from 'expo-router';
import { MaterialIcons } from '@expo/vector-icons'; // 官方推荐图标库

export default function TabsLayout() {
  return (
    <Tabs
      screenOptions={{
        // --- 全局 Tab 样式 ---
        tabBarActiveTintColor: '#1e90ff',       // 选中时颜色
        tabBarInactiveTintColor: '#888',        // 未选中颜色
        tabBarStyle: {
          height: 60,
          paddingBottom: 6,
          paddingTop: 6,
          borderTopWidth: 1,
          borderTopColor: '#eee',
        },

        // --- 每个页面的 Header 控制（统一设置）---
        headerShown: true,                      // 默认显示 header
        headerStyle: {
          backgroundColor: '#fff',
        },
        headerShadowVisible: false,             // 去掉 header 底部阴影（iOS/Android 统一）
        headerTitleAlign: 'center',             // 标题居中
      }}
    >
      <Tabs.Screen
        name="index"
        options={{
          title: '首页',
          headerShown: false, // 首页通常不需要 header
          tabBarIcon: ({ color, size }) => (
            <MaterialIcons name="home" size={size} color={color} />
          ),
        }}
      />
      <Tabs.Screen
        name="profile"
        options={{
          title: '我的',
          headerTitle: '个人中心', // 自定义 header 标题（不同于 tab 标题）
          tabBarIcon: ({ color, size }) => (
            <MaterialIcons name="person" size={size} color={color} />
          ),
        }}
      />
      <Tabs.Screen
        name="settings"
        options={{
          title: '设置',
          tabBarIcon: ({ color, size }) => (
            <MaterialIcons name="settings" size={size} color={color} />
          ),
        }}
      />
    </Tabs>
  );
}

Drawer

Slots

// 访问/ 则slot渲染index.tsx的内容
// 访问/profile 则slot渲染profile.tsx的内容
// app/_layout.tsx
import { View, Text } from 'react-native';
import { Slot } from 'expo-router';

export default function Layout() {
  return (
    <View style={{ flex: 1 }}>
      {/* 全局 Header */}
      <Text style={{ fontSize: 20, textAlign: 'center', padding: 10 }}>
        MyApp
      </Text>

      {/* 子页面内容在这里显示 */}
      <Slot />
    </View>
  );
}

路由守卫

import { Stack } from 'expo-router';
import { useAuthState } from '@/utils/authState';

export default function RootLayout() {
  const { isLoggedIn } = useAuthState();

  return (
    <Stack>
      <Stack.Protected guard={isLoggedIn}>
        <Stack.Screen name="(tabs)" />
        <Stack.Screen name="modal" />
      </Stack.Protected>

      <Stack.Protected guard={!isLoggedIn}>
        <Stack.Screen name="sign-in" />
        <Stack.Screen name="create-account" />
      </Stack.Protected>
    </Stack>
  );
}

expo file

GlueStack（UI库）

Flutter笔记

Sun, 04 Jan 2026 00:00:00 +0000

嘉立创EDA笔记

Sat, 20 Dec 2025 00:00:00 +0000

常用网站

立创商城 - 用于查芯片半导小芯 - 用于芯片选型

常用公式

1mil = 0.0254mm 1mm = 39.37mil

3W 原则：不同信号线的线间距应大于3倍线宽

常用快捷键

绘制器件元件与封装

元件

封装

引脚长度补偿（用于侧边含有引脚的，如果手册上写了照着画则别管）

参数说明：

器件实体长度：A
器件管脚可焊接高度：H
器件管脚可焊接长度：T
器件管脚宽度：W
外侧补偿值：T1
内侧补偿值：T2
侧边补偿值：W1
补偿后焊盘长度：X
补偿后焊盘宽度：Y
焊盘中心距：S 计算公式：
补偿后焊盘长度 = 外侧补偿值 + 器件管脚可焊接长度 + 内侧补偿值（X = T1 + T + T2）
补偿后焊盘宽度 = 侧边补偿值 + 器件管脚宽度 + 侧边补偿值（Y = W1 + W + W1）

焊盘中心距 = 器件实体长度 + 2倍的外侧补偿值 - 补偿后焊盘长度（S = A + T1 + T1 - X） 推荐取值范围：

参数	取值范围
外侧补偿值	0.1 ~ 1 mm
内侧补偿值	0.1 ~ 1 mm
侧边补偿值	0 ~ 0.2 mm

使用命令工具精细控制

打开方式：toolbar->工具->命令
常用命令:(使用前先切换到丝印绘制模式)

// 绝对坐标命令
x x坐标 y坐标
// x坐标相对坐标命令
ix x坐标偏移量
// y坐标相对坐标命令
iy y坐标偏移量

技巧

toolbar->工具->重新编号焊盘
toolbar->布线->自动裁剪丝印

注意点

丝印不要添加在焊盘上了
保持丝印大小合适，不要太大（影响排版）也不要太小（看不到）

按模块进行布局（先不需要连线）

参考顺序

结构器件（如装配图上给出的typec端子，主芯片）->特殊器件->主要器件

叠层设计

Layer 1：信号层（Top Signal）
Layer 2：地平面（Ground Plane）
Layer 3：电源平面（Power Plane）
Layer 4：信号层（Bottom Signal）

设计规则

线宽设置

添加电源线的类（）

一般外层铜厚为 1 OZ, 1.5 A电流至少大于23mil, 日常使用6-10mil合适（0.2A-0.5A）
BGA 封装的常用线宽： 4mil

阻抗匹配

嘉立创阻抗计算器

类型	别名	结构特点	回流路径
单端阻抗（外层）	微带线	信号线下方有地平面，同层无邻近地铜	通过下方地平面返回
共面单端阻抗（外层）	CPW	信号线两侧有同层地铜，下方可有/无地平面	通过同层地铜和下方地平面共同返回
差分阻抗（外层）	差分微带线	差分对下方有地平面，同层无侧边地铜	主要靠互耦，辅以下方地平面返回
共面差分阻抗（外层）	CPWG	差分对两侧有同层地铜，下方通常有地平面	通过同层地铜、下方地平面和互耦共同返回
常用数据：

USB2.0 90R
USB3.0 90或100R（具体查看对应手册）
SD座子 UHS-I（单端信号；推荐单端阻抗：50 Ω ±10%；信号线包括：CLK, CMD, DAT0~DAT3
SD座子 UHS-II（差分信号）；使用专用差分对（TX+/TX−, RX+/RX−）；差分阻抗：100 Ω ±10%

铺铜区域

网络间距

当铺铜时出现明显的铺铜区域受其他焊盘影响时，可以适当调小（比如8）

连接方式

直连：焊盘与内层铜皮（如GND或PWR平面）全周无缝连接
发散：焊盘通过2~4条细颈走线（spokes）与内层平面连接，形成“十字”或“米字”结构。

注意点

铺铜时要有倒角
大电源直接铺铜处理

电容放置规则

扇孔

该步骤负责较短的走线与打好过孔（含GND），尽可能多打孔，后期不用可以删掉

回流过孔（Return Vias）

丝印处可以打过孔与走线，但是不要在焊盘上打过孔（除非你用特殊工艺）
如果线需要很长且跨层的话，先不要连接，就近处引出过孔
一个器件的信号孔旁边就近打它的GND过孔（减少回流路径，也就是降低电感）

屏蔽过孔（Shielding Vias）

在差分对，敏感信号附近打屏蔽过孔（GND）
包地处理，直接使用 GND 线包着即可（同层）

地孔围栏（Ground Via Fence）

走线

注意点

要么垂直从焊盘出来，要么从焊盘四个角处45度出来，不要从边上45度出来
电源相关的布线宽度要大一点（如果引出的间距较小，可以先使用小宽度引出，然后再切回大宽度）
如果封装影响走线，可以适当修改封装的焊盘大小，改成长圆型（适当，适当）

电源与地平面的处理（4层板）

解决方案：

地平面尽量靠近需要地过孔比较多的，可以提供一个完整的地平面
将小信号走在电源层，这样顶层与底层都能有完整的地平面参考

修线

要求：不存在信号跨分割，满足载流路径，回流路径短，不存在环形、U型走线

等长处理

其他知识

散热过孔

将器件产生的热量从顶层（或底层）传导至内层或另一侧铜箔/平面的一种导热结构

特殊

顶层与底层板子的四周进行铺铜操作，并打上一排的过孔(构建 “PCB 边缘电磁屏蔽边界”)
电源->芯片，先大电容后小电容

常见元件

DC-DC 转换模块

LDO 电源转换模块

stm32h750xbh6学习笔记（配置篇）

Fri, 21 Nov 2025 00:00:00 +0000

因为前面内容太多了，所以单开一页记录Stm32CubeMX上的配置。

FMC

Clock and chip enable

可以控制两个SDRAM 芯片，每个有对应的时钟

4Banks

1 Bank = 32Mbits

Address（地址线）

你看原理图上有几个A[num]的线就是几个

Data

32位

Byte Enable

时序配置

看到对应芯片的OPERATING FREQUENCY / LATENCY RELATIONSHIPS部分

LTDC

DMA2D

为什么RGB565 -> RGB888

节省SDRAM空间
节省SDRAM的带宽占用，降低撕裂感

stm32h750xbh6学习笔记

Sat, 01 Nov 2025 00:00:00 +0000

本笔记主要记录在学习《安富莱 STM32-V7 开发板用户手册》需要注意的点。使用的开发板为反客的同型号开发板

如何配置下载算法

什么是下载算法

简单来说就是一段在 SRAM 运行的程序，将对应的hex文件烧录到指定的外部flash中。
现在我的程序分为两部分bootloader(内部flash),app(外部flash)。当你需要使用外部flash存放里的app时需要先下载bootloader程序到内部flash里。

一个简单的 bootloader 程序的样子

QSPI_HandleTypeDef hqspi;
UART_HandleTypeDef huart1;
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_QUADSPI_Init(void);
typedef  void (*pFunction)(void);

int main(void)
{
	SCB_EnableICache();		// 使能ICache
	SCB_EnableDCache();		// 使能DCache
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();
    MX_USART1_UART_Init();
    MX_QUADSPI_Init();
	QSPI_W25Qxx_Init();
	
	QSPI_W25Qxx_MemoryMappedMode(); 	 // 配置QSPI为内存映射模式
	SCB_DisableICache();		// 关闭ICache
	SCB_DisableDCache();		// 关闭Dcache
	SysTick->CTRL = 0;		// 关闭SysTick
	SysTick->LOAD = 0;		// 清零重载值
	SysTick->VAL = 0;			// 清零计数值
	JumpToApplication = (pFunction) (*(__IO uint32_t*) (W25Qxx_Mem_Addr + 4));	// 设置起始地址
	__set_MSP(*(__IO uint32_t*) W25Qxx_Mem_Addr);	// 设置主堆栈指针
	JumpToApplication();			// 执行跳转
  while (1);
}

keil

添加下载算法到keil路径(.flm文件)

找到商家提供的.flm文件，复制到keil存放路径的上一页，放到keil-ARM-Flash文件夹即可
魔术棒-Debug-Setting-FlashDownload-Add-选择上面加入的算法（这样keil就知道这段地址是存在的）
魔术棒-Target-Read/Only Memory Areas下将第一个勾选,配置为ROM1:Start:0x90000000Size:0x2000000(注意这里是32MB对应的)，其他的选项都叉掉

这步在app中完成

程序需要添加一个

`1`	`SCB->VTOR = 0x90000000; // 重定向向量表`

注意

如果后面无法加载下载算法，可能有一下原因：

线没接好
下载时钟过快
在Flash Download 页面中的 RAM for Algorithm 里的 Size 调大点

rtt studio

stm32prog(.stldr文件)

配置工程-下载-勾选外部下载器-选择指定的算法文件-添加商家提供的.stldr文件
工程目录-linkScript-…-link.lds
将ROM修改为0x90000000,大小改为32768（这里是因为我的开发板上有一块 32MB 的 QSPI FLASH，这里需要按照自己的开发板大小进行填写）

jlink

我手上没有jlink,这里引用别人的文章
参考： “使用 ART-Pi(STM32H750) 片外8M 之JLINK”

如何编写下载算法

flm文件

注意flash写操作尽量以256bits为单位进行（每256bits配10bit的ECC位，可以检测1个bit并纠正或是检测2个bit），这样硬件ECC不容易出问题。flash读操作支持64bits,32bits,16bits和8bits
找到…\keil\ARM\Flash_Template
“参考”

stldr文件

“参考”

Chap.9 EventRecoder(keil独有,通用调试器)

pre

基于EventRecoder的printf重定向

需要启用MicroLib

#include "EventRecorder.h"
int main(void)
{

  /* USER CODE BEGIN 1 */
	//放最前面
	EventRecorderInitialize(EventRecordAll, 1U);
	EventRecorderStart();
  /* USER CODE END 1 */

  /* MPU Configuration--------------------------------------------------------*/
  MPU_Config();
  while (1)
  {
		printf("hello world from SWD");
		HAL_Delay(1000);
  }
  /* USER CODE END 3 */
}

基于EventRecoder的时间测量功能

基础部分

Chap.10 Map文件的查看（可用于分析程序大小）

名词表

Section Cross References

不同函数的调用关系

Removing Unused input sections from the image

被删除的冗余函数，启用One ELF Section per Function功能后会有

Image Symbol Table

分为两部分Local Symbols（显示 static 修饰的函数地址，变量大小），Global Symbols（显示全局变量的）

Memory Map of the image

分为加载域 (Load Region，程序存放的样子) 和运行域（Execution Region，程序运行时的样子)

Image component sizes

.text:与 RO-code 同义
.constdata: 与 RO-data 同义
.bss：与 Zl-data 同义
.data: 与 RW-data 同义
Code (inc. Data)：显示代码占用了多少字节。在此映像中，有 19442 字节的代码，其中包括 1832 字节的内联数据 (inc. data)，例如文字池和短字符串。
RO Data：显示只读数据占用了多少字节（比如 const char buf[] = “123456”）。这是除 Code (inc. data) 列中包括的内联数据之外的数据。
RW Data：显示读写数据占用了多少字节。
ZI Data：显示零初始化的数据占用了多少字节。
Debug：显示调试数据占用了多少字节，例如，调试输入节以及符号和字符串。
Object Totals：显示链接到一起以生成映像的对象占用了多少字节。
(incl. Generated)：链接器会生成的映像内容，例如，交互操作中间代码。如果 Object Totals 行包含此类型的数据，则会显示在该行中。本例中共有 1016 字节的 RO 数据，其中 32 字节是链接器生成的 RO 数据。
(incl. Padding)：链接器根据需要插入填充，以强制字节对齐。

Library Totals

下面的 Librany Totals 显示已提取并作为单个对象添加到映像中的库成员占用了多少字节。

最后一项

Grand Totals：显示映像的真实大小。
ELF Image Totals：ELF (Executable and Linking Format) 可执行链接格式映像文件大小。
ROM Totals：显示包含映像所需的 ROM 的最小大小。这不包括 ZI 数据和存储在 ROM 中的调试信息。

htm文件的查看（用于查看工程/具体某个函数的最大栈深度）

自己看去

Chap.11 MDK移植SEGGER的硬件异常分析（jlink用的）

下载链接

认识HAL 库框架

stm32h7xx_hal_conf.h（如果不用 cubemx 的话就在这里改）

// 设计的板子的外部晶振要与这个一致（25MHz）
#define HSE_VALUE    (25000000UL)
// 注意滴答定时器的优先级，如果你需要在中断函数中使用HAL_Delay()时，因为delay需要基于滴答计时器进行计时，如果优先级较低会卡死。
#define  TICK_INT_PRIORITY            (15UL) /*!< tick interrupt priority */
// STM32H7 的 SDIO 外接支持 UHS-I 模式 (SDR12, SDR25, SDR50, SDR104 和 DDR50)
的 SD 卡， 需要 1.8 的电平转换器， 此选项就是来使能此功能用的
#define  USE_SD_TRANSCEIVER           0U               /*!< use uSD Transceiver */


// 使能断言函数（需要自己重写void assert_failed(uint8_t *file, uint32_t line)）默认关闭
#define USE_FULL_ASSERT    1U
#ifdef  USE_FULL_ASSERT
/**
  * @brief  The assert_param macro is used for function's parameters check.
  * @param  expr: If expr is false, it calls assert_failed function
  *         which reports the name of the source file and the source
  *         line number of the call that failed.
  *         If expr is true, it returns no value.
  * @retval None
  */
  #define assert_param(expr) ((expr) ? (void)0U : assert_failed((uint8_t *)__FILE__, __LINE__))
/* Exported functions ------------------------------------------------------- */
  void assert_failed(uint8_t *file, uint32_t line);
#else
  #define assert_param(expr) ((void)0U)
#endif /* USE_FULL_ASSERT */

启动流程

/*
******************************************************************************************************
*        函 数 名: bsp_Init
*        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。
*              只需要调用一次
*        形    参：无
*        返 回 值: 无
******************************************************************************************************
*/
void bsp_Init(void)
{
    		/* 配置MPU(内存保护) */
        MPU_Config();
        
        /* 使能L1 Cache */
        CPU_CACHE_Enable();

        /* 
       STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
           - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
           - 设置NVIV优先级分组为4。
         */
        HAL_Init();

        /* 
       配置系统时钟到400MHz
       - 切换使用HSE。
       - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
       - 它会开启滴答定时器中断，如果用户也要使用滴答定时器中断，此问
题就要引起注意。（见下面代码）
    */
        SystemClock_Config();

        
        bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
        bsp_InitTimer();          /* 初始化滴答定时器 */
        bsp_InitUart();        /* 初始化串口 */
        bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
        bsp_InitLed();            /* 初始化LED */        
        
        bsp_InitLPTIMOutPWM(); /* 低功耗定时器PWM输出 */
}

/*
*********************************************************************************************************
*        函 数 名: SysTick_Handler
*        功能说明: 系统嘀嗒定时器中断服务程序。启动文件中引用了该函数。
*        形    参:  无
*        返 回 值: 无
*********************************************************************************************************
*/
void SysTick_Handler(void)
{
        HAL_IncTick();        /* ST HAL库的滴答定时中断服务程序 */
        
        if (g_ucEnableSystickISR == 0) /* bsp配置的bsp层SysTickHandle使能标志，调用了函数bsp_InitTimer才置位此变量 */
        {
                return;
        }
        
        SysTick_ISR();        /* 安富莱bsp库的滴答定时中断服务程序 */
}

// 上面的函数注释
__weak void HAL_IncTick(void)
{
  uwTick += (uint32_t)uwTickFreq;
}
void SysTick_ISR(void)
{
	static uint8_t s_count = 0;
	uint8_t i;
	
	/* 每隔1ms进来1次 （仅用于 bsp_DelayMS） */
	if (s_uiDelayCount > 0)
	{
		if (--s_uiDelayCount == 0)
		{
			s_ucTimeOutFlag = 1;
		}
	}

	/* 每隔1ms，对软件定时器的计数器进行减一操作 */
	for (i = 0; i < TMR_COUNT; i++)
	{
		bsp_SoftTimerDec(&s_tTmr[i]);
	}

	/* 全局运行时间每1ms增1 */
	g_iRunTime++;
	if (g_iRunTime == 0x7FFFFFFF)	/* 这个变量是 int32_t 类型，最大数为 0x7FFFFFFF */
	{
		g_iRunTime = 0;
	}

	bsp_RunPer1ms();		/* 每隔1ms调用一次此函数，此函数在 bsp.c */

	if (++s_count >= 10)
	{
		s_count = 0;

		bsp_RunPer10ms();	/* 每隔10ms调用一次此函数，此函数在 bsp.c */
	}
}

HAL 库初始化外设(e.g. UART)

HAL_UART_Init()->__weak HAL_UART_MspInit();// 在此进行初始化

void HAL_UART_MspInit(UART_HandleTypeDef* huart)
{
        GPIO_InitTypeDef GPIO_InitStruct = {0};
        
        if(huart->Instance==USART1)
        {
                __HAL_RCC_USART1_CLK_ENABLE();

                __HAL_RCC_GPIOB_CLK_ENABLE();

                GPIO_InitStruct.Pin = GPIO_PIN_7;
                GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
                GPIO_InitStruct.Pull = GPIO_NOPULL;
                GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
                GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
                HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

                GPIO_InitStruct.Pin = GPIO_PIN_14;
                GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
                GPIO_InitStruct.Pull = GPIO_NOPULL;
                GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
                GPIO_InitStruct.Alternate = GPIO_AF4_USART1;
                HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
        }
        else if(huart->Instance==USART2)
        {
                __HAL_RCC_USART2_CLK_ENABLE();

                __HAL_RCC_GPIOD_CLK_ENABLE();
                __HAL_RCC_GPIOA_CLK_ENABLE();

                GPIO_InitStruct.Pin = GPIO_PIN_6;
                GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
                GPIO_InitStruct.Pull = GPIO_NOPULL;
                GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
                GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
                HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

                GPIO_InitStruct.Pin = GPIO_PIN_2;
                GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
                GPIO_InitStruct.Pull = GPIO_NOPULL;
                GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
                GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
                HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
        }
}

HAL 中断函数示例（e.g. HAL_UART_IRQHandler）

HAL_UART_TxHalfCpltCallback()  //DMA 发送模式下，发送缓冲区前半部分传输完成
HAL_UART_TxCpltCallback()  //中断或 DMA 模式下，整个发送完成
HAL_UART_RxHalfCpltCallback()  //DMA 接收模式下，接收缓冲区前半部分接收完成
//中断模式：单次接收完成；
//DMA 模式：整个缓冲区接收完成
HAL_UART_RxCpltCallback()
HAL_UART_ErrorCallback()

//调用 HAL_UART_Abort() 后，发送和接收都中止完成时调用
HAL_UART_AbortCpltCallback(UART_HandleTypeDef *huart)	
// 调用 HAL_UART_AbortTransmit() 后，发送中止完成
HAL_UART_AbortTransmitCpltCallback(UART_HandleTypeDef *huart)	
//调用 HAL_UART_AbortReceive() 后，接收中止完成
HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart)

HAL 库的 DMA 处理思路

HAL_UART_Transmit_DMA()
HAL_UART_Receive_DMA()
HAL_UART_DMAPause()
HAL_UART_DMAResume()
HAL_UART_DMAStop()

// 针对外设的 DMA 函数基本都有开启中断， 如果用户使能此外设的 NVIC， 使用
中务必别忘了写 DMA 的中断服务程序
void DMA1_Stream1_IRQHandler(void)
{
/* 参数是 DMA 句柄 */
HAL_DMA_IRQHandler(&hdma_usart1_tx);
}

Chap.13 STM32H7启动过程详解

启动文件分析

硬件复位后：
设置堆栈指针 SP = __initial_sp。
- 设置 PC 指针 = Reset_Handler。
- 设置中断向量表。
- 配置系统时钟。
- 配置外部 SRAM/SDRAM 用于程序变量等数据存储（这是可选的） 。
- 跳转到 C 库中的 __main ，最终会调用用户程序的 main()函数

; Amount of memory (in bytes) allocated for Stack
; Tailor this value to your application needs
; <h> Stack Configuration
;   <o> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>

Stack_Size      EQU     0x00001000

                AREA    STACK, NOINIT, READWRITE, ALIGN=3
Stack_Mem       SPACE   Stack_Size
__initial_sp

0x00001000 表示栈大小，注意这里是以字节为单位

ARER 伪指令表示下面将开始定义一个代码段或者数据段。此处是定义数据段。 
STACK ：表示这个段的名字，可以任意命名。
NOINIT：表示此数据段不需要填入初始数据。
READWRITE：表示此段可读可写。
ALIGN=3 ：表示首地址按照 2 的 3 次方对齐，也就是按照 8 字节对齐(地址对 8 求余数等于 0)

SPACE 这行指令告诉汇编器给 STACK 段分配 0x00000400 字节的连续内存空间。

initial_sp 紧接着 SPACE 语句放置，表示了栈顶地址。 __initial_sp只是一个标号，标号主
要用于表示一片内存空间的某个位置



; <h> Heap Configuration
;   <o>  Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>

Heap_Size       EQU     0x0000800

                AREA    HEAP, NOINIT, READWRITE, ALIGN=3
__heap_base
Heap_Mem        SPACE   Heap_Size
__heap_limit

__heap_base 表示堆的开始地址。武汉安富莱电子有限公司
__heap_limit 表示堆的结束地址




                PRESERVE8
                THUMB


; Vector Table Mapped to Address 0 at Reset
                AREA    RESET, DATA, READONLY
                EXPORT  __Vectors
                EXPORT  __Vectors_End
                EXPORT  __Vectors_Size

PRESERVE8 指定当前文件保持堆栈八字节对齐。
THUMB 表示后面的指令是 THUMB 指令集 ， CM7 采用的是 THUMB - 2 指令集。
AREA 定义一块数据段，只读，段名字是 RESET。 READONLY 表示只读，缺省就表示代码段了。
3 行 EXPORT 语句将 3 个标号申明为可被外部引用， 主要提供给链接器用于连接库文件或
其他文件。



__Vectors       DCD     __initial_sp                      ; Top of Stack
                DCD     Reset_Handler                     ; Reset Handler
                DCD     NMI_Handler                       ; NMI Handler
                DCD     HardFault_Handler                 ; Hard Fault Handler
                DCD     MemManage_Handler                 ; MPU Fault Handler
                DCD     PendSV_Handler                    ; PendSV Handler
                DCD     SysTick_Handler                   ; SysTick Handler

                ; External Interrupts
                DCD     WWDG_IRQHandler                   ; Window WatchDog interrupt ( wwdg1_it)                                         
                DCD     PVD_AVD_IRQHandler                ; PVD/AVD through EXTI Line detection                        
                DCD     TAMP_STAMP_IRQHandler             ; Tamper and TimeStamps through the EXTI line            
                DCD     RTC_WKUP_IRQHandler               ; RTC Wakeup through the Reserved                                    
                DCD     WAKEUP_PIN_IRQHandler             ; Interrupt for all 6 wake-up pins 
                

__Vectors_End

__Vectors_Size  EQU  __Vectors_End - __Vectors

建立中断向量表，中断向量表定位在代码段的最前面。具体的物理地址由链接器的
配置参数（IROM1 的地址）决定。如果程序在 Flash 运行，则中断向量表的起始地址是 0x08000000。



                AREA    |.text|, CODE, READONLY

; Reset handler
Reset_Handler    PROC
                 EXPORT  Reset_Handler                    [WEAK]
        IMPORT  SystemInit
        IMPORT  __main

                 LDR     R0, =SystemInit
                 BLX     R0
                 LDR     R0, =__main
                 BX      R0
                 ENDP
第 1 行： AREA 定义一块代码段，只读，段名字是 .text 。 READONLY 表示只读。
第 4 行： 利用 PROC、 ENDP这一对伪指令把程序段分为若干个过程，使程序的结构加清晰。
第 5 行： WEAK 声明其他的同名标号优先于该标号被引用,就是说如果外面声明了的话会调用外面的。 这个声明很重要，它让我们可以在 C文件中任意地方放置中断服务程序，只要保证 C 函数的名字和向量表中的名字一致即可。
第 6 行： IMPORT：伪指令用于通知编译器要使用的标号在其他的源文件中定义。但要在当前源文件中引用，而且无论当前源文件是否引用该标号，该标号均会被加入到当前源文件的符号表中。
第 9 行： SystemInit 函数在文件 system_stm32h7xx.c 里面，主要实现 RCC相关寄存器复位和中断向量表位置设置。
第 11 行： __main 标号表示 C/C++标准实时库函数里的一个初始化子程序__main的入口地址。该程序的一个主要作用是初始化堆栈(跳转__user_initial_stackheap标号进行初始化堆栈的，下面会讲到这个标号)，并初始化映像文件，最后跳转到 C 程序中的 main 函数。这就解释了为何所有的 C 程序必须有一个 main 函数作为程序的起点。因为这是由 C/C++标准实时库所规，并且不能更改



; Dummy Exception Handlers (infinite loops which can be modified)

NMI_Handler     PROC
                EXPORT  NMI_Handler                      [WEAK]
                B       .
                ENDP
HardFault_Handler\
                PROC
                EXPORT  HardFault_Handler                [WEAK]
                B       .
                ENDP
MemManage_Handler\
                PROC
                EXPORT  MemManage_Handler                [WEAK]
                B       .
                ENDP                                     

                EXPORT  WWDG_IRQHandler                   [WEAK]                                       
                EXPORT  PVD_AVD_IRQHandler                [WEAK]                         
                EXPORT  TAMP_STAMP_IRQHandler             [WEAK]   
                EXPORT  RTC_WKUP_IRQHandler               [WEAK]             
                EXPORT  FLASH_IRQHandler                  [WEAK]

WWDG_IRQHandler                                                          
PVD_AVD_IRQHandler                                             
TAMP_STAMP_IRQHandler                
RTC_WKUP_IRQHandler                            
FLASH_IRQHandler                                                          
RCC_IRQHandler                                                              
EXTI0_IRQHandler                                                              
EXTI1_IRQHandler                                                             
EXTI2_IRQHandler                                                              
EXTI3_IRQHandler                                                              
EXTI4_IRQHandler 
DMA1_Stream0_IRQHandler                                                         
SAI4_IRQHandler      
WAKEUP_PIN_IRQHandler

                B       .

                ENDP

                ALIGN

第 5 行： 死循环，用户可以在此实现自己的中断服务程序。 不过很少在这里实现中断服务程序，一般多是在其它的 C 文件里面重新写一个同样名字的中断服务程序， 因为这里是 WEEK 弱定义的。 如果没有在其它文件中写中断服务器程序，且使能了此中断，进入到这里后，会让程序卡在这个地方。
第 14 行： 缺省中断服务程序（开始）
第 23 行： 死循环， 如果用户使能中断服务程序，而没有在 C 文件里面写中断服务程序的话，都会进入到
这里。 比如在程序里面使能了串口 1 中断，而没有写中断服务程序 USART1_IRQHandle， 那么串口中断来了，会进入到这个死循环。
第 25 行： 缺省中断服务程序（结束） 。



;*******************************************************************************
; User Stack and Heap initialization
;*******************************************************************************
                 IF      :DEF:__MICROLIB
                
                 EXPORT  __initial_sp
                 EXPORT  __heap_base
                 EXPORT  __heap_limit
                
                 ELSE
                
                 IMPORT  __use_two_region_memory
                 EXPORT  __user_initial_stackheap
                 
__user_initial_stackheap

                 LDR     R0, =  Heap_Mem
                 LDR     R1, =(Stack_Mem + Stack_Size)
                 LDR     R2, = (Heap_Mem +  Heap_Size)
                 LDR     R3, = Stack_Mem
                 BX      LR

                 ALIGN

                 ENDIF

                 END

第 4 行： 简单的汇编语言实现 IF…….ELSE…………语句。如果定义了 MICROLIB，那么程序是不会执行 ELSE分支的代码。 __MICROLIB 可能大家并不陌生，就在 MDK 的 Target Option 里面设置。武汉安富莱电子有限公司
第 5 行： __user_initial_stackheap 将由__main 函数进行调用。

BOOT启动模式（H7）

boot引脚：
0->启动地址由 BOOT_ADD0 定义，默认值是 0x0800，对应Flash 首地址 0x0800 0000
1->启动地址由 BOOT_ADD1 定义，默认值是 0x1FF0，对应系统 bootloader 的首地址0x1FF0 0000

BOOT_ADD0 和 BOOT_ADD1 对应 32 位地址到高 16 位，这点要特别注意。通过这两个选项字节，所有 0x0000 0000 到 0x3FFF 0000 的存储器地址都可以设置，包括：

所有 Flash 地址空间。
所有 RAM 地址空间， ITCM， DTCM 和 SRAM。设置了选项字节后，掉电不会丢失，下次上电或者复位后，会根据 BOOT 引脚状态从 BOOT_ADD0，或 BOOT_ADD1 所设置的地址进行启动。

使用 BOOT 功能，注意以下几个问题：

如果用户不慎，设置的地址范围不在有效的存储器地址，那么 BOOT = 0 时，会从 Flash 首地址 0x08000000 启动， BOOT = 1 时，会从 ITCM 首地址 0x0000 0000 启动。
如果用户使能了 Flash Level 2 保护，那么只能从 Flash 地址空间进行启动。

GPIO

IO 补偿单元，用于高速

#define GPIO_SPEED_FREQ_LOW          ((uint32_t)0x00000000U)  /*!< Low speed    */
#define GPIO_SPEED_FREQ_MEDIUM       ((uint32_t)0x00000001U)  /*!< Medium speed */
#define GPIO_SPEED_FREQ_HIGH         ((uint32_t)0x00000002U)  /*!< Fast speed   */
#define GPIO_SPEED_FREQ_VERY_HIGH    ((uint32_t)0x00000003U)  /*!< High speed   */

不使用的引脚推荐设置为模拟模式
主要从功耗和防干扰考虑：

所有用作带上拉电阻输入的 I/O 都会在引脚外部保持为低时产生电流消耗。此电流消耗的值可通过使用的静态特性中给出的上拉 / 下拉电阻值简单算出。
对于输出引脚，还必须考虑任何外部下拉电阻或外部负载以估计电流消耗。若外部施加了中间电平，则额外的 I/O 电流消耗是因为配置为输入的 I/O。此电流消耗是由用于区分输入值的输入施密特触发器电路导致。除非应用需要此特定配置，否则可通过将这些 I/O 配置为模拟模式以避免此供电电流消耗。 ADC 输入引脚应配置为模拟输入就是这种情况。
任何浮空的输入引脚都可能由于外部电磁噪声，成为中间电平或意外切换。为防止浮空引脚相关的电流消耗，它们必须配置为模拟模式，或内部强制为确定的数字值。这可通过使用上拉 / 下拉电阻或将引脚配置为输出模式做到。综上考虑，不使用的引脚设置为模拟模式，悬空即可。

stm32h7xx_hal.c

Systick 的相关函数

__weak void HAL_IncTick(void)
__weak uint32_t HAL_GetTick(void)
uint32_t HAL_GetTickPrio(void)
HAL_StatusTypeDef HAL_SetTickFreq(HAL_TickFreqTypeDef Freq)
HAL_TickFreqTypeDef HAL_GetTickFreq(void)
__weak void HAL_Delay(uint32_t Delay)
__weak void HAL_SuspendTick(void)
__weak void HAL_ResumeTick(void)

函数 HAL_IncTick 在滴答定时器中断里面被调用，实现一个简单的计数功能，因为一般滴答定时器中断都是配置的 1ms，所以计数全局变量 uwTick 每毫秒加 1。

函数 HAL_GetTick 用于获取全局变量 uwTick 当前的计数。
函数 HAL_GetTickPrio 用于获取滴答时钟优先级。
函数 HAL_SetTickFreq 和 HAL_GetTickFreq 是一对，前者用于设置滴答中断频率，后再用于获取滴答中断频率。
函数 HAL_Delay 用于阻塞式延迟，默认单位是 ms。
函数 HAL_SuspendTick 和 HAL_ResumeTick 是一对，前者用于挂起滴答定时器，后者用于恢复

HAL_SYSCFG_VREFBUF_VoltageScalingConfig

配置 STM32H7 内部电压基准大小

当形参 VoltageScaling = SYSCFG_VREFBUF_VOLTAGE_SCALE0 时输出基准是 2.048 V，条件是 VDDA >= 2.4V。
当形参 VoltageScaling = SYSCFG_VREFBUF_VOLTAGE_SCALE1 时输出基准是 2.5 V，条件是 VDDA >= 2.8V。
当形参 VoltageScaling = SYSCFG_VREFBUF_VOLTAGE_SCALE2 时输出基准是 1.5 V，条件是 VDDA >= 1.8V。
当形参 VoltageScaling = SYSCFG_VREFBUF_VOLTAGE_SCALE3 时输出基准是 1.8 V，条件是 VDDA >= 2.1V

HAL_SYSCFG_AnalogSwitchConfig

`1`	`void HAL_SYSCFG_AnalogSwitchConfig (uint32_t SYSCFG_AnalogSwitch, uint32_t SYSCFG_SwitchState)`

引脚 PA0， PA1， PC2， PC3 用于 ADC 时，还有一组对应的可选引脚 PA0_C， PA1_C， PC2_C 和PC3_C。此函数的作用就是切换可选引脚。关于这个问题的详情可看此贴：

HAL_SYSCFG_CM7BootAddConfig

用于配置 BOOT = 0 或者 BOOT = 1 时的启动地址

IO 补偿相关

void HAL_EnableCompensationCell(void)
void HAL_DisableCompensationCell (void)       // 分别用于使能或者禁止 IO 补偿，只有在供电电压范围是 2.4V 到 3.6V 之间时，使用此功能才有意义
void HAL_SYSCFG_EnableIOSpeedOptimize (void)
void HAL_SYSCFG_DisableIOSpeedOptimize (void)     // 分别用于优化 IO 速度或者禁止优化，不过仅在供电电压低于 2.5V 时可用，高于 2.5V 是不可以使用的，另外使用这个功能的前提是用户使能了 PRODUCT_BELOW_25V（是可选字节配置选项里面的一个 bit） 。
void HAL_SYSCFG_CompensationCodeSelect (uint32_t SYSCFG_CompCode)     // IO 补偿单元的选择， 函数形参可以是 SYSCFG_CELL_CODE，即寄存器 SYSCFG_CCVR，也可以是SYSCFG_REGISTER_CODE，即寄存器 SYSCFG_CCCR。
void HAL_SYSCFG_CompensationCodeConfig (uint32_t SYSCFG_PMOSCode, uint32_t SYSCFG_NMOSCode)       // 用于设置 GPIO 内部构造中 NMOS 和 PMOS 的补偿值，两个形参的范围都是 0-15。根据用户调用函数 HAL_SYSCFG_CompensationCodeSelect 选择的寄存器，这里仅有一个形参的设置是有效的。

stm32h7xx_hal_rcc.c

BASE

HSI (high-speed internal):高速内部 RC 振荡器，可以直接或者通过 PLL 倍频后做系统时钟源。缺点是精度差些，即使经过校准。
CSI (Low-power internal oscillator):低功耗内部 RC 振荡器，作用同 HSI，不过主要用于低功耗。
LSI (low-speed internal):低速内部时钟，主要用于独立看门狗和 RTC 的时钟源。
HSE (high-speed external):高速外部晶振，可接 4 - 48MHz 的晶振，可以直接或者通过 PLL 倍频后做系统时钟源，也可以做 RTC 的是时钟源。
LSE (low-speed external):低速外部晶振，主要用于 RTC。
CSS (Clock security system):时钟安全系统，一旦使能后，如果 HSE 启动失败（不管是直接作为系统时钟源还是通过 PLL 输出后做系统时钟源），系统时钟将切换到 HSI。如果使能了中断的话，将进入不可屏蔽中断 NMI。
MCO1 (micro controller clock output):可以在 PA8 引脚输出 HSI, LSE, HSE, PLL1(PLL1_Q）或 HSI48 时钟。
MCO2 (micro controller clock output):可以在 PC9 引脚输出 HSE, PLL2(PLL2_P), SYSCLK, LSI, CSI 或 PLL1(PLL1_P) 时钟。
PLL 锁相环，时钟输入来自 HSI , HSE 或者 CSI: 主锁相环 PLL1，用于给 CPU 和部分外设提供时钟。专用锁相环 PLL2 和 PLL3，用于给部分外设提供时钟

HAL_RCC_ClockConfig

配置了 CPU、 AHB 和 APB 的所有总线时钟，即 HCLK， SYSTICK， D1PCLK1， PCLK1， PCLK2 和 D3PCLK1 时钟 注意事项：

此函数会更新全局变量 SystemCoreClock 的主频值，并且会再次调用函数 HAL_InitTick 更新系统滴答时钟，这点要特别注意。
系统上电复位或者从停机、待机模式唤醒后，使用的是 HSI 作为系统时钟。以防使用 HSE 直接或者通过 PLL 输出后做系统时钟时失败（如果使能了 CSS）。
目标时钟就绪后才可以从当前的时钟源往这个目标时钟源切换，如果目标时钟源没有就绪，就会等待直到时钟源就绪才可以切换。
根据设备的供电范围，必须正确设置 D1CPRE[3:0]位的范围，防止超过允许的最大频率。

HAL_RCC_MCOConfig

配置 MCO1（PA8 引脚）和 MCO2（PC9 引脚）的时钟输出以及选择的时钟源

stm32h7xx_hal_cortex.c

HAL 库的 GPIO 驱动

第 1 步：使能 GPIO 所在总线的 AHB 时钟， __HAL_RCC_GPIOx_CLK_ENABLE()。
第 2 步：通过函数 HAL_GPIO_Init()配置 GPIO。

通过结构体 GPIO_InitTypeDef 的成员 Mode 配置输入、输出、模拟等模式。
通过结构体 GPIO_InitTypeDef 的成员 Pull 配置上拉、下拉电阻。
通过结构体 GPIO_InitTypeDef 的成员 Speed 配置 GPIO 速度等级。
如果选择了复用模式，那么就需要配置结构体 GPIO_InitTypeDef 的成员 Alternate。
如果引脚功能用于 ADC、 DAC 的话，需要配置引脚为模拟模式。
如果是用于外部中断/事件，结构体 GPIO_InitTypeDef 的成员 Mode 可以配置相应模式，相应的上升沿、下降沿或者双沿触发也可以选择。第 3 步：如果配置了外部中断/事件，可以通过函数 HAL_NVIC_SetPriority 设置优先级，然后调用函数 HAL_NVIC_EnableIRQ 使能此中断。
第 4 步：输入模式读取引脚状态可以使用函数 HAL_GPIO_ReadPin。
第 5 步：输出模式设置引脚状态可以调用函数 HAL_GPIO_WritePin()和 HAL_GPIO_TogglePin。
另外注意下面三个问题：
系统上电复位后， GPIO 默认是模拟模式，除了 JTAG 相关引脚。
关闭 LSE 的话，用到的两个引脚 OSC32_IN 和 OSC32_OUT（分别是 PC14， PC15）可以用在通用IO，如果开启了，就不能再做 GPIO。
关闭 HSE 的话，用到的两个引脚 OSC_IN 和 OSC_OUT（分别是 PH0， PH1）可以用在通用 IO，如果开启了，就不能再做 GPIO。

按键 FIFO

#define KEY_FILTER_TIME   5
#define KEY_LONG_TIME     100     /* 单位10ms， 持续1秒，认为长按事件 */

#define ALL_KEY_GPIO_CLK_ENABLE() { \
    __HAL_RCC_GPIOB_CLK_ENABLE(); \
    __HAL_RCC_GPIOC_CLK_ENABLE(); \
    __HAL_RCC_GPIOG_CLK_ENABLE(); \
    __HAL_RCC_GPIOH_CLK_ENABLE(); \
    __HAL_RCC_GPIOI_CLK_ENABLE(); \
  };
// 初始化
typedef struct
{
  /* 下面是一个函数指针，指向判断按键手否按下的函数 */
  uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */

  uint8_t  Count;     /* 滤波器计数器 */
  uint16_t LongCount;   /* 长按计数器 */
  uint16_t LongTime;    /* 按键按下持续时间, 0表示不检测长按 */
  uint8_t  State;     /* 按键当前状态（按下还是弹起） */
  uint8_t  RepeatSpeed; /* 连续按键周期 */
  uint8_t  RepeatCount; /* 连续按键计数器 */
}KEY_T;

#define KEY_FIFO_SIZE 10
typedef struct
{
  uint8_t Buf[KEY_FIFO_SIZE];   /* 键值缓冲区 */
  uint8_t Read;         /* 缓冲区读指针1 */
  uint8_t Write;          /* 缓冲区写指针 */
  uint8_t Read2;          /* 缓冲区读指针2 */
}KEY_FIFO_T;

typedef struct
{
  GPIO_TypeDef* gpio;
  uint16_t pin;
  uint8_t ActiveLevel;  /* 激活电平 */
}X_GPIO_T;
// 注册
static const X_GPIO_T s_gpio_list[HARD_KEY_NUM] = {
  {GPIOI, GPIO_PIN_8, 0},   /* K1 */
  {GPIOC, GPIO_PIN_13, 0},  /* K2 */
  {GPIOH, GPIO_PIN_4, 0},   /* K3 */
  {GPIOG, GPIO_PIN_2, 0},   /* JOY_U */ 
  {GPIOB, GPIO_PIN_0, 0},   /* JOY_D */
  {GPIOG, GPIO_PIN_3, 0},   /* JOY_L */ 
  {GPIOG, GPIO_PIN_7, 0},   /* JOY_R */ 
  {GPIOI, GPIO_PIN_11, 0},  /* JOY_OK */
};

void bsp_InitKey(void);
void bsp_KeyScan10ms(void);
void bsp_PutKey(uint8_t _KeyCode);
uint8_t bsp_GetKey(void);
uint8_t bsp_GetKey2(void);
uint8_t bsp_GetKeyState(KEY_ID_E _ucKeyID);
void bsp_SetKeyParam(uint8_t _ucKeyID, uint16_t _LongTime, uint8_t  _RepeatSpeed);
void bsp_ClearKey(void);

void bsp_InitKey(void)
{
  bsp_InitKeyVar();   /* 初始化按键变量 */
  bsp_InitKeyHard();    /* 初始化按键硬件 */
}

static void bsp_InitKeyHard(void)
{ 
  GPIO_InitTypeDef gpio_init;
  uint8_t i;

  /* 第1步：打开GPIO时钟 */
  ALL_KEY_GPIO_CLK_ENABLE();
  
  /* 第2步：配置所有的按键GPIO为浮动输入模式(实际上CPU复位后就是输入状态) */
  gpio_init.Mode = GPIO_MODE_INPUT;         /* 设置输入 */
  gpio_init.Pull = GPIO_NOPULL;                 /* 上下拉电阻不使能 */
  gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
  
  for (i = 0; i < HARD_KEY_NUM; i++)
  {
    gpio_init.Pin = s_gpio_list[i].pin;
    HAL_GPIO_Init(s_gpio_list[i].gpio, &gpio_init); 
  }
}

static void bsp_InitKeyVar(void)
{
  uint8_t i;

  /* 对按键FIFO读写指针清零 */
  s_tKey.Read = 0;
  s_tKey.Write = 0;
  s_tKey.Read2 = 0;

  /* 给每个按键结构体成员变量赋一组缺省值 */
  for (i = 0; i < KEY_COUNT; i++)
  {
    s_tBtn[i].LongTime = KEY_LONG_TIME;     /* 长按时间 0 表示不检测长按键事件 */
    s_tBtn[i].Count = KEY_FILTER_TIME / 2;    /* 计数器设置为滤波时间的一半 */
    s_tBtn[i].State = 0;              /* 按键缺省状态，0为未按下 */
    s_tBtn[i].RepeatSpeed = 0;            /* 按键连发的速度，0表示不支持连发 */
    s_tBtn[i].RepeatCount = 0;            /* 连发计数器 */
  }

  /* 如果需要单独更改某个按键的参数，可以在此单独重新赋值 */
  
  /* 摇杆上下左右，支持长按1秒后，自动连发 */
  bsp_SetKeyParam(KID_JOY_U, 100, 6);
  bsp_SetKeyParam(KID_JOY_D, 100, 6);
  bsp_SetKeyParam(KID_JOY_L, 100, 6);
  bsp_SetKeyParam(KID_JOY_R, 100, 6);
}

// 下面只pin一些重要的
//判断按键是否按下
static uint8_t KeyPinActive(uint8_t _id)
{
  uint8_t level;
  if ((s_gpio_list[_id].gpio->IDR & s_gpio_list[_id].pin) == 0){
    level = 0;
  }else{
    level = 1;
  }
  if (level == s_gpio_list[_id].ActiveLevel){
    return 1;
  }else{
    return 0;
  }
}
// 封装KeyPinActive,支持判断多个按键同时按下的情况
static uint8_t IsKeyDownFunc(uint8_t _id)
{
  /* 实体单键 */
  if (_id < HARD_KEY_NUM)
  {
    uint8_t i;
    uint8_t count = 0;
    uint8_t save = 255; 
    /* 判断有几个键按下 */
    for (i = 0; i < HARD_KEY_NUM; i++)
    {
      if (KeyPinActive(i)) 
      {
        count++;
        save = i;
      }
    }
    if (count == 1 && save == _id)
    {
      return 1; /* 只有1个键按下时才有效 */
    }   
    return 0;
  }
  /* 组合键 K1K2 */
  if (_id == HARD_KEY_NUM + 0)
  {
    if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
    {
      return 1;
    }
    else
    {
      return 0;
    }
  }
  return 0;
}

// 数据入队
void bsp_PutKey(uint8_t _KeyCode)
{
  s_tKey.Buf[s_tKey.Write] = _KeyCode;

  if (++s_tKey.Write  >= KEY_FIFO_SIZE)
  {
    s_tKey.Write = 0;
  }
}

// 数据出队（消费）
uint8_t bsp_GetKey(void)
{
  uint8_t ret;

  if (s_tKey.Read == s_tKey.Write)
  {
    return KEY_NONE;
  }
  else
  {
    ret = s_tKey.Buf[s_tKey.Read];

    if (++s_tKey.Read >= KEY_FIFO_SIZE)
    {
      s_tKey.Read = 0;
    }
    return ret;
  }
}

// 直接读取状态
uint8_t bsp_GetKeyState(KEY_ID_E _ucKeyID)
{
  return s_tBtn[_ucKeyID].State;
}

// 带消抖的单个检测
static void bsp_DetectKey(uint8_t i)
{
  KEY_T *pBtn;

  pBtn = &s_tBtn[i];
  if (IsKeyDownFunc(i))
  {
    if (pBtn->Count < KEY_FILTER_TIME)
    {
      pBtn->Count = KEY_FILTER_TIME;      // 让它在T-2T之间抖动
    }
    else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    {
      pBtn->Count++;        // 当按下后开始计数，如果大于它说明按下
    }
    else
    {
      if (pBtn->State == 0)
      {
        pBtn->State = 1;

        /* 发送按钮按下的消息 */
        bsp_PutKey((uint8_t)(3 * i + 1));
      }

      if (pBtn->LongTime > 0)
      {
        if (pBtn->LongCount < pBtn->LongTime)
        {
          /* 发送按钮持续按下的消息 */
          if (++pBtn->LongCount == pBtn->LongTime)
          {
            /* 键值放入按键FIFO */
            bsp_PutKey((uint8_t)(3 * i + 3));
          }
        }
        else
        {
          if (pBtn->RepeatSpeed > 0)
          {
            if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
            {
              pBtn->RepeatCount = 0;
              /* 常按键后，每隔10ms发送1个按键 */
              bsp_PutKey((uint8_t)(3 * i + 1));
            }
          }
        }
      }
    }
  }
  else    // 如果停止按下
  {
    if(pBtn->Count > KEY_FILTER_TIME)
    {
      pBtn->Count = KEY_FILTER_TIME;    // 消抖，防止快速回落
    }
    else if(pBtn->Count != 0)
    {
      pBtn->Count--;        // 如果一直没有按下，则慢慢减少
    }
    else
    {
      if (pBtn->State == 1)
      {
        pBtn->State = 0;

        /* 发送按钮弹起的消息 */
        bsp_PutKey((uint8_t)(3 * i + 2));
      }
    }

    pBtn->LongCount = 0;
    pBtn->RepeatCount = 0;
  }
}

// 基于SysTick中断的扫描函数
void bsp_KeyScan10ms(void)
{
  uint8_t i;

  for (i = 0; i < KEY_COUNT; i++)
  {
    bsp_DetectKey(i);
  }
}

PWM(无源蜂鸣器)

NVIC 中断分组

STM32 支持 5 种优先级分组。 系统上电复位后，默认使用的是优先级分组 0 具有高抢占式优先级的中断可以在具有低抢占式优先级的中断服务程序执行过程中被响应，即中断嵌套，或者说高抢占式优先级的中断可以抢占低抢占式优先级的中断的执行。

在抢占式优先级相同的情况下，有几个子优先级不同的中断同时到来，那么高子优先级的中断优先被响应。
在抢占式优先级相同的情况下，如果有低子优先级中断正在执行，高子优先级的中断要等待已被响应的低子优先级中断执行结束后才能得到响应，即子优先级不支持中断嵌套。
Reset、 NMI、 Hard Fault 优先级为负数，高于普通中断优先级，且优先级不可配置。
初学者还有一个比较纠结的问题，就是系统中断（比如： PendSV， SVC， SysTick）是不是一定比外部中断（比如 SPI,USART）要高。答案：不是的，它们是在同一个 NVIC 下面设置的。掌握了这些基础知识基本就够用了。另外特别注意一点，配置抢占优先级和子优先级， 它们合并成的4bit 数字的数值越小，优先级越高，这一点千万不要搞错了。

HAL_NVIC_SetPriorityGrouping

设置中断组

HAL_NVIC_SetPriority

设置抢占优先级以及子优先级（需要先设置优先级分组）

HAL_NVIC_EnableIRQ

使能中断

SysTick

一个 24位的递减计数器，支持中断

将重装载值写入 LOAD 寄存器（24 位）
启动后，硬件自动将 LOAD 值复制到 VAL（当前值）寄存器
VAL 每个内核时钟周期递减 1
当 VAL 减到 0：触发 SysTick 异常（中断）
自动重新加载 LOAD 值到 VAL，开始下一轮计数

SysTick_Config(u32_t ticks)

函数的形参表示内核时钟多少个周期后触发一次 Systick 定时中断，比如形参配置为如下数值。
– SystemCoreClock / 1000 表示定时频率为 1000Hz，也就是定时周期为 1ms。
– SystemCoreClock / 500 表示定时频率为 500Hz，也就是定时周期为 2ms。
– SystemCoreClock / 2000 表示定时频率为 2000Hz，也就是定时周期为 500us。

多组软定时器驱动设计

#define TMR_COUNT 4   /* 软件定时器的个数 （定时器ID范围 0 - 3) */

/* 定时器结构体，成员变量必须是 volatile, 否则C编译器优化时可能有问题 */
typedef enum
{
  TMR_ONCE_MODE = 0,    /* 一次工作模式 */
  TMR_AUTO_MODE = 1   /* 自动定时工作模式 */
}TMR_MODE_E;

/* 定时器结构体，成员变量必须是 volatile, 否则C编译器优化时可能有问题 */
typedef struct
{
  volatile uint8_t Mode;    /* 计数器模式，1次性 */
  volatile uint8_t Flag;    /* 定时到达标志  */
  volatile uint32_t Count;  /* 计数器 */
  volatile uint32_t PreLoad;  /* 计数器预装值 */
}SOFT_TMR;

/* 提供给其他C文件调用的函数 */
void bsp_InitTimer(void);
void bsp_DelayMS(uint32_t n);
void bsp_DelayUS(uint32_t n);
void bsp_StartTimer(uint8_t _id, uint32_t _period);
void bsp_StartAutoTimer(uint8_t _id, uint32_t _period);
void bsp_StopTimer(uint8_t _id);
uint8_t bsp_CheckTimer(uint8_t _id);
int32_t bsp_GetRunTime(void);
int32_t bsp_CheckRunTime(int32_t _LastTime);

void bsp_InitHardTimer(void);
void bsp_StartHardTimer(uint8_t _CC, uint32_t _uiTimeOut, void * _pCallBack);

void bsp_StartTimer(uint8_t _id, uint32_t _period)
{
  if (_id >= TMR_COUNT)
  {
    /* 打印出错的源代码文件名、函数名称 */
    BSP_Printf("Error: file %s, function %s()\r\n", __FILE__, __FUNCTION__);
    while(1); /* 参数异常，死机等待看门狗复位 */
  }

  DISABLE_INT();        /* 关中断 */

  s_tTmr[_id].Count = _period;    /* 实时计数器初值 */
  s_tTmr[_id].PreLoad = _period;    /* 计数器自动重装值，仅自动模式起作用 */
  s_tTmr[_id].Flag = 0;       /* 定时时间到标志 */
  s_tTmr[_id].Mode = TMR_ONCE_MODE; /* 1次性工作模式 */

  ENABLE_INT();         /* 开中断 */
}

void bsp_StartAutoTimer(uint8_t _id, uint32_t _period)
{
  if (_id >= TMR_COUNT)
  {
    /* 打印出错的源代码文件名、函数名称 */
    BSP_Printf("Error: file %s, function %s()\r\n", __FILE__, __FUNCTION__);
    while(1); /* 参数异常，死机等待看门狗复位 */
  }

  DISABLE_INT();      /* 关中断 */

  s_tTmr[_id].Count = _period;      /* 实时计数器初值 */
  s_tTmr[_id].PreLoad = _period;    /* 计数器自动重装值，仅自动模式起作用 */
  s_tTmr[_id].Flag = 0;       /* 定时时间到标志 */
  s_tTmr[_id].Mode = TMR_AUTO_MODE; /* 自动工作模式 */

  ENABLE_INT();       /* 开中断 */
}

void bsp_StopTimer(uint8_t _id)
{
  if (_id >= TMR_COUNT)
  {
    /* 打印出错的源代码文件名、函数名称 */
    BSP_Printf("Error: file %s, function %s()\r\n", __FILE__, __FUNCTION__);
    while(1); /* 参数异常，死机等待看门狗复位 */
  }

  DISABLE_INT();    /* 关中断 */

  s_tTmr[_id].Count = 0;        /* 实时计数器初值 */
  s_tTmr[_id].Flag = 0;       /* 定时时间到标志 */
  s_tTmr[_id].Mode = TMR_ONCE_MODE; /* 自动工作模式 */

  ENABLE_INT();     /* 开中断 */
}

uint8_t bsp_CheckTimer(uint8_t _id)
{
  if (_id >= TMR_COUNT)
  {
    return 0;
  }

  if (s_tTmr[_id].Flag == 1)
  {
    s_tTmr[_id].Flag = 0;
    return 1;
  }
  else
  {
    return 0;
  }
}


void SysTick_ISR(void)
{
  static uint8_t s_count = 0;
  uint8_t i;
  
  /* 每隔1ms进来1次 （仅用于 bsp_DelayMS） */
  if (s_uiDelayCount > 0)
  {
    if (--s_uiDelayCount == 0)
    {
      s_ucTimeOutFlag = 1;
    }
  }

  /* 每隔1ms，对软件定时器的计数器进行减一操作 */
  for (i = 0; i < TMR_COUNT; i++)
  {
    bsp_SoftTimerDec(&s_tTmr[i]);
  }

  /* 全局运行时间每1ms增1 */
  g_iRunTime++;
  if (g_iRunTime == 0x7FFFFFFF) /* 这个变量是 int32_t 类型，最大数为 0x7FFFFFFF */
  {
    g_iRunTime = 0;
  }

  bsp_RunPer1ms();    /* 每隔1ms调用一次此函数，此函数在 bsp.c */

  if (++s_count >= 10)
  {
    s_count = 0;

    bsp_RunPer10ms(); /* 每隔10ms调用一次此函数，此函数在 bsp.c */
  }
}

MPU 内存保护单元

What

MPU 可以将 memory map 内存映射区分为多个具有一定访问规则的区域，通过这些规则可以实现如下功能：

防止不受信任的应用程序访问受保护的内存区域。
防止用户应用程序破坏操作系统使用的数据。
通过阻止任务访问其它任务的数据区。
允许将内存区域定义为只读，以便保护重要数据。
检测意外的内存访问。简单的说就是内存保护、外设保护和代码访问保护。

MPU 可以配置保护 16 个内存区域（这 16 个内存域是独立配置的），每个区域最小要求 256 字节，每个区域还可以配置为 8 个子区域。由于子区域一般都相同大小，这样每个子区域的大小就是 32 字节，正好跟 Cache 的 Cache Line 大小一样.
MPU 可以配置的 16 个内存区的序号范围是 0 到 15，还有默认区 default region，也叫作背景区，序号-1。由于这些内存区可以嵌套和重叠，所以这些区域在嵌套或者重叠的时候有个优先级的问题。序号15 的优先级最高，以此递减，序号-1，即背景区的优先级最低。这些优先级是固定的。

Cache 解读

注意：H7的 read allocate 是一直开启的
四种Cache模式:

缓存策略 (Cache Policy)	简明区别说明
Non-cacheable	数据不缓存，每次读写都直接访问主存。
Write back, write and read allocate	写操作先写入缓存（脏数据），读写时都分配缓存行（常见于高性能CPU）。
Write through, no write allocate	写操作同时更新缓存和主存，但写时不分配新缓存行（适合一致性要求高的场景）。
Write back, no write allocate	写操作只写入缓存（脏数据），但写时不分配新缓存行（节省空间，适合写密集型应用）。
注意当开启Share(多核共享)时缓存会有性能的下降，这是不必开启Cache

面对繁冗复杂的 Cache 配置，推荐方式和安全隐患解决办法

推荐使用 128KB 的 TCM 作为主 RAM 区，其它的专门用于大缓冲和 DMA 操作等。
Cache 问题主要是 CPU 和 DMA 都操作这个缓冲区时容易出现，使用时要注意。
Cache 配置的选择，优先考虑的是 Write Back，然后是 Write Through 和关闭 Cache，其中 WB 和 WT 的使用中可以配合 ARM 提供的函数解决上面说到的隐患问题。但不是万能的，在不起作用的时候，直接暴力选择函数 SCB_CleanInvlaidateDCache 解决。关于这个问题，在分别配置以太网MAC 的描述符缓冲区，发送缓冲区和接收缓冲区时尤其突出。

Cache 相关的函数

SCB_EnableICache()
SCB_DisableICache()
SCB_InvalidateICache()

SCB_EnableDCache()
SCB_DisableDCache()
SCB_InvalidateDCache()
SCB_CleanDCache()
// Clean+ Invaildate两个函数一起用
SCB_CleanInvalidateDCache()
SCB_InvalidateDCache_by_Addr()
SCB_CleanDCache_by_Addr()
SCB_CleanInvalidateDCache_by_Addr()

五种内存区域讲解

TCM 区 TCM : Tightly-Coupled Memory 紧密耦合内存。 ITCM 用于运行指令，也就是程序代码， DTCM用于数据存取，特点是跟内核速度一样，而片上 RAM 的速度基本都达不到这个速度，所以有降频处理。速度： 400MHz。

DTCM 地址： 0x2000 0000，大小 128KB。
ITCM 地址： 0x0000 0000，大小 64KB。

AXI SRAM 区位于 D1 域，数据带宽是 64bit，挂在 AXI 总线上。 除了 D3 域中的 BDMB 主控不能访问，其它都可以访问此 RAM 区。

速度： 200MHz。
地址： 0x2400 0000，大小 512KB。
用途：用途不限，可以用于用户应用数据存储或者 LCD 显存。

SRAM1， SRAM2 和 SRAM3 区位于 D2 域，数据带宽是 32bit，挂在 AHB 总线上。 除了 D3 域中的 BDMB 主控不能访问这三块 SRAM，其它都可以访问这几个 RAM 区。

速度： 200MHz。
SRAM1：地址 0x3000 0000，大小 128KB，用途不限，可用于 D2 域中的 DMA 缓冲，也可以当D1 域断电后用于运行程序代码。
SRAM2：地址 0x3002 0000，大小 128KB，用途不限，可用于 D2 域中的 DMA 缓冲，也可以用于用户数据存取。
SRAM3：地址 0x3004 0000，大小 32KB，用途不限，主要用于以太网和 USB 的缓冲。

SRAM4 区位于 D3 域，数据带宽是 32bit，挂在 AHB 总线上，大部分主控都能访这块 SRAM 区。

速度： 200MHz。
地址： 0x3800 0000，大小 64KB。
用途：用途不限，可以用于 D3 域中的 DMA 缓冲，也可以当 D1 和 D2 域进入 DStandby 待机方式后，继续保存用户数据。

Backup SRAM 区备份 RAM 区，位于 D3 域，数据带宽是 32bit，挂在 AHB 总线上，大部分主控都能访问这块 SRAM区。

速度： 200MHz。
地址： 0x3880 0000，大小 4KB。
用途：用途不限，主要用于系统进入低功耗模式后，继续保存数据（Vbat 引脚外接电池）。

建议手动使能SRAM1-3

AXI SRAM， SRAM4， ITCM 和 DTCM 可以在上电后直接使用。而 SRAM1， SRAM2， SRAM3是需要使能的，但是实际测试发现，不使能也可以正常使用。不过，建议用到时候开启下时钟，防止意想不到的问题发生。

#if 0
  __HAL_RCC_D2SRAM1_CLK_ENABLE();
  __HAL_RCC_D2SRAM2_CLK_ENABLE();
  __HAL_RCC_D2SRAM3_CLK_ENABLE();
#endif

如何使用 SRAM

自定义分散文件

LR_IROM1 0x08000000 0x00200000  {  ; load region size_region
  ER_IROM1 0x08000000 0x00200000  { ; load address = execution address
   *o (RESET, +First)
   *(InRoot$$Sections)
   .ANY (+RO)
  }
}
; RW data - 128KB DTCM
RW_IRAM1 0x20000000 0x00020000  {
  .ANY (+RW +ZI)
}
; RW data - 512KB AXI SRAM
RW_IRAM2 0x24000000 0x00080000  {
  *(RAM_D1)
}
; RW data - 128KB SRAM1(0x30000000) + 128KB SRAM2(0x3002 0000) + 32KB SRAM3(0x30040000)
RW_IRAM3 0x30000000 0x00048000  {
  *(RAM_D2)
}
; RW data - 64KB SRAM4(0x38000000)
RW_IRAM4 0x38000000 0x00010000  {
  *(RAM_D3)
}

应用内使用

// 将一个大数组放入 512KB 的 AXI SRAM (RAM_D1)
__attribute__((section("RAM_D1"))) float signal_buffer[16384];

// 将一个结构体放入 288KB 的 D2 域 SRAM (RAM_D2)
__attribute__((section("RAM_D2"))) my_peripheral_state_t device_state;

移植RTX5库动态分配内存

使用场景：在实际项目中有一定的实用价值，比如 MP3 编解码， JPEG 编解码，视频播放器，矢量字体等需要动态内存的场合。
需要使用文件：

rtx_lib.h
rtx_memory.c

/* DTCM, 64KB的 */
/* 用于获取当前使用的空间大小 */
mem_head_t *DTCMUsed;
/* 定义为64位变量，首地址是8字节对齐 */
uint64_t AppMallocDTCM[64*1024/8];


/* D1域, AXI SRAM, 512KB */
/* 用于获取当前使用的空间大小 */
mem_head_t *AXISRAMUsed;
/* 定义为64位变量，首地址是8字节对齐 */
uint64_t AppMallocAXISRAM[512*1024/8]__attribute__((at(0x24000000)));


osRtxMemoryInit(AppMallocDTCM,   sizeof(AppMallocDTCM));
osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

uint32_t *DTCM_Address0, *AXISRAM_Address0;


/* 从DTCM申请280字节空间，使用指针变量DTCM_Address0操作这些空间时不要超过280字节大小 */
DTCM_Address0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
DTCMUsed = MemHeadPtr(AppMallocDTCM);
printf("DTCM总大小 = %d 字节，申请大小 = 0280字节，当前共使用大小 = %d 字节\r\n", 
       DTCMUsed->size, DTCMUsed->used);

/* 从AXI SRAM申请160字节空间，使用指针变量AXISRAM_Address0操作这些空间时不要超过160字节大小 */
AXISRAM_Address0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
printf("AXI SRAM总大小 = %d 字节，申请大小 = 0162字节，当前共使用大小 = %d 字节\r\n", 
       AXISRAMUsed->size, AXISRAMUsed->used);


/* 释放从DTCM申请的280字节空间 */
osRtxMemoryFree(AppMallocDTCM, DTCM_Address0);
DTCMUsed = MemHeadPtr(AppMallocDTCM);
printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d 字节\r\n", DTCMUsed->used);

/* 释放从AXI SRAM申请的160字节空间 */
osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Address0);
AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d 字节\r\n", AXISRAMUsed->used);

关键代码在 ITCM 执行

配置链接到ITCM（会自动执行从FLASH区复制到ITCM区的操作）

复制中断向量表到 DTCM

int main(){
  uint32_t *SouceAddr = (uint32_t *)FLASH_BANK1_BASE;
  uint32_t *DestAddr = (uint32_t *)D1_DTCMRAM_BASE;
  memcpy(DestAddr, SouceAddr, 0x400);
  /* 设置中断向量表到 ITCM 里面 */
  SCB->VTOR = D1_DTCMRAM_BASE;
  MAIN_RAM();
}

局限

ITCM用起来也不是完美的，当涉及较多的函数间调用时，如果指令地址频繁在Flash、ITCM直接来回切换，会产生许多不必要的开销，因为它们两个区域的地址跨度太大，无法直接跳转，编译器会产生一些虚拟函数来实现这个跳转的过渡，无论是Flash到ITCM，还是ITCM到Flash都会有这样的操作。 ITCM主要是用于执行一些时间敏感的函数，例如中断函数，使得中断能够更快响应。还有就是例如FFT这种纯粹的计算型函数，它不会发生较多的其它函数调用且函数执行时间较长，这也能发挥ITCM的关键优势。

USART串口

intro

STM32H7 的串口比 STM32F4 和 F1 的串口支持了更多高级特性。比如超时接收检测、自适应波特率、 TX 和 RX 引脚互换等功能。

任意波特率。硬件采用分数波特率发生器系统，可以设置任意的波特率，最高达 4.5Mbits/s。这一点很重要。比如 ES8266 串口 WIFI 芯片，上电时有个奇怪的波特率 74880bps，当然 STM32 是可以支持的。
可编程数据字长度，支持 7bit， 8bit 和 9bit。
可配置的停止位。支持 1 或 2 个停止位。
发送器和接收器可以单独使能。比如 GPS 应用只需要串口接收，那么发送的 GPIO 就可以节省出来用作其他功能。
检测标志和中断：

接收缓冲器满，可产生中断。串口中断服务程序据此判断是否接收到数据。
发送缓冲器空，可产生中断。串口中断服务程序据此启动发送下一个数据。
传输结束标志，可产生中断。用于 RS485 通信，等最后一个字节发送完毕后，需要控制 RS485收发器芯片切换为接收模式。其它中断不常用，包括： CTS 改变、 LIN 断开符检测、检测到总线为空闲（在 DMA 不定长接收方式会用到）、溢出错误、帧错误、噪音错误、校验错误。 H7 Features:
数据逻辑电平翻转。
RX 和 TX 引脚交换。
超时接收特性。
MSB 位先发送。
自适应波特率。
外接 485 的 PHY 芯片时，硬件支持收发切换，无需用户手动控制 DE 引脚

重要的寄存器

标志宏	描述	置位条件	清零方式	中断使能位（在USART_CR1中）	状态含义
USART_FLAG_TXE	TXE:发送数据寄存器空 (Transmit data register empty)	当TDR寄存器中的数据被硬件转移到移位寄存器的时候，该位被硬件置位。	对USART_TDR的写操作，或将USART_RQR的TXFRQ位置1。	TXEIE	0: 数据未转移；1: 数据已转移
USART_FLAG_TC	TC: 发送完成 (Transmission complete)	当包含数据的一帧发送完成后，并且TXE=1时，由硬件将该位置‘1’。	对USART_TDR的写操作，或将USART_ICR的TCCF位置1。	TCIE	0: 发送未完成；1: 发送完成
USART_FLAG_RXNE	RXNE: 接收数据寄存器非空 (Read data register not empty)	当RDR移位寄存器中的数据被转移到USART_DR寄存器中，该位被硬件置位。	对USART_RDR的读操作，或将USART_RQR的RXFRQ位置1。	RXNEIE	0: 未收到数据；1: 收到数据可读出

串口FIFO

typedef struct
{
  USART_TypeDef *uart;    /* STM32内部串口设备指针 */
  uint8_t *pTxBuf;      /* 发送缓冲区 */
  uint8_t *pRxBuf;      /* 接收缓冲区 */
  uint16_t usTxBufSize;   /* 发送缓冲区大小 */
  uint16_t usRxBufSize;   /* 接收缓冲区大小 */
  __IO uint16_t usTxWrite;  /* 发送缓冲区写指针 */
  __IO uint16_t usTxRead;   /* 发送缓冲区读指针 */
  __IO uint16_t usTxCount;  /* 等待发送的数据个数 */

  __IO uint16_t usRxWrite;  /* 接收缓冲区写指针 */
  __IO uint16_t usRxRead;   /* 接收缓冲区读指针 */
  __IO uint16_t usRxCount;  /* 还未读取的新数据个数 */

  void (*SendBefor)(void);  /* 开始发送之前的回调函数指针（主要用于RS485切换到发送模式） */
  void (*SendOver)(void);   /* 发送完毕的回调函数指针（主要用于RS485将发送模式切换为接收模式） */
  void (*ReciveNew)(uint8_t _byte); /* 串口收到数据的回调函数指针 */
  uint8_t Sending;      /* 正在发送中 */
}UART_T;

void bsp_InitUart(void);
void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);
void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte);
uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte);
void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);
void comClearTxFifo(COM_PORT_E _ucPort);
void comClearRxFifo(COM_PORT_E _ucPort);
void comSetBaud(COM_PORT_E _ucPort, uint32_t _BaudRate);

void USART_SetBaudRate(USART_TypeDef* USARTx, uint32_t BaudRate);
void bsp_SetUartParam(USART_TypeDef *Instance,  uint32_t BaudRate, uint32_t Parity, uint32_t Mode);

void RS485_SendBuf(uint8_t *_ucaBuf, uint16_t _usLen);
void RS485_SendStr(char *_pBuf);
void RS485_SetBaud(uint32_t _baud);
uint8_t UartTxEmpty(COM_PORT_E _ucPort);


void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)
{
  UART_T *pUart;

  pUart = ComToUart(_ucPort);
  if (pUart == 0)
  {
    return;
  }

  if (pUart->SendBefor != 0)
  {
    pUart->SendBefor();   /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
  }

  UartSend(pUart, _ucaBuf, _usLen);
}

void comSendChar(COM_PORT_E _ucPort, uint8_t _ucByte)
{
  comSendBuf(_ucPort, &_ucByte, 1);
}

uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
{
  UART_T *pUart;

  pUart = ComToUart(_ucPort);
  if (pUart == 0)
  {
    return 0;
  }

  return UartGetChar(pUart, _pByte);
}

void comClearTxFifo(COM_PORT_E _ucPort)
{
  UART_T *pUart;

  pUart = ComToUart(_ucPort);
  if (pUart == 0)
  {
    return;
  }

  pUart->usTxWrite = 0;
  pUart->usTxRead = 0;
  pUart->usTxCount = 0;
}

void comClearRxFifo(COM_PORT_E _ucPort)
{
  UART_T *pUart;

  pUart = ComToUart(_ucPort);
  if (pUart == 0)
  {
    return;
  }

  pUart->usRxWrite = 0;
  pUart->usRxRead = 0;
  pUart->usRxCount = 0;
}

void comSetBaud(COM_PORT_E _ucPort, uint32_t _BaudRate)
{
  USART_TypeDef* USARTx;
  
  USARTx = ComToUSARTx(_ucPort);
  if (USARTx == 0)
  {
    return;
  }
  
  bsp_SetUartParam(USARTx,  _BaudRate, UART_PARITY_NONE, UART_MODE_TX_RX);
}

/* 如果是RS485通信，请按如下格式编写函数， 我们仅举了 USART3作为RS485的例子 */
void RS485_InitTXE(void)
{
  GPIO_InitTypeDef gpio_init;
  
  /* 打开GPIO时钟 */
  RS485_TXEN_GPIO_CLK_ENABLE();
  
  /* 配置引脚为推挽输出 */
  gpio_init.Mode = GPIO_MODE_OUTPUT_PP;     /* 推挽输出 */
  gpio_init.Pull = GPIO_NOPULL;         /* 上下拉电阻不使能 */
  gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
  gpio_init.Pin = RS485_TXEN_PIN;
  HAL_GPIO_Init(RS485_TXEN_GPIO_PORT, &gpio_init);  
}

void RS485_SetBaud(uint32_t _baud)
{
  comSetBaud(COM3, _baud);
}

void RS485_SendBefor(void)
{
  RS485_TX_EN();  /* 切换RS485收发芯片为发送模式 */
}

void RS485_SendOver(void)
{
  RS485_RX_EN();  /* 切换RS485收发芯片为接收模式 */
}

void RS485_SendBuf(uint8_t *_ucaBuf, uint16_t _usLen)
{
  comSendBuf(COM3, _ucaBuf, _usLen);
}

static void UartIRQ(UART_T *_pUart)
{
  uint32_t isrflags   = READ_REG(_pUart->uart->ISR);
  uint32_t cr1its     = READ_REG(_pUart->uart->CR1);
  uint32_t cr3its     = READ_REG(_pUart->uart->CR3);
  
  /* 处理接收中断  */
  if ((isrflags & USART_ISR_RXNE) != RESET)
  {
    /* 从串口接收数据寄存器读取数据存放到接收FIFO */
    uint8_t ch;

    ch = READ_REG(_pUart->uart->RDR);
    _pUart->pRxBuf[_pUart->usRxWrite] = ch;
    if (++_pUart->usRxWrite >= _pUart->usRxBufSize)
    {
      _pUart->usRxWrite = 0;
    }
    if (_pUart->usRxCount < _pUart->usRxBufSize)
    {
      _pUart->usRxCount++;
    }

    /* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */
    //if (_pUart->usRxWrite == _pUart->usRxRead)
    //if (_pUart->usRxCount == 1)
    {
      if (_pUart->ReciveNew)
      {
        _pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
      }
    }
  }

  /* 处理发送缓冲区空中断 */
  if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
  {
    //if (_pUart->usTxRead == _pUart->usTxWrite)
    if (_pUart->usTxCount == 0)
    {
      /* 发送缓冲区的数据已取完时， 禁止发送缓冲区空中断 （注意：此时最后1个数据还未真正发送完毕）*/
      //USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);
      CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);

      /* 使能数据发送完毕中断 */
      //USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);
      SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
    }
    else
    {
      _pUart->Sending = 1;
      
      /* 从发送FIFO取1个字节写入串口发送数据寄存器 */
      //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
      _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
      if (++_pUart->usTxRead >= _pUart->usTxBufSize)
      {
        _pUart->usTxRead = 0;
      }
      _pUart->usTxCount--;
    }

  }
  /* 数据bit位全部发送完毕的中断 */
  if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
  {
    //if (_pUart->usTxRead == _pUart->usTxWrite)
    if (_pUart->usTxCount == 0)
    {
      /* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */
      //USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);
      CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);

      /* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */
      if (_pUart->SendOver)
      {
        _pUart->SendOver();
      }
      
      _pUart->Sending = 0;
    }
    else
    {
      /* 正常情况下，不会进入此分支 */

      /* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */
      //USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
      _pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
      if (++_pUart->usTxRead >= _pUart->usTxBufSize)
      {
        _pUart->usTxRead = 0;
      }
      _pUart->usTxCount--;
    }
  }
  
  /* 清除中断标志 */
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);
  SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF);  
}


static void UartSend(UART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)
{
  uint16_t i;

  for (i = 0; i < _usLen; i++)
  {
    /* 如果发送缓冲区已经满了，则等待缓冲区空 */
    while (1)
    {
      __IO uint16_t usCount;

      DISABLE_INT();
      usCount = _pUart->usTxCount;
      ENABLE_INT();

      if (usCount < _pUart->usTxBufSize)
      {
        break;
      }
      else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */
      {
        if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
        {
          SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
        }  
      }
    }

    /* 将新数据填入发送缓冲区 */
    _pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf[i];

    DISABLE_INT();
    if (++_pUart->usTxWrite >= _pUart->usTxBufSize)
    {
      _pUart->usTxWrite = 0;
    }
    _pUart->usTxCount++;
    ENABLE_INT();
  }

  SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);  /* 使能发送中断（缓冲区空） */
}

static uint8_t UartGetChar(UART_T *_pUart, uint8_t *_pByte)
{
  uint16_t usCount;

  /* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
  DISABLE_INT();
  usCount = _pUart->usRxCount;
  ENABLE_INT();

  /* 如果读和写索引相同，则返回0 */
  //if (_pUart->usRxRead == usRxWrite)
  if (usCount == 0) /* 已经没有数据 */
  {
    return 0;
  }
  else
  {
    *_pByte = _pUart->pRxBuf[_pUart->usRxRead];   /* 从串口接收FIFO取1个数据 */

    /* 改写FIFO读索引 */
    DISABLE_INT();
    if (++_pUart->usRxRead >= _pUart->usRxBufSize)
    {
      _pUart->usRxRead = 0;
    }
    _pUart->usRxCount--;
    ENABLE_INT();
    return 1;
  }
}

低功耗串口 LPUART

TIM 定时器

时基单元

预分频器寄存器 (TIMx_PSC)用于设置定时器的分频，比如定时器的主频是 200MHz，通过此寄存器可以将其设置为 100MHz，50MHz， 25MHz 等分频值。注：预分频器有个缓冲功能，可以让用户实时更改，新的预分频值将在下一个更新事件发生时被采用（以递增计数模式为例，就是 CNT 计数值达到 ARR 自动重装寄存器的数值时会产生更新事件）。
计数器寄存器 (TIMx_CNT)计数器是最基本的计数单元，计数值是建立在分频的基础上面，比如通过 TIMx_PSC 设置分频后的频率为 100MHz，那么计数寄存器计一次数就是 10ns。
自动重载寄存器 (TIMx_ARR)自动重装寄存器是 CNT 计数寄存器能达到的最大计数值，以递增计数模式为例，就是 CNT 计数器达到 ARR 寄存器数值时，重新从 0 开始计数。注，自动重载寄存器是预装载的。对自动重载寄存器执行写入或读取操作时会访问预装载寄存器。预装载寄存器的内容既可以立即传送到影子寄存器（让设置立即起到效果的寄存器），也可以在每次发生更新事件时传送到影子寄存器。简单的说就是让 ARR 寄存器的数值立即更新还是更新事件发送的时候更新。
重复计数器寄存器 (TIMx_RCR)以递增计数模式为例，当 CNT 计数器数值达到 ARR 自动重载数值时，重复计数器的数值加 1，重复次数达到 TIMx_RCR+ 1 后就，将生成更新事件。注，只有 TIM1， TIM8， TIM15， TIM16， TIM17 有此寄存器.

定时器输出比较（PWM）

以 PWM 边沿对齐模式，递增计数配置为例：

当计数器 TIMx_CNT < 比较捕获寄存器 TIMx_CCRx 期间， PWM 参考信号 OCxREF 输出高电平。
当计数器 TIMx_CNT >= 比较捕获寄存器 TIMx_CCRx 期间， PWM 参考信号 OCxREF 输出低电平。
当比较捕获寄存器 TIMx_CCRx > 自动重载寄存器 TIMx_ARR， OCxREF 保持为 1。
当比较捕获寄存器 TIMx_CCRx = 0，则 OCxRef 保持为 0。

定时器输入捕获

使用定时器实现输入捕获，仅靠时基单元的那几个寄存器是不行的，我们需要一个寄存器来记录发生捕获时的具体时间，这个寄存器依然由比较捕获寄存器 TIMx_CCRx 来实现。

配置定时器为输入捕获模式，上升沿触发，设置分频，自动重装等寄存器，比如设置的 CNT 计数器计数 1 次是 1 微秒。
当有上升沿触发的时候， TIMx_CCRx 寄存器就会自动记录当前的 CNT 数值，然后用户就可以通过CC 中断，在中断复位程序里面保存当前的 TIMx_CCRx 寄存器数值。等下次再检测到上升沿触发，两次时间求差就可以得到方波的周期。 不过这里要特别注意一点，如果 CNT 发生溢出（比如 16 位定时器，计数到 65535 就溢出了）就需要特别处理下，将 CNT 计数溢出考虑进来

PWM

$$ _ulFreq=\frac{f_{sys}}{(ARR+1)(PSC+1)} $$

输出比较模式
// 使能 | 失能TIM RCC时钟
_HAL_RCC_TIM1_CLK_ENABLE();
__HAL_RCC_TIM3_CLK_DISABLE();

void bsp_ConfigTimGpio(GPIO_TypeDef* GPIOx, uint16_t GPIO_PinX, TIM_TypeDef* TIMx)
{
  GPIO_InitTypeDef   GPIO_InitStruct;

  /* 使能GPIO时钟 */
  bsp_RCC_GPIO_Enable(GPIOx);

    /* 使能TIM时钟 */
  bsp_RCC_TIM_Enable(TIMx);

  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = bsp_GetAFofTIM(TIMx);
  GPIO_InitStruct.Pin = GPIO_PinX;
  HAL_GPIO_Init(GPIOx, &GPIO_InitStruct);
}
//配置GPIO为推挽输出。主要用于PWM输出，占空比为0和100的情况。
void bsp_ConfigGpioOut(GPIO_TypeDef* GPIOx, uint16_t GPIO_PinX)
{
  GPIO_InitTypeDef   GPIO_InitStruct;

  bsp_RCC_GPIO_Enable(GPIOx);   /* 使能GPIO时钟 */

  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Pin = GPIO_PinX;
  HAL_GPIO_Init(GPIOx, &GPIO_InitStruct);
}
//_ulFreq : PWM信号频率，单位Hz (实际测试，可以输出100MHz），0 表示禁止输出
//_ulDutyCycle : PWM信号占空比，单位: 万分之一。如5000，表示50.00%的占空比
void bsp_SetTIMOutPWM(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, TIM_TypeDef* TIMx, uint8_t _ucChannel, uint32_t _ulFreq, uint32_t _ulDutyCycle)
{
  TIM_HandleTypeDef  TimHandle = {0};
  TIM_OC_InitTypeDef sConfig = {0}; 
  uint16_t usPeriod;
  uint16_t usPrescaler;
  uint32_t pulse;
  uint32_t uiTIMxCLK;
  const uint16_t TimChannel[6+1] = {0, TIM_CHANNEL_1, TIM_CHANNEL_2, TIM_CHANNEL_3, TIM_CHANNEL_4, TIM_CHANNEL_5, TIM_CHANNEL_6};
  if (_ucChannel > 6)
  {
    Error_Handler(__FILE__, __LINE__);
  }
  if (_ulDutyCycle == 0)
  {   
    //bsp_RCC_TIM_Disable(TIMx);    /* 关闭TIM时钟, 可能影响其他通道 */   
    bsp_ConfigGpioOut(GPIOx, GPIO_Pin); /* 配置GPIO为推挽输出 */     
    GPIOx->BSRRH = GPIO_Pin;    /* PWM = 0 */   
    return;
  }
  else if (_ulDutyCycle == 10000)
  {
    //bsp_RCC_TIM_Disable(TIMx);    /* 关闭TIM时钟, 可能影响其他通道 */
    bsp_ConfigGpioOut(GPIOx, GPIO_Pin); /* 配置GPIO为推挽输出 */   
    GPIOx->BSRRL = GPIO_Pin;    /* PWM = 1*/  
    return;
  }
  /* 下面是PWM输出 */
  bsp_ConfigTimGpio(GPIOx, GPIO_Pin, TIMx); /* 使能GPIO和TIM时钟，并连接TIM通道到GPIO */
  
    /*-----------------------------------------------------------------------
    bsp.c 文件中 void SystemClock_Config(void) 函数对时钟的配置如下: 

        System Clock source       = PLL (HSE)
        SYSCLK(Hz)                = 400000000 (CPU Clock)
        HCLK(Hz)                  = 200000000 (AXI and AHBs Clock)
        AHB Prescaler             = 2
        D1 APB3 Prescaler         = 2 (APB3 Clock  100MHz)
        D2 APB1 Prescaler         = 2 (APB1 Clock  100MHz)
        D2 APB2 Prescaler         = 2 (APB2 Clock  100MHz)
        D3 APB4 Prescaler         = 2 (APB4 Clock  100MHz)

        因为APB1 prescaler != 1, 所以 APB1上的TIMxCLK = APB1 x 2 = 200MHz;
        因为APB2 prescaler != 1, 所以 APB2上的TIMxCLK = APB2 x 2 = 200MHz;
        APB4上面的TIMxCLK没有分频，所以就是100MHz;

        APB1 定时器有 TIM2, TIM3 ,TIM4, TIM5, TIM6, TIM7, TIM12, TIM13, TIM14，LPTIM1
        APB2 定时器有 TIM1, TIM8 , TIM15, TIM16，TIM17

        APB4 定时器有 LPTIM2，LPTIM3，LPTIM4，LPTIM5

  ----------------------------------------------------------------------- */
  if ((TIMx == TIM1) || (TIMx == TIM8) || (TIMx == TIM15) || (TIMx == TIM16) || (TIMx == TIM17))
  {
    /* APB2 定时器时钟 = 200M */
    uiTIMxCLK = SystemCoreClock / 2;
  }
  else  
  {
    /* APB1 定时器 = 200M */
    uiTIMxCLK = SystemCoreClock / 2;
  }

  if (_ulFreq < 100)
  {
    usPrescaler = 10000 - 1;          /* 分频比 = 10000 */
    usPeriod =  (uiTIMxCLK / 10000) / _ulFreq  - 1;   /* 自动重装的值 */
  }
  else if (_ulFreq < 3000)
  {
    usPrescaler = 100 - 1;          /* 分频比 = 100 */
    usPeriod =  (uiTIMxCLK / 100) / _ulFreq  - 1;   /* 自动重装的值 */
  }
  else  /* 大于4K的频率，无需分频 */
  {
    usPrescaler = 0;          /* 分频比 = 1 */
    usPeriod = uiTIMxCLK / _ulFreq - 1; /* 自动重装的值 */
  }
  pulse = (_ulDutyCycle * usPeriod) / 10000;
  HAL_TIM_PWM_DeInit(&TimHandle);
    
  /*  PWM频率 = TIMxCLK / usPrescaler + 1）/usPeriod + 1）*/
  TimHandle.Instance = TIMx;
  TimHandle.Init.Prescaler         = usPrescaler;
  TimHandle.Init.Period            = usPeriod;
  TimHandle.Init.ClockDivision     = 0;
  TimHandle.Init.CounterMode       = TIM_COUNTERMODE_UP;
  TimHandle.Init.RepetitionCounter = 0;
  TimHandle.Init.AutoReloadPreload = 0;
  if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
  {
    Error_Handler(__FILE__, __LINE__);
  }

  /* 配置定时器PWM输出通道 */
  sConfig.OCMode       = TIM_OCMODE_PWM1;
  sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
  sConfig.OCFastMode   = TIM_OCFAST_DISABLE;
  sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
  sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
  sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;

  /* 占空比 */
  sConfig.Pulse = pulse;
  if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TimChannel[_ucChannel]) != HAL_OK)
  {
    Error_Handler(__FILE__, __LINE__);
  }
  
  /* 启动PWM输出 */
  if (HAL_TIM_PWM_Start(&TimHandle, TimChannel[_ucChannel]) != HAL_OK)
  {
    Error_Handler(__FILE__, __LINE__);
  }
}

高精度单次延迟实现

TL;DR
配置捕获比较中断  
读取当前cnt,设置为 CCR = CNT + WAIT_TICKS_YOU_WANT
TIMx->SR = (uint16_t)~TIM_IT_CC1;    /* 清除 CC1 中断标志 */
TIMx->DIER |= TIM_IT_CC1;            /* 使能 CC1 中断 */

LPTIM 低功耗定时器基础

LPTIM 的好处是系统处于睡眠，停机状态依然可以正常工作，但停机模式不能再正常工作。

对于睡眠模式，任何受 NVIC 控制的中断都可以唤醒休眠模式。进入睡眠模式调用函数HAL_PWR_EnterSLEEPMode 即可。
在系统停止模式下， 1.2V 供电域中的所有时钟都停止， PLL， HSI 和 HSE RC 振荡器被禁用。内部 SRAM和寄存器内容保留。而 LSE 和 LSI 是可以正常工作的，所以 LPTIM 系统时钟使用 LSE 或者 LSI 依然可以在停机模式下工作。进入停机模式调用函数 HAL_PWR_EnterSTOPMode 即可。

LPTIM PWM

差不多

LPTIM 超时唤醒

注意

LPTIM 的任何中断都可以唤醒停机模式
STM32H7 从停机模式唤醒后要重新配置系统时钟，这点跟 F1， F4 系列一样。
测试发现 STM32H7 的 LPTIM1 的中断可以唤醒停机模式，其它几个 LPTIM2-5 无法唤醒。

void bsp_InitLPTIM(void)
{
  RCC_PeriphCLKInitTypeDef   RCC_PeriphCLKInitStruct = {0};
  

  /* ## - 1 - 使能LPTIM时钟和GPIO时钟 ####################################### */
  __HAL_RCC_LPTIM1_CLK_ENABLE();

  /* ## - 2 - 配置LPTIM时钟，可以选择LSE，LSI或者PCLK ######################## */   
#if defined (LPTIM_CLOCK_SOURCE_LSE)
  {
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};

    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
    RCC_OscInitStruct.LSEState = RCC_LSE_ON;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;

    if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    {
      Error_Handler(__FILE__, __LINE__);    
    }
    
    RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPTIM1;
    RCC_PeriphCLKInitStruct.Lptim1ClockSelection = RCC_LPTIM1CLKSOURCE_LSE;
    HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
  }
#elif defined (LPTIM_CLOCK_SOURCE_LSI)
  {
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};

    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI;
    RCC_OscInitStruct.LSIState = RCC_LSI_ON;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;

    if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
    {
      Error_Handler(__FILE__, __LINE__);    
    }
    
    RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPTIM1;
    RCC_PeriphCLKInitStruct.Lptim1ClockSelection = RCC_LPTIM1CLKSOURCE_LSI;
    HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
  }
#elif defined (LPTIM_CLOCK_SOURCE_PCLK)
   /*-----------------------------------------------------------------------
    bsp.c 文件中 void SystemClock_Config(void) 函数对时钟的配置如下: 

        System Clock source       = PLL (HSE)
        SYSCLK(Hz)                = 400000000 (CPU Clock)
        HCLK(Hz)                  = 200000000 (AXI and AHBs Clock)
        AHB Prescaler             = 2
        D1 APB3 Prescaler         = 2 (APB3 Clock  100MHz)
        D2 APB1 Prescaler         = 2 (APB1 Clock  100MHz)
        D2 APB2 Prescaler         = 2 (APB2 Clock  100MHz)
        D3 APB4 Prescaler         = 2 (APB4 Clock  100MHz)

        因为APB1 prescaler != 1, 所以 APB1上的TIMxCLK = APB1 x 2 = 200MHz;
        因为APB2 prescaler != 1, 所以 APB2上的TIMxCLK = APB2 x 2 = 200MHz;
        APB4上面的TIMxCLK没有分频，所以就是100MHz;

        APB1 定时器有 TIM2, TIM3 ,TIM4, TIM5, TIM6, TIM7, TIM12, TIM13, TIM14，LPTIM1
        APB2 定时器有 TIM1, TIM8 , TIM15, TIM16，TIM17

        APB4 定时器有 LPTIM2，LPTIM3，LPTIM4，LPTIM5
  ----------------------------------------------------------------------- */
  RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPTIM1;
  RCC_PeriphCLKInitStruct.Lptim1ClockSelection = RCC_LPTIM1CLKSOURCE_LSE;
  HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
#else
  #error Please select the LPTIM Clock source inside the bsp_lptim_pwm.c file
#endif

  /* ## - 3 - 配置LPTIM ######################################################## */   
  LptimHandle.Instance = LPTIM1;

  LptimHandle.Init.Clock.Source    = LPTIM_CLOCKSOURCE_APBCLOCK_LPOSC; /* 对应寄存器CKSEL，选择内部时钟源 */
  LptimHandle.Init.Clock.Prescaler = LPTIM_PRESCALER_DIV8;        /* 设置LPTIM时钟分频 */
  LptimHandle.Init.CounterSource   = LPTIM_COUNTERSOURCE_INTERNAL;/* LPTIM计数器对内部时钟源计数 */
  LptimHandle.Init.Trigger.Source  = LPTIM_TRIGSOURCE_SOFTWARE;   /* 软件触发 */ 
  LptimHandle.Init.OutputPolarity  = LPTIM_OUTPUTPOLARITY_HIGH;   /* 超时模式用不到这个配置 */
  LptimHandle.Init.UpdateMode      = LPTIM_UPDATE_IMMEDIATE;      /* 比较寄存器和ARR自动重载寄存器选择更改后立即更新 */ 
  LptimHandle.Init.Input1Source    = LPTIM_INPUT1SOURCE_GPIO;     /* 外部输入1，本配置未使用 */
  LptimHandle.Init.Input2Source    = LPTIM_INPUT2SOURCE_GPIO;     /* 外部输入2，本配置未使用 */

  if (HAL_LPTIM_Init(&LptimHandle) != HAL_OK)
  {
    Error_Handler(__FILE__, __LINE__);
  }

  /* ## - 4 - 配置LPTIM ######################################################## */   
  /* 配置中断优先级并使能中断 */
  HAL_NVIC_SetPriority(LPTIM1_IRQn, 1, 0);
  HAL_NVIC_EnableIRQ(LPTIM1_IRQn);
}

高分辨率定时器 HRTIM

HRTIM PWM

DMA

DMAMUX 基础知识

DMAMUX 其实就是 DMA 控制器前一级的多路选择器，有了这个选择器就不用再像 F1， F4 系列那样每个通道（数据流）要固定选择指定的外设，有了多路选择器就可以任意选择，外设使用 DMA 方式时无需再选择指定的 DMA 通道（数据流），任意通道（数据流）都可以。当前STM32H7有两路DMAMUX，分别是DMAMUX1和DMAMUX2，其中DMAMUX1负责DMA1和 DMA2，而 DMAMUX2 负责 BDMA。 DMA1， DMA2 和 BDMA 都支持存储区到存储区的传输。

Request Multiplexer（请求多路复用器）

将某一 DMAMUX 通道的输入，从多个可能的 DMA 请求源中选择一个。
多进一出，选一个通

Request Generator（请求发生器）

将任意外部事件（如 GPIO 边沿、定时器信号、LPTIM 等）转换成一个 “虚拟 DMA 请求”。

BDMA 基础知识

BDMA 只能操作 D3 域的存储器和外设，这点比较重要，操作的时候容易被遗忘。详情看本章 2.6 小节。
BDMA 支持 8 路通道。虽然是 8 路，但这 8 路不是并行工作的，而是由 BDMA 的仲裁器决定当前处理哪一路。
BDMA 不支持硬件 FIFO，但是支持双缓冲。
BDMA 不支持突发模式。
BDMA 最大传输次数 65535 次，每次传输单位可以是字节、半字和字。
BDMA 的循环模式不可用于存储器到存储器模式

BDMA 支持存储器到外设，外设到存储器，存储器到存储器(循环模式不可用于存储器到存储器模式)和外设到外设的传输，其中外设到外设的传输， DMA1 和 DMA2 是不支持的，这个模式在低功耗模式下比较有用。
BDMA 只有一个 AHB 总线主控，而 DMA1 和 DMA2 是有两个的，可以分别用于源地址和目的地址的传输。
源地址和目的地址的数据宽度可以不同，但是数据地址必须要跟其数据类型对齐。比如源地址是uint32 类型的，那么此数组的地址必须 4 字节对齐。
BDMA 主要有两种模式，一个是 Normal 正常模式，传输一次后就停止传输；另一种是 Circular 循环模式，会一直循环的传输下去，即使有 DMA 中断，传输也是一直在进行的。
BDMA 的通道请求（Channel0 – Channel7）的优先级可编程，分为四级 Very high priority， Highpriority， Medium priority 和 Low priority。通道的优先级配置相同的情况下，如果同时产生请求，会优先响应编号低的，即 Channel0 优先响应。

BDMA 双缓冲

当用户开启了 BDMA 传输完成中断后，通过寄存器 CCRx 的 CT 位判断当前使用的是哪个缓冲区:

如果 CT = 1 表示当前正在使用缓冲区 1，即寄存器 BDMA_CM1ARx 记录的地址。
如果 CT = 0 表示当前正在使用缓冲区 0，即寄存器 BDMA_CM0ARx 记录的地址。

BDMA 仅可以操作： AHB4， APB4 的外设以及 SRAM4， Backup RAM

#if defined ( __ICCARM__ )
#pragma location = 0x38000000
uint32_t IO_Toggle[8]  =
                      { 
                          0x00000002U,   
                          0x00020000U,  
                          0x00000002U,   
                          0x00020000U,   
                          0x00000002U,   
                          0x00020000U,   
                          0x00000002U,   
                          0x00020000U,  
                      };

#elif defined ( __CC_ARM )
ALIGN_32BYTES(__attribute__((section (".RAM_D3"))) uint32_t IO_Toggle[8]) =
                                                      { 
                                                          0x00000002U,   
                                                          0x00020000U,  
                                                          0x00000002U,   
                                                          0x00020000U,   
                                                          0x00000002U,   
                                                          0x00020000U,   
                                                          0x00000002U,   
                                                          0x00020000U,  
                                                      };
#endif


void bsp_InitTimBDMA(void)
{
    GPIO_InitTypeDef  GPIO_InitStruct;
    DMA_HandleTypeDef DMA_Handle = {0};
    HAL_DMA_MuxRequestGeneratorConfigTypeDef dmamux_ReqGenParams ={0};

    
     /*##-1- 配置PB1用于PWM输出######################################*/ 
    __HAL_RCC_GPIOB_CLK_ENABLE();
      
    GPIO_InitStruct.Pin = GPIO_PIN_1;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    
  
    /*##-2- 配置DMA ##################################################*/
    __HAL_RCC_BDMA_CLK_ENABLE();

    DMA_Handle.Instance                 = BDMA_Channel0;           /* 使用的BDMA通道0 */
    DMA_Handle.Init.Request             = BDMA_REQUEST_GENERATOR0; /* 请求类型采用的DMAMUX请求发生器通道0 */  
    DMA_Handle.Init.Direction           = DMA_MEMORY_TO_PERIPH;    /* 传输方向是从存储器到外设 */  
    DMA_Handle.Init.PeriphInc           = DMA_PINC_DISABLE;        /* 外设地址自增禁止 */  
    DMA_Handle.Init.MemInc              = DMA_MINC_ENABLE;         /* 存储器地址自增使能 */  
    DMA_Handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;     /* 外设数据传输位宽选择字，即32bit */     
    DMA_Handle.Init.MemDataAlignment    = DMA_MDATAALIGN_WORD;     /* 存储器数据传输位宽选择字，即32bit */    
    DMA_Handle.Init.Mode                = DMA_CIRCULAR;            /* 循环模式 */   
    DMA_Handle.Init.Priority            = DMA_PRIORITY_LOW;        /* 优先级低 */  
    DMA_Handle.Init.FIFOMode            = DMA_FIFOMODE_DISABLE;    /* BDMA不支持FIFO */ 
    DMA_Handle.Init.FIFOThreshold       = DMA_FIFO_THRESHOLD_FULL; /* BDMA不支持FIFO阀值设置 */ 
    DMA_Handle.Init.MemBurst            = DMA_MBURST_SINGLE;       /* BDMA不支持存储器突发 */ 
    DMA_Handle.Init.PeriphBurst         = DMA_PBURST_SINGLE;       /* BDMA不支持外设突发 */ 
    
    HAL_DMA_Init(&DMA_Handle);

    /* 开启BDMA Channel0的中断 */
    HAL_NVIC_SetPriority(BDMA_Channel0_IRQn, 2, 0);
    HAL_NVIC_EnableIRQ(BDMA_Channel0_IRQn); 

    /*##-3- 配置DMAMUX #########################################################*/
    dmamux_ReqGenParams.SignalID  = HAL_DMAMUX2_REQ_GEN_LPTIM2_OUT;         /* 请求触发器选择LPTIM2_OUT */
    dmamux_ReqGenParams.Polarity  = HAL_DMAMUX_REQ_GEN_RISING_FALLING;      /* LPTIM2输出的上升沿和下降沿均可触发  */
    dmamux_ReqGenParams.RequestNumber = 1;                                  /* 触发后，传输进行1次DMA传输 */

    HAL_DMAEx_ConfigMuxRequestGenerator(&DMA_Handle, &dmamux_ReqGenParams); /* 配置DMAMUX */
    
    HAL_DMAEx_EnableMuxRequestGenerator (&DMA_Handle);                      /* 使能DMAMUX请求发生器 */        
      
    /*##-4- 启动DMA传输 ################################################*/
    HAL_DMA_Start_IT(&DMA_Handle, (uint32_t)IO_Toggle, (uint32_t)&GPIOB->BSRRL, 8);
    
    /* 
       默认情况下，用户通过注册回调函数DMA_Handle.XferHalfCpltCallback，然后函数HAL_DMA_Init会开启半传输完成中断，
       由于这里没有使用HAL库默认的中断管理函数HAL_DMA_IRQHandler，直接手动开启。
    */
    BDMA_Channel0->CCR |= BDMA_CCR_HTIE;
    
    LPTIM_Config(); /* 配置LPTIM触发DMAMUX */
}


void BDMA_Channel0_IRQHandler(void)
{
    /* 传输完成中断 */
    if((BDMA->ISR & BDMA_FLAG_TC0) != RESET)
    {
        BDMA->IFCR = BDMA_FLAG_TC0;

        /*
           1、传输完成开始使用DMA缓冲区的前半部分，此时可以动态修改后半部分数据
              比如缓冲区大小是IO_Toggle[0] 到 IO_Toggle[7]
              那么此时可以修改IO_Toggle[4] 到 IO_Toggle[7]
           2、变量所在的SRAM区已经通过MPU配置为WT模式，更新变量IO_Toggle会立即写入。
           3、不配置MPU的话，也可以通过Cahce的函数SCB_CleanDCache_by_Addr做Clean操作。
        */
    }
 
    /* 半传输完成中断 */    
    if((BDMA->ISR & BDMA_FLAG_HT0) != RESET)
    {
        BDMA->IFCR = BDMA_FLAG_HT0;
        
        /*
           1、半传输完成开始使用DMA缓冲区的后半部分，此时可以动态修改前半部分数据
              比如缓冲区大小是IO_Toggle[0] 到 IO_Toggle[7]
              那么此时可以修改IO_Toggle[0] 到 IO_Toggle[3]
           2、变量所在的SRAM区已经通过MPU配置为WT模式，更新变量IO_Toggle会立即写入。
           3、不配置MPU的话，也可以通过Cahce的函数SCB_CleanDCache_by_Addr做Clean操作。
        */
    }
 
    /* 传输错误中断 */
    if((BDMA->ISR & BDMA_FLAG_TE0) != RESET)
    {
        BDMA->IFCR = BDMA_FLAG_TE0;
    }
}

BDMA 应用之控制任意 IO做 PWM 和脉冲数控制

就是上面的代码，配置tim上升沿下降沿都发生中断，将一个数组内的数字分别传入GPIOB->BSRRL，实现PWM

动态修改需要注意的点

方法一：

设置 BDMA 所使用 SRAM3 存储区的 Cache 属性为 Write through, read allocate， no writeallocate。保证写入的数据会立即更新到 SRAM3 里面

方法二：

设置 SRAM3 的缓冲区做 32 字节对齐，大小最好也是 32 字节整数倍，然后调用函数SCB_CleanDCache_by_Addr 做 Clean 操作即可，保证 BDMA 读取到的数据是刚更新好的。

DMA 基础知识

DMA1 和 DMA2 均支持 8 路通道。虽然是 8 路，但这 8 路不是并行工作的，而是由 DMA 的仲裁器决定当前处理那一路。
DMA 最大传输次数 65535 次，每次传输单位可以是字节、半字和字。
DMA 的循环模式不可用于存储器到存储器模式。
DMA1 和 DMA2 带的 FIFO 是 4 个 32bit 的空间，即 16 字节。
使用 DMA 的 FIFO 和突发需要注意的问题较多

关键知识点

由于总线矩阵的存在，各个主控的道路四通八达，从而可以让 DMA 和 CPU 同时开工，但是注意一点，如果他们同时访问的同一个外设，会有一点性能影响的。

DMA 支持存储器到外设，外设到存储器和存储器到存储器的传输，不支持外设到外设的传输，而BDMA 是支持的，这个模式在低功耗模式下比较有用。
DMA1 和 DMA2 是有两个 AHB 总线主控，可以分别用于源地址和目的地址的传输。
源地址和目的地址的数据宽度可以不同，但是数据地址必须要跟其数据类型对齐。比如源地址是uint32 类型的，那么此数组的地址必须 4 字节对齐。
DMA 主要有两种模式，一个是 Normal 正常模式，传输一次后就停止传输；另一种是 Circular 循环模式，会一直循环的传输下去，即使有 DMA 中断，传输也是一直在进行的。
DMA 的数据流请求（Stream0 – Stream7）的优先级可编程，分为四级 Very high priority， High priority， Medium priority 和 Low priority。通道的优先级配置相同的情况下，如果同时产生请求，会优先响应编号低的，即 Stream0 优先响应。

DMA 的 FIFO 和突发支持

使用 DMA 的 FIFO 主要有两个作用，一个是降低总线带宽的需求，另一个是前面说的源地址数据宽度和目的地址数据宽度不同时的数据传输。而突发传输的含义是每个 DMA 请求后可以连续传输的数据项目数，支持 4 次， 8 次和 16 次。了解到以上两点就够用了，现在重点讲解下使用中的注意事项，使用 FIFO 要注意的事项较多。

禁止 FIFO 的情况下，即 STM32H7 参考手册里面所说的直接模式 Direct Mode，务必要保证外设数据宽度和内存数据宽度是一样的，而且禁止了 FIFO 的情况下，不支持突发，即使配置了，也是无效的。
禁止了 FIFO 的情况下，也不可用于存储器到存储器的数据传输，仅支持外设到存储器或者存储器到外设方式。
使能 FIFO 的情况下，可以使用突发模式，也可以不使用。
独立的源和目标传输宽度（字节、半字、字）：源和目标的数据宽度不相等时， DMA 自动封装/解封必要的传输数据来优化带宽。这个特性仅在 FIFO 模式下可用。这个特性非常重要，在 H7 使用SDIO 时要用到。无需像 F1 系列那样强行数据缓冲的 4 字节对齐要求。
最后要特别注意一点，一般应用中最好关闭 FIFO，实际测试发现容易有一些比较奇怪的问题.

// 多缓冲区的DMA的启用函数
HAL_DMAEx_MultiBufferStart()


void bsp_InitTimDMA(void)
{
    GPIO_InitTypeDef  GPIO_InitStruct;
    DMA_HandleTypeDef DMA_Handle = {0};
    HAL_DMA_MuxRequestGeneratorConfigTypeDef dmamux_ReqGenParams = {0};

    /*##-1- 配置PB1用于PWM输出 ##################################################*/
    __HAL_RCC_GPIOB_CLK_ENABLE();
    GPIO_InitStruct.Pin = GPIO_PIN_1;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  
    /*##-2- 使能DMA1时钟并配置 ##################################################*/
    __HAL_RCC_DMA1_CLK_ENABLE();
    DMA_Handle.Instance                 = DMA1_Stream1;            /* 使用的DMA1 Stream1 */
    DMA_Handle.Init.Request             = DMA_REQUEST_GENERATOR0;  /* 请求类型采用的DMAMUX请求发生器通道0 */  
    DMA_Handle.Init.Direction           = DMA_MEMORY_TO_PERIPH;    /* 传输方向是从存储器到外设 */  
    DMA_Handle.Init.PeriphInc           = DMA_PINC_DISABLE;        /* 外设地址自增禁止 */ 
    DMA_Handle.Init.MemInc              = DMA_MINC_ENABLE;         /* 存储器地址自增使能 */  
    DMA_Handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;     /* 外设数据传输位宽选择字，即32bit */     
    DMA_Handle.Init.MemDataAlignment    = DMA_MDATAALIGN_WORD;     /* 存储器数据传输位宽选择字，即32bit */    
    DMA_Handle.Init.Mode                = DMA_CIRCULAR;            /* 循环模式 */   
    DMA_Handle.Init.Priority            = DMA_PRIORITY_LOW;        /* 优先级低 */  
    DMA_Handle.Init.FIFOMode            = DMA_FIFOMODE_DISABLE;    /* 禁止FIFO*/
    DMA_Handle.Init.FIFOThreshold       = DMA_FIFO_THRESHOLD_FULL; /* 禁止FIFO此位不起作用，用于设置阀值 */
    DMA_Handle.Init.MemBurst            = DMA_MBURST_SINGLE;       /* 禁止FIFO此位不起作用，用于存储器突发 */
    DMA_Handle.Init.PeriphBurst         = DMA_PBURST_SINGLE;       /* 禁止FIFO此位不起作用，用于外设突发 */
 
    /* 初始化DMA */
    if(HAL_DMA_Init(&DMA_Handle) != HAL_OK)
    {
    Error_Handler(__FILE__, __LINE__);     
    }

    /* 开启DMA1 Stream1的中断 */
    HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 2, 0);
    HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn); 

    
    /*##-4- 配置DMAMUX ###########################################################*/
    dmamux_ReqGenParams.SignalID  = HAL_DMAMUX1_REQ_GEN_TIM12_TRGO;         /* 请求触发器选择LPTIM2_OUT */
    dmamux_ReqGenParams.Polarity  = HAL_DMAMUX_REQ_GEN_RISING;              /* 上升沿触发  */
    dmamux_ReqGenParams.RequestNumber = 1;                                  /* 触发后，传输进行1次DMA传输 */

    HAL_DMAEx_ConfigMuxRequestGenerator(&DMA_Handle, &dmamux_ReqGenParams); /* 配置DMAMUX */
    HAL_DMAEx_EnableMuxRequestGenerator (&DMA_Handle);                      /* 使能DMAMUX请求发生器 */   
 
    
    /*##-4- 启动DMA双缓冲传输 ################################################*/
    /*
        1、此函数会开启DMA的TC，TE和DME中断
        2、如果用户配置了回调函数DMA_Handle.XferHalfCpltCallback，那么函数HAL_DMA_Init会开启半传输完成中断。
        3、如果用户使用了DMAMUX的同步模式，此函数会开启同步溢出中断。
        4、如果用户使用了DMAMUX的请求发生器，此函数会开始请求发生器溢出中断。
    */
    HAL_DMAEx_MultiBufferStart_IT(&DMA_Handle, (uint32_t)IO_Toggle, (uint32_t)&GPIOB->BSRRL,(uint32_t)IO_Toggle1, 8);
    
    /* 用不到的中断可以直接关闭 */
    //DMA1_Stream1->CR &= ~DMA_IT_DME; 
    //DMA1_Stream1->CR &= ~DMA_IT_TE;
    //DMAMUX1_RequestGenerator0->RGCR &= ~DMAMUX_RGxCR_OIE;
    
    TIM12_Config(0);
}

// 功能说明: DMA1 Stream1中断服务程序
void DMA1_Stream1_IRQHandler(void)
{
  /* 传输完成中断 */
  if((DMA1->LISR & DMA_FLAG_TCIF1_5) != RESET)
  {
    /* 清除标志 */
    DMA1->LIFCR = DMA_FLAG_TCIF1_5;

    /* 当前使用的缓冲0 */
    if((DMA1_Stream1->CR & DMA_SxCR_CT) == RESET)
    {
      /*
        1、当前正在使用缓冲0，此时可以动态修改缓冲1的数据。
           比如缓冲区0是IO_Toggle，缓冲区1是IO_Toggle1，那么此时就可以修改IO_Toggle1。
        2、变量所在的SRAM区已经通过MPU配置为WT模式，更新变量IO_Toggle会立即写入。
        3、不配置MPU的话，也可以通过Cahce的函数SCB_CleanDCache_by_Addr做Clean操作。
      */
      
    }
    /* 当前使用的缓冲1 */
    else
    {
       /*
         1、当前正在使用缓冲1，此时可以动态修改缓冲0的数据。
          比如缓冲区0是IO_Toggle，缓冲区1是IO_Toggle1，那么此时就可以修改IO_Toggle。
         2、变量所在的SRAM区已经通过MPU配置为WT模式，更新变量IO_Toggle会立即写入。
         3、不配置MPU的话，也可以通过Cahce的函数SCB_CleanDCache_by_Addr做Clean操作。
      */

    }
  }

  /* 半传输完成中断 */    
  if((DMA1->LISR & DMA_FLAG_HTIF1_5) != RESET)
  {
    /* 清除标志 */
    DMA1->LISR = DMA_FLAG_HTIF1_5;
  }

  /* 传输错误中断 */
  if((DMA1->LISR & DMA_FLAG_TEIF1_5) != RESET)
  {
    /* 清除标志 */
    DMA1->LISR = DMA_FLAG_TEIF1_5;
  }

  /* 直接模式错误中断 */
  if((DMA1->LISR & DMA_FLAG_DMEIF1_5) != RESET)
  {
    /* 清除标志 */
    DMA1->LISR = DMA_FLAG_DMEIF1_5;
  }
}

// 功能说明: DMAMUX的中断服务程序，这里用于处理请求发生器的溢出。
void DMAMUX1_OVR_IRQHandler(void)
{
    if((DMAMUX1_RequestGenStatus->RGSR & DMAMUX_RGSR_OF0) != RESET)
    {
       /* 关闭溢出中断 */
       DMAMUX1_RequestGenerator0->RGCR &= ~DMAMUX_RGxCR_OIE;
       
       /* 清除标志 */
       DMAMUX1_RequestGenStatus->RGCFR = DMAMUX_RGSR_OF0;
    }
}

ADC

STM32H7 支持三路 ADC，分别是 ADC1， ADC2 和 ADC3。其中 ADC1 和 ADC2 可以组成双 ADC模式， ADC3 是独立的。这个跟 STM32F4 有所不同， F4 的 ADC1， ADC2 和 ADC3 可以组成三 ADC模式。
可以配置为 16bit， 14bit， 12bit， 10bit 或者 8bit 分辨率，分辨率越低可以做到的采样率越高，因为转换时间要短。
每个 ADC 都支持 20 路采样通道。其中有 6 路快速通道和 14 路慢速通道，慢速和快速的区别主要是支持的最高采样率不同，慢速通道要比快速通道低。
支持单独输入和差分输入，其中差分输入不支持负压测量
支持偏移校准和线性度校准， STM32F1 的时候还带校准功能，到了 STM32F4 取消掉了， H7 又恢复了校准功能。
支持规则通道和注入通道两种采样方式。
支持低功耗特性，系统在低频工作时保持最佳 ADC 性能（提供自动延迟插入）。
具有五条专用的内部通道，内部参考电压 VrefInt，内部温度传感器和 VBAT 监测通道 VBAT/4 都是连接到 ADC3。另外内部 DAC 通道 1 和通道 2，连接到 ADC2。
支持过采样，最高可以调整到 26bit 采样率。
ADC 采样的数据可接入 DFSDM 数字滤波器进行后期处理。
每个 ADC 支持三路模拟看门狗。

规则通道触发

注入通道触发

ADC 单端和差分的支持

单极性，双极性比较好理解，就是单电源供电或者双电源供电，这里的双电源是指的正负电压供电

单端输入模式下，通道 i 转换的模拟电压是 VINP[i]正向复用引脚与 VREF-之差。
差分输入模式下，通道 i 转换的模拟电压是 VINP[i]正向复用引脚与 VINN[i]反向复用引脚之差。
伪差分 AIP-AIN 就是第 5 幅图，内部 ADC 读取 AIP 和 AIN 的差值，但允许 AIN 上有一个很小的共模电压，比如正负 0.3V。
真差分是 AIP-AIN 就是第 2 幅或者第 5 幅图，其内部 AIP 和 AIN 分别有一个 ADC，分别读取转换AIP-GND，和 AIN-GND，再对这两个数字值做差，所以 AIN 上也可以接收很大的共模值。

ADC 过采样机制

ADC 校准问题

ADC 的 Vbat/4， VrefInt 和温度采样

Vbat/4 连接至 ADC3_INP17，所以可以使用 ADC3 的通道 17 进行测量。
VrefInt 连接至 ADC3_INP19，所以可以使用 ADC3 的通道 19 进行测量。可以通过监测内部电源模块参考电压 VrefInt 来评估 ADC Vref+电压的参考值。 VrefInt 的测量框图如下. STM32H7 带有温度传感器，可以使用 ADC3_INP18 进行测量，不过读取出来的还是个电压值，需要将其转换为温度值.

定时器触发配合 DMA 双缓冲

ADC->DMA Stream1->RAM

DMA 方式多通道采样

FMC 总线

SDRAM

// ll库
void SDRAM_Initialization_Sequence(SDRAM_HandleTypeDef *hsdram)
{
  __IO uint32_t tmpmrd = 0;


  /* Configure a clock configuration enable command */
  Command->CommandMode        = FMC_SDRAM_CMD_CLK_ENABLE; // 开启SDRAM时钟 
  Command->CommandTarget        = FMC_COMMAND_TARGET_BANK;  // 选择要控制的区域
  Command->AutoRefreshNumber    = 1;
  Command->ModeRegisterDefinition   = 0;

  HAL_SDRAM_SendCommand(hsdram, Command, SDRAM_TIMEOUT);  // 发送控制指令
  HAL_Delay(1);   // 延时等待

  /* Configure a PALL (precharge all) command */ 
  Command->CommandMode        = FMC_SDRAM_CMD_PALL;   // 预充电命令
  Command->CommandTarget        = FMC_COMMAND_TARGET_BANK;  // 选择要控制的区域
  Command->AutoRefreshNumber    = 1;
  Command->ModeRegisterDefinition   = 0;

  HAL_SDRAM_SendCommand(hsdram, Command, SDRAM_TIMEOUT);  // 发送控制指令

  /* Configure a Auto-Refresh command */ 
  Command->CommandMode        = FMC_SDRAM_CMD_AUTOREFRESH_MODE; // 使用自动刷新
  Command->CommandTarget        = FMC_COMMAND_TARGET_BANK;          // 选择要控制的区域
  Command->AutoRefreshNumber      = 8;                                // 自动刷新次数
  Command->ModeRegisterDefinition   = 0;

  HAL_SDRAM_SendCommand(hsdram, Command, SDRAM_TIMEOUT);  // 发送控制指令

  /* Program the external memory mode register */
  tmpmrd = (uint32_t)SDRAM_MODEREG_BURST_LENGTH_1         |
              SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL   |
              SDRAM_MODEREG_CAS_LATENCY_3           |
              SDRAM_MODEREG_OPERATING_MODE_STANDARD |
              SDRAM_MODEREG_WRITEBURST_MODE_SINGLE;

  Command->CommandMode          = FMC_SDRAM_CMD_LOAD_MODE;  // 加载模式寄存器命令
  Command->CommandTarget        = FMC_COMMAND_TARGET_BANK;  // 选择要控制的区域
  Command->AutoRefreshNumber    = 1;
  Command->ModeRegisterDefinition   = tmpmrd;

  HAL_SDRAM_SendCommand(hsdram, Command, SDRAM_TIMEOUT);  // 发送控制指令
  
  HAL_SDRAM_ProgramRefreshRate(hsdram, 1543);  // 配置刷新率

}

SD卡

驱动

FATOS

LittleOS

LTDC 屏幕驱动

LCD 的 DE 同步模式和 HV 同步模式的区别

DE

DE 为高电平时，表示当前 CLK 周期内传输的是有效像素；
DE 为低电平时，数据无效（如消隐区）。

HV

VSYNC：标识一帧开始；
HSYNC：标识一行开始；

LTDC 背景层，图层 1，图层 2 和 Alpha 混合

背景层:不是真正的“图层”，而是当 Layer 1/2 未覆盖区域显示的(LTDC->BCCR) 无像素缓冲区，不参与 Alpha 混合。
图层 1:可配置的图像层，有自己的显存地址、颜色格式、位置、Alpha 值等。
图层 2:优先级最高

Alpha 混合模式

Constant Alpha（常量 Alpha）：整个图层统一透明度（0~255，0=全透明，255=不透明）
Pixel Alpha（像素 Alpha）：每个像素自带 Alpha 通道（如 ARGB8888 格式）

LTDC 的水平消隐和垂直消隐

水平消隐就是 LCD 扫描一行结束到另一行开始的时间，这段消失的时间就是水平消隐，即 HSYNC宽度+ HBP + HFP 这段消失的时间。
垂直消隐就是 LCD 扫描最后一行结束到第一行开始的时间，这段消失的时间就是垂直消隐，即 VSYNC宽度+ VBP + VFP 这段消失的时间。

区分 FPS 帧率和刷新率

FPS：电脑渲染的帧率
刷新率：屏幕刷新率，与时钟频率相关

避免 LTDC 刷新撕裂感的解决办法

LTDC 刷新还在垂直消隐期间就将整个界面刷新完成，而我们如何只知道 LTDC 在垂直消隐期，通过函数 HAL_LTDC_ProgramLineEvent 设置刷新到指定行时进入中断即可，一般设置为第 0 行进入中断，然后设置个标志即可。一旦检测到这个标志，就通过 DMA2D 快速将界面刷新好，这样就有效的避免了撕裂感

Usage

LTDC 寄存器结构体 LTDC_TypeDef
LTDC 参数初始化结构体 LTDC_InitTypeDef
LTDC 图层配置结构体 LTDC_LayerCfgTypeDef
LTDC 句柄结构体 LTDC_HandleTypeDef

基本函数

HAL_LTDC_Init
HAL_LTDC_ConfigLayer
HAL_LTDC_SetAlpha
HAL_LTDC_Reload
HAL_LTDC_SetPixelFormat
HAL_LTDC_SetWindowPosition
HAL_LTDC_SetWindowSize_NoReload

电阻触摸和电容触摸

电阻触摸芯片 STMPE811 其实就是 ADC，返回的是 ADC 数值，而电容触摸芯片 GT811， GT911 和FT5X06 返回的是显示屏实际的坐标值。
使用电阻触摸芯片 STMPE811 需要做触摸校准，而使用电容触摸芯片 GT811， GT911 和 FT5X06 是自动校准的，无需手动校准。

过程

LTDC 显存使用 SDRAM

LTDC 的颜色格式是 32 位色 ARGB8888，那么所需要显存大小（单位字节）是：显示屏宽 * 显示屏高 * （32/8） , 其中 32/8 是表示这种颜色格式的一个像素点需要 4 个字节来表示。又比如配置颜色格式是 16 位色的 RGB565，那么需要的显存大小是：显示屏宽 * 显示屏高 *（16/8），其中 16/8 是表示这种颜色格式的一个像素点需要 2 个字节来表示。其它的颜色格式，依此类推。

LTDC 涉及到的引脚配置

LTDC 时钟和时序配置

具体查询屏幕手册

如何验证 LTDC 的时序配置是否正确

LCD_SetBackLight(BRIGHT_DEFAULT);
// 设置为红色
hltdc_F.Init.Backcolor.Blue = 0;
hltdc_F.Init.Backcolor.Green = 0;
hltdc_F.Init.Backcolor.Red = 255;

LTDC 图层配置

LCD 背光实现

LCD 的背光是 PWM 驱动方式

点阵字体和字符编码

GB2312

第一个字节从编号 0 到编号 127 的字符不变，还是表示 ASCII，而之后的 0xA1 到 0xFE 用于汉字编码，这个字节被称为汉字的区号或者高位字节， 0xA1 到 0xFE 换算成区号就是从 01 区到 94 区
第二个字节的 0xA1 到 0xFE 用于汉字编码，这个字节被称为汉字的位号或者低位字节， 0xA1 到 0xFE换算成位号就是从位号 01 到位号 94（换算关系就是对编码值减去 0xA0）。根据区号和位号的设置，那么就有 94*94 = 8836 个编码可供使用。在这些编码里，我们还把数学符号、罗马希腊字母、日文的假名都编码进去了，连在 ASCII 里本来就有的数字、标点、字母都统统重新编了两个字节长的编码，即全角字符，而原来在 127 号之前的那些字符称为半角字符。

电阻屏触摸校准原理(两点)

比如我们操作的显示屏分辨率是 800x480，电阻触摸芯片采用 STMPE811（12 位ADC，触摸值范围 0-4095），获得当前的触摸值是（1024, 2048），按照比例关系转换成坐标值就是(1024x800/4096， 2048x800/4096)，即（200， 400）。采用这种方法效果不好，容易出现点击不准确的问题。鉴于此原因，需要通过触摸校准在 ADC 数值和显示屏分辨率之间建立一个新的线性关系，**简单的说就是由比例关系 y = ax 升级为 y = ax + b。**如果有了新的触摸 ADC 数值，代入这个线性关系里面就可以得到当前实际的坐标值，触摸校准的作用就在这里了。具体实现原理图如下：在左上角和右下角分别设置两个坐标点（LcdX0, LcdY0）和（LcdX1, LcdY1），然后让用户去点击，会得到两组 ADC 数值（AdcX0， AdcY0）和（AdcX1, AdcY1）。

DMA2D

DMA2D 主要实现了两个功能，一个是 DMA 数据传输功能，另一个是 2D 图形加速功能。

DMA 数据传输:主要是两种方式，一个是寄存器到存储器，另一个是存储器到存储器。通过 DMA 可以大大降低 CPU的利用率。
2D 图形加速功能：支持硬件的颜色格式转换和 Alpha 混合效果。

DMA2D 工作模式

DMA2D 支持的工作模式如下：

模式 1：寄存器到存储器模式这个模式主要用于清屏，也即是将显示屏清为单色效果。
模式 2：存储器到存储器模式:这个模式用于从一个存储器复制一块数据到另一个存储器，比如将摄像头 OV7670 的输出图像复制到LCD 显存就可以采用这种方式。
模式 3：存储器到存储器模式，带颜色格式转换:这个模式比模式 2 多了一个颜色格式转换，比如我们要显示一幅 RGB888 颜色格式的位图到 RGB565颜色格式的显示屏，就需要用到这个模式，只需输入端配置为 RGB888，输出端配置 RGB565 即可。位图颜色格式转换后会显示到显示屏上。
模式 4：存储器到存储器模式，带颜色格式转换和混合:这个模式比模式 3 多了一个混合操作，通过混合，可以将两种效果进行混合显示。
模式 5：存储器到存储器模式，带颜色格式转换和混合，前景色是固定的:同模式 4，只是前景色的颜色值是固定的。

Usage

DMA2D 寄存器结构体 DMA2D_TypeDef
DMA2D 参数初始化结构体 DMA2D_InitTypeDef
DMA2D 的图层结构体 DMA2D_LayerCfgTypeDef
DMA2D 句柄结构体 DMA2D_HandleTypeDef

常用操作

_DMA2D_Fill
_DMA2D_Copy
_DMA2D_MixColorsBulk
_DMA2D_AlphaBlendingBulk
_DMA2D_DrawAlphaBitmap

转换 PNG 图片为 ARGB8888 格式位图

下载小软件 BmpCvt

硬件 JPEG 编解码

Usage

JPEG 寄存器结构体 JPEG_TypeDef
JPEG 的编解码参数结构体 JPEG_ConfTypeDef
JPEG 结构体句柄 JPEG_HandleTypeDef

查询式编解码函数 HAL_JPEG_Encode
HAL_JPEG_Decode
中断方式 HAL_JPEG_Encode_IT
HAL_JPEG_Decode_IT
DMA 方式 HAL_JPEG_Encode_DMA
HAL_JPEG_Decode

如果用户之前的数据已经处理完毕，需要插入新数据，会调用函数HAL_JPEG_GetDataCallback 输出缓冲区填充了给定大小的数据后，会调用回调函数 HAL_JPEG_DataReadyCallback

JPEG 解码时，如果解码成功，会调用回调函数 HAL_JPEG_InfoReadyCallback。
JPEG 编码操作结束后会调用回调函数 HAL_JPEG_EncodeCpltCallback。
JPEG 解码操作结束后，会调用回调函数 HAL_JPEG_DecodeCpltCallback。
操作过程中出现错误，会调用回调函数 HAL_JPEG_ErrorCallback，用户可以调用函数HAL_JPEG_GetError 获取错误类型。
HAL JPEG 默认使用的是 ISO/IEC 10918-1 规格量化表，如果要修改，可以调用函数HAL_JPEG_SetUserQuantTables 实现。
通过函数 HAL_JPEG_GetState 可以获取 JPEG 状态。

LVGL

SDMMC

“格式化软件下载”

DAC

RTT

RTT + DHT11 + ESP8266(mqtt)

HTTP 笔记 TCP/IP笔记

Sun, 12 Oct 2025 00:00:00 +0000

IP

IP 地址范围 / 示例	类型	说明
`127.0.0.0/8`（如 `127.0.0.1`）	本地	回环地址（Loopback），用于本机内部通信，所有发往该地址的数据包不会离开本机。
`::1`	本地	IPv6 的回环地址，等价于 IPv4 的 `127.0.0.1`。
`0.0.0.0`	本地（特殊）	表示“所有 IPv4 地址”或“未指定地址”，常用于服务监听所有本地网卡，不能用于网络通信目标。
`::`	本地（特殊）	IPv6 中的未指定地址，等价于 IPv4 的 `0.0.0.0`。
`10.0.0.0/8`	私有（本地网络）	私有 IP 地址段，用于局域网（如企业内网），不可在公网路由。
`172.16.0.0/12`	私有（本地网络）	私有 IP 地址段（172.16.0.0 – 172.31.255.255），用于内部网络。
`192.168.0.0/16`	私有（本地网络）	常见家用/小型办公局域网私有地址段（如 `192.168.1.1`）。
`169.254.0.0/16`	本地（链路本地）	链路本地地址（Link-Local），当 DHCP 失败时自动分配，仅在同一物理/逻辑链路内有效。
`fe80::/10`	本地（链路本地）	IPv6 链路本地地址，仅用于同一链路上的邻居通信。
公网 IP（如 `8.8.8.8`、`1.1.1.1`、`203.0.113.5` 等）	在线（公网）	可在全球互联网路由的 IP 地址，能被公网上的其他设备直接访问（假设无防火墙限制）。
任何不在上述私有/回环/特殊范围内的 IPv4 或 IPv6 地址	在线（公网）	默认视为公网 IP，可用于互联网通信。

特殊IP地址

受限广播地址：255.255.255.255（一般都被禁用）
直接广播地址：192.168.0.181（C类地址，它的主机号只有一个）
多播地址（D类地址）
环回地址：127.1.1.1
本网络本主机：0.0.0.0

HTTP

HTTP 方法

HTTP 方法	常见用途
GET	请求指定资源，用于获取数据（如网页、API数据），不应产生副作用。
POST	向指定资源提交数据，常用于表单提交、文件上传或创建新资源。
PUT	替换指定资源的全部内容，用于更新已有资源（幂等操作）。
PATCH	对资源进行部分修改，只更新指定字段（非幂等，但通常设计为幂等）。
DELETE	删除指定资源。
HEAD	类似于 GET，但服务器不返回响应体，仅返回响应头，用于获取资源元信息。
OPTIONS	获取目标资源支持的通信选项（如允许的 HTTP 方法），常用于 CORS 预检请求。
TRACE	回显服务器收到的请求，用于诊断或测试（出于安全考虑，通常被禁用）。
CONNECT	建立隧道连接，通常用于 HTTPS 代理或 WebSocket 协议升级。

HTTP 状态码

HTTP 状态码	状态码名称	常见含义与使用场景
200	OK	请求成功，服务器已成功处理请求并返回响应内容。
201	Created	请求成功并创建了新资源，通常用于 POST 或 PUT 操作成功后返回。
204	No Content	请求成功，但响应中不包含内容，常用于 DELETE 成功但无返回体的场景。
400	Bad Request	请求语法错误或参数非法，客户端应检查请求格式、参数是否符合 API 要求。
401	Unauthorized	请求缺少有效身份认证凭证（如 AccessKey 无效或缺失），需重新认证。
403	Forbidden	请求被服务器理解，但拒绝执行。常见原因包括权限不足、账号欠费、IP 被限制或 RAM 权限策略未授权。
404	Not Found	请求的资源不存在，可能因资源 ID 错误、服务未开通或路径拼写错误导致。
405	Method Not Allowed	请求使用了不被允许的 HTTP 方法（如对只读接口使用 POST）。
409	Conflict	请求与当前资源状态冲突，例如重复创建已存在的资源。
429	Too Many Requests	请求频率超过 API 限流阈值，触发限流策略。建议客户端降低调用频率或使用重试退避策略。
500	Internal Server Error	服务器内部错误，通常为服务端异常，建议稍后重试或联系技术支持。
502	Bad Gateway	网关或代理服务器从上游服务器收到无效响应，可能为后端服务异常。
503	Service Unavailable	服务暂时不可用，可能因系统维护、过载或依赖服务不可用导致。
504	Gateway Timeout	网关或代理服务器在等待上游服务响应时超时。

URL

`1`	`<scheme>://<user>:<password>@<host>:<port>/<path>;<params>?<query>#<frag>`

HTTP报文

请求报文

请求行
请求头（Headers）
空行
请求体（Body，可选）

// e.g. @GET请求
GET /index.html HTTP/1.1
Host: www.example.com
User-Agent: Mozilla/5.0
Accept: text/html
Connection: keep-alive

// POST请求
POST /login HTTP/1.1
Host: api.example.com
Content-Type: application/json
Content-Length: 36

{"username":"alice","password":"123456"}

// 网络调试助手
GET / HTTP/1.1\r\n
Host: www.baidu.com\r\n
\r\n

HTTP 响应报文

状态行
响应头（Headers）
空行
响应体（Body）

//e.g.
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 13
Server: nginx
Date: Thu, 29 Jan 2026 12:00:00 GMT

Hello, World!

MIME 类型

MIME 类型（Content-Type）	说明
`text/plain`	纯文本格式
`text/html`	HTML 文档
`text/css`	CSS 样式表文件
`text/javascript`	JavaScript 脚本（已逐渐被 `application/javascript` 取代）
`application/json`	JSON 数据格式，广泛用于 API 响应与请求体
`application/xml`	XML 数据格式
`application/octet-stream`	通用二进制流，常用于未知类型或文件下载
`application/pdf`	PDF 文档
`application/zip`	ZIP 压缩文件
`application/x-www-form-urlencoded`	表单数据（键值对），默认的 HTML 表单提交格式
`multipart/form-data`	用于包含文件上传的表单数据
`image/jpeg`	JPEG 图像格式
`image/png`	PNG 图像格式
`image/gif`	GIF 图像格式
`image/webp`	WebP 图像格式（现代高效压缩图像）
`audio/mpeg`	MP3 音频文件
`audio/ogg`	Ogg 音频容器格式
`video/mp4`	MP4 视频格式
`video/quicktime`	QuickTime 视频（.mov）
`font/woff`	WOFF 字体格式（Web Open Font Format）
`font/woff2`	WOFF2 字体格式（更高压缩率）
`application/vnd.ms-excel`	旧版 Microsoft Excel 文件（.xls）
`application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`	Excel 2007+ 文件（.xlsx）
`application/msword`	旧版 Microsoft Word 文档（.doc）
`application/vnd.openxmlformats-officedocument.wordprocessingml.document`	Word 2007+ 文档（.docx）
`application/vnd.ms-powerpoint`	旧版 PowerPoint 文件（.ppt）
`application/vnd.openxmlformats-officedocument.presentationml.presentation`	PowerPoint 2007+ 文件（.pptx）

邮件协议

协议名称	全称	端口（默认）	用途说明
SMTP	Simple Mail Transfer Protocol	25（明文） 465（SSL 加密） 587（STARTTLS 加密）	用于发送电子邮件，是邮件从客户端发送到服务器或服务器之间传输的标准协议。
POP3	Post Office Protocol version 3	110（明文） 995（SSL/TLS 加密）	用于从邮件服务器下载邮件到本地客户端，通常下载后会从服务器删除邮件（可配置保留）。
IMAP	Internet Message Access Protocol	143（明文） 993（SSL/TLS 加密）	用于在客户端与邮件服务器之间同步邮件，支持多设备访问、文件夹管理，邮件保留在服务器上。
STARTTLS	—	—	不是独立协议，而是一种命令机制，用于在 SMTP、POP3 或 IMAP 的明文连接上动态升级为加密连接（TLS）。

Nuxt4笔记

Sun, 12 Oct 2025 00:00:00 +0000

约定式路由

my-nuxt-app/
├─ app/
│  ├─ assets/		// 静态资源
│  ├─ components/	// 组件
│  ├─ composables/	// 组合式 API 函数
│  ├─ layouts/		// 布局（default.vue）
│  ├─ middleware/	// 中间件
│  ├─ pages/		// 页面（index.vue为默认页,[param].vue）
│  ├─ plugins/		// 注入全局功能
│  ├─ utils/		// 工具函数
│  ├─ app.vue
│  ├─ app.config.ts
│  └─ error.vue		// 错误页面
├─ content/			// 需要安装@nuxt/content，将md转换为page
├─ public/			// 直接暴露给浏览器的静态文件
├─ shared/
├─ server/			// 后端逻辑(./api/)
└─ nuxt.config.ts

Hooks概念

useFetch, &Fetch, useLazyFetch,useAsyncData

useFetch
在 服务端渲染时执行，首屏数据已经带在 HTML 中（SEO 友好）；
在 客户端导航时 会自动重新请求；
会自动缓存、解包响应（JSON 自动解析）；
<script setup lang="ts">
const { data, pending, error } = await useFetch('/api/user')
</script>

<template>
  <div v-if="pending">加载中...</div>
  <div v-else>{{ data }}</div>
</template>

const updatedUser = { id: 1, name: 'Updated Name' }

const { data, error } = await useFetch(`/api/users/${updatedUser.id}`, {
    method: 'PUT', // 或 'PATCH'
    body: updatedUser,
    params: {
    page: page.value,
    limit: limit.value
  }
})

$fetch
没有 SSR 自动序列化；
返回原始 Promise；
适合在 composable、middleware、server/api 或 事件回调中 使用；
可在服务端和客户端运行；
性能最高、控制最灵活。

useLazyFetch
类似 useFetch()，但不会在页面渲染时阻塞 SSR；
页面先渲染框架，然后异步加载数据；
适合非关键性数据（比如用户统计、推荐、评论等）。
const { data, pending } = useLazyFetch('/api/stats')

<template>
  <div>页面主内容</div>
  <div v-if="pending">加载统计中...</div>
  <div v-else>{{ data }}</div>
</template>


useAsyncData
执行任意异步函数
<script setup lang="ts">
const page = ref(1)
const { data: posts } = await useAsyncData(
  'posts',
  () => $fetch('https://fakeApi.com/posts', {
    params: {
      page: page.value
    }
  }), {
    watch: [page]
  }
)
</script>

useAsyncData

useCookeis

Create:
// 创建一个 cookie（自动创建）
const token = useCookie('token', {
  maxAge: 3600,   // 1小时
  path: '/',
  secure: true,   // 只在 HTTPS 下有效
  sameSite: 'lax'
})

// 设置值
token.value = 'abc123'

Read:
const token = useCookie('token')
console.log(token.value)  // "abc123"

Update:
const token = useCookie('token')
token.value = 'xyz789'   // 会覆盖原值

Delete:
const token = useCookie('token')
token.value = null

useState

`1`	`const count = useState('counter', () => Math.round(Math.random() * 100))`

标签概念

NuxtLink

//会翻译为<a>
<NuxtLink to="/about">关于页面</NuxtLink>

<NuxtLink :to="{ path: '/user', query: { id: 123, name: 'jhan' } }">打开用户页</NuxtLink>
// 接收
<script setup lang="ts">
const route = useRoute()
console.log(route.query.id)    // "123"
console.log(route.query.name)  // "jhan"
</script>

// 链接到静态文件
<NuxtLink to="/example-report.pdf" external>
  下载报告
</NuxtLink>

<NuxtLink to="https://nuxtjs.org">
  Nuxt 官网
</NuxtLink>

//activeClass 当前页面
<NuxtLink to="/" class="section-base block mb-2 p-3 rounded-lg no-underline text-gray-800 " activeClass="text-red-400"> 
  <h2 class="font-semibold">仪表盘</h2>
  <p class="text-sm text-gray-600">查看统计数据</p>
</NuxtLink>

NuxtImg

`1`	`npx nuxt module add image`

https://image.nuxt.com/usage/nuxt-img

`1`	`<NuxtImg src="/nuxt-icon.png" />`

其他概念

自定义layout

SSR/CSR 切换

SEO 优化与 sitemap

dotenv

首先需要注册

// nuxt.config.ts
export default defineNuxtConfig({
  runtimeConfig: {
    // 服务端可用
    apiSecret: process.env.API_SECRET,
    databaseUrl: process.env.DATABASE_URL,

    // 客户端也能访问
    public: {
      apiBase: process.env.PUBLIC_API_BASE
    }
  }
});


Usage:
back-end
export default defineEventHandler((event) => {
  const config = useRuntimeConfig();

  return {
    secret: config.apiSecret,         // 服务端变量
    db: config.databaseUrl,           // 服务端变量
    base: config.public.apiBase       // 客户端/服务端都能访问
  };
});


front-end
<script setup lang="ts">
const config = useRuntimeConfig()
const apiBase = config.public.apiBase

console.log('前端 API 地址:', apiBase)
</script>

构建 server api

例子：
server/
└── api/
    ├── devices.ts             // GET /api/devices
    ├── devices/[id].ts        // GET /api/devices/101
    ├── devices/[id].put.ts    // PUT /api/devices/101
    ├── devices/[id].delete.ts // DELETE /api/devices/101
    └── devices.post.ts        // POST /api/devices
    ~/server/api/foo/[...].ts  // 捕获所有路由
// server/api/devices/[id].ts
export default defineEventHandler(async (event) => {
  // 1. 获取 params （如 /devices/101）
  const id = Number(event.context.params?.id)
  // 2. 获取cookies
  const cookies = parseCookies(event);
  // 3. 获取 body （POST 数据）
  const body = await readBody(event)
  // 4. 获取 query 参数（如 ?page=1）
  const query = getQuery(event)
  const page = Number(query.page || 1)
  // 5. 使用中间件注入的 user
  const user = event.context.user
  // 返回数据
  return {
    id,
    user,
    cookies,
    body,
    page
  }
})



~/server/middleware/
auth.js
export default defineEventHandler((event) => {
  event.context.auth = { user: 123 }
})

错误处理

export default defineEventHandler((event) => {
  const id = parseInt(event.context.params.id) as number

  if (!Number.isInteger(id)) {
    throw createError({
      statusCode: 400,
      statusMessage: 'ID 应为整数',
    })
  }
  return '一切正常'
})

状态码
export default defineEventHandler((event) => {
  setResponseStatus(event, 202)
})

请求 Cookie
export default defineEventHandler((event) => {
  const cookies = parseCookies(event)

  return { cookies }
})

神人TV之如何解决特定路径中间件问题

export default defineEventHandler(async (event) => {
    if (!event.path.startsWith("/api/hello")) return;
    
    console.log("Hello middleware called");
});

使用插件

ElementPlus

暂未解决day.js问题

pinia

`1`	`yarn add pinia @pinia/nuxt`

持久化

SSR 仅支持 cookies docs npm i pinia-plugin-persistedstate

// stores/counter.ts
import { defineStore } from 'pinia'

export const useCounterStore = defineStore('counter', {
  state: () => ({
    count: 0,
    name: 'My Counter'
  }),

  getters: {
    doubleCount: (state) => state.count * 2
  },

  actions: {
    increment() {
      this.count++
    },
    reset() {
      this.count = 0
    }
  },
  persist: {
    storage: piniaPluginPersistedstate.cookies(),
  } 
}
)

animate.css

“anime.css manual”

yarn add animate.css

export default defineNuxtConfig({
  css: [
    'animate.css/animate.min.css',
  ],

tailwindcss, unocss

模板

error.vue
<script setup lang="ts">
import type { NuxtError } from '#app'

const props = defineProps({
  error: Object as () => NuxtError
})

const route = useRoute();
const isHome = route.path === '/';

const open2 = () => {
  ElNotification({
    title: 'Custom Position',
    message: "I'm at the bottom right corner",
    position: 'bottom-right',
    type:"warning"
  })
}
</script>

<template>
  <div class="flex min-h-screen items-center justify-center bg-gray-900 p-4">
    <div class="text-center text-white max-w-md w-full space-y-6 animate__animated animate__fadeIn">
      <Icon name="material-symbols:error-outline-rounded" size="64" class="text-white" />
      <h1 class="text-5xl font-bold">{{ error.statusCode }}</h1>
      <p class="text-gray-300 text-lg">
        {{ error.statusMessage || '页面加载失败' }}
      </p>
      <button
        v-if="isHome"
        @click="open2()"
        class="inline-block px-5 py-2.5 rounded-lg bg-green-600 text-white hover:bg-green-500 transition"
      >
        联系咨询
      </button>
      <NuxtLink
        v-else
        to="/"
        class="inline-block px-5 py-2.5 rounded-lg bg-blue-600 text-white hover:bg-blue-500 transition"
      >
        返回首页
      </NuxtLink>
    </div>
  </div>
</template>

image.vue
<template>
  <div
    class="relative w-2xs h-2xs overflow-hidden rounded-lg hover:brightness-[0.7] transform duration-500 shadow-2xl hover:shadow-none flex items-center justify-center"
  >
    <div v-if="hasError" class="absolute w-full h-full flex flex-col items-center justify-center text-4xl text-red-900">
      <Icon name="material-symbols:error-outline" />
      <p class="text-lg mt-2">Loading error!</p>
    </div>
    <a
      v-show="!hasError"
      :href="src"
      data-fancybox="gallery"
      :data-caption="alt"
    >
      <NuxtImg
        :src="src"
        :alt="alt || ''"
        format="webp"
        densities="x1 x2"
        class="object-cover w-full h-full transition-opacity duration-300 ease-in-out cursor-pointer"
        @load="onImageLoad"
        @error="onImageError"
      />
    </a>

    <div
      v-if="isLoading && !hasError"
      class="absolute inset-0 bg-gradient-to-r from-gray-200 via-gray-300 to-gray-200 bg-[length:200%_100%] animate-shimmer z-0"
    ></div>
  </div>
</template>

<script setup lang="ts">
import { ref, onMounted } from 'vue'
import { Fancybox } from '@fancyapps/ui'
import '@fancyapps/ui/dist/fancybox/fancybox.css'

const props = defineProps({
  src: {
    type: String,
    required: true
  },
  alt: {
    type: String,
    default: ''
  }
})

const isLoading = ref(true)
const hasError = ref(false)

const onImageLoad = () => {
  isLoading.value = false
  hasError.value = false
}

const onImageError = () => {
  isLoading.value = false
  hasError.value = true
  console.warn(`Image failed to load: ${props.src}`)
}

onMounted(() => {
  Fancybox.bind('[data-fancybox="gallery"]', {})
})
</script>

<style scoped>
@keyframes shimmer {
  0% {
    background-position: -200% 0;
  }
  100% {
    background-position: 200% 0;
  }
}

.animate-shimmer {
  animation: shimmer 1.5s infinite linear;
}
</style>

icon

“iconfiy”

npx nuxi module add icon

uasge:
<Icon name="material-symbols:14mp" style="color: #000fff" :size="38"/>

如何查看icon名称？
Component - Iconfiy Icon

减少服务器存储的bundle
export default defineNuxtConfig({
  modules: ['@nuxt/icon'],
  icon: {
    serverBundle: {
      collections: ['uil', 'mdi']
    }
  }
})

杂项

懒加载

stm32f103c8t6 库移植

Sun, 12 Oct 2025 00:00:00 +0000

本教程使用的是标准库

u8g2

“u8g2 github”
“u8g2 官方的移植文档”

Pre

只要复制csrc文件夹改名称为u8g2_libs
对于u8g2_d_*** 的文件，保留你屏幕使用的驱动，这里使用ssd_1306,所以选择u8g2_d_ssd1306_128x64_noname_f
精简u8g2_fonts.c，u8g2_d_setup.c, u8g2_d_memory.c 对于 u8g2_fonts 建议是根据需要保留字体
“u8g2 字体查看”
对于 u8g2_d_setup.c 保留这个函数 u8g2_Setup_ssd1306_i2c_128x64_noname_f(u8g2, U8G2_R0, u8x8_byte_sw_i2c, u8x8_gpio_and_delay)
对于 u8g2_d_memory.c 只要保留上面使用到的 u8g2_m_16_8_f(&tile_buf_height);

软件iic

u8g2提供的模板，需要你自己填写，建议放在存放u8g2_init函数的文件内:

uint8_t u8x8_gpio_and_delay_template(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
  switch(msg)
  {
    case U8X8_MSG_GPIO_AND_DELAY_INIT:	// called once during init phase of u8g2/u8x8
      break;							// can be used to setup pins
    case U8X8_MSG_DELAY_NANO:			// delay arg_int * 1 nano second
      break;    
    case U8X8_MSG_DELAY_100NANO:		// delay arg_int * 100 nano seconds
      break;
    case U8X8_MSG_DELAY_10MICRO:		// delay arg_int * 10 micro seconds
      break;
    case U8X8_MSG_DELAY_MILLI:			// delay arg_int * 1 milli second
      break;
    case U8X8_MSG_DELAY_I2C:				// arg_int is the I2C speed in 100KHz, e.g. 4 = 400 KHz
      break;							// arg_int=1: delay by 5us, arg_int = 4: delay by 1.25us
    case U8X8_MSG_GPIO_D0:				// D0 or SPI clock pin: Output level in arg_int
    //case U8X8_MSG_GPIO_SPI_CLOCK:
      break;
    case U8X8_MSG_GPIO_D1:				// D1 or SPI data pin: Output level in arg_int
    //case U8X8_MSG_GPIO_SPI_DATA:
      break;
    case U8X8_MSG_GPIO_D2:				// D2 pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_D3:				// D3 pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_D4:				// D4 pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_D5:				// D5 pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_D6:				// D6 pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_D7:				// D7 pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_E:				// E/WR pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_CS:				// CS (chip select) pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_DC:				// DC (data/cmd, A0, register select) pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_RESET:			// Reset pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_CS1:				// CS1 (chip select) pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_CS2:				// CS2 (chip select) pin: Output level in arg_int
      break;
    case U8X8_MSG_GPIO_I2C_CLOCK:		// arg_int=0: Output low at I2C clock pin
      break;							// arg_int=1: Input dir with pullup high for I2C clock pin
    case U8X8_MSG_GPIO_I2C_DATA:			// arg_int=0: Output low at I2C data pin
      break;							// arg_int=1: Input dir with pullup high for I2C data pin
    case U8X8_MSG_GPIO_MENU_SELECT:
      u8x8_SetGPIOResult(u8x8, /* get menu select pin state */ 0);
      break;
    case U8X8_MSG_GPIO_MENU_NEXT:
      u8x8_SetGPIOResult(u8x8, /* get menu next pin state */ 0);
      break;
    case U8X8_MSG_GPIO_MENU_PREV:
      u8x8_SetGPIOResult(u8x8, /* get menu prev pin state */ 0);
      break;
    case U8X8_MSG_GPIO_MENU_HOME:
      u8x8_SetGPIOResult(u8x8, /* get menu home pin state */ 0);
      break;
    default:
      u8x8_SetGPIOResult(u8x8, 1);			// default return value
      break;
  }
  return 1;
}

一个示例

#define SCL_Pin GPIO_Pin_8
#define SDA_Pin GPIO_Pin_9
#define IIC_GPIO_Port GPIOB

void IIC_Init(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE );

	GPIO_InitStructure.GPIO_Pin = SCL_Pin|SDA_Pin;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD ;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(IIC_GPIO_Port, &GPIO_InitStructure);
} 

uint8_t u8x8_gpio_and_delay(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
   switch (msg)
   {
	   	case U8X8_MSG_DELAY_100NANO:
		   	__NOP();
		   	break;
	   	case U8X8_MSG_DELAY_10MICRO:
		   	for (uint16_t n = 0; n < 320; n++)
		   	{
			   	__NOP();
		   	}
		   	break;
	   	case U8X8_MSG_DELAY_MILLI:
		   Delay_ms(1);
		   break;
	   	case U8X8_MSG_DELAY_I2C:
		   Delay_us(5);
		   break;
	   	case U8X8_MSG_GPIO_I2C_CLOCK:
		    arg_int ? GPIO_SetBits(IIC_GPIO_Port,SCL_Pin) : GPIO_ResetBits(IIC_GPIO_Port, SCL_Pin);
			break;
		case U8X8_MSG_GPIO_I2C_DATA:
			arg_int ? GPIO_SetBits(IIC_GPIO_Port,SDA_Pin) : GPIO_ResetBits(IIC_GPIO_Port, SDA_Pin);
		   	break;
	   	default:
		   	u8x8_SetGPIOResult(u8x8, 1);
		   	break;
	}
   	return 1;
}

void u8g2Init(u8g2_t *u8g2)
{
    u8g2_Setup_ssd1306_i2c_128x64_noname_f(u8g2, U8G2_R0, u8x8_byte_sw_i2c, u8x8_gpio_and_delay);
    u8g2_InitDisplay(u8g2);
    u8g2_SetPowerSave(u8g2, 0);
    u8g2_ClearBuffer(u8g2);
}

intro

void u8g2_Setup_ssd1306_i2c_128x64_noname_f(u8g2_t *u8g2, const u8g2_cb_t *rotation, u8x8_msg_cb byte_cb, u8x8_msg_cb gpio_and_delay_cb);
1.屏幕句柄
2.旋转方向
3.u8g2_mirror 是否镜像
4.u8g2_mirror_vertial

/**
 * 画实心矩形，左上角坐标为(x,y),宽度为w，高度为h
 * @param x 左上角的x坐标
 * @param y 左上角的y坐标
 * @param w 方形的宽度
 * @param h 方形的高度
 */
void u8g2_DrawBox(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t w, u8g2_uint_t h)

void u8g2_SetDrawColor(u8g2_t *u8g2, uint8_t color)

/**
 * 画空心圆，圆心坐标为(x0,y0),半径为rad
 * @param x0 圆点的x坐标
 * @param y0 圆点的y坐标
 * @param rad 圆形的半径
 * @param opt 圆形选项
 *        U8G2_DRAW_ALL 整个圆
 *        U8G2_DRAW_UPPER_RIGHT 右上部分的圆弧
 *        U8G2_DRAW_UPPER_LEFT  左上部分的圆弧
 *        U8G2_DRAW_LOWER_LEFT  左下部分的圆弧
 *        U8G2_DRAW_LOWER_RIGHT 右下部分的圆弧
 *        选项可以通过 | 操作符来组合
 */
void u8g2_DrawCircle(u8g2_t *u8g2, u8g2_uint_t x0, u8g2_uint_t y0, u8g2_uint_t rad, uint8_t option)

/**
 * 画实心圆，圆心坐标为(x0,y0),半径为rad
 * @param x0 圆点的x坐标
 * @param y0 圆点的y坐标
 * @param rad 圆形的半径
 * @param opt 圆形选项
 *        U8G2_DRAW_ALL 整个圆
 *        U8G2_DRAW_UPPER_RIGHT 右上部分的圆弧
 *        U8G2_DRAW_UPPER_LEFT  左上部分的圆弧
 *        U8G2_DRAW_LOWER_LEFT  左下部分的圆弧
 *        U8G2_DRAW_LOWER_RIGHT 右下部分的圆弧
 *       选项可以通过 | 操作符来组合
 */
void u8g2_DrawDisc(u8g2_t *u8g2, u8g2_uint_t x0, u8g2_uint_t y0, u8g2_uint_t rad, uint8_t option)

/**
 * 画空心椭圆，圆心坐标为(x0,y0),半径为rad
 * @param x0 圆点的x坐标
 * @param y0 圆点的y坐标
 * @param rx 椭圆形水平x方向的半径
 * @param ry 椭圆形竖直y方向的半径
 * @param opt 圆形选项
 *        U8G2_DRAW_ALL 整个椭圆
 *        U8G2_DRAW_UPPER_RIGHT 右上部分的圆弧
 *        U8G2_DRAW_UPPER_LEFT  左上部分的圆弧
 *        U8G2_DRAW_LOWER_LEFT  左下部分的圆弧
 *        U8G2_DRAW_LOWER_RIGHT 右下部分的圆弧
 *        选项可以通过 | 操作符来组合
 */
void u8g2_DrawEllipse(u8g2_t *u8g2, u8g2_uint_t x0, u8g2_uint_t y0, u8g2_uint_t rx, u8g2_uint_t ry, uint8_t option)

/**
 * 构造U8G2对象，初始化显示库。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param rotation 显示旋转角度（0, 90, 180, 270）
 * @param cb 回调函数，用于硬件通信
 * @param font 字体指针（可选）
 */
void u8g2_Setup(u8g2_t *u8g2, const u8g2_cb_t *rotation, u8x8_msg_cb byte_cb, u8x8_msg_cb gpio_and_delay_cb);

/**
 * 简化版初始化，自动选择合适的回调函数。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param rotation 显示旋转角度
 * @param byte_cb 字节传输回调
 * @param gpio_and_delay_cb GPIO和延时回调
 */
void u8g2_Begin(u8g2_t *u8g2);

/**
 * 初始化显示控制器，通常由begin()内部调用。
 * @param u8g2 指向u8g2_t结构体的指针
 */
void u8g2_InitDisplay(u8g2_t *u8g2);

/**
 * 清除屏幕上的所有内容（物理屏幕）。
 * @param u8g2 指向u8g2_t结构体的指针
 */
void u8g2_ClearDisplay(u8g2_t *u8g2);

/**
 * 设置省电模式。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param is_enable 1开启省电，0关闭省电
 */
void u8g2_SetPowerSave(u8g2_t *u8g2, uint8_t is_enable);

/**
 * 清除绘图缓冲区的内容（内存中的画布）。
 * @param u8g2 指向u8g2_t结构体的指针
 */
void u8g2_ClearBuffer(u8g2_t *u8g2);

/**
 * 禁用UTF-8打印功能。
 * @param u8g2 指向u8g2_t结构体的指针
 */
void u8g2_DisableUTF8Print(u8g2_t *u8g2);

/**
 * 启用UTF-8打印功能（支持中文等）。
 * @param u8g2 指向u8g2_t结构体的指针
 */
void u8g2_EnableUTF8Print(u8g2_t *u8g2);

/**
 * 将光标位置重置到屏幕左上角(0,0)。
 * @param u8g2 指向u8g2_t结构体的指针
 */
void u8g2_Home(u8g2_t *u8g2);

/**
 * 画一个实心矩形。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x 左上角x坐标
 * @param y 左上角y坐标
 * @param w 宽度
 * @param h 高度
 */
void u8g2_DrawBox(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t w, u8g2_uint_t h);

/**
 * 画一个空心圆。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x 圆心x坐标
 * @param y 圆心y坐标
 * @param r 半径
 */
void u8g2_DrawCircle(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t rad);

/**
 * 画一个实心圆。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x 圆心x坐标
 * @param y 圆心y坐标
 * @param r 半径
 */
void u8g2_DrawDisc(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t rad);

/**
 * 画一个空心椭圆。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x0 圆心x坐标
 * @param y0 圆心y坐标
 * @param rx 水平半径
 * @param ry 垂直半径
 * @param opt 绘制选项 (U8G2_DRAW_ALL, U8G2_DRAW_UPPER_RIGHT等)
 */
void u8g2_DrawEllipse(u8g2_t *u8g2, u8g2_uint_t x0, u8g2_uint_t y0, u8g2_uint_t rx, u8g2_uint_t ry, uint8_t option);

/**
 * 画一个实心椭圆。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x0 圆心x坐标
 * @param y0 圆心y坐标
 * @param rx 水平半径
 * @param ry 垂直半径
 */
void u8g2_DrawFilledEllipse(u8g2_t *u8g2, u8g2_uint_t x0, u8g2_uint_t y0, u8g2_uint_t rx, u8g2_uint_t ry);

/**
 * 画一个空心矩形边框。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x 左上角x坐标
 * @param y 左上角y坐标
 * @param w 宽度
 * @param h 高度
 */
void u8g2_DrawFrame(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t w, u8g2_uint_t h);

/**
 * 画单个字符（较少用）。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x 起始x坐标
 * @param y 起始y坐标
 * @param encoding 字符编码
 */
void u8g2_DrawGlyph(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, uint16_t encoding);

/**
 * 画一条水平线。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x 起始x坐标
 * @param y y坐标
 * @param len 长度
 */
void u8g2_DrawHLine(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t len);

/**
 * 画一条直线。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x1 起点x坐标
 * @param y1 起点y坐标
 * @param x2 终点x坐标
 * @param y2 终点y坐标
 */
void u8g2_DrawLine(u8g2_t *u8g2, u8g2_uint_t x1, u8g2_uint_t y1, u8g2_uint_t x2, u8g2_uint_t y2);

/**
 * 画一个像素点。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x x坐标
 * @param y y坐标
 */
void u8g2_DrawPixel(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y);

/**
 * 画一个带圆角的实心矩形。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x 左上角x坐标
 * @param y 左上角y坐标
 * @param w 宽度
 * @param h 高度
 * @param r 圆角半径
 */
void u8g2_DrawRBox(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t w, u8g2_uint_t h, u8g2_uint_t r);

/**
 * 画一个带圆角的空心矩形边框。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x 左上角x坐标
 * @param y 左上角y坐标
 * @param w 宽度
 * @param h 高度
 * @param r 圆角半径
 */
void u8g2_DrawRFrame(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t w, u8g2_uint_t h, u8g2_uint_t r);

/**
 * 画字符串。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x 起始x坐标
 * @param y 起始y坐标
 * @param str 字符串
 */
void u8g2_DrawStr(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, const char *str);

/**
 * 画一个实心三角形。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x1 第一个顶点x坐标
 * @param y1 第一个顶点y坐标
 * @param x2 第二个顶点x坐标
 * @param y2 第二个顶点y坐标
 * @param x3 第三个顶点x坐标
 * @param y3 第三个顶点y坐标
 */
void u8g2_DrawTriangle(u8g2_t *u8g2, u8g2_uint_t x1, u8g2_uint_t y1, u8g2_uint_t x2, u8g2_uint_t y2, u8g2_uint_t x3, u8g2_uint_t y3);

/**
 * 画UTF-8编码的字符串（支持中文）。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x 起始x坐标
 * @param y 起始y坐标
 * @param str UTF-8字符串
 */
void u8g2_DrawUTF8(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, const char *str);

/**
 * 画一条竖直线。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x x坐标
 * @param y 起始y坐标
 * @param len 长度
 */
void u8g2_DrawVLine(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t len);

/**
 * 画位图图片。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x 起始x坐标
 * @param y 起始y坐标
 * @param w 图片宽度
 * @param h 图片高度
 * @param data 图片数据数组
 */
void u8g2_DrawXBM(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t w, u8g2_uint_t h, const uint8_t *data);

/**
 * 开始分页绘制的第一帧。
 * @param u8g2 指向u8g2_t结构体的指针
 * @return 返回1表示有更多页，0表示结束
 */
uint8_t u8g2_FirstPage(u8g2_t *u8g2);

/**
 * 绘制下一页。
 * @param u8g2 指向u8g2_t结构体的指针
 * @return 返回1表示有更多页，0表示结束
 */
uint8_t u8g2_NextPage(u8g2_t *u8g2);

/**
 * 将缓冲区内容发送到屏幕显示。
 * @param u8g2 指向u8g2_t结构体的指针
 */
void u8g2_SendBuffer(u8g2_t *u8g2);

/**
 * 获取当前字体中字符基线以上的高度。
 * @param u8g2 指向u8g2_t结构体的指针
 * @return 高度值
 */
int8_t u8g2_GetAscent(u8g2_t *u8g2);

/**
 * 获取当前字体中字符基线以下的高度。
 * @param u8g2 指向u8g2_t结构体的指针
 * @return 高度值
 */
int8_t u8g2_GetDescent(u8g2_t *u8g2);

/**
 * 获取显示器的高度。
 * @param u8g2 指向u8g2_t结构体的指针
 * @return 屏幕高度
 */
u8g2_uint_t u8g2_GetDisplayHeight(u8g2_t *u8g2);

/**
 * 获取显示器的宽度。
 * @param u8g2 指向u8g2_t结构体的指针
 * @return 屏幕宽度
 */
u8g2_uint_t u8g2_GetDisplayWidth(u8g2_t *u8g2);

/**
 * 获取当前字体中最大字符的高度。
 * @param u8g2 指向u8g2_t结构体的指针
 * @return 最大高度
 */
uint8_t u8g2_GetMaxCharHeight(u8g2_t *u8g2);

/**
 * 获取当前字体中最大字符的宽度。
 * @param u8g2 指向u8g2_t结构体的指针
 * @return 最大宽度
 */
uint8_t u8g2_GetMaxCharWidth(u8g2_t *u8g2);

/**
 * 获取字符串在当前字体下的像素宽度。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param str 字符串
 * @return 像素宽度
 */
u8g2_uint_t u8g2_GetStrWidth(u8g2_t *u8g2, const char *str);

/**
 * 获取UTF-8字符串的像素宽度。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param str UTF-8字符串
 * @return 像素宽度
 */
u8g2_uint_t u8g2_GetUTF8Width(u8g2_t *u8g2, const char *str);

/**
 * 设置是否在每次分页时自动清空缓冲区。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param enable 1启用，0禁用
 */
void u8g2_SetAutoPageClear(u8g2_t *u8g2, uint8_t enable);

/**
 * 设置位图绘制模式（如透明/不透明）。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param mode 0为不透明，1为透明
 */
void u8g2_SetBitmapMode(u8g2_t *u8g2, uint8_t mode);

/**
 * 设置总线时钟频率（高级用法）。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param clock_freq 时钟频率（Hz）
 */
void u8g2_SetBusClock(u8g2_t *u8g2, uint32_t clock_freq);

/**
 * 设置绘图裁剪窗口。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param x 起始x坐标
 * @param y 起始y坐标
 * @param w 宽度
 * @param h 高度
 */
void u8g2_SetClipWindow(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t w, u8g2_uint_t h);

/**
 * 设置显示器的旋转角度。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param rotation 旋转角度 (0, 90, 180, 270)
 */
void u8g2_SetDisplayRotation(u8g2_t *u8g2, uint8_t rotation);

/**
 * 设置绘图颜色（前景色/背景色）。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param color 0为背景色，1为前景色
 */
void u8g2_SetDrawColor(u8g2_t *u8g2, uint8_t color);

/**
 * 设置当前使用的字体。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param font 字体指针
 */
void u8g2_SetFont(u8g2_t *u8g2, const uint8_t *font);

/**
 * 设置字体方向（从左到右或从右到左）。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param direction 0为从左到右，1为从右到左
 */
void u8g2_SetFontDirection(u8g2_t *u8g2, uint8_t direction);

/**
 * 获取缓存空间的地址。
 * @param u8g2 指向u8g2_t结构体的指针
 * @return 缓冲区指针
 */
uint8_t *u8g2_GetBufferPtr(u8g2_t *u8g2);

/**
 * 获取缓冲区的Tile高度。
 * @param u8g2 指向u8g2_t结构体的指针
 * @return Tile高度
 */
uint8_t u8g2_GetBufferTileHeight(u8g2_t *u8g2);

/**
 * 获取缓冲区的Tile宽度。
 * @param u8g2 指向u8g2_t结构体的指针
 * @return Tile宽度
 */
uint8_t u8g2_GetBufferTileWidth(u8g2_t *u8g2);

/**
 * 获取缓冲区的当前Tile行号。
 * @param u8g2 指向u8g2_t结构体的指针
 * @return 当前行号
 */
uint8_t u8g2_GetBufferCurrTileRow(u8g2_t *u8g2);

/**
 * 设置缓冲区的当前Tile行号。
 * @param u8g2 指向u8g2_t结构体的指针
 * @param row 行号
 */
void u8g2_SetBufferCurrTileRow(u8g2_t *u8g2, uint8_t row);

使用icon

icon list

1
2

u8g2_SetFont(u8g2, u8g2_font_open_iconic_all_4x_t);
u8g2_DrawGlyph(u8g2, 0, 60, 64);

使用自己的字模

`1`	`extern const uint8_t zhaocha[] U8G2_FONT_SECTION("***");`

预设

横向重复滚动

char scroll_text[] = "hello world! ";
uint16_t scroll_offset = 0;

void my_draw(u8g2_t *u8g2)
{
    u8g2_ClearBuffer(u8g2);

    u8g2_SetFont(u8g2, u8g2_font_chargen_92_te);

    uint8_t screen_w = u8g2_GetDisplayWidth(u8g2);
    uint8_t screen_h = u8g2_GetDisplayHeight(u8g2);
    uint16_t text_width = u8g2_GetStrWidth(u8g2, scroll_text);

    uint8_t y = screen_h / 2 + u8g2_GetAscent(u8g2) / 2;

    scroll_offset+= 5;
    if (scroll_offset > text_width + screen_w) {
        scroll_offset = 0;
    }

    // 画两次文本，实现无缝滚动
    u8g2_DrawStr(u8g2, screen_w - scroll_offset, y, scroll_text);
    u8g2_DrawStr(u8g2, screen_w - scroll_offset + text_width + 5, y, scroll_text);

    u8g2_SendBuffer(u8g2);
}

SPIFFS

“SPIFFS github”

#include "spiffs.h"
#include "w25q32.h"  // 你的 W25Q32 驱动

// SPIFFS 工作区（必须 4 字节对齐）
static u8_t spiffs_work_buf[LOG_PAGE_SIZE * 2];
static u8_t spiffs_fds[32 * 4];
static u8_t spiffs_cache[(LOG_PAGE_SIZE + 32) * 4];

// HAL 函数：SPIFFS 调用
static s32_t my_spi_read(u32_t addr, u32_t size, u8_t *dst) {
    w25q32_read(addr, dst, size);
    return SPIFFS_OK;
}

static s32_t my_spi_write(u32_t addr, u32_t size, const u8_t *src) {
    w25q32_write(addr, (u8_t*)src, size);  // 内部已处理页写入和 busy 等待
    return SPIFFS_OK;
}

static s32_t my_spi_erase(u32_t addr, u32_t size) {
    // SPIFFS 默认每次擦除 1 个 block（这里设为 4KB）
    for (u32_t i = 0; i < size; i += 4096) {
        w25q32_sector_erase(addr + i);  // 擦除 4KB 扇区
    }
    return SPIFFS_OK;
}

// 初始化 SPIFFS
int spiffs_init(void) {
    spiffs_config cfg = {0};
    cfg.phys_size = 1024 * 1024;        // 使用前 1MB（可改）
    cfg.phys_addr = 0;                  // 从 Flash 起始地址开始
    cfg.phys_erase_block = 4096;        // W25Q32 扇区大小 4KB
    cfg.log_block_size = 4096;          // 逻辑块 = 物理块
    cfg.log_page_size = 256;            // 页大小（W25Q32 页写 256B）

    cfg.hal_read_f = my_spi_read;
    cfg.hal_write_f = my_spi_write;
    cfg.hal_erase_f = my_spi_erase;

    int res = SPIFFS_mount(&fs, &cfg,
        spiffs_work_buf, spiffs_fds, sizeof(spiffs_fds),
        spiffs_cache, sizeof(spiffs_cache), NULL);

    if (res != SPIFFS_OK) {
        // 首次使用需格式化
        SPIFFS_format(&fs);
        res = SPIFFS_mount(&fs, &cfg,
            spiffs_work_buf, spiffs_fds, sizeof(spiffs_fds),
            spiffs_cache, sizeof(spiffs_cache), NULL);
    }
    return res;
}

// 使用示例：写文件
void test_spiffs(void) {
    spiffs_file fd = SPIFFS_open(&fs, "hello.txt", SPIFFS_CREAT | SPIFFS_RDWR, 0);
    const char *msg = "Hello, SPIFFS on W25Q32!";
    SPIFFS_write(&fs, fd, (void*)msg, strlen(msg));
    SPIFFS_close(&fs, fd);

    // 读回来
    fd = SPIFFS_open(&fs, "hello.txt", SPIFFS_RDONLY, 0);
    char buf[50] = {0};
    SPIFFS_read(&fs, fd, buf, sizeof(buf));
    SPIFFS_close(&fs, fd);
    // buf 现在是 "Hello, SPIFFS on W25Q32!"
}

LittleFS

#include "lfs.h"

// variables used by the filesystem
lfs_t lfs;
lfs_file_t file;

// configuration of the filesystem is provided by this struct
const struct lfs_config cfg = {
    // block device operations
    .read  = user_provided_block_device_read,
    .prog  = user_provided_block_device_prog,
    .erase = user_provided_block_device_erase,
    .sync  = user_provided_block_device_sync,

    // block device configuration
    .read_size = 16,
    .prog_size = 16,
    .block_size = 4096,
    .block_count = 128,
    .cache_size = 16,
    .lookahead_size = 16,
    .block_cycles = 500,
};


// 主要是手动实现
.read  = user_provided_block_device_read,
.prog  = user_provided_block_device_prog,
.erase = user_provided_block_device_erase,
.sync  = user_provided_block_device_sync,

MISRA C:2012 笔记

Sun, 05 Oct 2025 00:00:00 +0000

一、命名总体要求

Rule 5.1：标识符长度 ≤ 31 个字符（前 31 字符内必须唯一）
Rule 5.2：同一作用域中，名称不得仅以大小写区分
Rule 5.3：不同作用域的相似名称应避免混淆
Rule 5.4：宏名不能与变量、函数或类型名冲突
Rule 5.5：外部标识符（全局）在整个工程中必须唯一
Rule 5.6：禁止使用与标准库同名的标识符
Rule 5.7：命名应反映作用域（如 g_, s_ 前缀）
Directive 4.1：全项目需使用一致的命名约定

二、命名风格总览

类型	前缀	风格	示例	说明
宏常量	无或模块前缀	全大写 + 下划线	`MAX_TEMP`, `MOTOR_SPEED_LIMIT`	一眼识别为常量
全局变量	`g_`	小写 + 下划线	`g_sensor_value`	作用域：全局
文件内静态变量	`s_`	小写 + 下划线	`s_error_count`	作用域：文件内
局部变量	无	小写 + 下划线	`temp_value`, `index_count`	作用域：函数内
函数名	模块前缀 + 动词_名词	小写 + 下划线	`sensor_read_data()`	命名体现行为
类型（typedef）	模块前缀 + 首字母大写 + `_t` 后缀	PascalCase + `_t`	`SensorData_t`, `MotorState_t`	便于识别自定义类型
枚举成员	模块前缀 + 全大写	全大写 + 下划线	`SENSOR_OK`, `SENSOR_ERROR`	避免跨模块冲突

三、命名规范示例代码

#include <stdint.h>

/* -------------------------------
 * Rule 5.1, 5.2: 唯一且不混淆命名
 * Rule 5.7: 前缀反映作用域
 * ------------------------------- */

/* 宏定义：全大写 + 下划线 */
#define MAX_TEMP_VALUE      (100U)    /* Rule 5.4: 宏名不得与变量重名 */
#define SENSOR_COUNT        (4U)

/* 类型定义：模块前缀 + PascalCase + _t 后缀 */
typedef struct
{
    uint16_t temperature;
    uint16_t voltage;
} SensorData_t;

/* 枚举：全大写 + 模块前缀 */
typedef enum
{
    SENSOR_OK,
    SENSOR_ERROR
} SensorStatus_t;

/* 全局变量：g_ 前缀 */
SensorData_t g_sensorData;        /* 全局传感器数据 */
uint8_t      g_systemMode;        /* 系统模式标志 */

/* 文件内静态变量：s_ 前缀 */
static uint16_t s_errorCount = 0U;

/* 函数命名：模块前缀 + 动词_名词 */
void Sensor_Init(void);            /* 初始化传感器 */
SensorStatus_t Sensor_ReadData(SensorData_t* data); /* 读取传感器数据 */

/* -------------------------------
 * Rule 5.3: 避免相似名称混淆
 * Rule 15.6: 所有控制语句应使用 {}
 * ------------------------------- */

void Sensor_Init(void)
{
    g_sensorData.temperature = 0U;
    g_sensorData.voltage     = 0U;
    s_errorCount = 0U;
}

/* 函数参数使用小写下划线命名 */
SensorStatus_t Sensor_ReadData(SensorData_t* sensor_data)
{
    if (sensor_data == NULL)
    {
        s_errorCount++;
        return SENSOR_ERROR;
    }

    sensor_data->temperature = 25U;
    sensor_data->voltage     = 3300U;
    return SENSOR_OK;
}

四、命名规范检查清单（Checklist）

所有标识符长度 ≤ 31 个字符（Rule 5.1）
不存在仅大小写不同的标识符（Rule 5.2）
不存在跨作用域的相似命名（Rule 5.3）
宏名与其他标识符无重名（Rule 5.4）
所有全局标识符在项目中唯一（Rule 5.5）
不与标准库符号冲突（Rule 5.6）
前缀区分作用域（Rule 5.7）
全项目命名风格一致（Directive 4.1）

五、命名风格推荐

推荐使用 小写 + 下划线（snake_case） 为主风格，结合前缀区分作用域与类型，命名应反映语义。

例如：

/* 模块名：Motor */
void Motor_Start(void);
void Motor_Stop(void);
MotorState_t Motor_GetState(void);

六、总结

MISRA C 不强制具体命名风格，但要求：

唯一、无歧义、可读；
作用域区分明显；
全项目一致；
宏、类型、变量、函数命名规则清晰。

遵守以上规范有助于：

降低审查警告；
减少命名冲突；
提高团队协作与代码可维护性。

ElasticSearch 笔记

Sat, 06 Sep 2025 00:00:00 +0000

js版

import { Client } from '@elastic/elasticsearch';

const esClient = new Client({
  node: 'http://localhost:9200',
  auth: {
    username: 'elastic',
    password: '...',
  }
});

async function ensureIndexExist() {
  const indexName = 'documents';

  const exist = await esClient.indices.exists({ index: indexName });

  if (!exist) {
    await esClient.indices.create({
      index: indexName,
      body: {
        mappings: {
          properties: {
            title: { type: 'text' },
            content: { type: 'text' },
            createAt: { type: 'date' },
          }
        }
      }
    });
  }
}

// 初始化索引
await ensureIndexExist().catch(console.error);

app.post('/doc', async (req, res) => {
  try {
    const { title, content } = req.body;

    if (!title || !content) {
      return res.status(400).json({ error: "title and content required" });
    }

    const doc = {
      title,
      content,
      createAt: new Date().toISOString()
    };

    const result = await esClient.index({
      index: 'documents',
      document: doc,
      refresh: true
    });

    res.status(201).json({
      status: 'accept',
      id: result._id
    });
  } catch (error) {
    console.error('Indexing error:', error);
    res.status(500).json({ status: 'reject' });
  }
});

app.get('/search', async (req, res) => {
  try {
    const { q } = req.query;

    if (!q) {
      return res.status(400).json({ error: 'Query parameter "q" is required' });
    }

    const result = await esClient.search({
      index: 'documents',
      body: {
        query: {
          multi_match: {
            query: q,
            fields: ['title', 'content']
          }
        }
      }
    });

    const hits = result.hits.hits.map(hit => ({
      id: hit._id,
      ...hit._source
    }));

    res.json({
      total: result.hits.total.value,
      results: hits
    });
  } catch (error) {
    console.error('Search error:', error);
    res.status(500).json({ status: 'reject' });
  }
});

安装ik 分词器

bin/elasticsearch-plugin install https://get.infini.cloud/elasticsearch/analysis-ik/${ES_VERSION}

ik_smart：最少切分

ik_max_word：最细切分

usage

async function ensureIndexExist() {
  const indexName = 'documents';
  try {
    await esClient.indices.delete({ index: indexName });
    console.log('旧索引已删除');
  } catch (e) {
    if (e.meta?.statusCode !== 404) {
      console.error('删除索引失败:', e);
    }
  }
  await esClient.indices.create({
    index: indexName,
    body: {
      mappings: {
        properties: {
          title: {
            type: 'text',
            analyzer: 'ik_max_word',
            search_analyzer: 'ik_smart'
          },
          content: {
            type: 'text',
            analyzer: 'ik_max_word',
            search_analyzer: 'ik_smart'
          },
          createAt: { type: 'date' }
        }
      }
    }
  });
}

app.post('/test-docs', async (req, res) => {
  const testDocs = [
    { title: '苹果手机发布', content: '苹果公司发布了最新款iPhone手机，搭载A17芯片。' },
    { title: '华为鸿蒙系统', content: '华为推出了自研的鸿蒙操作系统，支持多设备协同。' },
    { title: '人工智能助手', content: '通义千问是阿里巴巴推出的AI大语言模型助手。' },
    { title: '新能源汽车', content: '比亚迪和特斯拉是新能源汽车领域的领先企业。' }
  ];

  try {
    const results = [];
    for (const doc of testDocs) {
      const result = await esClient.index({
        index: 'documents',
        document: {
          ...doc,
          createAt: new Date().toISOString()
        },
        refresh: true
      });
      results.push({ id: result._id, title: doc.title });
    }

    res.json({
      status: 'success',
      inserted: results.length,
      docs: results
    });
  } catch (error) {
    console.error('插入测试文档失败:', error);
    res.status(500).json({ error: '插入失败' });
  }
});

ESP-IDF 笔记

Sat, 06 Sep 2025 00:00:00 +0000

构建系统

项目结构

my_project/
├── CMakeLists.txt          ← 项目整体的定义入口
├── Makefile                ← 用于调用 CMake 构建的简单包装
├── sdkconfig               ← 通过 menuconfig 设置的构建选项
├── build/                  ← 构建产物（自动生成）
├── main/
│   ├── CMakeLists.txt      ← 定义此目录下的构建目标（例如 main.c）
│   └── main.c              ← 应用程序的入口点
│   └── Kconfig.projbuild   ← 项目专属定义
├── components/             ← 自定义组件存放目录
│   └── my_led_driver/
│       ├── CMakeLists.txt  ← 自定义组件的构建配置
│       ├── my_led_driver.c
│       ├── Kconfig         ← 自定义组件定义
│       └── include/
│           └── my_led_driver.h

cmake

项目 CMakeLists 文件

1
2
3

cmake_minimum_required(VERSION 3.16)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(myProject)

COMPONENT_DIRS：组件的搜索目录，默认为 IDF_PATH/components、 PROJECT_DIR/components、和 EXTRA_COMPONENT_DIRS。如果你不想在这些位置搜索组件，请覆盖此变量。

EXTRA_COMPONENT_DIRS：用于搜索组件的其它可选目录列表。路径可以是相对于项目目录的相对路径，也可以是绝对路径。

COMPONENTS：用于指定要构建到项目中的组件名称列表，默认为 COMPONENT_DIRS 目录下检索到的所有组件。使用此变量可以“精简”项目，从而缩短构建时间。请注意，如果一个组件通过 COMPONENT_REQUIRES 指定了它依赖的另一个组件，则会自动将其添加到 COMPONENTS 中，所以 COMPONENTS 列表可能会非常短。另外，还可以通过设置 MINIMAL_BUILD 构建属性 来指定 COMPONENTS 中的 main 组件。

BOOTLOADER_IGNORE_EXTRA_COMPONENT：可选组件列表，位于 bootloader_components/ 目录中，引导加载程序编译时会忽略该列表中的组件。使用这一变量可以将一个组件有条件地包含在项目中。

BOOTLOADER_EXTRA_COMPONENT_DIRS：可选的附加路径列表，引导加载程序编译时将从这些路径中搜索要编译的组件。注意，这是一个构建属性。

组件 CMakeLists 文件

idf_component_register(SRCS "foo.c" "bar.c"
INCLUDE_DIRS "include" REQUIRES mbedtls)

idf_component_register(SRCS "car.c"
                  INCLUDE_DIRS "."
                  REQUIRES engine)

idf_component_register(SRCS "engine.c"
                  INCLUDE_DIRS "include"
                  PRIV_REQUIRES spark_plug)

idf_component_register(SRCS "spark_plug.c"
                  INCLUDE_DIRS ".")

COMPONENT_DIR：组件目录，即包含 CMakeLists.txt 文件的绝对路径，它与 CMAKE_CURRENT_SOURCE_DIR 变量一样，路径中不能包含空格。

COMPONENT_NAME：组件名，与组件目录名相同。

COMPONENT_ALIAS：库别名，由构建系统在内部为组件创建。

COMPONENT_LIB：库名，由构建系统在内部为组件创建。

COMPONENT_VERSION：组件版本，由 idf_component.yml 指定并由 IDF 组件管理器设置。

// 全局
REQUIRES 需要包含所有在当前组件的 公共 头文件里 #include 的头文件所在的组件。
// 组件依赖的
PRIV_REQUIRES 需要包含被当前组件的源文件 #include 的头文件所在的组件（除非已经被设置在了 REQUIRES 中）。以及是当前组件正常工作必须要链接的组件。

特殊

嵌入二进制数据

idf_component_register(...
                       EMBED_TXTFILES server_root_cert.pem)

extern const uint8_t server_root_cert_pem_start[] asm("_binary_server_root_cert_pem_start");
extern const uint8_t server_root_cert_pem_end[]   asm("_binary_server_root_cert_pem_end");

Bootloader

引导加载程序是 /components/bootloader/subproject 内部独特的“子项目”，它有自己的项目 CMakeLists.txt 文件，能够构建独立于主项目的 .ELF 和 .BIN 文件，同时它又与主项目共享配置和构建目录。

子项目通过 /components/bootloader/project_include.cmake 文件作为外部项目插入到项目的顶层，主构建进程会运行子项目的 CMake，包括查找组件（主项目使用的组件的子集），生成引导加载程序专用的配置文件（从主 sdkconfig 文件中派生）。

使用第三方 CMake 项目

# 注册组件
idf_component_register(...)

# 设置 `foo` 项目中的一些 CMake 变量，以控制 `foo` 的构建过程
set(FOO_BUILD_STATIC OFF)
set(FOO_BUILD_TESTS OFF)

# 创建并导入第三方库目标
add_subdirectory(foo)

# 将 `foo` 目标公开链接至 `main` 组件
target_link_libraries(main PUBLIC foo)

外部库中使用 ESP-IDF 组件

add_library(foo bar.c fizz.cpp buzz.cpp)

if(ESP_PLATFORM)
  # 在 ESP-IDF 中、bar.c 需要包含 spi_flash 组件中的 esp_flash.h
  target_link_libraries(foo PRIVATE idf::spi_flash)
endif()

sdkconfig(用于配置 Kconfig)

板子或芯片相关芯片类型（ESP32/ESP32-S3 等）
外设功能启用 UART、SPI、I2C、Wi-Fi、BLE 等
FreeRTOS 配置任务数、栈大小、Tick 周期等
日志输出 LOG_LEVEL 的设置（DEBUG、INFO、WARN 等）
各组件配置例如是否使用 SPIFFS、Wi-Fi 的最大连接数等
条件编译

Kconfig

用于生成自定义sdkconfig配置

config ENABLE_LCD_OUTPUT
    bool "Enable LCD output."
    help
        Select this if your board has a LCD.

config ENABLE_LCD_CONSOLE
    bool "Output console text to LCD"
    depends on ENABLE_LCD_OUTPUT
    help
        Select this to output debugging output to the lcd

config ENABLE_LCD_PLOT
    bool "Output temperature plots to LCD"
    depends on ENABLE_LCD_OUTPUT
    help
        Select this to output temperature plots

if(CONFIG_ENABLE_LCD_OUTPUT)
   set(srcs lcd-real.c lcd-spi.c)
else()
   set(srcs lcd-dummy.c)
endif()

# 如果启用了控制台或绘图功能，则需要加入字体
if(CONFIG_ENABLE_LCD_CONSOLE OR CONFIG_ENABLE_LCD_PLOT)
   list(APPEND srcs "font.c")
endif()

idf_component_register(SRCS "${srcs}"
                    ...)

idf.py 命令

idf.py set-target esp32
idf.py menuconfig

idf.py build
idf.py -p PORT flash

idf.py -p PORT monitor

API

API 约定

esp_err_t

分区表

# ESP-IDF Partition Table
# Name,   Type, SubType, Offset,  Size,   Flags
nvs,      data, nvs,     0x9000,  0x6000,
phy_init, data, phy,     0xf000,  0x1000,
factory,  app,  factory, 0x10000, 1M,

分区表

OTA

封装

MQTT

电源管理

NVSFlash

SPIFFS

FreeRTOS 笔记

Sat, 06 Sep 2025 00:00:00 +0000

RTOS

创建一个任务

#include <freertos/FreeRTOS.h>
#include <freertos/task.h>

void taskA(void* param) {
	while(1) {
		ESP_LOGI("main", "打印logs");
		vTaskDelay(pdMS_TO_TICKS(500));
	}
}

void app_main(void){
	xTaskCreatePinnedToCore(taskA, "taskName", 2048, NULL, 3, NULL, NULL);
}

队列

数字越大优先级越高

#include <stdio.h>
#include "string.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "esp_log.h"

QueueHandle_t Queue_handle = NULL;

typedef struct 
{
    int value;
} queue_data_t;


void TaskA(void* param) {
    queue_data_t data;
    while(1) {
        if(pdTRUE ==xQueueReceive(Queue_handle, &data, 100)) {
            ESP_LOGI("queue","res");
        } 
    }
}

void TaskB(void* param) {
    queue_data_t data;
    memset(&data, 0,sizeof(queue_data_t));
    while(1) {
        xQueueSend(Queue_handle, &data, 100);
        vTaskDelay(1000);
        data.value++;
    }
}

void app_main(void)
{
    // num , size
    Queue_handle = xQueueCreate(10,sizeof(queue_data_t));
    xTaskCreatePinnedToCore(TaskB, "B", 2048, NULL, 3, NULL, 1);
    xTaskCreatePinnedToCore(TaskA, "A", 2048, NULL, 3, NULL, 1);
}

信号量

二值

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "esp_log.h"

SemaphoreHandle_t bin_sem;

void TaskA(void* param) {
    while(1) {
        vTaskDelay(pdMS_TO_TICKS(1000));
        ESP_LOGI("bin", "TaskA: giving semaphore");
        xSemaphoreGive(bin_sem); // 释放信号量，通知TaskB
    }
}

void TaskB(void* param) {
    while(1) {
        // 等待信号量（阻塞直到被Give）
        if(xSemaphoreTake(bin_sem, portMAX_DELAY) == pdTRUE) {
            ESP_LOGI("bin", "TaskB: took semaphore and is running!");
        }
    }
}

void app_main(void)
{
    bin_sem = xSemaphoreCreateBinary();
    xTaskCreatePinnedToCore(TaskB, "B", 2048, NULL, 4, NULL, 1);
    xTaskCreatePinnedToCore(TaskA, "A", 2048, NULL, 3, NULL, 1);
}

count

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "esp_log.h"

SemaphoreHandle_t buffer_sem;

// 模拟“使用资源”的任务
void TaskWorker(void* param) {
    int id = (int)param;
    while(1) {
        // 等待获取一个缓冲区
        if(xSemaphoreTake(buffer_sem, portMAX_DELAY) == pdTRUE) {
            ESP_LOGI("Worker", "Task %d got a buffer, processing...", id);
            vTaskDelay(pdMS_TO_TICKS(1000)); // 模拟处理1秒
            ESP_LOGI("Worker", "Task %d released buffer", id);
            xSemaphoreGive(buffer_sem); // 用完归还
        }
    }
}

void app_main(void)
{
    // 创建计数信号量：最多5个缓冲区，初始全部可用
    buffer_sem = xSemaphoreCreateCounting(5, 5);

    // 创建3个任务竞争5个缓冲区
    xTaskCreate(TaskWorker, "W1", 2048, (void*)1, 3, NULL);
    xTaskCreate(TaskWorker, "W2", 2048, (void*)2, 3, NULL);
    xTaskCreate(TaskWorker, "W3", 2048, (void*)3, 3, NULL);

    // 系统运行，3个任务共享5个缓冲区，不会冲突
}

互斥锁

优先级继承
当 H 等待 L 持有的 Mutex 时，FreeRTOS 临时将 L 的优先级提升到 H 的级别。

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "esp_log.h"

SemaphoreHandle_t mutex_sem;

void TaskA(void* param) {
    while(1) {
        xSemaphoreTake(mutex_sem, portMAX_DELAY);
        vTaskDelay(pdMS_TO_TICKS(1000));
        xSemaphoreGive(mutex_sem);
    }
}

void TaskB(void* param) {
    while(1) {
        xSemaphoreTake(mutex_sem, portMAX_DELAY);
        vTaskDelay(pdMS_TO_TICKS(1000));
        xSemaphoreGive(mutex_sem);
    }
}

void app_main(void)
{
    mutex_sem = xSemaphoreCreateMutex();
    xTaskCreatePinnedToCore(TaskB, "B", 2048, NULL, 4, NULL, 1);
    xTaskCreatePinnedToCore(TaskA, "A", 2048, NULL, 3, NULL, 1);
}

事件组

任务可以共同读取的数组事件组是 FreeRTOS 内核对象，天然线程安全

如果事件条件未满足，且你设置了阻塞等待（如 portMAX_DELAY），那么 xEventGroupWaitBits() 会阻塞当前任务，直到条件满足（或超时）—— 所以“不往下执行”是正确的！

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_log.h"

// 定义事件位（推荐用宏，清晰易读）
#define BIT_WIFI_READY    (1 << 0)   // bit 0
#define BIT_SENSOR_READY  (1 << 1)   // bit 1
#define BIT_USER_CONFIRM  (1 << 2)   // bit 2

EventGroupHandle_t event_group;

// 模拟网络任务：5秒后设置 Wi-Fi 就绪
void TaskWiFi(void* param) {
    vTaskDelay(pdMS_TO_TICKS(5000));
    ESP_LOGI("WiFi", "Connected to Wi-Fi!");
    xEventGroupSetBits(event_group, BIT_WIFI_READY);
    vTaskDelete(NULL);
}

// 模拟传感器任务：3秒后设置传感器就绪
void TaskSensor(void* param) {
    vTaskDelay(pdMS_TO_TICKS(3000));
    ESP_LOGI("Sensor", "Sensor initialized!");
    xEventGroupSetBits(event_group, BIT_SENSOR_READY);
    vTaskDelete(NULL);
}

// 模拟用户按键任务：8秒后模拟用户确认
void TaskUserKey(void* param) {
    vTaskDelay(pdMS_TO_TICKS(8000));
    ESP_LOGI("User", "User pressed CONFIRM!");
    xEventGroupSetBits(event_group, BIT_USER_CONFIRM);
    vTaskDelete(NULL);
}

// 主任务：等待所有事件到位
void TaskMain(void* param) {
    EventBits_t bits;

    ESP_LOGI("Main", "Waiting for all conditions...");

    // 等待所有位都被设置：使用 xWaitForAllBits = pdTRUE
    bits = xEventGroupWaitBits(
        event_group,                // 事件组句柄
        BIT_WIFI_READY | BIT_SENSOR_READY | BIT_USER_CONFIRM, // 等待这些位
        pdTRUE,                     // 退出时自动清除这些位（可选）
        pdTRUE,                     // 等待 ALL 位（不是任意一个）
        portMAX_DELAY               // 无限等待
    );

    ESP_LOGI("Main", "All conditions met! System ready.");
    // 此处可以启动主逻辑：如开始采集、上传数据等
    while(1) {
        vTaskDelay(pdMS_TO_TICKS(2000));
        ESP_LOGI("Main", "System running...");
    }
}

void app_main(void)
{
    event_group = xEventGroupCreate();

    // 创建各个任务
    xTaskCreate(TaskWiFi, "WiFi", 2048, NULL, 3, NULL);
    xTaskCreate(TaskSensor, "Sensor", 2048, NULL, 3, NULL);
    xTaskCreate(TaskUserKey, "UserKey", 2048, NULL, 3, NULL);
    xTaskCreate(TaskMain, "Main", 2048, NULL, 4, NULL); // 主任务优先级高些
}

任务间通信

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"

TaskHandle_t task_b_handle; // 用于向 TaskB 发送通知

void TaskA(void* param) {
    while(1) {
        vTaskDelay(pdMS_TO_TICKS(1000));
        // 直接通知 TaskB（相当于 Give 信号量）
        xTaskNotifyGive(task_b_handle); // 等价于对 TaskB 的通知值 +1
        ESP_LOGI("TaskA", "Sent notification to TaskB");
    }
}

void TaskB(void* param) {
    while(1) {
        // 等待通知（相当于 Take 信号量），阻塞直到收到
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY); // pdTRUE = 清除通知计数
        ESP_LOGI("TaskB", "Received notification!");
    }
}

void app_main(void)
{
    // 先创建 TaskB，拿到它的句柄
    xTaskCreate(TaskB, "TaskB", 2048, NULL, 3, &task_b_handle);
    xTaskCreate(TaskA, "TaskA", 2048, NULL, 2, NULL);
}

栈

由高地址到低地址

局部变量

volatile 关键字局部变量（在函数内部定义）→ 存在栈中
全局变量或 static 变量 → 存在全局数据区
其他没有使用该关键字的局部变量 -> 存放在寄存器中

函数调用

为什么每个rtos任务需要拥有自己的栈空间切换时，保存各自的局部变量、函数调用状态，实现安全的任务切换

堆

由高地址到低地址

源码结构

变量前缀

c       char
S       int16_t, short
l       int32_t, long
x       BaseType_t, 其他非标准类型
u       unsigned
p       指针
uc      uint8_t, unsigned char
pc      char 指针
p...    对应的指针

内存管理算法

文件	优点	缺点
heap_1.c	分配简单，时间确定	只分配、不回收
heap_2.c	动态分配、最佳匹配	碎片、时间不定
heap_3.c	调用标准库函数	速度慢、时间不定
heap_4.c	相邻空闲内存可合并	可解决碎片问题、时间不定
heap_5.c	在 heap_4 基础上支持分隔的内存块	可解决碎片问题、时间不定

Heap_1

它只实现了pvPortMalloc，没有实现vPortFree

Heap_2

最佳匹配算法 新设计中不再推荐使用Heap_2。建议使用Heap_4来替代Heap_2，更加高效。
与Heap_4相比，Heap_2不会合并相邻的空闲内存，所以Heap_2会导致严重的"碎片化"问题。
如果申请、分配内存时大小总是相同的，这类场景下Heap_2没有碎片化的问题。
虽然不再推荐使用heap_2，但是它的效率还是远高于malloc、free。

Heap_3

使用标准C库里的malloc、free函数，所以堆大小由链接器的配置决定，配置项configTOTAL_HEAP_SIZE不再起作用。
C库里的malloc、free函数并非线程安全的，Heap_3中先暂停FreeRTOS的调度器，再去调用这些函数，使用这种方法实现了线程安全

Heap_4

使用首次适应算法(first fit)来分配内存。它还会把相邻的空闲内存合并为一个更大的空闲内存，这有助于较少内存的碎片问题。
执行的时间是不确定的，但是它的效率高于标准库的malloc、free

Heap_5

Heap_5分配内存、释放内存的算法跟Heap_4是一样的。
相比于Heap_4，Heap_5并不局限于管理一个大数组：它可以管理多块、分隔开的内存。

// 原型
typedef struct HeapRegion
{
    uint8_t * pucStartAddress; // 起始地址
    size_t xSizeInBytes;       // 大小
} HeapRegion_t;

// 定义堆地址
HeapRegion_t xHeapRegions[] =
{
  { ( uint8_t * ) 0x80000000UL, 0x10000 }, // 起始地址0x80000000，大小0x10000
  { ( uint8_t * ) 0x90000000UL, 0xa0000 }, // 起始地址0x90000000，大小0xa0000
  { NULL, 0 } // 表示数组结束
 };

// 注册堆地址
 void vPortDefineHeapRegions( const HeapRegion_t * const pxHeapRegions );

Heap相关的函数

pvPortMalloc/vPortFree

如果分配内存不成功，则返回值为NULL。

xPortGetFreeHeapSize

当前还有多少空闲内存，这函数可以用来优化内存的使用情况。比如当所有内核对象都分配好后，执行此函数返回2000，那么configTOTAL_HEAP_SIZE就可减小2000。
注意：在heap_3中无法使用。

xPortGetMinimumEverFreeHeapSize

返回：程序运行过程中，空闲内存容量的最小值。
注意：只有heap_4、heap_5支持此函数。

malloc失败的钩子函数

void * pvPortMalloc( size_t xWantedSize )vPortDefineHeapRegions
{
    ......
    #if ( configUSE_MALLOC_FAILED_HOOK == 1 )
        {
            if( pvReturn == NULL )
            {
                extern void vApplicationMallocFailedHook( void );
                vApplicationMallocFailedHook();
            }
        }
    #endif
    
    return pvReturn;        
}

如果想使用这个钩子函数：
在FreeRTOSConfig.h中，把configUSE_MALLOC_FAILED_HOOK定义为1
提供vApplicationMallocFailedHook函数
pvPortMalloc失败时，才会调用此函数

任务管理

创建任务

BaseType_t xTaskCreate( TaskFunction_t pxTaskCode, // 函数指针, 任务函数
                        const char * const pcName, // 任务的名字
                        const configSTACK_DEPTH_TYPE usStackDepth, // 栈大小,单位为word,10表示40字节
                        void * const pvParameters, // 调用任务函数时传入的参数
                        UBaseType_t uxPriority,    // 优先级
                        TaskHandle_t * const pxCreatedTask ); // 任务句柄, 以后使用它来操作这个任务

参数	描述
pvTaskCode	函数指针，任务对应的 C 函数。任务应该永远不退出，或者在退出时调用 `"vTaskDelete(NULL)"`。
pcName	任务的名称，仅用于调试目的，FreeRTOS 内部不使用。pcName 的长度为 `configMAX_TASK_NAME_LEN`。
usStackDepth	每个任务都有自己的栈，usStackDepth 指定了栈的大小，单位为 word。例如，如果传入 100，表示栈的大小为 100 word，即 400 字节。最大值为 `uint16_t` 的最大值。确定栈的大小并不容易，通常是根据估计来设定。精确的办法是查看反汇编代码。
pvParameters	调用 pvTaskCode 函数指针时使用的参数：`pvTaskCode(pvParameters)`。
uxPriority	任务的优先级范围为 0~`(configMAX_PRIORITIES - 1)`。数值越小，优先级越低。如果传入的值过大，xTaskCreate 会将其调整为 `(configMAX_PRIORITIES - 1)`。
pxCreatedTask	用于保存 xTaskCreate 的输出结果，即任务的句柄（task handle）。如果以后需要对该任务进行操作，如修改优先级，则需要使用此句柄。如果不需要使用该句柄，可以传入 NULL。
返回值	成功时返回 `pdPASS`，失败时返回 `errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY`（失败原因是内存不足）。请注意，文档中提到的失败返回值是 `pdFAIL` 是不正确的。`pdFAIL` 的值为 0，而 `errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY` 的值为 -1。

删除任务

`1`	`vTaskDelete(xSoundTaskHandle);`

任务优先级和Tick

数值越大优先级越高

通用方法

使用C函数实现，对所有的架构都是同样的代码。对configMAX_PRIORITIES的取值没有限制。但是configMAX_PRIORITIES的取值还是尽量小，因为取值越大越浪费内存，也浪费时间。
configUSE_PORT_OPTIMISED_TASK_SELECTION被定义为0、或者未定义时，使用此方法。

架构相关的优化的方法

架构相关的汇编指令，可以从一个32位的数里快速地找出为1的最高位。使用这些指令，可以快速找出优先级最高的、可以运行的任务。使用这种方法时，configMAX_PRIORITIES的取值不能超过32。 configUSE_PORT_OPTIMISED_TASK_SELECTION被定义为1时，使用此方法。

Tick

时间片的长度由configTICK_RATE_HZ 决定，假设configTICK_RATE_HZ为100，那么时间片长度就是10ms

vTaskDelay(2);  // 等待2个Tick，假设configTICK_RATE_HZ=100, Tick周期时10ms, 等待20ms

// 还可以使用pdMS_TO_TICKS宏把ms转换为tick
vTaskDelay(pdMS_TO_TICKS(100));  // 等待100ms

注意，基于Tick实现的延时并不精确，比如vTaskDelay(2)的本意是延迟2个Tick周期，有可能经过1个Tick多一点就返回了。 使用vTaskDelay函数时，建议以ms为单位，使用pdMS_TO_TICKS把时间转换为Tick。

修改优先级

// 获得任务的优先级
UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask );

// 设置任务的优先级
void vTaskPrioritySet( TaskHandle_t xTask,
                       UBaseType_t uxNewPriority );

任务状态

// 进入暂停状态
// 参数xTaskToSuspend表示要暂停的任务，如果为NULL，表示暂停自己。

/**要退出暂停状态，只能由别人来操作：
别的任务调用：vTaskResume
中断程序调用：xTaskResumeFromISR
**/
void vTaskSuspend( TaskHandle_t xTaskToSuspend );

Delay函数

// vTaskDelay：至少等待指定个数的Tick Interrupt才能变为就绪状态
// vTaskDelayUntil：等待到指定的绝对时刻，才能变为就绪态。
void vTaskDelay( const TickType_t xTicksToDelay ); /* xTicksToDelay: 等待多少给Tick */

/* pxPreviousWakeTime: 上一次被唤醒的时间
 * xTimeIncrement: 要阻塞到(pxPreviousWakeTime + xTimeIncrement)
 * 单位都是Tick Count
 */
BaseType_t xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
                            const TickType_t xTimeIncrement );

// 获取当前时间
TickType_t xLastWakeTime = xTaskGetTickCount();

空闲任务及其钩子函数

简单来说就是没有用户的任务需要执行的时候需要有一个空闲任务
钩子函数的作用有这些：

执行一些低优先级的、后台的、需要连续执行的函数
测量系统的空闲时间：空闲任务能被执行就意味着所有的高优先级任务都停止了，所以测量空闲任务占据的时间，就可以算出处理器占用率。
让系统进入省电模式：空闲任务能被执行就意味着没有重要的事情要做，当然可以进入省电模式了。空闲任务的钩子函数的限制：
不能导致空闲任务进入阻塞状态、暂停状态
如果你会使用vTaskDelete()来删除任务，那么钩子函数要非常高效地执行。如果空闲任务移植卡在钩子函数里的话，它就无法释放内存。

使用钩子函数的前提

把这个宏定义为1：configUSE_IDLE_HOOK
实现vApplicationIdleHook函数

调度算法

FreeRTOSConfig.h的两个配置项来配置调度算法：configUSE_PREEMPTION、configUSE_TIME_SLICING。

configUSE_PREEMPTION 高优先级的任务能否优先执行

可以：被称作"可抢占调度"(Pre-emptive)，高优先级的就绪任务马上执行，下面再细化。
不可以：不能抢就只能协商了，被称作"合作调度模式"(Co-operative Scheduling)

当前任务执行时，更高优先级的任务就绪了也不能马上运行，只能等待当前任务主动让出CPU资源。
其他同优先级的任务也只能等待：更高优先级的任务都不能抢占，平级的更应该老实点

configUSE_TIME_SLICING 可抢占的前提下，同优先级的任务是否轮流执行

轮流执行：被称为"时间片轮转"(Time Slicing)，同优先级的任务轮流执行，你执行一个时间片、我再执行一个时间片
不轮流执行：英文为"without Time Slicing"，当前任务会一直执行，直到主动放弃、或者被高优先级任务抢占

configIDLE_SHOULD_YIELD 空闲任务是否让步于用户任务

空闲任务低人一等，每执行一次循环，就看看是否主动让位给用户任务
空闲任务跟用户任务一样，大家轮流执行，没有谁更特殊

配置项	A	B	C	D	E
configUSE_PREEMPTION	1	1	1	1	0
configUSE_TIME_SLICING	1	1	0	0	x
configIDLE_SHOULD_YIELD	1	0	1	0	x
说明	常用	很少用	很少用	很少用	几乎不用

同步互斥与通信

队列

CRUD

// 创建
QueueHandle_t xQueueCreateStatic(*
                    UBaseType_t uxQueueLength,*
                    UBaseType_t uxItemSize,*
                    uint8_t *pucQueueStorageBuffer,*
                    StaticQueue_t *pxQueueBuffer*
                 );

// 列恢复为初始状态
BaseType_t xQueueReset( QueueHandle_t pxQueue);

// 删除
void vQueueDelete( QueueHandle_t xQueue );


/* 等同于xQueueSendToBack
 * 往队列尾部写入数据，如果没有空间，阻塞时间为xTicksToWait
 */
BaseType_t xQueueSend(
                                QueueHandle_t    xQueue,
                                const void       *pvItemToQueue,
                                TickType_t       xTicksToWait
                            );

/* 
 * 往队列尾部写入数据，如果没有空间，阻塞时间为xTicksToWait
 */
BaseType_t xQueueSendToBack(
                                QueueHandle_t    xQueue,
                                const void       *pvItemToQueue,
                                TickType_t       xTicksToWait
                            );


/* 
 * 往队列尾部写入数据，此函数可以在中断函数中使用，不可阻塞
 */
BaseType_t xQueueSendToBackFromISR(
                                      QueueHandle_t xQueue,
                                      const void *pvItemToQueue,
                                      BaseType_t *pxHigherPriorityTaskWoken
                                   );

/* 
 * 往队列头部写入数据，如果没有空间，阻塞时间为xTicksToWait
 */
BaseType_t xQueueSendToFront(
                                QueueHandle_t    xQueue,
                                const void       *pvItemToQueue,
                                TickType_t       xTicksToWait
                            );

/* 
 * 往队列头部写入数据，此函数可以在中断函数中使用，不可阻塞
 */
BaseType_t xQueueSendToFrontFromISR(
                                      QueueHandle_t xQueue,
                                      const void *pvItemToQueue,
                                      BaseType_t *pxHigherPriorityTaskWoken
                                   );


// 读队列
BaseType_t xQueueReceive( QueueHandle_t xQueue,
                          void * const pvBuffer,
                          TickType_t xTicksToWait );

BaseType_t xQueueReceiveFromISR(
                                    QueueHandle_t    xQueue,
                                    void             *pvBuffer,
                                    BaseType_t       *pxTaskWoken
                                );

// 查询
/*
 * 返回队列中可用数据的个数
 */
UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue );

/*
 * 返回队列中可用空间的个数
 */
UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue );

队列集

如何及时读取到多个队列的数据？要使用队列集

CRUD

// 队列集长度，最多能存放多少个数据(队列句柄)  
QueueSetHandle_t xQueueCreateSet( const UBaseType_t uxEventQueueLength )

// 把队列加入队列集
BaseType_t xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,QueueSetHandle_t xQueueSet );

// 读取队列集
QueueSetMemberHandle_t xQueueSelectFromSet( QueueSetHandle_t xQueueSet,TickType_t const xTicksToWait );

信号量

/* 创建一个二进制信号量，返回它的句柄。
 * 此函数内部会分配信号量结构体 
 * 返回值: 返回句柄，非NULL表示成功
 */
SemaphoreHandle_t xSemaphoreCreateBinary( void );

/* 创建一个二进制信号量，返回它的句柄。
 * 此函数无需动态分配内存，所以需要先有一个StaticSemaphore_t结构体，并传入它的指针
 * 返回值: 返回句柄，非NULL表示成功
 */
SemaphoreHandle_t xSemaphoreCreateBinaryStatic( StaticSemaphore_t *pxSemaphoreBuffer );

/* 创建一个计数型信号量，返回它的句柄。
 * 此函数内部会分配信号量结构体 
 * uxMaxCount: 最大计数值
 * uxInitialCount: 初始计数值
 * 返回值: 返回句柄，非NULL表示成功
 */
SemaphoreHandle_t xSemaphoreCreateCounting(UBaseType_t uxMaxCount, UBaseType_t uxInitialCount);

/* 创建一个计数型信号量，返回它的句柄。
 * 此函数无需动态分配内存，所以需要先有一个StaticSemaphore_t结构体，并传入它的指针
 * uxMaxCount: 最大计数值
 * uxInitialCount: 初始计数值
 * pxSemaphoreBuffer: StaticSemaphore_t结构体指针
 * 返回值: 返回句柄，非NULL表示成功
 */
SemaphoreHandle_t xSemaphoreCreateCountingStatic( UBaseType_t uxMaxCount, UBaseType_t uxInitialCount, StaticSemaphore_t *pxSemaphoreBuffer );


/*
 * xSemaphore: 信号量句柄，你要删除哪个信号量
 */
void vSemaphoreDelete( SemaphoreHandle_t xSemaphore );

BaseType_t xSemaphoreGive( SemaphoreHandle_t xSemaphore );

BaseType_t xSemaphoreGiveFromISR(SemaphoreHandle_t xSemaphore,BaseType_t *pxHigherPriorityTaskWoken);

BaseType_t xSemaphoreTake(
                   SemaphoreHandle_t xSemaphore,
                   TickType_t xTicksToWait
               );

BaseType_t xSemaphoreTakeFromISR(
                        SemaphoreHandle_t xSemaphore,
                        BaseType_t *pxHigherPriorityTaskWoken
                    );

互斥量(Mutex)

// 需要定义
#define configUSE_MUTEXES 1

/* 创建一个互斥量，返回它的句柄。
 * 此函数内部会分配互斥量结构体 
 * 返回值: 返回句柄，非NULL表示成功
 */
SemaphoreHandle_t xSemaphoreCreateMutex( void );

/* 创建一个互斥量，返回它的句柄。
 * 此函数无需动态分配内存，所以需要先有一个StaticSemaphore_t结构体，并传入它的指针
 * 返回值: 返回句柄，非NULL表示成功
 */
SemaphoreHandle_t xSemaphoreCreateMutexStatic( StaticSemaphore_t *pxMutexBuffer );

递归锁

任务A获得递归锁M后，它还可以多次去获得这个锁
“take"了N次，要"give"N次，这个锁才会被释放

/* 创建一个递归锁，返回它的句柄。*

 * 此函数内部会分配互斥量结构体* 

 * 返回值: 返回句柄，非NULL表示成功*

 */

SemaphoreHandle_t xSemaphoreCreateRecursiveMutex( void );

// 释放

BaseType_t xSemaphoreGiveRecursive( SemaphoreHandle_t xSemaphore );

// 获得

BaseType_t xSemaphoreTakeRecursive(

         SemaphoreHandle_t xSemaphore,

         TickType_t xTicksToWait

        );

事件组(event group)

事件组用一个整数来表示，其中的高8位留给内核使用，只能用其他的位来表示事件。那么这个整数是多少位的？

如果configUSE_16_BIT_TICKS是1，那么这个整数就是16位的，低8位用来表示事件
如果configUSE_16_BIT_TICKS是0，那么这个整数就是32位的，低24位用来表示事件

configUSE_16_BIT_TICKS是用来表示Tick Count的，怎么会影响事件组？这只是基于效率来考虑

如果configUSE_16_BIT_TICKS是1，就表示该处理器使用16位更高效，所以事件组也使用16位
如果configUSE_16_BIT_TICKS是0，就表示该处理器使用32位更高效，所以事件组也使用32位

/* 创建一个事件组，返回它的句柄。
 * 此函数内部会分配事件组结构体 
 * 返回值: 返回句柄，非NULL表示成功
 */
EventGroupHandle_t xEventGroupCreate( void );

/* 创建一个事件组，返回它的句柄。
 * 此函数无需动态分配内存，所以需要先有一个StaticEventGroup_t结构体，并传入它的指针
 * 返回值: 返回句柄，非NULL表示成功
 */
EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer );

/*
 * xEventGroup: 事件组句柄，你要删除哪个事件组
 */
void vEventGroupDelete( EventGroupHandle_t xEventGroup )


/* 设置事件组中的位
 * xEventGroup: 哪个事件组
 * uxBitsToSet: 设置哪些位? 
 *              如果uxBitsToSet的bitX, bitY为1, 那么事件组中的bitX, bitY被设置为1
 *              可以用来设置多个位，比如 0x15 就表示设置bit4, bit2, bit0
 * 返回值: 返回原来的事件值(没什么意义, 因为很可能已经被其他任务修改了)
 */
EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
                                    const EventBits_t uxBitsToSet );

/* 设置事件组中的位
 * xEventGroup: 哪个事件组
 * uxBitsToSet: 设置哪些位? 
 *              如果uxBitsToSet的bitX, bitY为1, 那么事件组中的bitX, bitY被设置为1
 *              可以用来设置多个位，比如 0x15 就表示设置bit4, bit2, bit0
 * pxHigherPriorityTaskWoken: 有没有导致更高优先级的任务进入就绪态? pdTRUE-有, pdFALSE-没有
 * 返回值: pdPASS-成功, pdFALSE-失败
 */
BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup,
                                      const EventBits_t uxBitsToSet,
                                      BaseType_t * pxHigherPriorityTaskWoken );

EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
                                 const EventBits_t uxBitsToWaitFor,
                                 const BaseType_t xClearOnExit,
                                 const BaseType_t xWaitForAllBits,
                                 TickType_t xTicksToWait );

同步点

使用 xEventGroupSync() 函数可以同步多个任务

EventBits_t xEventGroupSync(    EventGroupHandle_t xEventGroup,
                                const EventBits_t uxBitsToSet,
                                const EventBits_t uxBitsToWaitFor,
                                TickType_t xTicksToWait );

任务通知(Task Notifications)

任务通知的优势：

效率更高：使用任务通知来发送事件、数据给某个任务时，效率更高。比队列、信号量、事件组都有大的优势。
更节省内存：使用其他方法时都要先创建对应的结构体，使用任务通知时无需额外创建结构体。

任务通知的限制：

不能发送数据给ISR：
ISR并没有任务结构体，所以无法使用任务通知的功能给ISR发送数据。但是ISR可以使用任务通知的功能，发数据给任务。
数据只能给该任务独享
使用队列、信号量、事件组时，数据保存在这些结构体中，其他任务、ISR都可以访问这些数据。使用任务通知时，数据存放入目标任务中，只有它可以访问这些数据。
在日常工作中，这个限制影响不大。因为很多场合是从多个数据源把数据发给某个任务，而不是把一个数据源的数据发给多个任务。
无法缓冲数据
使用队列时，假设队列深度为N，那么它可以保持N个数据。
使用任务通知时，任务结构体中只有一个任务通知值，只能保持一个数据。
无法广播给多个任务
使用事件组可以同时给多个任务发送事件。
使用任务通知，只能发个一个任务。
如果发送受阻，发送方无法进入阻塞状态等待
假设队列已经满了，使用 xQueueSendToBack() 给队列发送数据时，任务可以进入阻塞状态等待发送完成。

通知状态和通知值

typedef struct tskTaskControlBlock
{
    ......
    /* configTASK_NOTIFICATION_ARRAY_ENTRIES = 1 */
    volatile uint32_t ulNotifiedValue[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
    volatile uint8_t ucNotifyState[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
    ......
} tskTCB;

// 任务没有在等待通知
##define taskNOT_WAITING_NOTIFICATION              ( ( uint8_t ) 0 )  /* 也是初始状态 */

// 任务在等待通知
##define taskWAITING_NOTIFICATION                  ( ( uint8_t ) 1 )
// 任务接收到了通知，也被称为pending
##define taskNOTIFICATION_RECEIVED                 ( ( uint8_t ) 2 )

任务通知的使用

基本

BaseType_t xTaskNotifyGive( TaskHandle_t xTaskToNotify );

void vTaskNotifyGiveFromISR( TaskHandle_t xTaskHandle, BaseType_t *pxHigherPriorityTaskWoken );

uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait );

高级

BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction );

BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify,
                               uint32_t ulValue, 
                               eNotifyAction eAction, 
                               BaseType_t *pxHigherPriorityTaskWoken );

BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, 
                            uint32_t ulBitsToClearOnExit, 
                            uint32_t *pulNotificationValue, 
                            TickType_t xTicksToWait );

软件定时器(software timer)

/* 使用动态分配内存的方法创建定时器
 * pcTimerName:定时器名字, 用处不大, 尽在调试时用到
 * xTimerPeriodInTicks: 周期, 以Tick为单位
 * uxAutoReload: 类型, pdTRUE表示自动加载, pdFALSE表示一次性
 * pvTimerID: 回调函数可以使用此参数, 比如分辨是哪个定时器
 * pxCallbackFunction: 回调函数
 * 返回值: 成功则返回TimerHandle_t, 否则返回NULL
 */
TimerHandle_t xTimerCreate( const char * const pcTimerName, 
                            const TickType_t xTimerPeriodInTicks,
                            const UBaseType_t uxAutoReload,
                            void * const pvTimerID,
                            TimerCallbackFunction_t pxCallbackFunction );

/* 使用静态分配内存的方法创建定时器
 * pcTimerName:定时器名字, 用处不大, 尽在调试时用到
 * xTimerPeriodInTicks: 周期, 以Tick为单位
 * uxAutoReload: 类型, pdTRUE表示自动加载, pdFALSE表示一次性
 * pvTimerID: 回调函数可以使用此参数, 比如分辨是哪个定时器
 * pxCallbackFunction: 回调函数
 * pxTimerBuffer: 传入一个StaticTimer_t结构体, 将在上面构造定时器
 * 返回值: 成功则返回TimerHandle_t, 否则返回NULL
 */
TimerHandle_t xTimerCreateStatic(const char * const pcTimerName,
                                 TickType_t xTimerPeriodInTicks,
                                 UBaseType_t uxAutoReload,
                                 void * pvTimerID,
                                 TimerCallbackFunction_t pxCallbackFunction,
                                 StaticTimer_t *pxTimerBuffer );


/* 删除定时器
 * xTimer: 要删除哪个定时器
 * xTicksToWait: 超时时间
 * 返回值: pdFAIL表示"删除命令"在xTicksToWait个Tick内无法写入队列
 *        pdPASS表示成功
*/
BaseType_t xTimerDelete( TimerHandle_t xTimer, TickType_t xTicksToWait );

/* 启动定时器
 * xTimer: 哪个定时器
 * xTicksToWait: 超时时间
 * 返回值: pdFAIL表示"启动命令"在xTicksToWait个Tick内无法写入队列
 *        pdPASS表示成功
 */
BaseType_t xTimerStart( TimerHandle_t xTimer, TickType_t xTicksToWait );

/* 启动定时器(ISR版本)
 * xTimer: 哪个定时器
 * pxHigherPriorityTaskWoken: 向队列发出命令使得守护任务被唤醒,
 *                            如果守护任务的优先级比当前任务的高,
 *                            则"*pxHigherPriorityTaskWoken = pdTRUE",
 *                            表示需要进行任务调度
 * 返回值: pdFAIL表示"启动命令"无法写入队列
 *        pdPASS表示成功
 */
BaseType_t xTimerStartFromISR(   TimerHandle_t xTimer,
                                 BaseType_t *pxHigherPriorityTaskWoken );

/* 停止定时器
 * xTimer: 哪个定时器
 * xTicksToWait: 超时时间
 * 返回值: pdFAIL表示"停止命令"在xTicksToWait个Tick内无法写入队列
 *        pdPASS表示成功
 */
BaseType_t xTimerStop( TimerHandle_t xTimer, TickType_t xTicksToWait );

/* 停止定时器(ISR版本)
 * xTimer: 哪个定时器
 * pxHigherPriorityTaskWoken: 向队列发出命令使得守护任务被唤醒,
 *                            如果守护任务的优先级比当前任务的高,
 *                            则"*pxHigherPriorityTaskWoken = pdTRUE",
 *                            表示需要进行任务调度
 * 返回值: pdFAIL表示"停止命令"无法写入队列
 *        pdPASS表示成功
 */
BaseType_t xTimerStopFromISR(    TimerHandle_t xTimer,
                                 BaseType_t *pxHigherPriorityTaskWoken );


/* 复位定时器
 * xTimer: 哪个定时器
 * xTicksToWait: 超时时间
 * 返回值: pdFAIL表示"复位命令"在xTicksToWait个Tick内无法写入队列
 *        pdPASS表示成功
 */
BaseType_t xTimerReset( TimerHandle_t xTimer, TickType_t xTicksToWait );

/* 复位定时器(ISR版本)
 * xTimer: 哪个定时器
 * pxHigherPriorityTaskWoken: 向队列发出命令使得守护任务被唤醒,
 *                            如果守护任务的优先级比当前任务的高,
 *                            则"*pxHigherPriorityTaskWoken = pdTRUE",
 *                            表示需要进行任务调度
 * 返回值: pdFAIL表示"停止命令"无法写入队列
 *        pdPASS表示成功
 */
BaseType_t xTimerResetFromISR(   TimerHandle_t xTimer,
                                 BaseType_t *pxHigherPriorityTaskWoken );

/* 修改定时器的周期
 * xTimer: 哪个定时器
 * xNewPeriod: 新周期
 * xTicksToWait: 超时时间, 命令写入队列的超时时间 
 * 返回值: pdFAIL表示"修改周期命令"在xTicksToWait个Tick内无法写入队列
 *        pdPASS表示成功
 */
BaseType_t xTimerChangePeriod(   TimerHandle_t xTimer,
                                 TickType_t xNewPeriod,
                                 TickType_t xTicksToWait );

/* 修改定时器的周期
 * xTimer: 哪个定时器
 * xNewPeriod: 新周期
 * pxHigherPriorityTaskWoken: 向队列发出命令使得守护任务被唤醒,
 *                            如果守护任务的优先级比当前任务的高,
 *                            则"*pxHigherPriorityTaskWoken = pdTRUE",
 *                            表示需要进行任务调度
 * 返回值: pdFAIL表示"修改周期命令"在xTicksToWait个Tick内无法写入队列
 *        pdPASS表示成功
 */
BaseType_t xTimerChangePeriodFromISR( TimerHandle_t xTimer,
                                      TickType_t xNewPeriod,
                                      BaseType_t *pxHigherPriorityTaskWoken );

/* 获得定时器的ID
 * xTimer: 哪个定时器
 * 返回值: 定时器的ID
 */
void *pvTimerGetTimerID( TimerHandle_t xTimer );

/* 设置定时器的ID
 * xTimer: 哪个定时器
 * pvNewID: 新ID
 * 返回值: 无
 */
void vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID );

资源管理(Resource Management)

/* 在任务中，当前时刻中断是使能的
 * 执行这句代码后，屏蔽中断
 */
taskENTER_CRITICAL();

/* 访问临界资源 */

/* 重新使能中断 */
taskEXIT_CRITICAL();

void vAnInterruptServiceRoutine( void )
{
    /* 用来记录当前中断是否使能 */
    UBaseType_t uxSavedInterruptStatus;
    
    /* 在ISR中，当前时刻中断可能是使能的，也可能是禁止的
     * 所以要记录当前状态, 后面要恢复为原先的状态
     * 执行这句代码后，屏蔽中断
     */
    uxSavedInterruptStatus = taskENTER_CRITICAL_FROM_ISR();
    
    /* 访问临界资源 */

    /* 恢复中断状态 */
    taskEXIT_CRITICAL_FROM_ISR( uxSavedInterruptStatus );
    /* 现在，当前ISR可以被更高优先级的中断打断了 */
}

/* 暂停调度器 */
void vTaskSuspendAll( void );

/* 恢复调度器
 * 返回值: pdTRUE表示在暂定期间有更高优先级的任务就绪了
 *        可以不理会这个返回值
 */
BaseType_t xTaskResumeAll( void );

llama.cpp 速查

Sat, 06 Sep 2025 00:00:00 +0000

速查

功能分类	简写	完整名字	功能说明	专家建议
模型路径	-m	–model	主模型路径	必须指定
投机模型	-md	–model-draft	草稿模型路径	用于提升生成速度
GPU卸载	-ngl	–n-gpu-layers	主模型卸载到 GPU 层数	4B 模型设为 999 全量卸载
草稿卸载	-ngld	–n-gpu-layers-draft	草稿模型卸载到 GPU 层数	必须与 -md 配合使用
上下文	-c	–ctx-size	最大上下文长度 (Tokens)	8G 显存建议 8192-16384
闪速注意	-fa	–flash-attn	启用 Flash Attention	必开，大幅节省显存并提速
批处理	-b	–batch-size	逻辑批处理大小	设为 1024 可提升预处理速度
物理批次	-ub	–ubatch-size	物理批处理大小	建议设为 512，平衡显存与速度
投机步长	-dr	–draft	投机采样预测数量	建议 8-16，过大会增加开销
并发数	-np	–parallel	同时处理的请求槽位	4060 跑 4B 建议设为 2-4
专家卸载	-ncm	–n-cpu-moe	将 MoE 专家层卸载到 CPU	仅在显存不足以放下 9B+ 模型时使用
KV量化	-ctk	–cache-type-k	Key 缓存数据类型 (q8_0/q4_0)	显存极度紧张时设为 q8_0

使用指令

使用 Draft Model

41.86t/s

llama-server  -m .\Qwen3.5-4B-Q4_K_S.gguf  -md ..\Qwen3.5-0.8B-GGUF\Qwen3.5-0.8B-IQ4_NL.gguf  --n-gpu-layers 999  --n-gpu-layers-draft 999  --flash-attn on  --ctx-size 8192  --batch-size 1024  --ubatch-size 512  --draft 8  --host 0.0.0.0  --port 8080  --temp 0.7  --top-p 0.8  --min-p 0.05

将专家放到 CPU 中

`1`	`llama-server -m .\your-moe-9b-model.gguf --n-gpu-layers 99 --n-cpu-moe 99 --ctx-size 8192 --flash-attn on`

使用mmjproj

`1`	`llama-server -m .\Qwen3.5-9B-Q4_K_S.gguf --mmproj .\mmproj-model-f16.gguf -ngl 99 --flash-attn on -c 8192`

关闭思考模式

llama-server -m .\Qwen3.5-9B-Q3_K_M.gguf --mmproj .\mmproj-F32.gguf -ngl 99 --flash-attn on -c 8192 --chat-template-kwargs '{"enable_thinking": false}' --temp 0.7 --top-p 0.8 --top-k 20 --min-p 0.0 --presence-penalty 1.5 --repeat-penalty 1.0

postresql 笔记

Sat, 06 Sep 2025 00:00:00 +0000

安装与配置

sudo apt install postgresql sudo nano /etc/postgresql/16/main/pg_hba.conf sudo nano /etc/postgresql/16/main/postgresql.conf

进入

sudo -u postgres psql

退出

什么是schema

就是子database
PostgreSQL Database 想象成“一家公司”，
里面的 Schema 是“不同部门”（如销售部、人事部、财务部），
而 Tables 是每个部门管理的“具体业务数据表”（如订单表、员工表、报销表）。

基础

psql 原命令

\q 退出psql
\l 列出所有数据库
\c database_name 连接到指定数据库
\d table_name  查看tables
\du 列出所有角色
\dt 列出所有表

创建

create database testdb;

create user user_name with password 'your_pwsd';

create schema my_schema;

create table user(
	id serial primary key,
	name text not null,
	email text not null,
	age integer check (age >= 0 and age <=150),
	is_active BOOLEAN default true,
	created_at timestamp default current_timestamp,
	updated_at timestamp default current_timestamp
);
# 在sales schema 中直接创建表
create TABLE sales.orders (
    id SERIAL PRIMARY KEY,
    amount DECIMAL(10,2)
);
# 创建一个带约束的表
CREATE TABLE products (
    id SERIAL PRIMARY KEY,
    sku TEXT NOT NULL UNIQUE,
    name TEXT NOT NULL,
    price DECIMAL(10,2) NOT NULL CHECK (price > 0),
    category_id INTEGER REFERENCES categories(id) ON DELETE CASCADE,
    created_at TIMESTAMPTZ DEFAULT NOW()
);
PRIMARY KEY (user_id, role_id),
UNIQUE (student_id, course_code),
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
FOREIGN KEY (role_id) REFERENCES roles(id) ON DELETE CASCADE
ON UPDATE(一般不用)
1. CASCADE     → 父删子随删（适合从属强依赖数据）
2. SET NULL    → 父删子设空（字段必须可 NULL）
3. RESTRICT    → 父删若子存在则报错（默认，最安全）


-- 普通索引
CREATE INDEX idx_users_email ON users(email);
-- 唯一索引
CREATE UNIQUE INDEX idx_users_lower_email ON users(LOWER(email));
-- 多列索引
CREATE INDEX idx_orders_user_date ON orders(user_id, created_at DESC);
-- 针对 JSONB 字段的索引（GIN）
CREATE INDEX idx_products_tags ON products USING GIN(tags); -- tags 是 jsonb

插入

INSERT INTO users (id, name, email, age, created_at) VALUES (100, 'Bob', 'bob@example.com', 25, '2025-01-01');

INSERT INTO users (name, email) 
VALUES 
    ('Charlie', 'charlie@example.com'),
    ('David', 'david@example.com'),
    ('Eve', 'eve@example.com');

INSERT INTO user_stats (user_id, total_orders)
SELECT user_id, COUNT(*) 
FROM orders 
GROUP BY user_id;

alter tables users add column phone text;

ALTER TABLE users ADD CONSTRAINT chk_age CHECK (age >= 0 AND age <= 150);

UPDATE users SET phone = 'unknown' WHERE phone IS NULL;

查询

SELECT * FROM users;
SELECT name AS "姓名", age AS "年龄" FROM users;

SELECT * FROM users WHERE age = 25;
SELECT * FROM users WHERE age > 30;
SELECT * FROM users WHERE age <> 25;  -- 不等于（也可用 !=）

SELECT * FROM users 
WHERE (age < 25 OR age > 30) AND is_active = true;

SELECT * FROM users WHERE dept_id IN (1, 2);
SELECT * FROM users WHERE name NOT IN ('Alice', 'Bob');

# 模糊匹配（LIKE / ILIKE）
-- 名字以 'A' 开头
SELECT * FROM users WHERE name LIKE 'A%';
-- 名字包含 'ar'
SELECT * FROM users WHERE name LIKE '%ar%';
-- 不区分大小写（PostgreSQL 特有）
SELECT * FROM users WHERE name ILIKE 'alice'; -- 可匹配 'Alice', 'ALICE' 等
SELECT * FROM users WHERE name LIKE 'A__e'; -- 如 "Anna", "Aime"（4个字母，首A尾e）
ELECT * FROM users WHERE name ~ '^[AB]';

SELECT * FROM users WHERE dept_id IS NULL;
SELECT * FROM users WHERE dept_id IS NOT NULL;


# 查找属于 'Engineering' 部门的用户
SELECT * FROM users 
WHERE dept_id IN (
    SELECT id FROM departments WHERE name = 'Engineering'
);

# 排序
SELECT * FROM users ORDER BY age DESC;     -- 从大到小
SELECT * FROM users ORDER BY name ASC;     -- 从小到大（默认）
SELECT * FROM users ORDER BY dept_id, age; -- 多列排序

SELECT *
FROM users
ORDER BY name ASC, created_at DESC;

# 第一页，每页2条
SELECT * FROM users ORDER BY id LIMIT 2 OFFSET 0;

更新

UPDATE users SET age = 31, salary = 9500.00 WHERE name = 'Bob';

UPDATE users 
SET salary = salary * 1.1  -- 涨薪10%
WHERE dept_id = 1;         -- Engineering 部门

UPDATE users 
SET updated_at = NOW()     -- 记录更新时间
WHERE id = 1;

UPDATE users 
SET salary = salary * 1.05 
WHERE name = 'Alice'
RETURNING id, name, salary AS new_salary;

删除

DELETE FROM users WHERE is_active = false;

DELETE FROM users 
WHERE name = 'Alice'
RETURNING id, name, email;

DELETE FROM users 
WHERE is_active = false 
ORDER BY created_at ASC  -- 先删最早注册的
LIMIT 1;

ALTER TABLE users DROP COLUMN salary;
drop table users;
-- 级联删除（同时删除依赖它的视图、外键等）
DROP TABLE users CASCADE;

-- 删除索引
DROP INDEX IF EXISTS idx_users_email;
-- 删除约束
ALTER TABLE users DROP CONSTRAINT users_email_key;
-- 删除默认值
ALTER TABLE users ALTER COLUMN age DROP DEFAULT;

用户授权

-- 授权连接数据库
GRANT CONNECT ON DATABASE myapp TO myuser;

-- 授权使用 schema（通常是 public）
GRANT USAGE ON SCHEMA public TO myuser;

-- 授权对所有表的 SELECT（只读）
GRANT SELECT ON ALL TABLES IN SCHEMA public TO myuser;

-- 授权增删改查 + 序列使用（读写）
GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO myuser;
GRANT USAGE ON ALL SEQUENCES IN SCHEMA public TO myuser;

-- 授权未来新建的表也自动继承权限（重要！）
ALTER DEFAULT PRIVILEGES IN SCHEMA public
    GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO myuser;
ALTER DEFAULT PRIVILEGES IN SCHEMA public
    GRANT USAGE ON SEQUENCES TO myuser;

插件

KV

-- 启用插件
CREATE EXTENSION hstore;

-- 创建表
CREATE TABLE products (
    id SERIAL PRIMARY KEY,
    name TEXT,
    attributes HSTORE  -- 存储动态属性
);

-- 插入
INSERT INTO products (name, attributes) VALUES
    ('笔记本电脑', '品牌 => "Dell", 内存 => "16GB", 硬盘 => "512GB SSD"'),
    ('手机', '品牌 => "Apple", 型号 => "iPhone 15", 颜色 => "黑色"');

-- 查询
SELECT name, attributes->'品牌' as brand FROM products;  -- -> 返回 text
SELECT * FROM products WHERE attributes ? '颜色';       -- 是否包含某个 key
SELECT * FROM products WHERE attributes @> '"品牌"=>"Apple"'; -- 包含特定键值对

TSDB

# 添加官方源
echo "deb https://packagecloud.io/timescale/timescaledb/ubuntu/ $(lsb_release -c -s) main" | sudo tee /etc/apt/sources.list.d/timescaledb.list

# 导入 GPG 密钥
curl -L https://packagecloud.io/timescale/timescaledb/gpgkey | sudo apt-key add -

# 安装
sudo apt update
sudo apt install timescaledb-2-postgresql-15

# 自动配置优化参数
sudo timescaledb-tune

sudo systemctl restart postgresql

CREATE EXTENSION IF NOT EXISTS timescaledb CASCADE;

-- 1. 创建普通表（必须包含时间字段）
CREATE TABLE sensor_data (
    time TIMESTAMPTZ NOT NULL,
    sensor_id INTEGER NOT NULL,
    temperature FLOAT,
    humidity FLOAT
);

-- 2. 转换为 Hypertable
SELECT create_hypertable('sensor_data', 'time');

-- 可选：按 sensor_id 分区（空间分区）
SELECT create_hypertable('sensor_data', 'time', partitioning_column => 'sensor_id');

-- 插入数据（完全兼容 INSERT）
INSERT INTO sensor_data (time, sensor_id, temperature, humidity)
VALUES 
    (NOW(), 1, 23.5, 45.0),
    (NOW() - INTERVAL '1 hour', 1, 22.8, 47.2);

-- 查询最近1小时数据（自动只查相关 Chunk，极快！）
SELECT * FROM sensor_data 
WHERE time > NOW() - INTERVAL '1 hour' 
  AND sensor_id = 1
ORDER BY time DESC;

-- 保留最近30天数据，自动删除旧数据
SELECT add_retention_policy('sensor_data', INTERVAL '30 days');

RTThread 笔记

Sat, 06 Sep 2025 00:00:00 +0000

Pre

“官网文档”

标准版

Nano

接口文档笔记

Sun, 31 Aug 2025 00:00:00 +0000

Python 相关

Sun, 20 Jul 2025 00:00:00 +0000

基础

# 算数运算符
+-*/(a**b, b次幂)(// 整除)
# 成员运算符
in , not in

# 字符串运算
print(str)                 # 输出字符串
print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str[0])              # 输出字符串第一个字符
print(str[2:5])            # 输出从第三个开始到第六个的字符（不包含）
print(str[2:])             # 输出从第三个开始后的所有字符
print(str[1:5:2])          # 输出从第二个开始到第五个且每隔一个的字符（步长为2）
print(str * 2)             # 输出字符串两次
print(str + '你好')        # 连接字符串
'''
string1
string2
'''

a= True
b= False

list = [0, 1, 2, 3, 4]
Tuple = (1, 2, 3);
set = {'a', 'a', 'b', 'c', 'd', 'd'}

a = set('abracadabra')
b = set('alacazam')
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素

dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])

# bytes 类型
x = bytes("hello", encoding="utf-8")

# if
if num == 3:
    print 'boss'        
elif num == 2:
    print 'user'
else:
	fn();

# while
while i < 10:   
    i += 1
    if i%2 > 0:     # 非双数时跳过输出
        continue
    else: 
    	break
    print i
else:
	print i

# for
fruits = ['banana', 'apple',  'mango']
for index in range(len(fruits)):
   print ('当前水果 : %s' % fruits[index])

# Number
int(x [,base ])         将x转换为一个整数  
float(x )               将x转换到一个浮点数  
complex(real [,imag ])  创建一个复数  
str(x )                 将对象 x 转换为字符串  
repr(x )                将对象 x 转换为表达式字符串  
eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象  
tuple(s )               将序列 s 转换为一个元组  
list(s )                将序列 s 转换为一个列表  
chr(x )                 将一个整数转换为一个字符  
ord(x )                 将一个字符转换为它的整数值  
hex(x )                 将一个整数转换为一个十六进制字符串  
oct(x )                 将一个整数转换为一个八进制字符串  

# 三角函数

acos(x)	    返回x的反余弦弧度值。
asin(x)	    返回x的反正弦弧度值。
atan(x)	    返回x的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
cos(x)	    返回x的弧度的余弦值。
hypot(x, y)	返回欧几里德范数 sqrt(x*x + y*y)。
sin(x)	    返回的x弧度的正弦值。
tan(x)	    返回x弧度的正切值。
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)	将角度转换为弧度

# 字符串格式化
# usage:
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
 %c	 格式化字符及其ASCII码
 %s	 格式化字符串
 %d	 格式化整数
 %u	 格式化无符号整型
 %o	 格式化无符号八进制数
 %x	 格式化无符号十六进制数
 %X	 格式化无符号十六进制数（大写）
 %f	 格式化浮点数字，可指定小数点后的精度
 %e	 用科学计数法格式化浮点数
 %E	 作用同%e，用科学计数法格式化浮点数
 %g	 %f和%e的简写
 %G	 %F 和 %E 的简写
 %p	 用十六进制数格式化变量的地址

 # 列表
 [['a', 'b', 'c'], [1, 2, 3]]
 x[0][1]
 ## 列表比较
 # 导入 operator 模块
import operator
a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))
## 方法
1	list.append(obj)
在列表末尾添加新的对象
2	list.count(obj)
统计某个元素在列表中出现的次数
3	list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj)
将对象插入列表
6	list.pop([index=-1])
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj)
移除列表中某个值的第一个匹配项
8	list.reverse()
反向列表中元素
9	list.sort( key=None, reverse=False)
对原列表进行排序
10	list.clear()
清空列表
11	list.copy()
复制列表

# With
with open('example.txt', 'r') as file:
    content = file.read()
    print(content)
# 文件已自动关闭

# 函数
def change(a):
    print(id(a))   # 指向的是同一个对象
    a=10
    print(id(a))   # 一个新对象
a=1
print(id(a))
change(a)

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

# lambda
sum = lambda arg1, arg2: arg1 + arg2
print ("相加后的值为 : ", sum( 10, 20 ))

# 装饰器
def decorator_function(original_function):
    def wrapper(*args, **kwargs):
        # 这里是在调用原始函数前添加的新功能
        before_call_code()
        
        result = original_function(*args, **kwargs)
        
        # 这里是在调用原始函数后添加的新功能
        after_call_code()
        
        return result
    return wrapper
@decorator_function
def target_function(arg1, arg2):
# 带参数的写法
def repeat(num_times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("Hello!")

say_hello()

# 自定义模块
## // fib.py
# 斐波那契(fibonacci)数列模块
 
def fib(n):    # 定义到 n 的斐波那契数列
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()
 
def fib2(n): # 返回到 n 的斐波那契数列
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result
## 使用
import fub
fibo.fib(1000)

from math import sqrt as square_root

文件操作

import os

class ScriptParser:
    def __init__(self, input_path, output_path):
        self.input_path = input_path
        self.output_path = output_path

    def read_script(self):
        """从文件中读取脚本内容"""
        try:
            with open(self.input_path, 'r', encoding='utf-8') as file:
                lines = file.readlines()
            return lines
        except FileNotFoundError:
            print(f"错误：文件 {self.input_path} 未找到。")
            return []
        except Exception as e:
            print(f"读取文件时发生错误：{e}")
            return []

    def process_script(self, lines):
        """处理每一行，在其后添加“翻译：”行"""
        processed_lines = []
        for line in lines:
            line = line.rstrip('\n')
            processed_lines.append(line + '\n')
            processed_lines.append("翻译：\n")
        return processed_lines

    def write_script(self, content):
        """将处理后的内容写入新文件"""
        try:
            with open(self.output_path, 'w', encoding='utf-8') as file:
                file.writelines(content)
            print(f"文件已成功写入到 {self.output_path}")
        except Exception as e:
            print(f"写入文件时发生错误：{e}")

    def run(self):
        """运行解析器流程"""
        if not os.path.exists(self.input_path):
            print("输入文件不存在，请检查路径。")
            return

        print("开始读取脚本...")
        lines = self.read_script()

        print("开始处理脚本...")
        processed_lines = self.process_script(lines)

        print("开始写入翻译版脚本...")
        self.write_script(processed_lines)


def main():
    # 示例路径（请根据实际情况修改）
    input_file = "script.txt"
    output_file = "translated_script.txt"

    # 创建解析器实例并运行
    parser = ScriptParser(input_file, output_file)
    parser.run()


if __name__ == "__main__":
    main()

模块

math

math.pi	    # 圆周率 π ≈ 3.141592653589793
math.e	    # 自然对数的底 e ≈ 2.718281828459045
math.tau	# τ = 2π ≈ 6.283185307179586
math.inf	# 表示正无穷大（float 类型）
math.nan	# 表示“非数字”（Not a Number）

abs(x)	        返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	        返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)	    如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x)	        返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	        以浮点数形式返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	    返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	        如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	    返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
modf(x)	        返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	    x**y 运算后的值。
round(x [,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)	        返回数字x的平方根

os

import os
current_directory = os.getcwd()
print("当前工作目录:", current_directory)

os.chdir("/path/to/new/directory")
print("新的工作目录:", os.getcwd())

files_and_dirs = os.listdir()
print("目录内容:", files_and_dirs)

os.mkdir("new_directory")
os.rmdir("new_directory")
os.remove("file_to_delete.txt")
os.rename("old_name.txt", "new_name.txt")
# 获取环境变量
home_directory = os.getenv("HOME")
print("HOME 目录:", home_directory)
# sh
os.system("ls -l")

re(正则表达式)

re.search() 
# 函数用于在字符串中搜索正则表达式的第一个匹配项。与 re.match() 不同，re.search() 不要求匹配从字符串的起始位置开始。
pattern = r"world"
text = "hello world"
match = re.search(pattern, text)

re.sub() 
# 函数用于替换字符串中与正则表达式匹配的部分。
pattern = r"apple"
text = "I have an apple."

new_text = re.sub(pattern, "banana", text)
print("替换后的文本:", new_text)

json

import json
 
# Python 字典类型转换为 JSON 对象
data1 = {
    'no' : 1,
    'name' : 'Runoob',
    'url' : 'http://www.runoob.com'
}
 
json_str = json.dumps(data1)  // 编码
print ("Python 原始数据：", repr(data1))
print ("JSON 对象：", json_str)
 
# 将 JSON 对象转换为 Python 字典
data2 = json.loads(json_str) // 解码
print ("data2['name']: ", data2['name'])
print ("data2['url']: ", data2['url'])

pyecharts

图表类型	pyecharts 类	包引入语句
折线图	Line	`from pyecharts.charts import Line`
柱状图	Bar	`from pyecharts.charts import Bar`
散点图	Scatter	`from pyecharts.charts import Scatter`
饼图	Pie	`from pyecharts.charts import Pie`
雷达图	Radar	`from pyecharts.charts import Radar`
热力图	HeatMap	`from pyecharts.charts import HeatMap`
K 线图	Kline	`from pyecharts.charts import Kline`
箱线图	Boxplot	`from pyecharts.charts import Boxplot`
地图	Map	`from pyecharts.charts import Map`
词云图	WordCloud	`from pyecharts.charts import WordCloud`
仪表盘	Gauge	`from pyecharts.charts import Gauge`
漏斗图	Funnel	`from pyecharts.charts import Funnel`
树图	Tree	`from pyecharts.charts import Tree`
平行坐标系图	Parallel	`from pyecharts.charts import Parallel`
桑基图	Sankey	`from pyecharts.charts import Sankey`
地理坐标系图	Geo	`from pyecharts.charts import Geo`
时间线图	Timeline	`from pyecharts.charts import Timeline`
3D 散点图	Scatter3D	`from pyecharts.charts import Scatter3D`
3D 柱状图	Bar3D	`from pyecharts.charts import Bar3D`
3D 曲面图	Surface3D	`from pyecharts.charts import Surface3D`

from pyecharts import options as opts
from pyecharts.charts import Bar
# 内置主题类型可查看 pyecharts.globals.ThemeType
from pyecharts.globals import ThemeType

# 准备数据
x_data = ['一月', '二月', '三月', '四月', '五月']
y_data = [10, 20, 15, 25, 30]

# 创建柱状图
bar_chart = Bar(init_opts=opts.InitOpts(theme=ThemeType.LIGHT))  # 初始主题为亮色系
bar_chart.add_xaxis(x_data)
bar_chart.add_yaxis("销售额", y_data)

# 配置图表
bar_chart.set_global_opts(
    title_opts=opts.TitleOpts(title="月度销售额柱状图"),
    xaxis_opts=opts.AxisOpts(name="月份"),
    yaxis_opts=opts.AxisOpts(name="销售额（万元）"),
)

# 切换到暗色系主题
bar_chart.set_global_opts(theme=ThemeType.DARK)

# 渲染图表
bar_chart.render("themed_bar_chart.html")

zlib

import zlib

# 要压缩的数据
data = b"This is some data that we're going to compress"

# 使用 zlib.compress() 压缩数据
compressed_data = zlib.compress(data)

print(f"Compressed data: {compressed_data}")

# 使用 zlib.decompress() 解压数据
decompressed_data = zlib.decompress(compressed_data)

print(f"Decompressed data: {decompressed_data}")

import zlib

# 创建一个压缩对象
compressor = zlib.compressobj()

# 分块压缩数据
compressed_chunks = []
for i in range(0, len(data), 10):
    compressed_chunks.append(compressor.compress(data[i:i+10]))
compressed_chunks.append(compressor.flush())

# 创建一个解压对象
decompressor = zlib.decompressobj()

# 分块解压数据
decompressed_chunks = []
for chunk in compressed_chunks:
    decompressed_chunks.append(decompressor.decompress(chunk))
decompressed_chunks.append(decompressor.flush())

# 验证解压后的数据是否和原始数据一致
assert b"".join(decompressed_chunks) == data

socket

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名：client.py
 
import socket               # 导入 socket 模块
 
s = socket.socket()         # 创建 socket 对象
host = socket.gethostname() # 获取本地主机名
port = 12345                # 设置端口号
 
s.connect((host, port))
print s.recv(1024)
s.close()

创建虚拟对象

官方

miniconda

Numpy

import numpy as np

# 创建数组
a = np.array([1, 2, 3])
b = np.array([[1, 2], [3, 4]])
c = np.zeros((3, 3))  # 创建一个3x3的全0数组
d = np.ones((2, 2))   # 创建一个2x2的全1数组
e = np.eye(3)         # 创建一个3x3的单位矩阵
f = np.arange(0, 10, 2)  # 从0到10（不包含），步长为2的数组
g = np.linspace(0, 10, 5)  # 在0到10之间生成5个均匀分布的样本

# 索引和切片
print("b[0, 1] =", b[0, 1])  # 获取b的第一行第二列元素
print("b[:, 1] =", b[:, 1])  # 获取b的所有行的第二列

# 基本运算
print("a + a =", a + a)  # 数组加法
print("a * 2 =", a * 2)  # 数组乘以标量
print("np.dot(b, [[1], [2]]) =", np.dot(b, [[1], [2]]))  # 矩阵乘法

# 广播机制
print("b + a =", b + a)  # 尝试对不同形状的数组执行加法

# 聚合操作
print("a.sum() =", a.sum())  # 数组元素总和
print("b.min() =", b.min())  # 数组最小值
print("b.mean() =", b.mean())  # 数组平均值

# 线性代数运算
h = np.array([[1, 2], [3, 4]])
i = np.linalg.inv(h)  # 求逆矩阵
print("Inverse of h:\n", i)
print("Check inverse:", np.dot(h, i))  # 验证逆矩阵，结果应接近单位矩阵

# 改变数组形状
j = np.arange(6).reshape((2, 3))  # 重塑数组形状
print("Reshaped array:\n", j)

# 随机数生成
k = np.random.rand(2, 3)  # 生成2x3的随机数数组
print("Random array:\n", k)

# 定义两个三维向量
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# 计算点乘
dot_product = np.dot(a, b)
print("Dot product:", dot_product)

# 计算叉乘
cross_product = np.cross(a, b)
print("Cross product:", cross_product)

PyQt

openCV

Pillow

from PIL import Image
import numpy as np

# 打开图像文件
img = Image.open("1.png")
# 转换为numpy数组以进行处理
imgArr = np.array(img)

# 确保图像是RGB图像
if len(imgArr.shape) == 3:
    # 分离RGB通道
    r, g, b = imgArr[:,:,0], imgArr[:,:,1], imgArr[:,:,2]
    # 应用公式转换为灰度
    grayImgArr = 0.299 * r + 0.587 * g + 0.114 * b
else:
    grayImgArr = imgArr

# 将numpy数组转换回图像并显示
gray_img = Image.fromarray(np.uint8(grayImgArr))
gray_img.thumbnail((128,128));
gray_img.show()

# 复制子矩形
box = (100, 100, 400, 400)
region = im.crop(box)

region = region.transpose(Image.ROTATE_180) # 颠倒180度
box = (400, 400, 700, 700)  # 粘贴位置，像素必须吻合，300 * 300
im.paste(region, box)

r, g, b = im.split()
im = Image.merge("RGB", (b, g, r))

out = im.resize((128, 128))
out = out.rotate(45)
im.convert("L"); # 转换成灰阶

ImageFilter

from PIL import Image, ImageFilter
# 打开图像
image = Image.open("example.jpg")

# 应用高斯模糊
blurred = image.filter(ImageFilter.GaussianBlur(radius=2))

# 保存处理后的图像
blurred.save("blurred_example.jpg")

# 显示图像
blurred.show()

result = img.filter(ImageFilter.EDGE_ENHANCE) \
            .filter(ImageFilter.SHARPEN) \
            .filter(ImageFilter.GaussianBlur(0.5))

Matplotlib

Pyplot（plt）

plot()：用于绘制线图和散点图
scatter()：用于绘制散点图
bar()：用于绘制垂直条形图和水平条形图
hist()：用于绘制直方图
pie()：用于绘制饼图
imshow()：用于绘制图像
subplots()：用于创建子图

Usage

import matplotlib.pyplot as plt
import numpy as np

xpoints = np.array([0, 6])
ypoints = np.array([0, 100])

plt.plot(xpoints, ypoints)
plt.show()

Seaborn（Matplotlib 封装）

分布绘图

# histplot: 纯直方图
sns.histplot(df['age'].dropna(), bins=20, kde=True, color='skyblue')

# kdeplot: 核密度估计图（看平滑曲线）
sns.kdeplot(df['age'], shade=True)

# jointplot: 联合分布（同时看两个变量的分布及相关性）
sns.jointplot(x='age', y='fare', data=df, kind='hex') # kind可为'reg','kde','hex'

分类绘图

# boxplot: 箱线图，看离群点和中位数
sns.boxplot(x='day', y='total_bill', data=tips, hue='sex') # hue用于多维度对比

# barplot: 条形图，默认显示平均值和置信区间
sns.barplot(x='sex', y='survived', data=titanic)

# countplot: 计数图，专门统计频数
sns.countplot(x='class', data=titanic, palette='Set3')

矩阵绘图

# heatmap: 热力图，常用于相关系数矩阵
sns.heatmap(df.corr(), annot=True, fmt=".2f", cmap='coolwarm')

# pairplot: 变量两两关系图（神图，快速探索数据集）
sns.pairplot(df, hue='target_column')

MISC

调色板

# 查看当前调色板
sns.color_palette("rocket") 

# 常用分类色板：'Paired', 'Set2', 'husl'
# 常用连续色板：'Blues', 'YlGnBu', 'magma'

背景

1
2

# white / whitegrid / dark / darkgrid / ticks 
sns.set_style("whitegrid")

显示中文

# 指定默认字体
mpl.rcParams['font.sans-serif'] = ['SimHei']  

# 解决保存图像是负号'-'显示为方块的问题 
mpl.rcParams['axes.unicode_minus'] = False

保存图片

#设置一个（12，6）的画布
plt.figure(figsize=(12, 6))

#图形绘制代码
sns.boxplot(data=data,palette=sns.color_palette('Blues')) 

#将画布保存为'xiang.png'，还可以保存为jpg、svg格式图片
plt.savefig('xiang.png')

librosa（音频处理）

# 读取文件(sr 采样率，mono:采样为单声道)
librosa.load(path, sr=22050, mono=True, offset=0.0, duration=None)
# 保存为音频
import soundfile
soundfile.write(file, data, samplerate)

# 读取采样率
librosa.get_samplerate(path)
# 重采样
librosa.resample(y, orig_sr, target_sr, fix=True, scale=False) 
# 读取时长
librosa.get_duration(y=None, sr=22050, S=None, n_fft=2048, hop_length=512, center=True, filename=None)

# 绘制频谱图
librosa.display.specshow(data, x_axis=None, y_axis=None, sr=22050, hop_length=512)

# 短时傅里叶变换
librosa.stft(y, n_fft=2048, hop_length=None, win_length=None, window='hann', center=True, pad_mode='reflect')

# 幅值转dB
librosa.amplitude_to_db(S, ref=1.0)
# 功率转dB
librosa.core.power_to_db(S, ref=1.0)

# 创建mei滤波器组
librosa.filters.mel(sr, n_fft, n_mels=128, fmin=0.0, fmax=None, htk=False, norm=1)
# 计算Mei频谱
librosa.feature.melspectrogram(y=None, sr=22050, S=None, n_fft=2048, hop_length=512, win_length=None, window='hann', center=True, pad_mode='reflect', power=2.0)
# 计算Log-Mel
melspec = librosa.feature.melspectrogram(y, sr, n_fft=1024, hop_length=512, n_mels=128)
logmelspec = librosa.power_to_db(melspec)
# MFCC
librosa.feature.mfcc(y=None, sr=22050, S=None, n_mfcc=20, dct_type=2, norm='ortho', **kwargs)

ROS学习笔记

Sun, 20 Jul 2025 00:00:00 +0000

ROS2

MircoROS

庐山派k230学习笔记

Sun, 20 Jul 2025 00:00:00 +0000

Linux SDK

嘉楠官网Docs

常见问题

如何联网

如何编译

buildroot

ubuntu

实战派学习笔记

Sun, 20 Jul 2025 00:00:00 +0000

按键

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <inttypes.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "driver/gpio.h"


static QueueHandle_t gpio_evt_queue = NULL;

static void IRAM_ATTR gpio_isr_handler(void* arg)
{
    uint32_t gpio_num = (uint32_t) arg;
    xQueueSendFromISR(gpio_evt_queue, &gpio_num, NULL);
}

static void gpio_task_example(void* arg)
{
    uint32_t io_num;
    for(;;) {
        if(xQueueReceive(gpio_evt_queue, &io_num, portMAX_DELAY)) {
            printf("GPIO[%"PRIu32"] intr, val: %d\n", io_num, gpio_get_level(io_num));
        }
    }
}

void app_main(void)
{   
    //结构体
    gpio_config_t io_conf = {};
    // 定义中断
    io_conf.intr_type = GPIO_INTR_NEGEDGE;
    io_conf.mode = GPIO_MODE_INPUT;
    io_conf.pin_bit_mask = 1ULL << GPIO_NUM_0;
    io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
    io_conf.pull_up_en = GPIO_PULLUP_ENABLE;

    gpio_config(&io_conf);

    gpio_evt_queue = xQueueCreate(10, sizeof(uint32_t));
    xTaskCreate(&gpio_task_example, "gpio_task_example", 2048, NULL, 10, NULL);
    gpio_install_isr_service(0);
    gpio_isr_handler_add(GPIO_NUM_0, gpio_isr_handler, (void*) GPIO_NUM_0);
}

esp_err_t gpio_install_isr_service(int intr_alloc_flags);

|0 |默认配置，适用于大多数普通中断 |ESP_INTR_FLAG_LEVEL1 |分配一级中断（低优先级） |ESP_INTR_FLAG_LEVEL2 |分配二级中断（中等优先级） |ESP_INTR_FLAG_LEVEL3 |分配三级中断（高优先级） |ESP_INTR_FLAG_SHARED |允许多个外设共享同一个中断线（多个 GPIO 共用） |ESP_INTR_FLAG_EDGE |指定为边沿触发中断（默认是电平触发）

esp_err_t gpio_isr_handler_add(gpio_num_t gpio_num, gpio_isr_t isr_handler, void *args);

姿态传感器

esp_err_t bsp_i2c_init(void)
{
    i2c_config_t i2c_conf = {
        .mode = I2C_MODE_MASTER,
        .sda_io_num = BSP_I2C_SDA,
        .sda_pullup_en = GPIO_PULLUP_ENABLE,
        .scl_io_num = BSP_I2C_SCL,
        .scl_pullup_en = GPIO_PULLUP_ENABLE,
        .master.clk_speed = BSP_I2C_FREQ_HZ
    };
    i2c_param_config(BSP_I2C_NUM, &i2c_conf);

    return i2c_driver_install(BSP_I2C_NUM, i2c_conf.mode, 0, 0, 0);
}


// 读取QMI8658寄存器的值
esp_err_t qmi8658_register_read(uint8_t reg_addr, uint8_t *data, size_t len)
{
    return i2c_master_write_read_device(BSP_I2C_NUM, QMI8658_SENSOR_ADDR,  &reg_addr, 1, data, len, 1000 / portTICK_PERIOD_MS);
}

// 给QMI8658的寄存器写值
esp_err_t qmi8658_register_write_byte(uint8_t reg_addr, uint8_t data)
{
    uint8_t write_buf[2] = {reg_addr, data};

    return i2c_master_write_to_device(BSP_I2C_NUM, QMI8658_SENSOR_ADDR, write_buf, sizeof(write_buf), 1000 / portTICK_PERIOD_MS);
}

// 初始化qmi8658
void qmi8658_init(void)
{
    uint8_t id = 0; // 芯片的ID号

    qmi8658_register_read(QMI8658_WHO_AM_I, &id ,1); // 读芯片的ID号
    while (id != 0x05)  // 判断读到的ID号是否是0x05
    {
        vTaskDelay(1000 / portTICK_PERIOD_MS);  // 延时1秒
        qmi8658_register_read(QMI8658_WHO_AM_I, &id ,1); // 读取ID号
    }
    ESP_LOGI(TAG, "QMI8658 OK!");  // 打印信息

    qmi8658_register_write_byte(QMI8658_RESET, 0xb0);  // 复位  
    vTaskDelay(10 / portTICK_PERIOD_MS);  // 延时10ms
    qmi8658_register_write_byte(QMI8658_CTRL1, 0x40); // CTRL1 设置地址自动增加
    qmi8658_register_write_byte(QMI8658_CTRL7, 0x03); // CTRL7 允许加速度和陀螺仪
    qmi8658_register_write_byte(QMI8658_CTRL2, 0x95); // CTRL2 设置ACC 4g 250Hz
    qmi8658_register_write_byte(QMI8658_CTRL3, 0xd5); // CTRL3 设置GRY 512dps 250Hz 
}

// 读取加速度和陀螺仪寄存器值
void qmi8658_Read_AccAndGry(t_sQMI8658 *p)
{
    uint8_t status, data_ready=0;
    int16_t buf[6];

    qmi8658_register_read(QMI8658_STATUS0, &status, 1); // 读状态寄存器 
    if (status & 0x03) // 判断加速度和陀螺仪数据是否可读
        data_ready = 1;
    if (data_ready == 1){  // 如果数据可读
        data_ready = 0;
        qmi8658_register_read(QMI8658_AX_L, (uint8_t *)buf, 12); // 读加速度和陀螺仪值
        p->acc_x = buf[0];
        p->acc_y = buf[1];
        p->acc_z = buf[2];
        p->gyr_x = buf[3];
        p->gyr_y = buf[4];
        p->gyr_z = buf[5];
    }
}

// 获取XYZ轴的倾角值
void qmi8658_fetch_angleFromAcc(t_sQMI8658 *p)
{
    float temp;

    qmi8658_Read_AccAndGry(p); // 读取加速度和陀螺仪的寄存器值
    // 根据寄存器值 计算倾角值 并把弧度转换成角度
    temp = (float)p->acc_x / sqrt( ((float)p->acc_y * (float)p->acc_y + (float)p->acc_z * (float)p->acc_z) );
    p->AngleX = atan(temp)*57.29578f; // 180/π=57.29578
    temp = (float)p->acc_y / sqrt( ((float)p->acc_x * (float)p->acc_x + (float)p->acc_z * (float)p->acc_z) );
    p->AngleY = atan(temp)*57.29578f; // 180/π=57.29578
    temp = sqrt( ((float)p->acc_x * (float)p->acc_x + (float)p->acc_y * (float)p->acc_y) ) / (float)p->acc_z;
    p->AngleZ = atan(temp)*57.29578f; // 180/π=57.29578
}
enum qmi8658_reg
{
    QMI8658_WHO_AM_I,
    QMI8658_REVISION_ID,
    QMI8658_CTRL1,
    QMI8658_CTRL2,
    QMI8658_CTRL3,
    QMI8658_CTRL4,
    QMI8658_CTRL5,
    QMI8658_CTRL6,
    QMI8658_CTRL7,
    QMI8658_CTRL8,
    QMI8658_CTRL9,
    QMI8658_CATL1_L,
    QMI8658_CATL1_H,
    QMI8658_CATL2_L,
    QMI8658_CATL2_H,
    QMI8658_CATL3_L,
    QMI8658_CATL3_H,
    QMI8658_CATL4_L,
    QMI8658_CATL4_H,
    QMI8658_FIFO_WTM_TH,
    QMI8658_FIFO_CTRL,
    QMI8658_FIFO_SMPL_CNT,
    QMI8658_FIFO_STATUS,
    QMI8658_FIFO_DATA,
    QMI8658_STATUSINT = 45,
    QMI8658_STATUS0,
    QMI8658_STATUS1,
    QMI8658_TIMESTAMP_LOW,
    QMI8658_TIMESTAMP_MID,
    QMI8658_TIMESTAMP_HIGH,
    QMI8658_TEMP_L,
    QMI8658_TEMP_H,
    QMI8658_AX_L,
    QMI8658_AX_H,
    QMI8658_AY_L,
    QMI8658_AY_H,
    QMI8658_AZ_L,
    QMI8658_AZ_H,
    QMI8658_GX_L,
    QMI8658_GX_H,
    QMI8658_GY_L,
    QMI8658_GY_H,
    QMI8658_GZ_L,
    QMI8658_GZ_H,
    QMI8658_COD_STATUS = 70,
    QMI8658_dQW_L = 73,
    QMI8658_dQW_H,
    QMI8658_dQX_L,
    QMI8658_dQX_H,
    QMI8658_dQY_L,
    QMI8658_dQY_H,
    QMI8658_dQZ_L,
    QMI8658_dQZ_H,
    QMI8658_dVX_L,
    QMI8658_dVX_H,
    QMI8658_dVY_L,
    QMI8658_dVY_H,
    QMI8658_dVZ_L,
    QMI8658_dVZ_H,
    QMI8658_TAP_STATUS = 89,
    QMI8658_STEP_CNT_LOW,
    QMI8658_STEP_CNT_MIDL,
    QMI8658_STEP_CNT_HIGH,
    QMI8658_RESET = 96
};

前端八股文笔记

Tue, 01 Jul 2025 00:00:00 +0000

minio (js版)

import * as Minio from 'minio'

const minioClient = new Minio.Client({
  endPoint: 'play.min.io',
  port: 9000,
  useSSL: true,
  accessKey: 'Q3AM3UQ867SPQQA43P2F',
  secretKey: 'zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG',
})

存储桶操作

// 创建存储桶
minioClient.makeBucket('mybucket', 'us-east-1',function (err) {
  if (err) return console.log('Error creating bucket with object lock.', err)
  console.log('Bucket created successfully in "us-east-1" and enabled object lock')
})

// removeBucket
try {
  await minioClient.removeBucket('mybucket')
  console.log('Bucket removed successfully.')
} catch (err) {
  console.log('unable to remove bucket.')
}

// setBucketLifecycle
const lifecycleConfig = {
  Rule: [
    {
      ID: 'Transition and Expiration Rule',
      Status: 'Enabled',
      Filter: {
        Prefix: '',
      },
      Expiration: {
        Days: '3650',
      },
    },
  ],
}

await minioClient.setBucketLifecycle('bucketname', lifecycleConfig)

// removeBucketLifecycle
await minioClient.removeBucketLifecycle('bucketname')

对象操作

// 对象流式下载
let size = 0
const dataStream = await minioClient.getObject('mybucket', 'photo.jpg')
dataStream.on('data', function (chunk) {
  size += chunk.length
})
dataStream.on('end', function () {
  console.log('End. Total size = ' + size)
})
dataStream.on('error', function (err) {
  console.log(err)
})

// 获取加密对象
const dataStream = await minioClient.getObject('mybucket', 'photo.jpg', {
  SSECustomerAlgorithm: 'AES256',
  SSECustomerKey: 'YOUR_KEY',
  SSECustomerKeyMD5: 'YOUR_MD5',
})

// 下载对象并将其保存为本地文件系统中的文件
minioClient.fGetObject('mybucket', 'photo.jpg', '/tmp/photo.jpg', function (err) {
  if (err) {
    return console.log(err)
  }
  console.log('success')
})

// fPutObject(bucketName, objectName, filePath, metaData[, callback])
const file = '/tmp/40mbfile'
const metaData = {
  'Content-Type': 'text/html',
  'Content-Language': 123,
  'X-Amz-Meta-Testing': 1234,
  example: 5678,
}
minioClient.fPutObject('mybucket', '40mbfile', file, metaData, function (err, objInfo) {
  if (err) {
    return console.log(err)
  }
  console.log('Success', objInfo.etag, objInfo.versionId)
})

// 获取对象的元数据
const stat = await minioClient.statObject('mybucket', 'photo.jpg')
console.log(stat)  //size, etag, version, metadata, lastModified(time-stamp)

// removeObject
await minioClient.removeObject('mybucket', 'photo.jpg')

// removeObjects
const objectsList = []

// List all object paths in bucket my-bucketname.
const objectsStream = s3Client.listObjects('my-bucketname', 'my-prefixname', true)

objectsStream.on('data', function (obj) {
  objectsList.push(obj.name)
})

objectsStream.on('error', function (e) {
  console.log(e)
})

objectsStream.on('end', async () => {
  await s3Client.removeObjects(bucket, objectsList)
})

const offsetY = event.nativeEvent.contentOffset.y;
setScrollY(offsetY);

rn如何与webview通信(react-native-webview)

import React, { useRef } from 'react';
import { View } from 'react-native';
import { WebView } from 'react-native-webview';

const MyWebComponent = () => {
  const webviewRef = useRef(null);

  const sendToWebView = () => {
    if (webviewRef.current) {
      webviewRef.current.injectJavaScript(`yourJavaScriptCodeHere`);
    }
  };

  return (
    <View style={{ flex: 1 }}>
      <WebView
        ref={webviewRef}
        source={{ uri: 'https://example.com' }}
        onMessage={(event) => console.log('Message from webview:', event.nativeEvent.data)}
        injectedJavaScript="window.onload=function(){window.ReactNativeWebView.postMessage('hello from webview')};"
      />
    </View>
  );
};

react 笔记

Sat, 14 Jun 2025 00:00:00 +0000

TS 速查

显示声明

boolean
string
number
bigint // 大整数 ，与number不兼容
symbol
object
undefined
null

let x: any;
let var_name: string = "String";
function fuc(a:string ,b?:string) {

}
function fn(x: string | number)
let gender: "male" | "female";


// any 的污染问题
let x: any = "hello";
let y: number;

y = x; // 不报错

y * 123; // 不报错
y.toFixed(); // 不报错
// solvor: unknown
let v: unknown = 123;

let v1: boolean = v; // 报错
let v2: number = v; // 报错
// never
never类型的一个重要特点是，可以赋值给任意其他类型。
function f(): never {
  throw new Error("Error");
}

let v1: number = f(); // 不报错
let v2: string = f(); // 不报错
let v3: boolean = f(); // 不报错


// 含包装对象与不含包装对象
"hello"; // 字面量
new String("hello"); // 包装对象

Boolean 和 boolean
String 和 string
Number 和 number
BigInt 和 bigint
Symbol 和 symbol


// 交叉类型
let obj: { foo: string } & { bar: string };

obj = {
  foo: "hello",
  bar: "world",
};


// type
type Age = number;

let age: Age = 55;


//数组
let arr: (number | string)[];


//元组
type t = readonly [number, string];
type myTuple = [number, number, number?, string?];

type t1 = [string, number, ...boolean[]];
type t2 = [string, ...boolean[], number];
type t3 = [...boolean[], string, number];


// 函数
// 写法一
const hello = function (txt: string) {
  console.log("hello " + txt);
};

// 写法二
const hello: (txt: string) => void = function (txt) {
  console.log("hello " + txt);

const repeat = (str: string, times: number): string => str.repeat(times);
};
function f(x?: number)// 可选参数
// 函数结构
function sum({ a, b, c }: { a: number; b: number; c: number }) {
  console.log(a + b + c);
}


// 类型断言
type T = "a" | "b" | "c";

let foo = "a";
let bar: T = foo as T; // 正确

// interface
interface Person {
  firstName: string;
  lastName: string;
  age: number;
}

// 类
class Point {
  x: number;
  y: number;

  constructor(x: number, y: number) {
    this.x = x;
    this.y = y;
  }

  add(point: Point) {
    return new Point(this.x + point.x, this.y + point.y);
  }
}

// 泛型
function getFirst<T>(arr: T[]): T {
  return arr[0];
}

hooks

useState

自动触发渲染

useRef

不自动触发渲染

1
2

const ref = useRef(0);
ref.current 属性访问该 ref 的当前值

useContext (自己可以实现一个Zustand)

上下文钩子 Usage:

// 首先要将 provider 包裹App，你也可以包在需要的组件上，只是这样方便能把一些库的Provider放一起管理（）
const AppContext = React.createContext({});
<AppContext.Provider value={{
  username: '666'
}}>
    <App/>
</AppContext.Provider>

// 在其他组件的使用
const { username } = useContext(AppContext)

可以放在那里

1.自定义Toast组件 2.主题切换

useEffect

副作用钩子 + 首次加载时执行

1
2
3

    useEffect(()=>{

    },[需要添加副作用的变量]);

灵感

1.用于从后端加载数据

useCallback

缓存函数（组件），防止造成不必要的重新渲染.
保持函数的引用稳定

 // 缓存回调函数
  const handleItemClick = useCallback((item) => {
    alert("你点击了：" + item);
  }, []);

useMemo

缓存变量

  const filteredItems = useMemo(() => {
    console.log("过滤列表");
    return ["苹果", "香蕉", "橙子", "西瓜"].filter(item =>
      item.includes(filter)
    );
  }, [filter]);

随便写个组件

import React, { useState } from 'react';

const CardComponent = ({ children }) => {
  const [isHighlighted, setIsHighlighted] = useState(false);

  const toggleHighlight = () => {
    setIsHighlighted(!isHighlighted);
  };

  return (
    <div
      className={`p-6 border rounded-lg shadow-md transition-all duration-300 ${
        isHighlighted ? 'bg-blue-100 border-blue-500' : 'bg-white border-gray-300'
      }`}
    >
      <h2 className="text-xl font-semibold mb-4">Card Title</h2>
      <div className="mb-4">
        {children}
      </div>
      <button
        onClick={toggleHighlight}
        className="px-4 py-2 bg-blue-500 text-white rounded hover:bg-blue-600 focus:outline-none"
      >
        {isHighlighted ? 'Remove Highlight' : 'Highlight'}
      </button>
    </div>
  );
};

export default CardComponent;

zustand

一般业务场景只有管理auth时才会用，所以找个模板直接抄就行（bushi）其实redux也简单，但是一上到写addCase的程度就麻烦起来了（兄啊，不写这个的话好像也没必要用这个吧）

// stores/authStore.js
import { create } from 'zustand';

const useAuthStore = create((set) => {
  const savedToken = localStorage.getItem('token');
  const savedUser = savedToken ? { id: 1, name: 'Alice' } : null;

  return {
    user: savedUser,
    token: savedToken,
    isAuthenticated: !!savedToken,

    login: (userData, token) => {
      localStorage.setItem('token', token);
      set({ user: userData, token, isAuthenticated: true });
    },

    logout: () => {
      localStorage.removeItem('token');
      set({ user: null, token: null, isAuthenticated: false });
    },
  };
});

export default useAuthStore;

// 使用
// components/UserInfo.jsx
import React from 'react';
import useAuthStore from '../stores/authStore';

const UserInfo = () => {
  const { user, isAuthenticated } = useAuthStore();

  return (
    <div>
      {isAuthenticated ? (
        <p>Welcome, {user.name}</p>
      ) : (
        <p>You are not logged in.</p>
      )}
    </div>
  );
};

export default UserInfo;
// 处理
// components/LogoutButton.jsx
import React from 'react';
import useAuthStore from '../stores/authStore';

const LogoutButton = () => {
  const logout = useAuthStore((state) => state.logout);

  return <button onClick={logout}>Logout</button>;
};

export default LogoutButton;

tailwind

pre

1
2

npm install -D tailwindcss
npx tailwindcss init

// tailwind.config.js
/** @type {import('tailwindcss').Config} */
module.exports = {
  content: ["./src/**/*.{html,js}"],
  theme: {
    extend: {},
  },
  plugins: [],
}

/*src/input.css*/
@tailwind base;
@tailwind components;
@tailwind utilities;

`1`	`npx tailwindcss -i ./src/input.css -o ./src/output.css --watch`

基础

<div class="px-2 mx-2 border border-gray-300 rounded-full dark:... hover:... focus:... ring(环) ring-[#fff] acitve:">
  <Text class="font-bold text-xl text-gray-300">...</Text>
</div>

<div class="flex-1 flex-row first:pt-0 last:pb-0 odd:bg-white(奇数) even:bg-slate-50（偶数）(数组控制) selection:bg-fuchsia-300 selection:text-fuchsia-900"></div>

<input type="" name="" class="disabled: focus: invaild: placeholder:"/>

<div class="group"> // 父元素变化传递
  <div class="group-hover:"></div>
</div>

<input type="file" class="block
  file:mr-4 file:py-2 file:px-4
  file:rounded-full file:border-0
  file:text-sm file:font-semibold
  file:bg-violet-50 file:text-violet-700
  hover:file:bg-violet-100
"/>

<p class="first-line:uppercase first-line:tracking-widest
  first-letter:text-7xl first-letter:font-bold first-letter:text-slate-900
  first-letter:mr-3 first-letter:float-left
">
  Well, let me tell you something, funny boy. Y'know that little stamp, the one
  that says "New York Public Library"? Well that may not mean anything to you,
  but that means a lot to me. One whole hell of a lot.
</p>

<div class="grid grid-cols-3 md:grid-cols-4 lg:grid-cols-6">
  <!-- ... -->
</div>

<div class="grid grid-cols-4 gap-4">
  <div>01</div>
  <!-- ... -->
  <div>05</div>
  <div class="grid grid-cols-subgrid gap-4 col-span-3">
    <div class="col-start-2">06</div>
  </div>
</div>

// 效果
<div class="blur-lg drop-shadow-sm"></div>
// 渐变
<div class="bg-gradient-to-r from-cyan-500 to-blue-500 w-full h-64">
  <!-- 内容 -->
</div>

响应式

注意：tailwind 中断点是min而不是max

| Breakpoint prefix | Minimum width | CSS                                  |
|-------------------|---------------|--------------------------------------|
| `sm`              | 640px         | `@media (min-width: 640px) { ... }`  |
| `md`              | 768px         | `@media (min-width: 768px) { ... }`  |
| `lg`              | 1024px        | `@media (min-width: 1024px) { ... }` |
| `xl`              | 1280px        | `@media (min-width: 1280px) { ... }` |
| `2xl`             | 1536px        | `@media (min-width: 1536px) { ... }` |

`1`	`<div class="text-center sm:text-left"></div>`

定制

/** @type {import('tailwindcss').Config} */
module.exports = {
  theme: {
    screens: {
      sm: '480px',
      md: '768px',
      lg: '976px',
      xl: '1440px',
    },
    colors: {
      'blue': '#1fb6ff',
      'purple': '#7e5bef',
      'pink': '#ff49db',
      'orange': '#ff7849',
      'green': '#13ce66',
      'yellow': '#ffc82c',
      'gray-dark': '#273444',
      'gray': '#8492a6',
      'gray-light': '#d3dce6',
    },
    fontFamily: {
      sans: ['Graphik', 'sans-serif'],
      serif: ['Merriweather', 'serif'],
    },
    extend: {
      spacing: {
        '128': '32rem',
        '144': '36rem',
      },
      borderRadius: {
        '4xl': '2rem',
      }
    }
  }
}

socket.io

  useEffect(() => {
    if (!user || !accessToken || !chatId) return;

    const newSocket = io(BASE_INFO.BASE_SOCKET_URL, {
      auth: {
        token: accessToken,
        room_id: String(chatId),
      },
      transports: ['websocket'],
      reconnectionAttempts: Infinity,
    });
    // 认证失败拦截器
    setupSocketIOInterceptor(newSocket);
    
    newSocket.on('connect', () => {
      console.log('Socket 已连接');
    });

    newSocket.on('disconnect', (reason) => {
        console.log('Socket 断开连接:', reason);
        if (reason === 'io server disconnect') {
          newSocket.connect(); // 主动重连
        }
      });

    newSocket.on('receive:message', handleNewMessage);
    newSocket.on('message:error', handleMessageError);

    setSocket(newSocket);

    return () => {
      newSocket.off('receive:message', handleNewMessage);
      newSocket.off('message:error', handleMessageError);
      newSocket.disconnect();
    };
  }, [user, accessToken, chatId, handleNewMessage, handleMessageError]);

拦截器

import { getItemFromAsyncStorage, setItemToAsyncStorage } from "./LocalStorage";
import { refreshAccessToken } from "./LoginUtil";

let isRefreshing = false;
let failedQueue = [];

const processQueue = (error, token = null) => {
  failedQueue.forEach((prom) => {
    if (error) {
      prom.reject(error);
    } else {
      prom.resolve(token);
    }
  });

  failedQueue = [];
};

export function setupSocketIOInterceptor(socket) {
  const originalConnect = socket.connect.bind(socket);
  socket.connect = function (...args) {
    socket.on('connect_error', async (error) => {
      if (error.message.includes('jwt expired') || error.message.includes('invalid token')) {
        if (isRefreshing) {
          return new Promise((resolve, reject) => {
            failedQueue.push({ resolve, reject });
          })
            .then((token) => {
              socket.auth.token = token;
              originalConnect();
            })
            .catch((err) => {
              console.error('Failed to refresh token:', err);
            });
        }

        isRefreshing = true;

        try {
          const oldRefreshToken = await getItemFromAsyncStorage("refreshToken");
          const { refreshToken, accessToken } = await refreshAccessToken(oldRefreshToken);

          await setItemToAsyncStorage("accessToken", accessToken);
          await setItemToAsyncStorage("refreshToken", refreshToken);

          socket.auth.token = accessToken;
          processQueue(null, accessToken);
          
          // 重新连接
          originalConnect();
        } catch (err) {
          processQueue(err, null);
          console.error("刷新 token 失败:", err);
        } finally {
          isRefreshing = false;
        }
      }
    });

    originalConnect(...args);
  };

  return socket;
}

axios

const response = axios.get(`BASE_URL`);
axios.post(
  'https://xxx.com',
  { param1, param2 },
  {
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json'
    }
  }
);

axios.post('https://api.example.com/submit', {
  firstName: 'Alice',
  lastName: 'Smith'
})
.then(response => console.log(response.data))
.catch(error => console.error(error));

Electron

main

import { app, BrowserWindow, ipcMain, fs, path } from 'electron';

let mainWindow;

function createWindow() {
  mainWindow = new BrowserWindow({
    width: 1000,
    height: 600,
    webPreferences: {
      preload: path.resolve('preload.js'),
      contextIsolation: true,
      sandbox: true
    }
  });

  mainWindow.loadFile('index.html');
  // mainWindow.webContents.openDevTools();
}

app.whenReady().then(createWindow);

app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') {
    app.quit();
  }
});

app.on('activate', () => {
  if (BrowserWindow.getAllWindows().length === 0) {
    createWindow();
  }
});

// 🔄 双向通信：渲染进程请求，主进程响应
ipcMain.handle('read-file', async (event, filePath) => {
  try {
    const fullPath = path.resolve(filePath);
    const data = await fs.promises.readFile(fullPath, 'utf-8');
    return { success: true, content: data };
  } catch (err) {
    return { success: false, error: err.message };
  }
});

// 📢 主进程主动发送消息给渲染进程
setInterval(() => {
  if (mainWindow && !mainWindow.isDestroyed()) {
    mainWindow.webContents.send('main-to-renderer', {
      message: '这是主进程主动发送的消息！',
      timestamp: Date.now()
    });
  }
}, 5000); // 每5秒推送一次

preload

import { contextBridge, ipcRenderer } from 'electron';

contextBridge.exposeInMainWorld('electronAPI', {
  // 🔄 双向通信：调用主进程并等待结果
  readFile: (filePath) => ipcRenderer.invoke('read-file', filePath),
  // 💬 主进程推送：注册监听器
  onMessageFromMain: (callback) => ipcRenderer.on('main-to-renderer', callback)
});

renderer

document.addEventListener('DOMContentLoaded', () => {
  const output = document.getElementById('output');
  const input = document.getElementById('file-path');

  // 💬 主进程主动发送的消息监听
  window.electronAPI.onMessageFromMain((event, message) => {
    const msgDiv = document.createElement('div');
    msgDiv.textContent = `[主进程消息] ${message.message} - ${new Date(message.timestamp).toLocaleTimeString()}`;
    document.body.appendChild(msgDiv);
  });

  // 🔄 渲染进程请求主进程读取文件
  document.getElementById('btn-read').addEventListener('click', async () => {
    const filePath = input.value;
    if (!filePath) return;

    try {
      const result = await window.electronAPI.readFile(filePath);
      if (result.success) {
        output.textContent = result.content;
      } else {
        output.textContent = '读取失败：' + result.error;
      }
    } catch (err) {
      output.textContent = '发生错误：' + err;
    }
  });
});

Posts on Aobara的Blog

Elysia Js Note

路由

常用

分组路由

前缀

生命周期

Interger with OpenAPI

Lua 学习笔记

Lua 速查表（Lua 5.5）

一、基础语法

1. 变量

2. 数据类型

二、运算符

1. 算术

2. 比较

3. 逻辑

三、控制结构

1. if

2. 循环

while

repeat

for 数值循环

for 泛型循环

四、函数

1. 基础定义

2. 局部函数

3. 可变参数

4. 多返回值

五、Table

1. 创建

2. 数组与字典混合

3. 删除元素

4. table库

六、字符串

常用函数

七、错误处理

error

pcall

八、元表

常见元方法

__index 示例

九、简单面向对象

十、协程

常用函数

十一、模块

require

十二、重要语义总结

LVGL 学习笔记

概念

对象(lv_obj_t)

LVGL的三层屏幕

基础操作

对齐方式

盒子模型

Widget

标签(lv_label)

按钮(lv_btn)

与按键相关的Group Events

开关(lv_switch)

Part

Usage

Style

样式状态

Exmaple

过渡

主题

Events

Event bubbling（事件冒泡）

Custom events（自定义事件）

Refresh event（刷新事件）

MISC

自定义字体

转换

常用字体范围

使用

图标的使用

DrawAPI

i18n

BouffaloSDK笔记