不知名LZJ的博客 https://www.mcoi.top/ 分享技术与经历 | 学习嵌入式ing Tue, 15 Sep 2026 06:30:35 GMT https://validator.w3.org/feed/docs/rss2.html https://github.com/jpmonette/feed zh-CN All rights reserved 2026, L_Z_J <![CDATA[【MatterChipTool环境】在Ubuntu下搭建python-matter-server、Chip-tool、chip-lighting-app 并简单运用]]> https://www.mcoi.top/article/Post-matter-chiptool-ubuntu-python-matter-server-chip-lighting-app https://www.mcoi.top/article/Post-matter-chiptool-ubuntu-python-matter-server-chip-lighting-app Mon, 01 Dec 2025 00:00:00 GMT
子系统配置为：在Windows11环境下配置WSL Ubuntu24.04子系统， 也可以使用虚拟机例如VMware等

Python Matter 服务器配置

写在前面
注意今后每次开启服务器时都需要先进入虚拟环境

步骤 1：创建并激活虚拟环境

安装 Python 虚拟环境、pip 和（理论上）蓝牙支持：
验证一下蓝牙（多半是没有设备的，这是预期现象）：
创建并激活虚拟环境：
激活后，命令行前面会有前缀：

步骤 2：升级 pip

虚拟环境就位后，先升级 pip：
此时使用的是虚拟环境里的 pip，不会影响系统全局环境。

步骤 3：安装 python-matter-server

安装核心包：
安装成功后，可执行文件在虚拟环境的 bin 目录下，确认一下路径：

步骤 4：一次性补齐 Python 依赖

实际运行过程中，matter-server 会在导入阶段不断暴露出缺少的模块。最开始我是通过多次执行 matter-server --help，一个个看缺什么再装什么，依次踩到了：
  • cryptography
  • chip.exceptions（来自 home-assistant-chip-core）
  • zeroconf
  • atomicwrites
为了让后来的人少走弯路，可以直接一次性补齐这些依赖：
依赖全部装完后，可以先试：
如果能正常输出 Usage/Options 帮助，而不是 ModuleNotFoundError，说明 Python 层依赖已经齐了。

步骤 5：补充系统库依赖（libnl）

启动时，底层 CHIP 栈会加载一些系统动态库。如果缺失，会看到类似这样的错误：
这说明缺少 Netlink 相关的系统库。直接在 Ubuntu/WSL 中安装：
安装完成后，可以确认一下库文件是否存在：
到这里，底层系统库就准备好了。

步骤 6：解决 CHIP 在 /data 下写配置失败的问题

系统库装好后，再次启动 matter-server，会看到 CHIP 栈开始初始化失败：
核心问题是：CHIP 试图在 /data 目录下写入 chip_factory.ini，但默认的 WSL Ubuntu 并不存在 /data 这个目录，导致初始化失败。
一个简单粗暴、实测有效的解决方案：把 /data 软链接到我们自己的配置目录 ~/.matter_server。
先确保存储路径存在：
然后创建软链接：
检查一下链接是否正确：
这样，当 CHIP 再次尝试访问 /data/chip_factory.ini 时，实际就会落在 ~/.matter_server/chip_factory.ini，文件可以正常创建，栈也能顺利初始化。

步骤 7：正式启动 matter-server

准备好目录之后，就可以正式启动了：
参数说明：
  • -storage-path ~/.matter_server：用于保存配网信息、证书等持久化数据；
  • -port 5580：matter-server 暴露的 HTTP / WebSocket 端口；
  • -log-level DEBUG：开启详细日志，方便调试。
• 注意：新版本已经不支持旧文中的 -v 参数，使用 --log-level 代替。
如果一切正常，此时你会在终端看到类似下面的输出，并且不会再出现 traceback / core dumped：
2025-12-01 17:xx:xx.xxx (MainThread) DEBUG [matter_server.server.stack] Using storage file: ~/.matter_server/chip.json - Bluetooth commissioning enabled: NO
[...... 后面是 CHIP:CTL / CHIP:DL 等日志 ......]
source ~/matter-python-server/bin/activate
curl -v http://127.0.0.1:5580/
sudo apt update
sudo apt install -y git gcc g++ pkg-config libssl-dev libdbus-1-dev \
libglib2.0-dev libavahi-client-dev ninja-build python3-venv \
python3-dev python3-pip unzip libgirepository1.0-dev libcairo2-dev \
libreadline-dev libncurses-dev
cd ~
git clone https://github.com/project-chip/connectedhomeip.git
cd connectedhomeip

初始化/拉依赖（第一次会稍久）

source scripts/bootstrap.sh
source scripts/activate.sh

--- 步骤 A: 编译 chip-tool (Matter 控制器) ---

1. 在根目录生成构建配置

gn gen out/debug

2. 编译 chip-tool

ninja -C out/debug chip-tool

编译完成后，chip-tool 可执行文件位于：out/debug/chip-tool

--- 步骤 B: 编译 chip-lighting-app (模拟灯泡设备) ---

注意：示例应用需要进入对应的目录单独编译，不能直接在根目录编译

1. 进入 lighting-app 的 Linux 示例目录

cd examples/lighting-app/linux

2. 为该应用生成独立的构建配置 (这一步会在当前目录下生成一个新的 out/debug)

gn gen out/debug

3. 开始编译

ninja -C out/debug

编译完成后，模拟灯泡的可执行文件位于：

examples/lighting-app/linux/out/debug/chip-lighting-app

cd ~/connectedhomeip

把 .gitmodules 中所有 https://github.com/ 替换为代理前缀

sed -i 's|https://github.com/|https://hk.gh-proxy.org/https://github.com/|g' .gitmodules
grep -A2 'submodule "pigweed"' .gitmodules
grep -A2 'submodule "qrcode"' .gitmodules
[submodule "qrcode"]path = examples/common/QRCode/repourl = https://hk.gh-proxy.org/https://github.com/nayuki/QR-Code-generator.git
[submodule "pigweed"]path = third_party/pigweed/repourl = https://hk.gh-proxy.org/https://github.com/google/pigweed.git
git submodule sync
git submodule update --init --recursive
pip install pproxy

启动转换：将本机的 8888 端口转发到 VPN 的 1080 端口

注意：请根据你实际的 VPN 端口修改 1080

pproxy -l http://:8888 -r socks5://127.0.0.1:1080 -v

设置环境变量强制走代理 (指向刚才 pproxy 设置的 8888 端口)

export http_proxy="http://127.0.0.1:8888"
export https_proxy="http://127.0.0.1:8888"
export all_proxy="http://127.0.0.1:8888"

防止代理本地流量

export no_proxy="localhost,127.0.0.1,::1"

验证网络 (应返回 200 OK)

curl -I https://www.google.com

配置 Git 代理

git config --global http.proxy http://127.0.0.1:8888
git config --global https.proxy http://127.0.0.1:8888

--- 开始初始化 ---

这步会下载 Pigweed 环境和 CIPD 依赖，网速快的话约 5-10 分钟

source scripts/bootstrap.sh
#注意后续取消代理
ls ~/connectedhomeip/out/debug/chip-tool
ls ~/connectedhomeip/examples/lighting-app/linux/out/debug/chip-lighting-app
cd ~/connectedhomeip/examples/lighting-app/linux
./out/debug/chip-lighting-app --discriminator 3840 --passcode 20202021
Setup Pin Code ...: 20202021
Setup Discriminator ...: 3840
...
[SC] Waiting for PBKDF param request
[DIS] CHIP minimal mDNS configured as 'Commissionable node device'
cd ~/connectedhomeip
source scripts/activate.sh
./out/debug/chip-tool pairing onnetwork 1 20202021 \
--paa-trust-store-path ~/connectedhomeip/credentials/development/paa-root-certs
[TOO] Secure Pairing Success
[TOO] CASE establishment successful
[CTL] Commissioning complete for node ID 0x0000000000000001: success
[TOO] Device commissioning completed with success
开灯
./out/debug/chip-tool onoff on 1 1

关灯

./out/debug/chip-tool onoff off 1 1
[ZCL] Toggle ep1 on/off from state 0 to 1
source ~/matter-python-server/bin/activate
matter-server \
--storage-path ~/.matter_server \
--port 5580 \
--log-level DEBUG
cd ~/connectedhomeip/examples/lighting-app/linux
./out/debug/chip-lighting-app --discriminator 3840 --passcode 20202021
Setup Pin Code ...: 20202021
Setup Discriminator ...: 3840
[DIS] CHIP minimal mDNS configured as 'Commissionable node device'
[SC] Waiting for PBKDF param request
rm -f /tmp/chip_*
ifconfig
http://172.22.133.5:5580/
CHIP_ERROR [chip.native.-] Unable to find PAA, err: ... CHIP Error 0x0000004A: CA certificate not found, PAI's AKID: 6A:FD:22:77:1F:51:1F:EC:BF:16:41:97:67:10:DC:DC:31:A1:71:7E
CHIP_ERROR [chip.native.CTL] Failed in verifying 'Attestation Information' command received from the device: err 101 (PAA not found in DCL and/or local PAA trust store)
CHIP_ERROR [chip.native.CTL] Error on commissioning step 'AttestationVerification': '... Failed Device Attestation'
cd ~/connectedhomeip/credentials/test/attestation
openssl x509 -in "Chip-Test-PAA-FFF1-Cert.pem" -noout -text | grep -A1 "Subject Key Identifier"
X509v3 Subject Key Identifier:
6A:FD:22:77:1F:51:1F:EC:BF:16:41:97:67:10:DC:DC:31:A1:71:7E
cd ~/connectedhomeip/credentials/test/attestation
openssl x509 \
-in Chip-Test-PAA-FFF1-Cert.pem \
-outform der \
-out 6AFD22771F511FECBF1641976710DCDC31A1717E.der
hexdump -C 6AFD22771F511FECBF1641976710DCDC31A1717E.der | head

1. 建立中划线版本的默认目录

mkdir -p ~/.matter-server/paa-root-certs

2. 把 DER 文件复制进去

cp ~/connectedhomeip/credentials/test/attestation/6AFD22771F511FECBF1641976710DCDC31A1717E.der \
~/.matter-server/paa-root-certs/
source ~/matter-python-server/bin/activate
MATTER_PAA_ROOT_CERTS_DIR=~/.matter-server/paa-root-certs \
matter-server \
--storage-path ~/.matter_server \
--port 5580 \
--log-level DEBUG \
--paa-root-cert-dir ~/.matter-server/paa-root-certs
  • 日志里不再有 Unable to find PAA、CA certificate not found、PAA not found in DCL and/or local PAA trust store；
  • 设备证明（AttestationVerification）成功，后续网络配置和访问控制步骤可以继续执行，灯泡最终成功“收进来”。
结果如图：
notion image
notion image
notion image
由于Server是通过自身暴露的 API（REST/WebSocket/其它 RPC）由“客户端”（浏览器、自动化系统、Home Assistant 等）通过这些 API 去控制设备
所以。。。。。。。。。
]]> <![CDATA[STM32-HAL库学习笔记]]> https://www.mcoi.top/article/Post-stm32-hal https://www.mcoi.top/article/Post-stm32-hal Tue, 01 Oct 2024 00:00:00 GMT
😀
一个简单的开头

介绍

此笔记为观看B站UP：超子说物联网所写，感谢老师。老师的架构真的特别好！
我在学习HAL库之前有标准库基础，所以学习稍快，但会尽量详细记录
笔记和项目文件在gitee开源了
大家可以在我的gitee仓库 中下载笔记源文件、STM32F1C8T6资料等
笔记源文件可以在Notion中导入
正在更新~
超子物联网 HAL库学习 写作不易，如果您觉得写的不错，欢迎给博主来一波点赞、收藏~让博主更有动力吧！

内容导航

子页面开头

超子物联网 HAL库学习 汇总入口：超子物联网HAL库笔记：[汇总] 写作不易，如果您觉得写的不错，欢迎给博主来一波点赞、收藏~让博主更有动力吧！
 

准备篇

1. HAL库简介

HAL库
  • HAL库（Hardware Abstraction Layer）是STMicroelectronics提供的STM32微控制器的硬件抽象层库。
  • 它通过一套统一的API接口，简化了对STM32外设的配置和操作，使开发者能够更快速地进行嵌入式系统开发，而不必深入了解底层硬件细节。
HAL库的优点
  • 高层次抽象：HAL库提供了高层次的抽象接口，简化了对硬件外设的操作。开发者可以通过调用库函数完成复杂的硬件配置，而不必直接操作寄存器。
  • 易于使用：由于提供了丰富的库函数和示例代码，开发者可以快速上手进行开发，减少了开发时间。
  • 一致性和移植性：HAL库在不同的STM32系列中保持了一致的API接口，增强了代码的移植性和重用性。如果需要更换STM32系列微控制器，代码的修改量较小。
  • 简化调试：由于HAL库屏蔽了底层的寄存器操作，调试过程中更容易定位和解决问题，减少了开发和维护的复杂性。
  • 代码维护性好：HAL库的高层次封装和良好的代码结构使得代码更容易维护和更新。
对比标准固件库的不同
  1. 抽象层次：
      • 标准固件库：直接操作寄存器，提供底层硬件访问，要求开发者对STM32微控制器的寄存器有较深入的理解。
      • HAL库：提供高层次的抽象接口，屏蔽底层寄存器操作，使开发者可以更快速地进行开发。
  1. 代码复杂性：
      • 标准固件库：代码较复杂，涉及大量的寄存器配置，开发者需要处理更多的细节。
      • HAL库：代码简洁易读，通过调用库函数进行配置和操作，减少了代码量和复杂性。
  1. 学习曲线：
  • 标准固件库：学习曲线较陡，需要花费较多时间了解和掌握硬件细节。
  • HAL库：学习曲线较缓，提供了丰富的示例代码和文档，开发者可以快速上手。
  1. 开发效率：
  • 标准固件库：适合对性能和功耗有严格要求的项目，但开发和调试时间较长。
  • HAL库：提高了开发效率，适合快速开发和原型设计，缩短了开发周期。
  1. 移植性：
  • 标准固件库：不同系列的STM32微控制器之间存在较大的差异，代码移植工作量较大。
  • HAL库：提供一致的API接口，增强了代码的移植性和重用性，不同系列之间的移植工作量较小。

2. 创建HAL库工程模板

1. 制作文件模板

  • 先找一个位置，存放工程模板
  • 在工程模板中 添加 User、Library 、 Hardware 、 CMSIS 文件夹：
    • User：
      • main.c
    • Library：
      • Include
      • Source
    • Hardware：
      • Include
      • Source
    • CMSIS ：
      • Include
      • Source
  • 解压并打开
  • 拷贝HAL库（Library）
      1. 进入\STM32Cube_FW_F1_V1.8.0\Drivers\STM32F1xx_HAL_Driver 把头文件夹 Inc 和源文件夹 Src 移动到自己的Library的对应的文件中
  • 拷贝启动文件（CMSIS\Include）
      1. 先进入内核文件\STM32Cube_FW_F1_V1.8.0\Drivers\CMSIS
      1. 进入头文件\CMSIS\Include 把所有文件拷贝到自己的CMSIS/Include文件中 再进入\CMSIS\Device\ST\STM32F1xx\Include 把所有文件拷贝到自己的CMSIS/Include文件中
  • 拷贝源文件（CMSYS\Source）
      1. 进入\STM32Cube_FW_F1_V1.8.0\Drivers\CMSIS\Device\ST\STM32F1xx\Source\Templates
      1. 把\Templates 文件的的system_stm32f1xx.c拷贝到自己的CMSIS/Source文件中
      1. 再进入/arm文件下，把所有文件拷贝到自己的CMSIS/Source文件中
  • 编辑Hardware文件夹
      • 分别在源文件家和头文件夹添加stm32f1xx_it.c 和stm32f1xx_it.h 代码如下

stm32f1xx_it.c

stm32f1xx_it.h

CMSIS
Include
cmsis_armcc.h
cmsis_armclang.h
cmsis_compiler.h
cmsis_gcc.h
cmsis_iccarm.h
cmsis_version.h
core_armv8mbl.h
core_armv8mml.h
core_cm0.h
core_cm0plus.h
core_cm1.h
core_cm23.h
core_cm3.h
core_cm33.h
core_cm4.h
core_cm7.h
core_sc000.h
core_sc300.h
mpu_armv7.h
mpu_armv8.h
stm32f100xb.h
stm32f100xe.h
stm32f101x6.h
stm32f101xb.h
stm32f101xe.h
stm32f101xg.h
stm32f102x6.h
stm32f102xb.h
stm32f103x6.h
stm32f103xb.h
stm32f103xe.h
stm32f103xg.h
stm32f105xc.h
stm32f107xc.h
stm32f1xx.h
system_stm32f1xx.h
tz_context.h
Source
startup_stm32f100xb.s
startup_stm32f100xe.s
startup_stm32f101x6.s
startup_stm32f101xb.s
startup_stm32f101xe.s
startup_stm32f101xg.s
startup_stm32f102x6.s
startup_stm32f102xb.s
startup_stm32f103x6.s
startup_stm32f103xb.s
startup_stm32f103xe.s
startup_stm32f103xg.s
startup_stm32f105xc.s
startup_stm32f107xc.s
system_stm32f1xx.c
DebugConfig
Project_STM32F103C8_1.0.0.dbgconf
Target_1_STM32F103C8_1.0.0.dbgconf
Hardware
Include
stm32f1xx_it.h
Source
stm32f1xx_it.c
Library
Include
Legacy
stm32f1xx_hal_can_ex_legacy.h
stm32f1xx_hal_can_legacy.h
stm32_hal_legacy.h
stm32f1xx_hal.h
stm32f1xx_hal_adc.h
stm32f1xx_hal_adc_ex.h
stm32f1xx_hal_can.h
stm32f1xx_hal_cec.h
stm32f1xx_hal_conf.h
stm32f1xx_hal_cortex.h
stm32f1xx_hal_crc.h
stm32f1xx_hal_dac.h
stm32f1xx_hal_dac_ex.h
stm32f1xx_hal_def.h
stm32f1xx_hal_dma.h
stm32f1xx_hal_dma_ex.h
stm32f1xx_hal_eth.h
stm32f1xx_hal_exti.h
stm32f1xx_hal_flash.h
stm32f1xx_hal_flash_ex.h
stm32f1xx_hal_gpio.h
stm32f1xx_hal_gpio_ex.h
stm32f1xx_hal_hcd.h
stm32f1xx_hal_i2c.h
stm32f1xx_hal_i2s.h
stm32f1xx_hal_irda.h
stm32f1xx_hal_iwdg.h
stm32f1xx_hal_mmc.h
stm32f1xx_hal_nand.h
stm32f1xx_hal_nor.h
stm32f1xx_hal_pccard.h
stm32f1xx_hal_pcd.h
stm32f1xx_hal_pcd_ex.h
stm32f1xx_hal_pwr.h
stm32f1xx_hal_rcc.h
stm32f1xx_hal_rcc_ex.h
stm32f1xx_hal_rtc.h
stm32f1xx_hal_rtc_ex.h
stm32f1xx_hal_sd.h
stm32f1xx_hal_smartcard.h
stm32f1xx_hal_spi.h
stm32f1xx_hal_sram.h
stm32f1xx_hal_tim.h
stm32f1xx_hal_tim_ex.h
stm32f1xx_hal_uart.h
stm32f1xx_hal_usart.h
stm32f1xx_hal_wwdg.h
stm32f1xx_ll_adc.h
stm32f1xx_ll_bus.h
stm32f1xx_ll_cortex.h
stm32f1xx_ll_crc.h
stm32f1xx_ll_dac.h
stm32f1xx_ll_dma.h
stm32f1xx_ll_exti.h
stm32f1xx_ll_fsmc.h
stm32f1xx_ll_gpio.h
stm32f1xx_ll_i2c.h
stm32f1xx_ll_iwdg.h
stm32f1xx_ll_pwr.h
stm32f1xx_ll_rcc.h
stm32f1xx_ll_rtc.h
stm32f1xx_ll_sdmmc.h
stm32f1xx_ll_spi.h
stm32f1xx_ll_system.h
stm32f1xx_ll_tim.h
stm32f1xx_ll_usart.h
stm32f1xx_ll_usb.h
stm32f1xx_ll_utils.h
stm32f1xx_ll_wwdg.h
stm32_assert_template.h
Source
Legacy
stm32f1xx_hal_can.c
stm32f1xx_hal.c
stm32f1xx_hal_adc.c
stm32f1xx_hal_adc_ex.c
stm32f1xx_hal_can.c
stm32f1xx_hal_cec.c
stm32f1xx_hal_cortex.c
stm32f1xx_hal_crc.c
stm32f1xx_hal_dac.c
stm32f1xx_hal_dac_ex.c
stm32f1xx_hal_dma.c
stm32f1xx_hal_eth.c
stm32f1xx_hal_exti.c
stm32f1xx_hal_flash.c
stm32f1xx_hal_flash_ex.c
stm32f1xx_hal_gpio.c
stm32f1xx_hal_gpio_ex.c
stm32f1xx_hal_hcd.c
stm32f1xx_hal_i2c.c
stm32f1xx_hal_i2s.c
stm32f1xx_hal_irda.c
stm32f1xx_hal_iwdg.c
stm32f1xx_hal_mmc.c
stm32f1xx_hal_msp_template.c
stm32f1xx_hal_nand.c
stm32f1xx_hal_nor.c
stm32f1xx_hal_pccard.c
stm32f1xx_hal_pcd.c
stm32f1xx_hal_pcd_ex.c
stm32f1xx_hal_pwr.c
stm32f1xx_hal_rcc.c
stm32f1xx_hal_rcc_ex.c
stm32f1xx_hal_rtc.c
stm32f1xx_hal_rtc_ex.c
stm32f1xx_hal_sd.c
stm32f1xx_hal_smartcard.c
stm32f1xx_hal_spi.c
stm32f1xx_hal_sram.c
stm32f1xx_hal_tim.c
stm32f1xx_hal_timebase_rtc_alarm_template.c
stm32f1xx_hal_timebase_tim_template.c
stm32f1xx_hal_tim_ex.c
stm32f1xx_hal_uart.c
stm32f1xx_hal_usart.c
stm32f1xx_hal_wwdg.c
stm32f1xx_ll_adc.c
stm32f1xx_ll_crc.c
stm32f1xx_ll_dac.c
stm32f1xx_ll_dma.c
stm32f1xx_ll_exti.c
stm32f1xx_ll_fsmc.c
stm32f1xx_ll_gpio.c
stm32f1xx_ll_i2c.c
stm32f1xx_ll_pwr.c
stm32f1xx_ll_rcc.c
stm32f1xx_ll_rtc.c
stm32f1xx_ll_sdmmc.c
stm32f1xx_ll_spi.c
stm32f1xx_ll_tim.c
stm32f1xx_ll_usart.c
stm32f1xx_ll_usb.c
stm32f1xx_ll_utils.c
Listings
Project.map
Objects
main.d
main.o
Project.axf
Project.build_log.htm
Project.htm
Project.lnp
Project.sct
Project_Project.dep
startup_stm32f101xb.o
stm32f1xx_hal.d
stm32f1xx_hal.o
stm32f1xx_hal_cortex.d
stm32f1xx_hal_cortex.o
stm32f1xx_hal_gpio.d
stm32f1xx_hal_gpio.o
stm32f1xx_hal_gpio_ex.d
stm32f1xx_hal_gpio_ex.o
stm32f1xx_hal_rcc.d
stm32f1xx_hal_rcc.o
stm32f1xx_hal_rcc_ex.d
stm32f1xx_hal_rcc_ex.o
system_stm32f1xx.d
system_stm32f1xx.o
User
main.c
HAL_Init();//初始化HAL库
HAL_RCC_MCOConfig(RCC_MCO1,RCC_MCO1SOURCE_SYSCLK,RCC_MCODIV_1);//PA8引脚输出、系统时钟、不分频
#include "stm32f1xx_hal.h"
#include "rcc.h"
/*函 数 名：hal库rcc输出内部8Mhz方波
*参 数：
*返 回 值：
*注意事项：
*/
uint32_t HCLKFreq = 0;//显示时钟树三处频率
uint32_t PCLK1Freq = 0;
uint32_t PCLK2Freq = 0;
int main (void)
{
HAL_Init();//初始化HAL库
RCC_ClockInit();//配置时钟树初始化
HAL_RCC_MCOConfig(RCC_MCO1,RCC_MCO1SOURCE_SYSCLK,RCC_MCODIV_1);//PA8引脚输出、系统时钟、不分频
HCLKFreq = HAL_RCC_GetHCLKFreq();
PCLK1Freq = HAL_RCC_GetPCLK1Freq();
PCLK2Freq = HAL_RCC_GetPCLK2Freq();
while(1)
{
}
}
#include "stm32f1xx_hal.h"
#include "rcc.h"
void RCC_ClockInit()
{
RCC_OscInitTypeDef RCC_OsInitStructure; //设置内外部时钟源配置结构体
RCC_ClkInitTypeDef RCC_ClkInitStructure;//设置总线时钟结构体
RCC_OsInitStructure.OscillatorType = RCC_OSCILLATORTYPE_HSI; //选择震荡电路为内部高速
RCC_OsInitStructure.HSIState = RCC_HSI_ON; //打开时钟
RCC_OsInitStructure.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT; //设置微调值 默认
RCC_OsInitStructure.PLL.PLLState = RCC_PLL_ON; //设置PLL为打开
RCC_OsInitStructure.PLL.PLLSource = RCC_PLLSOURCE_HSI_DIV2; //选择PLL输入为内部高速时钟
RCC_OsInitStructure.PLL.PLLMUL = RCC_PLL_MUL16; //设置16倍频
HAL_RCC_OscConfig(&RCC_OsInitStructure); //传给话务员..
RCC_ClkInitStructure.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 |RCC_CLOCKTYPE_PCLK2 | RCC_CLOCKTYPE_SYSCLK;//需要配置的时钟
RCC_ClkInitStructure.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK; //SYSCLK系统时钟输入源 PLL作为系统时钟
RCC_ClkInitStructure.AHBCLKDivider = RCC_SYSCLK_DIV1; //AHB预分频 1分频
RCC_ClkInitStructure.APB1CLKDivider = RCC_HCLK_DIV2; //APB1预分频 2分频
RCC_ClkInitStructure.APB2CLKDivider = RCC_HCLK_DIV1; //APB2预分频 1分频
HAL_RCC_ClockConfig(&RCC_ClkInitStructure,FLASH_LATENCY_2);//传给话务员，并且根据频率设置FLASH等待周期为2
//话务员相关配置可以在API函数中找到。结构体相关配置在结构体和成员中可找到
}
#include "stm32f1xx_hal.h"
#include "rcc.h"
void RCC_ClockInit()
{
RCC_OscInitTypeDef RCC_OsInitStructure; //设置内外部时钟源配置结构体
RCC_ClkInitTypeDef RCC_ClkInitStructure;//设置总线时钟结构体
RCC_OsInitStructure.OscillatorType = RCC_OSCILLATORTYPE_HSE; //选择震荡电路为外部高速
RCC_OsInitStructure.HSEState = RCC_HSE_ON; //打开HSE时钟
RCC_OsInitStructure.HSEPredivValue = RCC_HSE_PREDIV_DIV1; //不分频
RCC_OsInitStructure.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT; //设置微调值 默认
RCC_OsInitStructure.PLL.PLLState = RCC_PLL_ON; //设置PLL为打开
RCC_OsInitStructure.PLL.PLLSource = RCC_PLLSOURCE_HSE; //选择PLL输入为外部高速时钟
RCC_OsInitStructure.PLL.PLLMUL = RCC_PLL_MUL9; //设置9倍频
HAL_RCC_OscConfig(&RCC_OsInitStructure); //传给话务员..
RCC_ClkInitStructure.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 |RCC_CLOCKTYPE_PCLK2 | RCC_CLOCKTYPE_SYSCLK;//需要配置的时钟
RCC_ClkInitStructure.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK; //SYSCLK系统时钟输入源 PLL作为系统时钟
RCC_ClkInitStructure.AHBCLKDivider = RCC_SYSCLK_DIV1; //AHB预分频 1分频
RCC_ClkInitStructure.APB1CLKDivider = RCC_HCLK_DIV2; //APB1预分频 2分频
RCC_ClkInitStructure.APB2CLKDivider = RCC_HCLK_DIV1; //APB2预分频 1分频
HAL_RCC_ClockConfig(&RCC_ClkInitStructure,FLASH_LATENCY_2);//传给话务员，并且根据频率设置FLASH等待周期为2
//话务员相关配置可以在API函数中找到。结构体相关配置在结构体和成员中可找到
}
//stm启动文件中已经定义的中断服务函数
void HAL_GPIO_EXTI_IRQHandler(uint16_t GPIO_Pin)
{
if (__HAL_GPIO_EXTI_GET_IT(GPIO_Pin) != 0x00u)//帮我们判断标志位
{
__HAL_GPIO_EXTI_CLEAR_IT(GPIO_Pin);//帮我们清除标志位
HAL_GPIO_EXTI_Callback(GPIO_Pin);//执行回调函数
}
}
// 弱声明 的回调函数 只是为了防止报错用
__weak void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
UNUSED(GPIO_Pin);//什么都不执行，只是为了防止编译时报错：没有使用xxx
}
void EXTI15_10_IRQHandler (void) //如果发生了这个中断
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);//跳转到HAL库的中断处理
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_12);//跳转到HAL库的中断处理
}
/ 注册回调函数 /
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
if (GPIO_Pin == GPIO_PIN_13) // 判断是不是13线
{
// 执行13线程序
// ...
}
else if (GPIO_Pin == GPIO_PIN_12) // 判断是不是12线
{
// 执行12线程序
// ...
}
}

串口篇

这篇文章介绍了HAL库大多的使用方法，并配有详细的思路和注释。

一、介绍

HAL库在 异步通信UART 串口部分提供了三种方式：
  • 轮询阻塞
  • 非阻塞中断 或者 DMA
  • 所以在使用串口时，也要添加DMA.c到库
以STM32C8T6为例，有三个串口资源：
  • USART1：
    • TX：PA9 可重映射为 PB 6
    • RX：PA10 可重映射为 PB 7
  • USART2：
    • TX：PA2
    • RX：PA3
  • USART3：
    • TX：PB10
    • RX：PB11

二、HAL库：阻塞轮询方式 实现USART1 串口 异步收发

1. 引脚定义

  • USART1：
    • TX：PA9
    • RX：PA10

2. 补充：为什么在while循环接收时，没必要对HAL_ERROR、HAL_BUSY进行处理

HAL_ERROR：
  • 用于判断buff为空指针或者数据长度为0的情况
HAL_BUSY：
  • 用于判断Busy状态
所以我们只需要判断他的另外两种状态，HAL_OK(在规定时间内接收到n个数据)、和HAL_TIMEOUT(未在规定时间接收到n个数据，导致超时退出接收)

3. 注意事项：

  • HAL库的串口初始化， 硬件部分的时钟以及GPIO口的配置，需要我们自己来配置
      • 在HAL_UART_Init(&Uart1); 函数被调用时。 会调用一个weak弱声明的void HAL_UART_MspInit(UART_HandleTypeDef *huart) 函数。 这个函数就是留给我们强声明 配置硬件用的。我们需要在里边打开 串口1 和 GPIO的 时钟。
  • 需要注意的是USART1与定时器的引脚有冲突。 如果发生冲突 可以重映射 串口到别的引脚。
  • RxXferSiZe是用来记录接收总量的
  • RxXferCount是用来记录剩余需要接收数量的
      • 注意，这里的RxXferCount 进到while中就先减1 了。这个知识点后面会用到

4. 串口1初始化部分：

5. 串口1配置硬件部分

6. 主函数部分

  • 主函数中。需要使用接收串口的函数：HAL_UART_Receive(&Uart1,Buff,Rx_Size,200)
      • 他的参数分别为：串口配置结构体地址、接收缓冲区（我们自己定义的数组）、预计接收的字节个数（我们自己定义）、超时时间（单位为ms）
      这里的 Rx_Size 为 200
      因此我们需要在UART.h 头文件中添加结构体对外声明extern UART_HandleTypeDef Uart1;
  • 接收串口的函数会有 四个返回值：
    • HAL_OK、 代表此次在200ms内接受到了 200 字节。 （也就是与预计相等）
    • HAL_ERROR 、代表传参错误、 比如超时时间为0、或者数据缓冲区地址为空
    • HAL_TIMEOUT 、代表未能在规定时间内接收到 200 个字节
      • 往往分为两种情况： 1、接收了但没接收完、2、一点没接收
    • HAL_BUSY、代表已经在接受了。你别来烦我
下面可以看代码来分析

三、HAL库：阻塞轮询方式 实现串口2、3 和串口1重映射

1. 引脚定义

  • USART1：
    • TX：PA9 可重映射为 PB 6
    • RX：PA10 可重映射为 PB 7
  • USART2：
    • TX：PA2
    • RX：PA3
  • USART3：
    • TX：PB10
    • RX：PB11

2. 关键代码：

  • 如果需要重映射，则还需要打开AFIO的时钟和 使用重映射 API：

    3. 串口1、2、3、初始化部分：

    与之前的无异，只是添加拷贝了三次

    4. 主函数部分

    • 与之前的一样，想使用什么修改下”UartX“参数就行，

    四、HAL库：中断方式 实现串口1 定长数组异步收发

    我们就使用上一小节所讲的多指针定位+循环收发缓冲区方案设计，来实现这次的中断接收~

    1. 注意事项

    1. HAL库为 串口中断提供了很多回调函数。 比如 错误回调、半完成回调、Rx、Tx完成回调。你需要用什么回调，就声明什么回调~
        • 这里只用了接收完成回调函数：void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
            • 其中“RxCpltCallback” 可以分解为以下部分：
          • “Rx” 通常代表 “Receive”，即接收。
          • “Cplt” 通常代表 “Complete”，即完成。
          • “Callback” 即回调，指的是当某个特定事件发生时被调用的函数。
    1. 我们在回调函数中。 我们将接收缓冲区的数据memcpy到 发送缓冲区。 并置 接收完成标志位。 在主函数中，只需要循环检测 标志位 后 并发送发送缓冲区中的数据就可以完成接收并发送数据了。 中断接收在接收到数据之后 需要在回调函数中要重新打开。 因为中断接收一次会自动关闭
    1. 在使用UART 的IT 接收时。要配置NVIC ：USART 线的 优先级和 使能USART线
      1. 这里的定长，是因为中断只有接收到20个字节之后，才会进入回调函数

      2. 初始化UART1部分

      • 主要关注中断 完成接收回调函数部分。 主要完成了数据cpy 和置位接收状态以及 重新启动接收数据。
      • 以及关注定义的接收、发送缓冲区和Rx_Date接收状态标志位

      3. UART硬件初始化回调

      3. 回调函数部分

      / 强声明的错误回调函数 /
      void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
      {
      if(huart->Instance == USART1){
      }else if(huart->Instance == USART2){
      }else if(huart->Instance == USART3){
      }
      }
      / 强声明的发送完成回调函数 /
      void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart)
      {
      if(huart->Instance == USART1){
      }else if(huart->Instance == USART2){
      }else if(huart->Instance == USART3){
      }
      }
      #include "stm32f1xx_hal.h"
      #include "rcc.h"
      #include "led.h"
      #include "key.h"
      #include "Uart.h"
      /函 数 名：HAL库：中断方式。实现UART串口数据收发。 定长 20字节 /
      int main (void)
      {
      HAL_Init();//初始化HAL库
      RccClock_Init();//配置时钟树72M
      LED_Init();
      Uart1_Init(921600);//初始化串口1
      while(1)
      {
      if(Rx_Date == 1) //如果接收标志位置1
      {
      Rx_Date = 0;
      HAL_UART_Transmit_IT(&Uart1,Tx_Buff,20);//发送 发送缓冲区的20个字节
      }
      }
      }
      / 缓冲区宏定义 /
      #define U1_RX_SIZE 2048
      #define U1_TX_SIZE 2048
      #define U1_RX_MAX 256 //这里需要注意，我们是利用空闲中断对数据进行处理，不能单次发送256字节，否则进入完成中断
      / 缓冲区 /
      uint8_t U1_Rx_Buff[U1_RX_SIZE];
      uint8_t U1_Tx_Buff[U1_TX_SIZE];
      / Location Ctrl Block /
      / （接收/发送）位置控制块 /
      typedef struct{
      uint8_t* start;
      uint8_t* end;
      }LCB;
      / Uart Ctrl Block /
      / 串口控制块 /
      typedef struct{
      uint32_t rxCount; //记录接收缓冲区中当前已有的数据量
      uint32_t txCount; //记录发送缓冲区中当前已有的数据量
      LCB rxLocation[10]; //记录接收缓冲区每次接收的位置
      LCB txLocation[10]; //记录发送缓冲区每次接收的位置
      LCB* rxInPtr; //指向下次接收缓冲区存放位置
      LCB* rxOutPtr; //指向下次接收缓冲区读取位置
      LCB* rxEndPtr; //指向接收缓冲区结束位置
      LCB* txInPtr; //指向下次发送缓冲区存放位置
      LCB* txOutPtr; //指向下次发送缓冲区读取位置
      LCB* txEndPtr; //指向发送缓冲区结束位置
      UART_HandleTypeDef uart; //串口总控结构体
      uint8_t TxState; //发送忙碌标志位
      }UCB;
      / 初始化 /
      void U1_Init(uint32_t bandrate);
      / 初始化UCB控制块指针 /
      void U1_PtrInit(void);
      / 转移RxBuff数据到TxBuff /
      void U1_DataRxToTx(uint8_t* data, uint32_t data_len);
      / 总控结构体 /
      extern UCB uart1;
      / 缓冲区 /
      extern uint8_t U1_Rx_Buff[U1_RX_SIZE];
      extern uint8_t U1_Tx_Buff[U1_TX_SIZE];
      / 状态位 /
      extern uint8_t rxState;
      #ifndef __UART_H
      #define __UART_H
      #include "stm32f1xx_hal.h"
      #include "stdint.h"
      #include "string.h"
      / 缓冲区宏定义 /
      #define U1_RX_SIZE 2048
      #define U1_TX_SIZE 2048
      #define U1_RX_MAX 256 //这里需要注意，我们是利用空闲中断对数据进行处理，不能单次发送256字节，否则进入完成中断
      / Location Ctrl Block /
      / （接收/发送）位置控制块 /
      typedef struct{
      uint8_t* start;
      uint8_t* end;
      }LCB;
      / Uart Ctrl Block /
      / 串口控制块 /
      typedef struct{
      uint32_t rxCount; //记录接收缓冲区中当前已有的数据量
      uint32_t txCount; //记录发送缓冲区中当前已有的数据量
      LCB rxLocation[10]; //记录接收缓冲区每次接收的位置
      LCB txLocation[10]; //记录发送缓冲区每次接收的位置
      LCB* rxInPtr; //指向下次接收缓冲区存放位置
      LCB* rxOutPtr; //指向下次接收缓冲区读取位置
      LCB* rxEndPtr; //指向接收缓冲区结束位置
      LCB* txInPtr; //指向下次发送缓冲区存放位置
      LCB* txOutPtr; //指向下次发送缓冲区读取位置
      LCB* txEndPtr; //指向发送缓冲区结束位置
      UART_HandleTypeDef uart; //串口总控结构体
      uint8_t TxState; //发送忙碌标志位
      }UCB;
      / 初始化 /
      void U1_Init(uint32_t bandrate);
      / 初始化UCB控制块指针 /
      void U1_PtrInit(void);
      / 转移RxBuff数据到TxBuff /
      void U1_DataRxToTx(uint8_t* data, uint32_t data_len);
      / 总控结构体 /
      extern UCB uart1;
      / 缓冲区 /
      extern uint8_t U1_Rx_Buff[U1_RX_SIZE];
      extern uint8_t U1_Tx_Buff[U1_TX_SIZE];
      / 状态位 /
      extern uint8_t rxState;
      #endif
      #include "uart.h"
      / 创建串口总控结构体 /
      UCB uart1;
      / 缓冲区 /
      uint8_t U1_Rx_Buff[U1_RX_SIZE];
      uint8_t U1_Tx_Buff[U1_TX_SIZE];
      / 初始化串口 /
      void U1_Init(uint32_t bandrate){
      uart1.uart.Instance = USART1; //使用那个串口
      uart1.uart.Init.BaudRate = bandrate; //波特率
      uart1.uart.Init.WordLength = UART_WORDLENGTH_8B; //数据位长度
      uart1.uart.Init.StopBits = UART_STOPBITS_1; //停止位
      uart1.uart.Init.Parity = UART_PARITY_NONE; //校验模式
      uart1.uart.Init.Mode = UART_MODE_TX_RX; //传输模式
      uart1.uart.Init.HwFlowCtl = UART_HWCONTROL_NONE; //流控
      HAL_UART_Init(&uart1.uart);
      / 初始化UCB控制块指针 /
      U1_PtrInit();
      / 打开空闲中断 /
      __HAL_UART_ENABLE_IT(&uart1.uart,UART_IT_IDLE);
      / 开始接收数据 /
      HAL_UART_Receive_IT(&uart1.uart, uart1.rxInPtr->start, U1_RX_MAX); //接收位置为当前LCB位置控制块的In指针所指向的缓冲区的位置
      }
      / 初始化U1_UCB控制块指针 /
      void U1_PtrInit(void){
      uart1.rxCount = 0;
      uart1.rxInPtr = &uart1.rxLocation[0];
      uart1.rxOutPtr = &uart1.rxLocation[0];
      uart1.rxEndPtr = &uart1.rxLocation[9];
      uart1.rxInPtr->start = &U1_Rx_Buff[0]; //让当前接收位置控制块的start，指向下一次接收到的数据将要存放的位置
      uart1.txCount = 0;
      uart1.txInPtr = &uart1.txLocation[0];
      uart1.txOutPtr = &uart1.txLocation[0];
      uart1.txEndPtr = &uart1.txLocation[9];
      uart1.txInPtr->start = &U1_Tx_Buff[0]; //让当前发送位置控制块的start，指向下一次需要发送的数据的存放位置
      }
      / 转移U1_Rx_Buff数据到 U1_Tx_Buff /
      void U1_DataRxToTx(uint8_t* data, uint32_t data_len){
      / 判断剩余空间是否足够，要不要回卷 /
      if((U1_TX_SIZE - uart1.txCount) > data_len){
      / 如果够 /
      uart1.txInPtr->start = &U1_Tx_Buff[uart1.txCount];
      }
      else{/ 如果剩余空间不够 /
      uart1.txCount = 0;
      uart1.txInPtr->start = &U1_Tx_Buff[0];
      }
      / 复制data到U1_Tx_Buff缓冲区 /
      memcpy(uart1.txInPtr->start, data, data_len);
      / 累加txCount /
      uart1.txCount += data_len;
      / 标记这次的发送数据的结束位置 /
      uart1.txInPtr->end = &U1_Tx_Buff[uart1.txCount - 1];
      / 移动txIn /
      uart1.txInPtr++;
      / 判断txIn指针是否需要回卷 /
      if(uart1.txInPtr == uart1.txEndPtr){
      uart1.txInPtr = &uart1.txLocation[0];
      }
      }
      / UART硬件初始化回调 /
      void HAL_UART_MspInit(UART_HandleTypeDef *huart){
      GPIO_InitTypeDef GPIO_InitType;
      if(huart->Instance == USART1){ //判断那个串口在进行初始化
      __HAL_RCC_USART1_CLK_ENABLE();
      __HAL_RCC_GPIOA_CLK_ENABLE();
      GPIO_InitType.Pin = GPIO_PIN_9;
      GPIO_InitType.Mode = GPIO_MODE_AF_PP;
      GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
      HAL_GPIO_Init(GPIOA,&GPIO_InitType);
      GPIO_InitType.Pin = GPIO_PIN_10;
      GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
      GPIO_InitType.Pull = GPIO_NOPULL;
      HAL_GPIO_Init(GPIOA,&GPIO_InitType);
      //打开了串口1的总中断
      HAL_NVIC_SetPriority(USART1_IRQn,3,0);
      HAL_NVIC_EnableIRQ(USART1_IRQn);
      }else if(huart->Instance == USART2){
      __HAL_RCC_GPIOA_CLK_ENABLE();
      __HAL_RCC_USART2_CLK_ENABLE();
      GPIO_InitType.Pin = GPIO_PIN_2;
      GPIO_InitType.Mode = GPIO_MODE_AF_PP;
      GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
      HAL_GPIO_Init(GPIOA,&GPIO_InitType);
      GPIO_InitType.Pin = GPIO_PIN_3;
      GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
      GPIO_InitType.Pull = GPIO_NOPULL;
      HAL_GPIO_Init(GPIOA,&GPIO_InitType);
      }else if(huart->Instance == USART3){
      __HAL_RCC_GPIOB_CLK_ENABLE();
      __HAL_RCC_USART3_CLK_ENABLE();
      GPIO_InitType.Pin = GPIO_PIN_10;
      GPIO_InitType.Mode = GPIO_MODE_AF_PP;
      GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
      HAL_GPIO_Init(GPIOB,&GPIO_InitType);
      GPIO_InitType.Pin = GPIO_PIN_11;
      GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
      GPIO_InitType.Pull = GPIO_NOPULL;
      HAL_GPIO_Init(GPIOB,&GPIO_InitType);
      }
      }
      / 强声明的接收完成回调函数 /
      void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
      {
      if(huart->Instance == USART1){
      }else if(huart->Instance == USART2){
      }else if(huart->Instance == USART3){
      }
      }
      / 强声明的错误回调函数 /
      void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
      {
      if(huart->Instance == USART1){
      }else if(huart->Instance == USART2){
      }else if(huart->Instance == USART3){
      }
      }
      / 强声明的发送完成回调函数 /
      void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
      {
      if(huart->Instance == USART1){
      / 发送完成，标志位清零 /
      uart1.TxState = 0;
      }else if(huart->Instance == USART2){
      }else if(huart->Instance == USART3){
      }
      }
      / 强声明的接收终止回调函数 /
      void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart)
      {
      if(huart->Instance == USART1){
      / 标记结束位置 /
      uart1.rxInPtr->end = &U1_Rx_Buff[uart1.rxCount - 1];
      / 挪动rxIn指针 /
      uart1.rxInPtr++;
      / 判断rxIn指针是否需要回卷 /
      if(uart1.rxInPtr == uart1.rxEndPtr){
      uart1.rxInPtr = &uart1.rxLocation[0];
      }
      / 判断接收缓冲区是否需要回卷 /
      if((U1_RX_SIZE - uart1.rxCount) < U1_RX_MAX){
      uart1.rxCount = 0;
      uart1.rxInPtr->start = &U1_Rx_Buff[0];
      }else{
      / 剩余位置够 /
      uart1.rxInPtr->start = &U1_Rx_Buff[uart1.rxCount];
      }
      / 重新开启中断接收 /
      HAL_UART_Receive_IT(&uart1.uart, uart1.rxInPtr->start, U1_RX_MAX);
      }else if(huart->Instance == USART2){
      }else if(huart->Instance == USART3){
      }
      }
      /-------------------------------------------------/
      / /
      / 实现各种中断服务函数的源文件 /
      / /
      /-------------------------------------------------/
      #include "stm32f1xx_hal.h"
      #include "stm32f1xx_it.h"
      #include "uart.h"
      void EXTI15_10_IRQHandler(void)
      {
      HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
      }
      void EXTI0_IRQHandler(void)
      {
      HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
      }
      /-------------------------------------------------/
      /函数名：不可屏蔽中断处理函数 /
      /参 数：无 /
      /返回值：无 /
      /-------------------------------------------------/
      void NMI_Handler(void)
      {
      }
      /-------------------------------------------------/
      /函数名：硬件出错后进入的中断处理函数 /
      /参 数：无 /
      /返回值：无 /
      /-------------------------------------------------/
      void HardFault_Handler(void)
      {
      }
      /-------------------------------------------------/
      /函数名：软中断，SWI 指令调用的处理函数 /
      /参 数：无 /
      /返回值：无 /
      /-------------------------------------------------/
      void SVC_Handler(void)
      {
      }
      /-------------------------------------------------/
      /函数名：可挂起的系统服务处理函数 /
      /参 数：无 /
      /返回值：无 /
      /-------------------------------------------------/
      void PendSV_Handler(void)
      {
      }
      /-------------------------------------------------/
      /函数名：SysTic系统嘀嗒定时器处理函数 /
      /参 数：无 /
      /返回值：无 /
      /-------------------------------------------------/
      void SysTick_Handler(void)
      {
      HAL_IncTick();
      }
      ]]>             <![CDATA[【Cursor 开发】Cursor配置 + WSL2 + 地区限制解决 + AI Coding 技巧]]> https://www.mcoi.top/article/Post-cursor-wsl2-region-ai-coding https://www.mcoi.top/article/Post-cursor-wsl2-region-ai-coding Wed, 25 Feb 2026 00:00:00 GMT
      这部分的实现方法实际上与 在WSL中打开trae、vscode窗口类似。都是找到它们的「启动脚本」即xx/bin/xx
      在之前的环境搭建也有提到【ESP-IDF环境】在Windows子系统WSL下搭建Ubuntu24.04的ESP32+vscode开发环境
      前提是在Cursor中安装了WSL插件， 在类Vscode的软件中安装插件快捷键为Ctrl+Shift+X
      在 Windows 下使用 Cursor 打开并编辑 WSL2 内的项目，可以让你直接在 AI 辅助编辑器中进行 Linux 环境的开发。以下是配置与操作步骤。
      notion image

      零、基础配置

      1. 【必选】设置隐私模式

      （主要保证项目内文件不被Cursor上传用于训练）
      notion image

      2. 【必看】可选但建议：添加【默认规则提示词】避免AI输出无用功

      我这里自己改了一份提示词，可以用来参考：
      你可以把他配置到cursor的 Rules中。不用每次写在提示词里。
      notion image

      3. 【必看】：提问提示词

      我这里简单提供一个提问提示词模板，可以用来参考：
      这里我引入一个旨在为中文开发者和AI爱好者提供各种流行AI编程工具的系统提示词和模型设计文档的Github仓库：https://github.com/CreatorEdition/system-prompts-and-models-of-ai-tools-chinese
      一个好的AI Coding，光打磨提示词都要占去大半的时间。

      4. 可选：添加Chinese插件

      可以按Ctrl+Shift+X打开插件市场…下载后根据其README配置即可。

      5. 问题修复：针对大陆和香港地区不可用问题

      Cursor对中国地区进行了限制，下面列出三种解决办法

      1. 推荐解决方案：Proxifier代理，稍复杂但速度快（Http 2.0）

      写在前面：一定要先在WSL里Cursor . 连接好WSL 或 SSH连接上设备后再 打开Proxifier， 否则Cursor会连接不上 cursor-server。（应该是Proxifier代理导致的，应该能细致写入一些规则避免，但我不会。。）
      （ Proxifier 有一个免费的替代，github名为： proxifyre ，我没搞太清楚，听说这个比较好用。你们可以尝试一下）
      • 输入激活码：
          • L6Z8A-XY2J4-BTZ3P-ZZ7DF-A2Q9C（Portable Edition）#免安装版本
          5EZ8G-C3WL5-B56YG-SCXM9-6QZAP（Standard Edition）#安装版本
          P427L-9Y552-5433E-8DSR3-58Z68（MAC） #mac版本
      • 配置代理服务器
          • 然后打开Proxifier，根据图示进行（实际端口根据你自己的梯子端口修改）配置
          notion image
      • 将规则加入配置服务器
        • 参照图示顺序和内容添加规则即可
          • notion image
      • 最后打开梯子的全局代理模式，就能在HTTP Compatibility Mode 为 2.0 的情况下，愉快的使用AI编程了
      PE（便携）版本会有飞书、edge浏览器崩溃的状况（崩溃后无法打开），已经被我划掉了，留作备用吧。

      5.2 简单但速度稍慢的解决办法：在开启全局梯子之后，将HTTP Compatibility Mode 从2.0设置为 1.1 （如果1.1不行就设置1.0）

      notion image
      缺点：AI吐字有时速度很慢，有可能会吐一半就开始重连 或掉线

      5.3 简单但不一定有效的方法：虚拟网卡（TUN)+全局模式

      开启 梯子软件的 虚拟网卡（TUN)+全局模式，此时可以将HTTP Compatibility Mode设置为2.0此时可以将HTTP Compatibility Mode设置为2.0。 然后尝试使用。但不一定能成功。
      缺点：大部分人，例如我 就仍然没办法在HTTP 2.0 模式下 使用 TUN的方式使用Cursor，仍然提示地区不可用的问题

      一、以Cursor启动并编辑 Linux 项目（别名方式）

      1. 安装并配置 WSL2 环境
          2. 可选2部分不要做，替换为下面的部分
      1. 安装 Cursor 并配置 PATH
          • 从 Cursor 官网下载安装 Windows 版本，并完成登录。
          • 在 WSL 中编辑 ~/.bashrc，添加以下内容：
              • 需要根据实际安装的Cursor目录来替换中间的的d/LZJ_Software
          • 保存后执行：
      1. 在 WSL2 中启动 Cursor 打开项目
          • 切换到你的项目目录，例如：
          • 执行：
          • Cursor 会在 Windows 中启动，并直接打开该 WSL 路径下的项目。
      1. 可选：Cursor区域限制解决方法， Cursor 提示：“Model not available“的原因

      二、SSH连接不上设备的解决办法（WSL同理）

      1. 手动获取 Cursor Server 压缩包
      从 Cursor 日志中提取 ARM64 版本的 Cursor Server 下载链接，在 Windows 本地下载对应的cursor-reh-linux-arm64.tar.gz压缩包。
      • 建立基础 SSH 连接并传输文件
      • 在 Windows CMD 中先通过ssh lzj@192.168.137.187建立与 OrangePi 的 SSH 连接（验证基础连通性）；
      • 用scp命令将本地下载的压缩包传输到 OrangePi 的~/.cursor-server/目录：
      • 在 OrangePi 上解压并部署文件到指定路径
      • 解压压缩包到~/.cursor-server/bin/linux-arm64/目录；
      • 创建 Cursor 日志中指定的哈希目录（要匹配 Cursor 的固定查找路径）：
      • 将解压后的node及所有文件移动到该哈希目录：
      • 验证文件路径（确保node文件存在）：
      • 完成连接
      重新在 Cursor 中选择orangepi5Plus_computer_wifi建立 SSH 连接，此时 Cursor 能识别到已部署的 Server，无需自动下载，直接连接成功。

      三、【必看】AI使用/技巧

      成本与 Token 优化

      1. 上下文与任务拆分
          • 将复杂任务拆分为独立小单元，每个会话窗口仅执行单一小任务，避免在长上下文会话中持续追问，减少不必要的 token 消耗。一般上下文到120K左右，就可以新建窗口刷新上下文了。
          • 注意部分模型在上下文长度超过 20K 后会收取双倍费用，合理控制会话上下文长度，避免无意义的长会话
      1. 模型选择策略
          • 根据任务复杂度匹配对应模型：简单查询、文本格式化等轻量任务选择轻量模型，复杂代码编写、架构设计等任务选择大模型，平衡效果与使用成本。
      1. 查询token用量
          • 对于Cursor ，可以在https://cursor.com/cn/dashboard?tab=spending 中查看已使用付费模型额度的百分比（下方的API）。

      提示词与交互效率

      1. 一次性明确完整需求
          • 输入提示词前，提前梳理所有需求，明确说明技术栈、代码风格、特殊约束、输出格式等所有要求，避免多次补充要求来回修改，节省额度与沟通时间
      1. 精准引导 AI 输出
          • 当 AI 输出不符合预期时，明确指出具体问题所在，提供参考示例或修改方向，而非使用模糊的 “不对”“重新来” 等表述
      1. 善用 AI 解释功能
          • 让 AI 解释生成内容的设计思路与逻辑，帮助自己理解的同时，验证 AI 的输出逻辑是否合理

      项目与上下文管理

      1. 项目框架沉淀复用
          • 先让 AI 对项目框架进行总结，后续交互直接基于该框架进行阅读或补充，避免 AI 重复解析整个项目内容，提升处理效率
      1. 最小化工作空间
          • 按项目模块分别打开工作空间（如前端、后端分开用 Cursor 打开），避免一次性加载整个项目，让 AI 的关注点更集中
      1. 文件引用与内容排除
          • 明确需要修改的代码时，通过拖文件或 “@” 方式精确引用；不确定修改内容时，配置.cursorignore文件，排除编译目录（build、target 等）、敏感信息文件、无关资源文件，减少 AI 处理的无关内容
      1. 避免上传完整项目
          • 不要将整个项目文件直接拖入 AI 对话框，若必须上传，确保排除编译、缓存等无关目录，避免冗余内容干扰 AI 判断

      开发流程规范

      1. 先方案后执行
          • 让 AI 先输出方案或执行计划，经人工仔细审阅后再执行；也可新开窗口让其他 AI 评估该方案，确保方案合理性
          • 执行plan时，建议新开一个窗口执行，并把“执行所需的最小上下文包”带过去。因为在输出plan后的上下文接近很多模型/平台的有效上限或“注意力衰减区”，后续执行时更容易出现：
            • 早期约束（命名规则、不要兼容、多 Fabric 设计边界）被忽略
            • 对文档/日志细节记忆混乱、前后不一致
            • 生成 patch 时遗漏关键文件或偏离 plan
      1. 改动前设计评估
          • 在每次改动前，要求 AI 回答 “这是否符合 best practice？为什么？有哪些替代方案与权衡？”，迫使其显式化设计判断，避免不合理设计
      1. 代码 Review 重点
          • AI 生成代码后必须进行 Review，重点关注是否破坏整体架构、是否存在 “走捷径” 的不合理实现，而非逐行检查代码细节，并且Review也有利于自己吸收经验学习框架。
      1. 自动化脚本生成
          • 让 AI 生成重复性任务的自动化脚本（如代码格式化、文件批量处理等），让AI自己创建skill。提升长期开发效率
          notion image

      结构与知识管理

      1. 强化文档与结构化知识
          • 完善项目文档与结构化知识，AI 会放大 “好结构” 的优势，也会放大 “坏结构” 的问题，清晰的结构能让 AI 输出更符合预期
          • 每次让AI写一些新的功能或者内容。都要让AI去维护或生成相关的“技术文档”，文档不能太冗长。
      1. 沉淀可复用内容
          • 将 AI 生成的优质代码、方案、提示词整理成模板，后续类似任务直接复用，提升效率
      ]]>             <![CDATA[配置ESP32开发环境]]> https://www.mcoi.top/article/Post-ESP32-Development-environment-configuration https://www.mcoi.top/article/Post-ESP32-Development-environment-configuration Sat, 16 Nov 2024 00:00:00 GMT
      😀
      一个简单的开头

      Ubuntu开发环境

      1. 虚拟机创建Ubuntu20.04.6 server
          • 注意在安装的时候勾选SSH server
      1. 安装网络工具 :
          • sudo apt-get install net-tools
          • 输入ifconfig查看ip
          • 使用MobaXterm登录
      1. 修改pip源为阿里云源
          • 在根目录创建mkdir .pip文件夹
          • 创建vim pip.conf文件
          • 新增如下内容
      1. 修改清华源
          2. 使用国内源更稳定，还能加速下载。 官网如下： ubuntu | 镜像站使用帮助 | 清华大学开源软件镜像站 | Tsinghua Open Source Mirror （如果你是别的系统，可以输入lsb_release -a来查看当前的系统，然后根据清华源的官网的提示来更换相应地文本） 我这里是Ubuntu 20.04 LTS (focal)
        1. 首先备份系统原有的更新源配置文件： sudo cp /etc/apt/sources.list /etc/apt/sources.list_backup
        2. 然后使用文本编辑器（如sudo vim /etc/apt/sources.list）打开sources.list文件， 将其内容替换为清华的源。以下是 Ubuntu 20.04（flcal）的清华源示例：
            3. 在vim文本编辑器下，清除所有文本需要进入命令模式（按 Esc 键）。 按shift + ：键开始输入命令。 输入 %d 然后按回车键。表示全部删除。 输入然后输入i 进入编辑模式，开始输入（Ctrl+Shift+V可以粘贴）。 输入完毕后按ESC键，再按shift + ：输入set noreadonly取消文件只读设置 然后shift + ： 输入wq 然后回车（w为保存，q为退出）
            • 直接使用 su 登录root 也很方便。
            恭喜啊！！到这一步，你就成功的将软件源配置为清华源了。 可以验证一下，输入sudo apt update 系统将从清华源获取软件包信息并进行更新 并且不会出现错误提示。
      1. 安装各种必要的工具
          • sudo apt-get install git wget flex bison gperf python3-pip python3-venv cmake ninja-build ccache libffi-dev libssl-dev dfu-util libusb-1.0-0 net-tools
      1. 新建esp32目录
          • mkdir esp32
          • cd esp32
      1. 拉取gitee工具
          • 执行gitee工具切换镜像脚本
            • cd esp-gitee-tools
            • ./jihu-mirror.sh set
            • 上面这句命令，会将github的地址自动替换成jihulab上的镜像地址，这样就不用担心github的访问问题了
              • 然后我们可以理直气壮的拉取github 源码了，先回到esp32目录，
      1. 拉取esp-idf源码
          • 回到ESP32目录 cd ..
          • --recursive：这个选项告诉 Git 在克隆仓库的同时，递归地克隆该仓库所包含的所有子模块。
      1. 切换esp-idf版本分支到v5.2（大版本不兼容，小版本一般兼容）
          • cd esp-idf
          • 切换分支到5.2版本 git checkout v5.2
          • git branch 可以看一下到底切换成功了没
          • 把相应的子模块切换到对应的版本 git submodule update --init --recursive
      1. 安装编译工具
          • ../esp-gitee-tools/install.sh
      1. 设置临时环境变量
          • source export.sh
      1. 添加全局环境变量
          • vim ~/.profile
          • 添加一行：source esp32/esp-idf/export.sh
          • 也就是登录这个用户自动运行 这样就能不会退出而不能编译了
      1. 下载课程配套源码
          • cd ~/esp32
          • git clone --recursive https://gitee.com/vi-iot/esp32-board.git
      1. 编译
          • cd esp32-board/helloworld
          • idf.py build
          • 如果没红色或黄色报错就成功了。
      1. vscode连接
          • 下载ssh插件
          • 配置ssh插件登录格式
            • 右键在当前界面登录就OK 了。
        1. 通过本地vscode在Ubuntu vscode-server下载 C/C++ 、乐鑫ESP-IDF插件
        1. 装好后，最好重启一下VSCode，重复上述步骤登录ubuntu和打开helloworld文件夹，然后我们回到我们的helloworld工程
        1. 按下ctrl+shift+p，弹出搜索框，搜索ESP-IDF:Add vscode Configuration Folder，在下拉列表出现后，点击一下就可以了，这步的目的是为了把esp-idf里面的源码路径也加到我们的工程中，现在我们可以通过按着ctrl键点击函数或变量进行跳转看代码了
        1. 设置远程插件的C/C++扩展设置。搜索workspace ，把CPU占用调整为medium 中等。否则会占用100% CPU。
        1. 设置USB串口权限
            • sudo usermod -aG dialout xxx xxx为用户名
            • exit 退出，然后r重启一下
        1. 设置虚拟机USB为 USB3.1，防止烧录时提示一直正在使用
        1. 插入USB，在虚拟机设置连接USB到虚拟机。
        1. 烧录 idf.py flash
        1. sudo chmod 777 /dev/ttyUSB0 提升权限
        1. idf.py monitor 调试
        • Ctrl+]退出调试
        注意，esp-idf的版本记得选择v5.2 要一样的~，这个如果是Ubuntu server版本，可以用vscode连接之后 设置， 如果是Ubuntu desktop版本，可以直接在桌面 插件设置~

        WIndows开发环境

        vscode+ESP-IDF

        不重复造轮子了，挺多的

        CLion+ESP-IDF

        1. 下载安装离线安装包
        1. 基础指令
            • idf.py create-project 路径指令可以创建一个基础的ESP模板
            • idf.py build dome1 可以编译这个dome
            • idf.py monitor 是调试 监视
        1. 使用idf.py create-project 路径创建一个demo
        1. 在CLion 软件添加一个新的环境，编辑环境变量(ESP32-S2)
            • IDF_PATH=D:\Espressif\frameworks\esp-idf-v5.3.1;ESPPORT=COM15;IDF_TARGET=esp32
            • 在PATH添加下面这段环境目录
                • notion image
        1. 编辑工具链为 D:\Espressif\espidf_source.bat
          1. 重新加载CMake项目
          1. 构建app
          1. 切换flash烧录
              2. notion image
          1. 针对部分monitor不能用（提示 Monitor requires standard input to be attached to TTY. Try using a different terminal.错误），经查：可以使用外部模拟~
              2. 参考：ESP-IDF Monitor error: Monitor requires standard input to be attached to TTY : CPP-34647
              notion image
          1. 使用CLion 打开我们创建的demo，然后进行编译、烧录、调试。测试一下。
          小技巧：第一次编译（app）之后，后续可以直接选择flash，否则会重新编译，又得等老久了。
          配置开发环境挺麻烦的，其实可以直接使用ESP-IDF 5.3 PowerShell\ESP-IDF 5.3 CMD 这些终端进行编译、烧录和调试等等
          后续都是根据VsCode.进行的ESP32开发。
           
          💡
          有关LVGL其他问题，欢迎您在底部评论区留言，一起交流~
          ]]>                     <![CDATA[Csharp学习笔记]]> https://www.mcoi.top/article/Post-Csharp https://www.mcoi.top/article/Post-Csharp Thu, 12 Sep 2024 00:00:00 GMT
          😀
          此笔记是C#学习笔记，个人认为对入门面向对象思想 和 了解函数栈帧有很大的帮助 视频并没有看完，只是简单的做了个课设（串口助手） 以后有机会再往后看吧~

          一、类与名称空间

          1. 简介

          • 类（class）构成程序的主题
          • 空间名称（namespace）以树型结构组织类（和其他类型）
            • 例如Button 和 Path 类。
          • using 类似于 C语言的引用头文件，在C#中是名称空间。
           
          使用名称空间，可以避免类的冲突。 比如Windows名称空间 与 IO 名称空间中都有Path 类。他们的作用不同但名称相同。这时候如果要使用就需要用 全限命名 xxx.xx.path
          所以在以后使用时，就要对类进行精确命名，并且应该把他精确的放到 名称空间中去

          2. 类库的引用

          类库

          • 是以.dll为结尾的文件。 dll为（dynamic link Library） 动态 链接 库。在项目树的references可查看
          • 在引用类库的时候，要尤其注意依赖关系，最好用依赖关系比较弱的包。在类库有问题时，可以暂时用别的类库先替代。

          类库的引用

          • 类库可以有黑盒引用，也可以有白盒引用
              1. 黑盒引用是对编译好的dll文件直接引用
              1. 白盒引用是把源代码放到项目中直接引语
          在生成项目的时候，系统会自动引用一些必要的或者常用的库。可以再次选择系统自带的库，也可以去引用别人或是自己曾经写的库

          管理NuGet包

          • 在使用类库时，往往还需要更底层的类库。如果手动添加会比较麻烦。我们可以安装Entity Framework ，安装后，我们就不需要担心类库的依赖了。NuGet会自动管理依赖库。

          白盒引用

          朋友发给你他的项目，你可以把他的项目添加到你的解决方案（Solution）中。
          添加后就可以直接使用这个项目中的名称空间中的类
          在解决方案中添加现有项目。然后在主项目中引用添加的项目

          编译dll

          我们要发给别人dll时，需要创建醒目为Class Library。同样也可以在自己的项目中引用

          3. 依赖关系

          • 类（或对象）之间的耦合关系
          • 好的程序追求“高内聚，低耦合”
            • 高内聚指的是 类和名称空间精准的分类放置
            • 依赖关系，也被称为耦合关系，低耦合指的就是依赖关系低
          • UML（通用建模语言）类图
            • 类图用来展现类和类之间的关系。

          二、类、对象、类成员、实例成员

          类（class）

          类（class）是现实世界对实物的模型
          • 类是对现实世界事物进行抽象所得到的结果
            • 事物包括“物质"( 实体 )与“运动"( 逻辑)
            • 建模是一个去伪存真、由表及里的过程
              • （去伪存真的意思是，在程序中去除用不到的功能）（表是我们最终达到的效果。里则是程序内封装的逻辑）

          类（class）与对象（instance）的关系

          • 对象也叫实例（instance），是类经过“实例化”后得到的内存中的实体
            • Formally"instance"is synonymous with“object”——对象和实例是一回事
            • “飞机"与”一架飞机"有何区别？天上有(一架)飞机——必需是实例飞，概念是不能飞的
            • 有些类是不能实例化的，比如“数学"( Math class)，我们不能说”一个数学
          • 依照类（class），我们可以创建对象，这就是“实例化“
            • 现实世界中常称“对象", 程序世界中常称“实例”
            • 二者并无太大区别，常常混用，初学者不必迷惑
          • 使用new操作符创建类的实例
          • 引用变量与实例的关系
            • 孩子与气球
            • 气球不一定有孩子牵着
            • 多个孩子可以使用各自的绳子牵着同一个气球，也可以都通过一根绳子牵着气球
          • 在现实世界中一般称作对象、在程序世界中一般称作实例
          • 以Form来举例
            • 使用new来创建实例。
            • 使用Form MyForm1；来创建引用变量（可以理解为C语言指针）
            • 使用MyForm1 = new Form()；来将引用变量绑定到实例上（可以理解为指针指向实例）
            • 不同于C，需要解引用。 我们后续对MyForm1的操作，实际上是对new Form() 这个创建的实例在操作

          类的三大成员

          • 属性（Property）
            • 存储数据”，组合起来表示类或对象当前的状态
          • 方法（Method）
            • 由C语言中的函数(function)进化而来，表示类或对象”能做什么’
            • 工作中90%的时间是在与方法打交道，因为它是“真正做事”、”构成逻辑”的成员
          • 事件（Event )
            • 类或对象通知其它类或对象的机制，为C#所特有（Java通过其它办法实现这个机制）
            • 善用事件机制非常重要
          • 使用MSDN文档
          • 某些特殊类或对象在成员方面侧重点不同
          • 模型类或对象重在属性，如Entity Framework
          • 工具类或对象重在方法，如Math,Console
          • 通知类或对象重在事件，如各种Timer

          静态成员与实例成员*

          静态成员属于类本身而不是类的特定实例。在创建时可以用static 来前缀

          一、语义及特点

          静态成员
          1. 静态成员在语义上表示它是 “类的成员”，可想象成班级里的公共用品如时钟，也像人类的总数、平均身高体重等概念。它是与生俱来的，只要类被抽象出来，静态成员就存在。
          1. 静态成员隶属于类本身，在内存中只有一个副本。例如 Console.WriteLine 中的 WriteLine 是静态方法，通过类名 Console 直接访问，无需特定对象。
          1. 静态成员可以被所有的对象访问，而不需要通过特定的对象去访问。 同时，静态成员只能访问其他静态成员，不能访问类的实例成员。
          实例成员
          1. 实例成员在语义上表示它是 “对象的成员”，如同学生自己的书包，每个学生（对象）都有自己独立的书包，不同学生书包里的东西可能不一样。
          1. 实例成员属于特定对象的实例，每个对象都有自己的实例成员副本。
          1. 实例成员需要通过实例化对象来访问， 并且实例成员可以访问类的其他实例和静态成员。

          二、访问方式

          1. 静态成员访问
          静态成员可以通过类名直接访问，如 Console.WriteLine 。
          1. 实例成员访问
          实例成员需要通过实例化对象来访问，如From from = new From();。 这里的意思就是用From这个类。实例化了一个From对象。
          当使用类名From来引出方法和工具时，通常是调用静态方法或访问静态成员。
          • 静态方法和成员属于类本身，在内存中只有一份，不依赖于特定的对象实例。
          • 可以直接通过类名来访问，无需创建对象实例。例如From.StaticMethod();。
          • 静态成员不能直接访问类的实例成员，因为它们与特定的对象实例无关。
          使用实例名来引出方法和工具时，是调用实例方法或访问实例成员。
          • 实例方法和成员属于特定的对象实例，每个对象实例都有自己独立的副本。
          • 必须先创建类的实例，然后通过实例名来访问。例如from.InstanceMethod();。
          • 实例成员可以访问类的其他实例成员和静态成员，因为它们在对象的上下文中运行。
          总的来说，主要区别在于静态成员和实例成员的本质特性以及访问方式不同。静态成员适用于与类相关的通用操作，不依赖于特定的对象状态；而实例成员则与特定的对象实例相关联，反映对象的具体状态和行为。

          三、基本元素、初识类型、变量与方法、算法简介

          1. 章节介绍

          • 构成C#语言的基本元素
            • 标记( Token ) 标记 是对于编译器有意义的记号
              • 关键字(Keyword)
              • 操作符(Operator)
              • 标识符(ldentifier)
              • 标点符号
              • 文本
            • 注释与空白
          • 简要介绍类型、变量与方法算法简介

          2. 构成C#语言的基本结构

          一、标记（token）概述
          在 C# 中，标记是对编译器有意义的记号，主要分为以下几类：
          1. 关键字：具有特定含义的保留词汇，如for循环中的 “for” 就是关键字。它们在语言中被赋予了特定的功能和用途，用于构建程序的逻辑结构和表达特定的操作。
          1. 操作符：用于执行各种运算，如算术运算（+、-、*、/ 等）、比较运算（==、!=、>、< 等）、逻辑运算（&&、||、! 等）。
          1. 标识符：
              • “什么是合法的标识符” 部分主要涉及到在 C# 中定义变量、方法、类等命名时需要遵循的规则。合法的标识符通常由字母、数字和下划线组成，但不能以数字开头。并且要不与C#的保留字
              • “大小写规范” 则涉及到 C# 中标识符的大小写敏感性。一般来说，C# 是区分大小写的语言。
              • “命名规范” 包括各种命名约定，如变量名通常使用小写字母开头的驼峰命名法（myVariable），类名使用大写字母开头的帕斯卡命名法（MyVarable）等。
                  • （一般变量名，都是驼峰法。类、名称空间、等都是实用的帕斯卡法）
          1. 标点符号：在 C# 中，标点符号用于分隔语句、表示语句的结束等，例如分号（;）用于结束一条语句，括号（()）用于方法调用和表达式分组等。
          1. 文本（字面值）：
              • “整数” 可以有多种后缀，例如 “L” 表示 long 类型的整数，“U” 表示 unsigned 整数等2、2L。
              • “实数” 也有多种后缀，用于表示不同精度的浮点数。F单精度，D双精度，默认双精度。
              • “字符字符串” 用于表示一串字符，用双引号括起来。
              • “布尔” 类型只有两个值：true 和 false。
              • “空（null）” 表示一个对象没有值。
          二、注释与空白
          1. 单行注释：使用 “//” 开头，用于在代码中添加单行注释，解释代码的功能或提供其他信息。
          1. 多行（块注释）：使用 “/” 和 “/” 包围起来，可以包含多行注释内容。多行注释通常用于对一段代码或一个函数进行详细的解释。

          3. 初识类型、变量和方法

          • 初识类型 (Type)
            • 亦称数据类型 (Data Type)。不同的数据类型在内存中占据不同的空间大小，并且具有特定的操作和用途。例如，整数类型用于存储整数值，浮点类型用于存储带有小数部分的数值。
          • 变量是存放数据的地方，简称 “数据”
            • 变量的声明：在 C# 中，变量的声明需要指定变量的类型和名称。例如，int num;声明了一个名为num的整数类型变量。
            • 变量的使用：声明变量后，可以通过赋值语句为变量赋予具体的值。例如，num = 10;将整数值 10 赋给变量num。变量可以在表达式中使用，也可以作为方法的参数传递。
          • 方法 (旧称函数) 是处理数据的逻辑，又称 “算法”
            • 方法的声明：方法的声明包括方法的返回类型、方法名、参数列表和方法体。例如，public int Add(int a, int b) { int result = a + b; return result; }声明了一个名为Add的方法，该方法接受两个整数参数a和b，并返回它们的和。其中public 是 为了让 类 外边 也能访问到这个方法。
            • 方法的调用：可以通过方法名和参数列表来调用方法。但在此之前 要把类创建为实例。然后再使用int sum = c.Add(5, 3);调用了Add方法，并将返回值赋给变量sum。（其中c为创建的实例名）
            • 方法一般分为三类：有输入有输出，例如求和；没输入有输出，例如显示日期；无输入有输出。一般是在方法内直接输出或者做了某些事情。
          • 程序 = 数据 + 算法
            • 有了变量和方法就可以写有意义的程序了。程序通过对数据的操作和处理来实现特定的功能。变量存储程序中的数据，方法提供对数据的处理逻辑。通过合理地组织变量和方法，可以构建出复杂的程序。一般有for 和 递归。
          在 C# 中，正确地理解和使用数据类型、变量和方法是编写高效、可靠程序的基础。了解不同数据类型的特点和用途，合理地声明和使用变量，以及设计有效的方法，可以提高程序的可读性、可维护性和性能。

          四、详解C#类型、变量与对象

          什么是类型(Type)

          一、又名数据类型( Data Type )
          • A data type is a homogeneous collection of values, effectively presented, equipped with a set of operations which manipulate these values
          • 数据类型是值的同质集合，有效地呈现，配备了一组操作这些值的操作
          • 是数据在内存中存储时的“型号（Type 又称型号）
          • 若误小内存容纳大尺寸数据会丢失精确度、发生
          • 大内存容纳小尺寸数据会导致浪费
          • 编程语言的数据类型与数据的数据类型不完全相同
          二、强类型语言与弱类型语言的比较
          数据被数据类型约束，叫强类型语言。反之被约束的少，甚至不约束。叫弱类型
          • C语言示例:if条件
              • 例如在C语言中 if(x = 10)是可以被编译过去的。 而 C#语言则不允许， 因为C#语言中 括号内强制 要求为一个bool类型的值，也就是只能为true 和 false
          • JavaScript示例:动态类型
              • var myVar = 100; myVar = “hello”; alert(myVar); 这段代码在这里是可以运行的
          • C#语言对弱类型/动态类型的模仿
              • 在C#语言中为了模仿弱类型，引用了一个新的关键字：dynamic 这个关键字可以实现上边的功能

          在C#语言中的作用

          一、程序的静态与动态时期
          程序在执行时为动态时期（运行时期），也称为运行或调试阶段。在这个阶段，程序被加载到内存中运行。可以说，动态的程序是在内存里的，此时方法调用使用栈（Stack），存储对象使用堆（Heap）。
          而在静态时期，即写代码或编译阶段，程序以代码文件的形式存储在硬盘里。
          二、栈（Stack）的特点
          栈的空间相对较小，一般为 1 - 2M，但其速度快。当方法被调用时，方法的参数和局部变量会在栈上分配内存。由于栈的内存空间有限，当不断进行方法调用或在方法中不断创建新的变量，导致栈满时，就会出现栈溢出（Stack overflow）的情况。例如，可以通过直接递归某个方法，在方法中不断创建新的变量来测试栈溢出；或者在方法前添加unsafe前缀后，使用int* p = stackalloc int(9999999);在栈中切除很大的一块内存，也可能引发栈溢出。
          三、堆（Heap）的特点
          堆的空间相对较大，能有几个 G。对象存储在堆上，在堆上分配内存相对较慢。同时，堆可能会出现内存泄漏的情况，即如果程序员忘记释放不再使用的内存，就会导致内存浪费。不过，C# 有垃圾收集器的机制，垃圾收集器会自动收集不再使用的对象所占用的内存空间，从而在一定程度上避免了内存泄漏的问题。
           
          在C#语言中的作用
          • 一个C#类型中所包含的信息有：
            • 存储此类型变量所需的内存空间大小
            • 此类型的值可表示的最大、最小值范围
            • 此类型所包含的成员(如方法、属性、事件等 )
            • 此类型由何基类派生而来
            • 程序运行的时候，此类型的变量在分配在内存的什么位置
              • Stack简介
              • Stack overflow
              • Heap简介
              • 使用Performance Monitor查看进程的堆内存使用量
              • 关于内存泄漏
            • 此类型所允许的操作(运算)

          C#语言的类型系统

          一、C#的五大数据类型：
          • 类(Classes): 如Windows, Form, Console, String
          • 结构体(Structures): 如Int32, Int64, Single, Double
          • 枚举(Enumerations): 如HorizontalAlignment, Visibility
          • 接口(Interfaces )
          • 委托(Delegates )
          二、C#类型的派生谱系：
          notion image
          C shap中 的类型分为两种：引用类型和值类型。引用类型分为类、接口、委托；值类型有结构体和枚举。所有类型都以Object类型为自己的基类型。
          第一组（左边）
          • Object、string 为真正的数据类型（因为这两个太常用了。所以C#把他吸收为自己的关键字了。） string 为 引用类型 存储在 堆
          • 横线下边的三个数据类型 不是具体的数据类型，而是我们用他们三个关键字去定义自己的数据类型
          第二组
          • 同上
          第三组
          • 上为bool类型的值
          • 中为 无返回值 和 为空
          • 下为 声明变量

          变量、对象与内存

          • 什么是变量
              1. 表面上来看，变量的用途是存储数据
              1. 实际上，变量表示了存储位置，并且每个变量都有一个类型，以决定什么样的值能够存入变量 （变量名（对应这）变量的值在内存中存储位置 并且决定了什么样的值能够存融入）
              1. 变量一共有7种·
                  • 静态变量（静态字段），实例变量(成员变量,字段), 数组元素, 值参数, 引用参数, 输出参数, 局部变量 ref 引用的 值参数 为引用变量。out 引用的 值参数 为输出参数 一般称的变量为：局部变量
              1. 狭义的变量指局部变量，因为其它种类的变量都有自己的约定名称
                  • 简单地讲，局部变量就是方法体(函数体)里声明的变量
              1. 变量的声明
                  • 有效的修饰符组合opt - 类型 - 变量名 - 初始化器opt。 opt意思就是可有可无 比如public static int Age = 0:; public static 是有效的修饰符组合 int 为类型 Age 为变量名 =0 则为初始化器
                  总结： ”变量 = 以变量名所对应的内存地址为起点、以其数据类型所要求的存储空间为长度的一块内存区域“ （大小端 与硬件有关） 值类型在栈上分配内存，不同的值类型占用的字节大小固定，如byte占用 1 个字节，int占用 4 个字节等。 引用类型的对象在堆上分配内存，引用本身在 32 位系统上通常占用 4 个字节，在 64 位系统上通常占用 8 个字节，它只是指向堆上对象的内存地址。 栈内存的增长方向通常是由高地址向低地址
          • 值类型的变量
              1. 以byte / sbtye / short / ushort为例
              1. 值类型没有实例，所谓的“实例”与变量合而为一 也就是说，int x; 相当于 int x = new int x();
          • 引用类型的变量与实例
              1. 引用类型变量与实例的关系:引用类型变量里存储的数据是对象的内存地址
          • 变量的默认值
          • 常量(值不可改变的变量) const
          • 装箱与拆箱(Boxing & Unboxing)
            • 当把一个值类型转换为object类型时，会发生装箱操作。 （object obj ，obj 变量是在栈上的） 例如，将一个整数赋值给object变量：
                • 在这个过程中，会在堆上创建一个新的对象，并将值类型的值复制到这个对象中。同时，在栈上会存储对这个堆上对象的引用。
            • 当从object类型转换回值类型时，会发生拆箱操作。例如：
                • 在拆箱过程中，首先要检查堆上的对象是否为正确的类型，如果是，则将值从堆上的对象复制到栈上的值类型变量中。
                总的来说，装箱和拆箱操作涉及到堆和栈的交互。 装箱时，值类型的值被复制到堆上的对象中，栈上存储对堆上对象的引用； 拆箱时，从堆上的对象中复制值到栈上的值类型变量中。 这些操作会带来一些性能开销

          五、方法的定义、调用和调试*

          方法在创建时，被static 修饰 会变为 类的方法。 否则为 实例的方法。
          实例的方法只有在创建出实例后，用实例引出。
          静态的方法会一直占用内存， 实例 则可以被释放
           
          调用方法的()为 方法调用操作符

          构造器(一种特殊的方法)

          构造器(constructor)是类型的成员之一
          狭义的构造器指的是“实例构造器'(instance constructor )

          声明和调用构造器

          在 C# 中，当我们写好一个类之后，如果没有进行额外的操作，系统会自动提供一个默认的构造器。这个默认构造器会将类中没有赋值的参数初始化为默认值。例如：
          此时若调用 Console.WriteLine(student.ID); 和 Console.WriteLine(student.Name);，那么输出就是 0 和空字符串。 我们也可以自己创建构造器。由于构造器没有输入与输出，所以可以像下面这样创建：
          这样，当创建一个 Student 类的实例时，使用默认构造器初始化后的输出就是 1 和 "No Name"。 当然，我们还可以在创建实例时要求给变量初始值，这就是构造函数重载。例如：
          现在，当我们运行以下代码：
          输出结果为：先是 1 和 "No Name"，接着是一个分隔符 "=================="，然后是 2 和 "Hello"。通过构造函数重载，我们可以根据不同的需求灵活地初始化类的实例。

          构造器的内存原理

          在 C# 中，对于类Student含有int ID和string Name两个成员变量。
          当类中没有显式编写构造器时，即使用默认构造器。 此时创建实例Student stu = new Student();，在内存中的操作如下：首先在栈区为变量stu分配内存，该内存用于保存堆区中实例的地址。接着在堆区为int类型的ID和string类型的Name各分配四个字节的内存。其中，int类型的四个字节会以小端的补码形式存入，而string类型在默认情况下会被初始化为指向空字符。
          当类中自己创建了构造器，并且在构造器中将ID赋值为 1，Name赋值为 "Hello"。当创建实例Student stu = new Student();时，内存操作过程与默认构造器类似，首先在栈区为stu变量分配内存以保存堆区实例地址。然后在堆区为int和string各分配四个字节内存。对于int类型依旧以小端的方式存入数字 1。对于string类型，系统会在堆区另外开辟足够大的内存空间来存储 "Hello" 字符串，然后Name会指向堆区这个存储 "Hello" 的地址，以小端的补码形式存储在内存中。
          总之，构造器的不同 会影响堆区中对象的初始化方式，进而影响内存的分配和数据的存储。

          方法的重载(Overload )

          声明带有重载的方法
          方法签名由方法的名称、类型形参的个数以及它的每一个形参（按从左到右的顺序）的类型和种类（值、引用或输出）组成。需注意，方法签名不包含返回类型。 同样，实例构造器签名由它的每一个形参（按从左到右的顺序）的类型和种类组成。
          重载决策是在给定了参数列表和一组候选函数成员的情况下，选择一个最佳函数成员来实施调用。例如，在 C# 中常见的 Console.WriteLine 方法就有多种重载形式，可以根据不同的参数类型输出不同的内容。
          下面以一个简单的计算器类为例：
          在这个例子中，Calculator类中的Add方法有多个重载版本。当调用这个方法时，编译器会根据传入的参数来确定具体调用哪个重载的方法。
          对于方法的重载，作为初学者要记住，方法的名字可以相同，但它的参数列表不能完全一样，即参数的个数、类型或种类不同，从而形成不同的方法签名。这样，在调用方法时，编译器可以根据传入的参数来确定具体调用哪个重载的方法。

          如何对方法进行debug

          Call Stack 调用堆栈 ：可以看注意看栈的深度（函数之间的调用调用调用）
          还有看变量，这个很熟悉了不写了

          方法的调用与栈*

          栈内存的增长方向是由高字节位向低字节位发展，当不断进行方法调用而栈内存使用达到其最大限度时（层级过深），就会出现 “Stack overflow（栈溢出）” 的情况。
          对栈帧（stack frame）进行分析可以更好地理解方法调用在栈中的布局。首先，程序从main方法开始执行，main方法会占用一部分栈空间。当main方法调用其他方法时，main方法成为主调者（caller），被调用的方法成为被调者（callee）。
          在调用方法时，传入的参数如果是变量，这些变量会被压入栈中。在 C# 语言中，这些变量由主调者（这里即main方法）管理，并且是从左往右依次压入栈的。所以，传入的变量都处于主调者的栈帧中。
          接着进入被调用的方法，被调用者的局部变量由被调用方法管理。如果在这个方法中又调用了其他方法，同样遵循上述规则。
          当方法执行完毕准备退出时，会首先将返回值存入 CPU 寄存器（如果寄存器空间不够，可能会采用在栈中开辟空间。CPU寄存器根据型号不同个数不同。一般就几个）。然后，销毁被调用方法中的局部变量。接着，销毁上一个调用者（主调者）传过来的参数。最后，将返回值赋值给上一个调用者的某个局部变量，以便主调者继续执行后续代码。
          总的来说，栈按照压入的顺序进行操作，后进先出。每个方法的调用都会在栈上创建一个新的栈帧，包含方法的参数和局部变量等信息。当方法执行完毕，对应的栈帧被销毁，释放内存空间。这种栈的管理方式确保了方法调用的正确执行和内存的有效管理。

          六、操作符详解

          • 操作符也叫运算符（Operator）
          • 操作符是用来操作数据的，被操作符操作的数据称为操作数（Operand）

          操作符概览

          notion image
          • 从上往下优先级依次降低
          • 只有赋值操作符是从右往左运算

          操作符的本质

          • 操作符的本质是函数(即算法)的“简记法”
            • 假如没有发明”+”、只有Add函数，算式3+4+5将可以写成Add(Add(3,4),5)
            • 假如没有发明“x” 、只有Mul函数，那么算式3+4x5将只能写成Adǎ(3,Mul(4,5))
          • 操作符不能脱离与它关联的数据类型
            • 可以说操作符就是与固定数据类型相关联的一套基本算法的简记法
            • 比如 int a ，b a/b 这里的/是与证书相关联的。 同理double也是一样
          举个栗子，我们来自己创建一个关联我们的函数的 数据类型 通过这个例子，我们可以清晰地知道。 C# 的操作符本质上 就是 方法 的简记法

          一个栗子

          操作符的优先级

          • 操作符的优先级
            • 可以使用圆括号提高被括起来表达式的优先级
            • 圆括号可以嵌套
            • 不像数学里有方括号和花括号，在C#语言里““[ ]"与”{ }“有专门的用途
          • 同优先级操作符的运算顺序
            • 除了带有赋值功能的操作符，同优先级操作符都是由左向右进行运算
            • 带有赋值功能的操作符的运算顺序是由右向左
            • 与数学运算不同，计算机语言的同优先级运算没有“结合率”
              • 3+4+5只能理解为Add(Add(3,4),5)不能理解为Add(3,Add(4,5))

          各类操作符的示例

          1. 成员访问运算符“.”：用于访问类中的成员或者访问位于某个名空间中的类
          1. typeof操作符：可以用于获取一个类型的完整信息，包括完整的类型名称，该类型包含在哪个命名空间中，该类型包含哪些成员等等
          1. default：该运算符用于获取一个类型的默认值，比如：
          1. var操作符：var可以声明隐式变量，他没有数据类型。它会根据赋值到的变量实例自动推断自己的类型。
          1. new操作符：new有两种用法
            1. 作为操作符，用于创建内存实例，并且立刻调用这个实例的实例构造器。并且返回实例的地址。
                • 并且可以在实例后加入花括号，为实例的属性设置它的值。比如Form myFrom = new Form() {text = “Hello”};
                • 当然有时候也不用new ，比如string ， 这是一个类类型，是为了规范，所以让我们省去了new 操作符，来创建 string实例
                • 以上都是非匿名类型的。 new 操作符的使用也不一定非得跟一个数据类型， new后也可以不跟东西。比如 var person = new {Name = “Haha”, Num = 34}； （编译器会自动推断变量的类型） 这个 就是一个隐式变量。 他的类型会根据约定好的方式进行命名<>f__AnonymousType0\2（f__AnonymousTyp 为 约定前缀，0为，程序中第1个，\2指这是一个泛型类，构成这个类型需要两个类型。） 所以我们可以直接使用这个 person 实例
                • #使用new操作符要小心，因为在类的方法中创建实例后，这个类就会和这个实例对应的对象所处的类紧密耦合，当后者 出现问题，前者也不能正常运行。产生了依赖。（为了解决这个，有个技术叫设计模式，可以有依赖注入，可以把紧耦合变为相对松一点的。）
            2. 作为修饰符，作为关键字 在类成员前面 表示子类的方法 隐藏 父类方法
                • 派生（继承）：用法是子类方法名:父类方法名 子类 会继承 父类的所有方法。 子类可以在类中创建与父类 相同名称的方法，并在前缀加入new 修饰符。来覆盖（或隐藏）父类的方法。然后在子类中调用方法就是子类中创建的方法。父类调用则还是父类的方法。
          1. checked、unchecked 用来判断一个值是否在内存中溢出。
              • 对一个已经赋值为最大值的 x = checked(x+1) 会弹出警告，程序无法运行
              • 可以使用try catch 来抓住异常并处理异常
              • C#中默认为unchecked
              • 可以使用checked { } 语句块中所有溢出都会被检测到
          1. sizeof 操作符使用 时，如果要求结构体，需要把它放到不安全的上下文中才可以（unsafe{ }）
          1. ->操作符
              • C#中规定 指针操作、取地址操作、以及用指针访问成员额操作 只能操作结构体类型，不能操作引用类型。
              • 同理，也要用unsafe 来放到不安全的上下文中
           

          七、表达式和语句

          表达式

          表达式的定义：
          • 表达式是任何一门编程语言的基本组件最重要的组成部分之一
          • 表达式是专门用来求值的一种语法实体
          C#对表达式的定义
          • 表达式是由一个或多个操作数和零个或多个操作符组成的序列，这些操作符可以求值为单个值、对象、方法或名称空间。
          • 得到值：x++，x = 100， --x等。他们的结果是一个值
          • 得到对象：new Form() 其中new为操作符， Form为操作数、（）为调用它的构造函数。他们的结果是一个对象
          • 得到方法：Action myAction = new Action（Console.WriteLine）；
            • 其中.为成员访问表达式，操作数有两个，在这个函数中左边是类型，右边是类型的成员
            • 这个表达式得到的结果，是一个方法。 方法也是一个语法实体。
          • 得到名称空间：System.Windows.Forms.Form myForm = new Form()
            • 其中，.是名称空间访问表达式，在这里。左边为主名称空间，.右边是子名称空间。这个表达式经过求职之后得到的值就是一个名称空间。
          • 表达式可以由文字值、方法调用、操作符及其操作数或简单名称组成。
          • 简单名称可以是变量、类型成员、方法参数、名称空间或类型的名称
          • 算法逻辑的基本（最小）的组成单元，表达一定的算法意图
          • 因为操作符有优先级，所以表达式也就有了优先级。
          notion image

          语句的定义

          在计算机编程语言中，语句是命令式编程语言中最小的独立元素。
          • 命令式语言：大部分是高级语言，比如C# C++ JAVA等
          语句，是一种语法实体。他的功能是表达一些将被执行的动作。
          语句的内部组件就是表达式，每一个表达式都对应一个这个语句索要执行的一个动作。
          一个高级语言所写成的程序，它实际上是由一系列语句所构成的
          低级语言例如汇编语言和机器语言，他们只有指令，对应着CPU可以直接置信的动作
           
          例如我们可以在C语言 或C#语言编写后，勾选输出汇编文件或使用 对应的工具来查看C或C#语言编译出的的汇编代码
           
          程序之中，语句执行的顺序称为控制流（执行流）
          C#语言的语句除了能够让程序员“顺序地”(sequentially)表达算法思想，还能通过条件判断、跳转和循环等方法控制程序逻辑的走向。
          简言之就是: 陈述算法思想，控制逻辑走向，完成有意义的动作(action)
          C#语言的语句由分号( ; )结尾，但由分号结尾的不一定都是语句
          • 例如引入名称空间。using 指令。
          • 例如public string Name; 字段的声明
          语句一定是出现在方法体里

          语句详解

          C#语言的语句三大类

          • 标签语句
              • 前面带标签的语句，用得不多
          • 声明语句
              • 用来声明变量，常量、
          • 嵌入式语句
          • 被嵌入在其他语句当中的语句，就称为嵌入式语句
              • notion image

          C#语言语句详解

          1. 声明语句
              • 比如 int a ； int a = 100；（注意这俩，一个是声明，后续可赋值。一个是声明后追加初始化器）
          1. 表达式语句
              • 语句表达式+ ; = 表达式语句。 （语句表达式是可以形成语句的表达式。不是所有表达式都可以作为语句来使用的）
                • 方法调用表达式（）； 比如打印“Hello World” 就是选择调用只接收一个字符串类型的重载。
                • 对象创建表达式 new ：new操作符会创建一个对象，并调用对象的构造器。
                • 赋值语句
                • 后置（前置）自增（自减）表达式
                • await- expression
                  • 异步编程才用到。
          1. C#语言对语句的定义比C语言严格得多 一些在C#中不能当做语句的表达式
              • 单独一行 x+y； 、 x； y；
              • 而C语言可以。
           

          基于C#的串口助手

          Demo1 实现基础的收发框架

          实现的功能

          1. 建立WinFrom项目
          1. 熟悉常用控件

          用到的控件

          • label
            • 标签
          • ComboBox
            • 下拉菜单
          • TextBox
            • 文本框
          • RichTextBox
            • 复文本框
            • 复文本框与文本框、标签的区别是，可以设置更多东西。有文本编辑等能力。
          • Button
            • 按钮

          实现方法和思路

          各个控件设置好位置和名称后，可以看到，在这个程序里，软件已经自动实例化了各个控件的对象，并且配置好了基础的属性，并在最后声明了这些实例化的对象。
          notion image
          notion image
          下面再摸索一下，在窗口加载时初始化一些对象中的属性，需要在这个窗口控件的 这个事件下双击配置
          notion image
          双击后，软件会自动生成一私有的方法， 可以在方法内对 声明的 实例化的对象进行属性的配置。如图
          notion image
          下面是发送按钮的配置，同上，也是在事件中，找到点击事件（也可以直接双击button控件）
          notion image
          下面在私有的方法中配置如下内容，实现发送的基本逻辑

          Demo2 创建界面

          实现的功能

          1. 完善界面规划
              • 配置区
              • 发送区
              • 接收区
          1. 添加布局所有控件

          用到的控件

          • label
            • 标签
          • ComboBox
            • 下拉菜单
          • TextBox
            • 文本框
          • RichTextBox
            • 复文本框
          • Button
            • 按钮
          • GropBox
            • 分组控件
          • CheckBox
            • 选择框控件
          • StatusStrip
            • 状态栏控件

          实现方法和思路

          1. 使用分组控件，分出三个区域，分别用作串口配置、接收配置和发送配置
          1. 使用选择框控件，用作功能开关
          1. 使用状态栏控件， 创建StatusLabel标签，用于状态指示
            1. 如果和下图一样，“初始化正常”字样的占长 修改的话， 需要修改下 状态图标的Spring（是否填满剩余空间）和AutoSize（自动调整项的大小） 设置为False
          1. 最终效果如图
          notion image

          Demo3 串口了解

          实现的功能

          1. 修改各个控件的name，使其更加规范
          1. 了解串口类
              • string PortName（端口号）
              • int DataBits（数据位）
              • StopBits StopBits（停止位）
              • Parity Parity（校验位）
              • int BaudRate（波特率）
              • bool IsOpen（状态）DtrEnable / RtsEnable
              • 获取端口号：RegistryKey keyCom = Registry.LocalMachine.OpenSubKey(@"Hardware\DeviceMap\SerialComm");
              • 初始化配置参数，主要包括：端口号、波特率、数据位、停止位、校验位、编码格式 serialPort1.Encoding = Encoding.GetEncoding("GB2312");

          用到的控件

          • label
            • 标签
          • ComboBox
            • 下拉菜单
          • TextBox
            • 文本框
          • RichTextBox
            • 复文本框
          • Button
            • 按钮
          • GropBox
            • 分组控件
          • CheckBox
            • 选择框控件
          • StatusStrip
            • 状态栏控件
          • SerialPort
            • 串口控件

          实现方法和思路

          这个Demo只做了解SerialPort类。所以只写了，点击打开串口时，的逻辑。
          在使用串口等 需要操作IO的类时，为了避免发生的错误，一般会用
          来吧可能出现的错误先 抛出来。
          最终代码

          Demo4 串口打开、关闭

          实现的功能

          1. 实现串口的初始化（port，波特率、奇偶校验、停止位）
          1. 串口开关

          用到的控件（不变）

          • label
            • 标签
          • ComboBox
            • 下拉菜单
          • TextBox
            • 文本框
          • RichTextBox
            • 复文本框
          • Button
            • 按钮
          • GropBox
            • 分组控件
          • CheckBox
            • 选择框控件
          • StatusStrip
            • 状态栏控件
          • SerialPort
            • 串口控件

          实现方法和思路

          在上个Demo的基础上修改，添加了一个标志位，用于 开，关串口
          最终代码

          Demo5 获取端口及串口简单收发

          实现的功能

          1. 从本地设备列表中获取串口
          1. 串口数据的发送
          1. 串口数据的接收

          用到的控件（不变）

          • label
            • 标签
          • ComboBox
            • 下拉菜单
          • TextBox
            • 文本框
          • RichTextBox
            • 复文本框
          • Button
            • 按钮
          • GropBox
            • 分组控件
          • CheckBox
            • 选择框控件
          • StatusStrip
            • 状态栏控件
          • SerialPort
            • 串口控件

          实现方法和思路

          1. 获取系统端口
              2. 获取系统端口需要使用到注册表的一个类，从类中读取设备号
              RegistryKey keyCom = Registry.LocalMachine.OpenSubKey(@"Hardware\DeviceMap\SerialComm");
              实际上就对应了我们 计算机设备ide注册表的这个目录
              notion image
          1. 串口数据发送方法
              • public void Write(byte[] buffer, int offset, int count);
                • 写入字节数组
              • public void Write(string text);
                • 写入字符串
              • public void Write(char[] buffer, int offset, int count);
                • 写入字符数组
              • public void WriteLine(string text);
                • 写入一行字符串（在字符串末尾添加换行符）
          1. 串口数据接收方法
              • public int Read(byte[] buffer, int offset, int count);
                • 从字节数组中读取数据
              • public int Read(char[] buffer, int offset, int count);
                • 从字符数组中读取数据
              • public int ReadByte();
                • 读取一个字节的数据
              • public int ReadChar();
                • 读取一个字符的数据
              • public string ReadExisting();
                • 读取所有可用的数据，并以字符串形式返回
              • public string ReadLine();
                • 读取一行数据，并以字符串形式返回
              • public string ReadTo(string value);
                • 读取数据直到遇到指定的字符串，并以字符串形式返回。
              • public event SerialDataReceivedEventHandler DataReceived;
                • 接收到数据时触发，使用SerialDataReceivedEventHandler类型的委托来处理事件。
          最终代码
          1. 获取系统端口：
            1. 点击发送按钮：
              1. 点击接收按钮：
                1. 其他

                  Demo6 串口收发优化

                  实现的功能

                  1. 异步线程：更新UI
                  1. 接收字符处理
                  1. 发送字符处理

                  用到的控件（添加了timer 定时器）

                  • label
                    • 标签
                  • ComboBox
                    • 下拉菜单
                  • TextBox
                    • 文本框
                  • RichTextBox
                    • 复文本框
                  • Button
                    • 按钮
                  • GropBox
                    • 分组控件
                  • CheckBox
                    • 选择框控件
                  • StatusStrip
                    • 状态栏控件
                  • SerialPort
                    • 串口控件
                  • Timer
                    • 定时器

                  实现方法和思路

                  1. 异步线程
                      • 为什么要使用异步线程？
                          • 因为串口的data receive 接收，是在辅助线程执行，数据需要更新到ui的主线程时，这个操作就会跨线程，跨线程是不安全的。
                          这时候就需要执行一个异步线程来执行数据䣌更新
                  1. 数据的接收处理
                      • 将数据接收，并缓存到数据缓冲区（List<byte> 优于 byte[] )
                      • 字符的编码格式：GB2312、UTF8 等等。。
                  1. 数据的发送处理
                      • 发送普通字符串
                      • 发送16进制数据
                  代码部分——————————————
                  • 异步线程：更新UI代码
                      • 这里是为了防止一个线程来操作另一个线程，这样会导致问题出现。
                  • 接收数据处理
                      1. 数据处理并显示在发送文本框
                          2. 其中包含了数据的处理和 累加接收长度
                      1. 16进制勾选逻辑
                          2. 实现在勾选和取消勾选16进制时，使接收文本框内的数据变为相应的进制。
                      1. 清空接收数据
                        1. 自动清空
                            2. 这里使用了一个新的控件：Timer，（设置为100ms一次的定时），当自动清空被勾选时，会打开定时器，定时器则会1s检测10次 接收框的数据长度，如果大于4096（默认）那么就清空。（后续会改为可设置）
                        1. 暂停接收
                      • 发送数据处理
                          1. 数据处理并显示在接收文本框
                              2. 这里使用到了一个新的事件：发送文本框的Leave 离开焦点事件，当焦点离开时，执行下面的方法。目的时检测当前数据是否为16进制数据，如果不是，则发送相应警告。
                              根据选择， 处理或者不处理数据，让后放到发送缓冲区中
                              其中包含了数据的处理和 累加发送长度
                              注意如果使用文本发生变化事件，去处理16进制的转换，会发生错误 问题就是0x00 转换
                              sendBuffer.AddRange(Transform.ToBytes(send_rtb.Text.Replace(" ", "")));
                              }
                              else //不是16进制数据
                              {
                              MessageBox.Show("请输入正确的十六进制数据！！", "发送框警告");
                              send_rtb.Select();
                              }
                              }
                              else //未选中16进制。
                              {
                              sendBuffer.Clear();
                              //把当前数据，存放到发送缓冲区。
                              sendBuffer.AddRange(Encoding.GetEncoding("gb2312").GetBytes(send_rtb.Text));
                              }
                      }
                      //发送 16进制切换 框 点击
                      private void sendhex_chb_CheckedChanged(object sender, EventArgs e)
                      {
                      //判断发送框文本你是否为空
                      if (send_rtb.Text == "") return;
                      //把发送缓冲区的所有 变为 16进制， 用空格隔开
                      if (sendhex_chb.Checked == true)
                      {
                      send_rtb.Text = Transform.ToHexString(sendBuffer.ToArray(), " ");
                      }
                      else
                      {
                      send_rtb.Text = Encoding.GetEncoding("gb2312").GetString(sendBuffer.ToArray()).Replace("0","\0");
                      }
                      }
                      //发送框清除按钮点击事件
                      private void sendclear_btn_Click(object sender, EventArgs e)
                      {
                      sendBuffer.Clear(); //清除发送框缓冲区
                      send_rtb.Text = ""; //清除发送框
                      sendCount = 0; //清除发送计数
                      sencount_tssl.Text = "0"; //清除发送框计数
                      }
                      using Microsoft.Win32;
                      using System;
                      using System.Collections.Generic;
                      using System.ComponentModel;
                      using System.Data;
                      using System.Drawing;
                      using System.IO.Ports;
                      using System.Text;
                      using System.Windows.Forms;
                      namespace 串口助手
                      {
                      public partial class Form1 : Form
                      {
                      //串口标志位
                      private bool isOpen = false;
                      //暂停标志位
                      private bool isRxShow = true;
                      //接收缓冲区
                      private List<byte> reciveBuffer = new List<byte>();
                      //发送缓冲区
                      private List<byte> sendBuffer = new List<byte>();
                      //接收计数
                      private int reciveCount = 0;
                      //发送计数
                      private int sendCount = 0;
                      //实例化SerialPort窗口事件
                      public Form1()
                      {
                      InitializeComponent();
                      Control.CheckForIllegalCrossThreadCalls = false;
                      }
                      //加载窗口控件事件
                      private void Form1_Load(object sender, EventArgs e)
                      {
                      serialLoad();
                      }
                      //自定义私有方法，初始化串口配置等
                      private void serialLoad()
                      {
                      EncodingInfo[] encodingInfos = Encoding.GetEncodings();
                      RegistryKey keyCom = Registry.LocalMachine.OpenSubKey(@"HardwareDeviceMapSerialComm");
                      string[] sSubKeys = keyCom.GetValueNames();
                      port_cbb.Items.Clear();
                      foreach (var sValue in sSubKeys)
                      {
                      string portName = (string)keyCom.GetValue(sValue);
                      port_cbb.Items.Add(portName);
                      }
                      this.port_cbb.SelectedIndex = 0;
                      this.baud_cbb.SelectedIndex = 1;
                      this.check_cbb.SelectedIndex = 0;
                      this.databit_cbb.SelectedIndex = 3;
                      this.stopbit_cbb.SelectedIndex = 0;
                      }
                      //发送
                      private void sendData()
                      {
                      //写串口，发送缓冲区中的数据
                      serialPort1.Write(sendBuffer.ToArray(),0,sendBuffer.Count);
                      //累加发送数据长度
                      sendCount += sendBuffer.Count;
                      //更新数据长度到状态
                      sencount_tssl.Text = sendCount.ToString();
                      }
                      private void send_btn_Click(object sender, EventArgs e)
                      {
                      // 如果发送的数据不为空，则发送
                      if (this.send_rtb.Text != "" && serialPort1.IsOpen)
                      {
                      Console.WriteLine(Transform.ToHexString(sendBuffer.ToArray()));//调试用
                      sendData(); //调用自己的发送方法
                      }
                      else
                      {
                      MessageBox.Show("请先输入发送数据！");
                      }
                      }
                      //点击打开串口按钮
                      private void open_btn_Click(object sender, EventArgs e)
                      {
                      try
                      {
                      if (serialPort1.IsOpen == false)
                      {
                      //设置基础配置
                      serialPort1.PortName = port_cbb.Text;
                      serialPort1.BaudRate = Convert.ToInt32(baud_cbb.Text);
                      serialPort1.DataBits = Convert.ToInt32(databit_cbb.Text);
                      switch (check_cbb.SelectedIndex)
                      {
                      // none odd even
                      case 0:
                      serialPort1.Parity = Parity.None;
                      break;
                      case 1:
                      serialPort1.Parity = Parity.Odd;
                      break;
                      case 2:
                      serialPort1.Parity = Parity.Even;
                      break;
                      default:
                      serialPort1.Parity = Parity.None;
                      break;
                      }
                      switch (stopbit_cbb.SelectedIndex)
                      {
                      // 1 1.5 2
                      case 0:
                      serialPort1.StopBits = StopBits.One;
                      break;
                      case 1:
                      serialPort1.StopBits = StopBits.OnePointFive;
                      break;
                      case 2:
                      serialPort1.StopBits = StopBits.Two;
                      break;
                      default:
                      serialPort1.StopBits = StopBits.One;
                      break;
                      }
                      serialPort1.Open();
                      isOpen = true;
                      open_btn.Text = "关闭串口";
                      }
                      else
                      {
                      serialPort1.Close();
                      isOpen = false;
                      open_btn.Text = "打开串口";
                      }
                      }
                      catch (Exception ex)
                      {
                      MessageBox.Show(ex.ToString()+serialPort1.PortName.ToString());
                      }
                      }
                      //串口接收到数据事件
                      private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
                      {
                      //如果暂停了，那么就不显示在接收框，直接return
                      if (isRxShow == false) return;
                      // 1,需要读取有效的数据 BytesToRead
                      //创建一个 数组，大小是当前串口缓存中的字节数量
                      byte[] dataTemp = new byte[serialPort1.BytesToRead];
                      //读取数据。
                      serialPort1.Read(dataTemp,0,dataTemp.Length);
                      //添加一组（集合）数据到接收框的末尾
                      reciveBuffer.AddRange(dataTemp);
                      //计数下接收到的数据
                      reciveCount += dataTemp.Length;
                      // 使用 Invoke 方法确保在 UI 线程上执行以下操作，防止异步线程
                      this.Invoke(new EventHandler(delegate //委托给 UI 线程
                      {
                      // 显示接收数据的长度
                      recivecount_tssl.Text = reciveCount.ToString();
                      //如果没有勾选16进制
                      if (!recivehex_chb.Checked)
                      {
                      // 通过指定的编码格式来获取字符串
                      string str = Encoding.GetEncoding("gb2312").GetString(dataTemp);
                      // 3，0x00 -> 0 结束 不会显示，所以转义成0 显示出来
                      str=str.Replace("0", "\0");
                      //向接收文本框追加处理后的数据
                      recive_rtb.AppendText(str);
                      //下面等同于上面三句话
                      //recive_rtb.AppendText(Encoding.GetEncoding("gb2312").GetString(dataTemp).Replace("0", "\0"));
                      }
                      else
                      {
                      // 十六进制是选中的状态下
                      //向接收文本框追加 将byte转化为16进制的 数据，然后追加一个空格
                      recive_rtb.AppendText(Transform.ToHexString(dataTemp, " "));
                      }
                      }));
                      }
                      //暂停按键事件
                      private void stop_btn_Click(object sender, EventArgs e)
                      {
                      if (isRxShow == true)
                      {
                      isRxShow = false;
                      stop_btn.Text = "取消暂停";
                      }
                      else
                      {
                      isRxShow = true;
                      stop_btn.Text = "暂停";
                      }
                      }
                      //接收 16进制切换 框 点击
                      private void recivehex_chb_CheckedChanged(object sender, EventArgs e)
                      {
                      //如果接收缓冲区 为空，直接退出
                      if (recive_rtb.Text == "") return;
                      //如果16进制为勾选状态
                      if (recivehex_chb.Checked)
                      {
                      //把接收缓冲区的所有 变为 16进制， 用空格隔开
                      recive_rtb.Text = Transform.ToHexString(reciveBuffer.ToArray()," ");
                      }
                      else
                      {
                      //将接收到的字节数据根据 GB2312 编码转换为字符串，替换不可见的空字符 0 为可见的 \0
                      recive_rtb.Text = Encoding.GetEncoding("gb2312").GetString(reciveBuffer.ToArray()).Replace("0","\0");
                      }
                      }
                      //清空接收的数据
                      private void clear_btn_Click(object sender, EventArgs e)
                      {
                      reciveBuffer.Clear();
                      recivecount_tssl.Text = "";
                      recive_rtb.Text = "";
                      }
                      //自动清空点击事件
                      private void autoclear_chb_CheckedChanged(object sender, EventArgs e)
                      {
                      //如果勾选了自动清空，那么启动定时器
                      if (autoclear_chb.Checked)
                      {
                      timer1.Start();
                      }
                      else
                      {
                      timer1.Stop();
                      }
                      }
                      //Timer定时事件到（100ms检测一次)
                      private void timer1_Tick(object sender, EventArgs e)
                      {
                      //如果接收框内容大于4096，那么自动清除
                      if (recive_rtb.Text.Length > 4096)
                      {
                      reciveBuffer.Clear(); //清除接收缓冲区
                      recive_rtb.Text = ""; //清除接收框
                      recivecount_tssl.Text = ""; //清除计数
                      }
                      }
                      //当焦点移开发送框时触发
                      private void send_rtb_Leave(object sender, EventArgs e)
                      {
                      //判断是否要发送16进制数据（是否为选中状态）
                      if (sendhex_chb.CheckState == CheckState.Checked)
                      {
                      //选中了16进制发送
                      //把所有空格删除后，判断这是不是一个16进制字符串
                      if (DataEncoding.IsHexString(send_rtb.Text.Replace(" ", "")))
                      {
                      sendBuffer.Clear();
                      //把转换好的数据，存放到发送缓冲区
                      sendBuffer.AddRange(Transform.ToBytes(send_rtb.Text.Replace(" ", "")));
                      }
                      else //不是16进制数据
                      {
                      MessageBox.Show("请输入正确的十六进制数据！！", "发送框警告");
                      send_rtb.Select();
                      }
                      }
                      else //未选中16进制。
                      {
                      sendBuffer.Clear();
                      //把当前数据，存放到发送缓冲区。
                      sendBuffer.AddRange(Encoding.GetEncoding("gb2312").GetBytes(send_rtb.Text));
                      }
                      }
                      //注意如果使用文本发生变化事件，去处理16进制的转换，会发生错误
                      private void send_rtb_TextChanged(object sender, EventArgs e)
                      {
                      // 十六进制切换 会出现问题 这问题就是0x00 转换
                      }
                      //发送 16进制切换 框 点击
                      private void sendhex_chb_CheckedChanged(object sender, EventArgs e)
                      {
                      //判断发送框文本你是否为空
                      if (send_rtb.Text == "") return;
                      //把发送缓冲区的所有 变为 16进制， 用空格隔开
                      if (sendhex_chb.Checked == true)
                      {
                      send_rtb.Text = Transform.ToHexString(sendBuffer.ToArray(), " ");
                      }
                      else
                      {
                      send_rtb.Text = Encoding.GetEncoding("gb2312").GetString(sendBuffer.ToArray()).Replace("0","\0");
                      }
                      }
                      //发送框清除按钮点击事件
                      private void sendclear_btn_Click(object sender, EventArgs e)
                      {
                      sendBuffer.Clear(); //清除发送框缓冲区
                      send_rtb.Text = ""; //清除发送框
                      sendCount = 0; //清除发送计数
                      sencount_tssl.Text = "0"; //清除发送框计数
                      }
                      }
                      }
                      private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
                      {
                      if (isRxShow == false) return;
                      // 1,需要读取有效的数据 BytesToRead
                      byte[] dataTemp = new byte[serialPort1.BytesToRead];
                      serialPort1.Read(dataTemp,0,dataTemp.Length);
                      reciveBuffer.AddRange(dataTemp);
                      reciveCount += dataTemp.Length;
                      this.Invoke(new EventHandler(delegate
                      {
                      // 显示接收数据的长度
                      recivecount_tssl.Text = reciveCount.ToString();
                      //如果数据帧格式没有被选中，那么就按照原先逻辑
                      if (startData_chb.Checked == false)
                      {
                      if (!recivehex_chb.Checked)
                      {
                      // 2, 编码格式的选择
                      string str = Encoding.GetEncoding("gb2312").GetString(dataTemp);
                      // 3，0x00 -> 0 结束 不会显示
                      str = str.Replace("0", "\0");
                      recive_rtb.AppendText(str);
                      // recive_rtb.AppendText(Encoding.GetEncoding("gb2312").GetString(dataTemp).Replace("0", "\0"));
                      }
                      else
                      {
                      // 十六进制是选中的状态下
                      recive_rtb.AppendText(Transform.ToHexString(dataTemp, " "));
                      }
                      }
                      else//如果选中了，那么久按照数据帧逻辑
                      {
                      // 解析数据 queue
                      foreach (byte item in dataTemp)
                      {
                      // 入列
                      bufferQueue.Enqueue(item);
                      }
                      // 解析获取帧头
                      if (isHeadRecive == false)
                      {
                      foreach (byte item in bufferQueue.ToArray())
                      {
                      //查找帧头
                      if (item != 0x7f)
                      {
                      // 出列
                      bufferQueue.Dequeue();
                      Console.WriteLine("not 0x7f, Dequeue !!");
                      }
                      else
                      {
                      // get 0x7f from bufferQueue
                      isHeadRecive = true;
                      Console.WriteLine("0x7f is recived !!");
                      break;
                      }
                      }
                      }
                      //接收数据
                      if (isHeadRecive == true)
                      {
                      // 判断有数据帧长度
                      if (bufferQueue.Count >= 2)
                      {
                      //调试数据
                      Console.WriteLine(DateTime.Now.ToLongTimeString());
                      Console.WriteLine($"show the data in bufferQueue{Transform.ToHexString(bufferQueue.ToArray())}");
                      Console.WriteLine($"frame lenth ={String.Format("{0:X2}", bufferQueue.ToArray()[1])}");
                      frameLenth = bufferQueue.ToArray()[1];
                      // 一帧完整的数据长度判断，不代表数据是正确的
                      if(bufferQueue.Count>=1+1+frameLenth+2) //帧头、数据、数据、CRC校验
                      {
                      //把有效的帧长度拷贝出去
                      byte[] frameBuffer = new byte[1 + 1 + frameLenth + 2];
                      Array.Copy(bufferQueue.ToArray(), 0, frameBuffer, 0, frameBuffer.Length);
                      if(crc_chech(frameBuffer)) //CRC校验有效则进入
                      {
                      Console.WriteLine("frame is check ok,pick it");
                      data_txb.Text = Transform.ToHexString(frameBuffer);
                      data1_txb.Text = String.Format("{0:X2}", frameBuffer[2]);
                      data2_txb.Text = String.Format("{0:X2}", frameBuffer[3]);
                      data3_txb.Text = String.Format("{0:X2}", frameBuffer[4]);
                      data4_txb.Text = String.Format("{0:X2}", frameBuffer[5]);
                      }
                      else
                      {
                      // 无效数据
                      Console.WriteLine("bad frame, drop it");
                      }
                      for(int i=0; i<1 + 1+frameLenth+2;i++) //抛弃（出列），
                      {
                      bufferQueue.Dequeue();
                      }
                      //处理下一帧数据
                      isHeadRecive = false;
                      }
                      }
                      //接续接收数据
                      }
                      }
                      }));
                      }
                      //CRC校验，自己定义的。
                      private bool crc_chech(byte[] frameBuffer)
                      {
                      /*大端模式: 是指数据的高字节保存在内存的低地址中，
                      • 而数据的低字节保存在内存的高地址中，这样的存储
                      • 模式有点儿类似于把数据当作字符串顺序处理：地址
                      • 由小向大增加，而数据从高位往低位放；这和我们的
                      • 阅读习惯一致。
                        • 小端模式: 是指数据的高字节保存在内存的高地址中，
                        • 而数据的低字节保存在内存的低地址中，这种存储模
                        • 式将地址的高低和数据位权有效地结合起来，高地址
                        • 部分权值高，低地址部分权值低。
                        */
                        bool ret = false;
                        byte[] temp = new byte[frameBuffer.Length - 2];
                        Array.Copy(frameBuffer, 0, temp, 0, temp.Length);
                        byte[] crcdata = DataCheck.DataCrc16_Ccitt(temp, DataCheck.BigOrLittle.BigEndian); //使用大端 CRC校验
                        if (crcdata[0] == frameBuffer[frameBuffer.Length - 2] &&
                        crcdata[1]== frameBuffer[frameBuffer.Length-1]) //如果校验值相等
                        {
                        // check ok
                        ret = true;
                        }
                        return ret;
                        }
                        ]]>                                                 <![CDATA[LVGL学习-PC]]> https://www.mcoi.top/article/Post-LVGL-PC https://www.mcoi.top/article/Post-LVGL-PC Sat, 16 Nov 2024 00:00:00 GMT
                        😀
                        一个简单的开头

                        一、LVGL是什么

                        简介

                        LVGL (Light and Versatile Graphics Library)是一个开源的图形用户界面库，旨在提供轻量级、可移植、灵活和易于使用的图形用户界面解决方案。 它适用于嵌入式系统，可以在不同的操作系统、微控制器和图形加速器上运行。LVGL的核心代码是用C语言编写的，支持多种显示设备和输入设备，包括液晶显示屏、0LED显示屏、触摸屏、按键和编码器害， LVGL提供了一系列组件和小部件，例如文本框、按钮、滑动条、表格、菜单等，可以快速构建交互式用户界面。LVGL还具有高度自定义的能力，用户可以根据需要修改或扩展库的功能。总之，LVGL是一个功能强大、易于使用的图形用户界面库，可以帮助开发人员在嵌入式系统中实现各种交互式应用程序。

                        特点

                        1. 轻量级和高效: LVGL的核心代码非常小巧，可以在资源受限的嵌入式系统上运行，同时具有出色的性能和速度。
                        1. 可移植性: LVGL支持多种处理器架构和操作系统，可以在不同的平台上使用。
                        1. 灵活性: LVGL提供了大量的可自定义选项，包括主题、字体、颜色、大小、形状等，可以根据项目需求进行灵活定制。
                        1. 易于使用: LVGL提供了简单易懂的API和丰富的文档，使开发人员可以快速上手，构建复杂的图形用户界面。
                        1. 多种输入设备支持: LVGL支持多种输入设备，包括触摸屏、按键、编码器等，可以满足不同应用场景的需求。
                        1. 多种组件支持: LVGL提供了多种常用组件，如文本框、按钮、滑动条、表格、菜单等，同时还支持自定义组件。
                        1. 兼容性: LVGL支持多种显示设备，包括LCD、OLED、ePaper等，可以适应不同的显示分辨率和屏幕尺寸。
                        1. 社区支持: LVGL有一个活跃的社区，用户可以在社区中获得支持和帮助，同时也可以分享自己的经验和贡献代码。

                        二、LVGL模拟器环境搭建（PC端）

                        为什么用PC端的模拟器： 方便调试，后续可移植MCU MPU
                        Github lvgl库
                        1. LVGL github库版本调试不好，这里选择用CodeBlocks，建议去看韦东山老师的教学1-4-0_LVGL入门教程之设置CodeBlocks（补充内容-重要必看）_哔哩哔哩_bilibili
                        1. 如何修改CodeBlocks工程的LVGL源码2-1-1_LVGL入门教程之如何获取LVGL的源码_哔哩哔哩_bilibili
                         

                        三、LVGL的学习（看手册去了， 这里不写了）

                        LVGL目录解析

                        LVGL的启动流程

                        LVGL的裁剪

                        LVGL的基础对象（lv_obj）2.3.1

                        • 在面向对象的思想中，基础对象 是 LVGL 中所有其他对象都继承自的基类。
                        • 我们在学习时以基础对象为开头进行学习。
                        • 在LVGL中，有三层屏幕：活动屏幕(screen_active) < 顶层(top layer) < 系统层(system layer)
                          • 同级的话，先创建的被后创建的覆盖，示例：
                            • notion image

                          LVGL对象的大小

                          修改大小
                          • 可以使用 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_hight(obj) 来获取宽度
                          • 使用lv_obj_get_content_width (obj)获取实际可用宽度
                          • 使用lv_obj_get_content_height(obj)获取实际可用高度
                          💡
                          后者获取的大小会比前者小， 因为LVGL为了更美观，会预留空间，这个空间是可调的
                          notion image
                          • 注意：坐标会被延迟计算，强制更新坐标函数为lv_obj_update_layout()
                          notion image
                          文档位置

                          LVGL对象的位置

                          位置的设置

                          一个对象未设置位置，会默认位于左上角
                          notion image
                          可以使用
                          来设置大小，这里的200指的是右移200， -50为上移 如图
                          notion image

                          位置的对齐

                          api：
                          notion image
                          例如：lv_obj_set_align(obj, LV_ALIGN_CENTER);
                          notion image
                          也能居中后偏移，lv_obj_align(obj, LV_ALIGN_CENTER, 100, 100);
                          lv_obj_align_to(label, obj, LV_ALIGN_OUT_BOTTOM_MID, 0, 0); 相较于一个对象的位置

                          获取位置

                          两个点就能确定一块区域。
                          可以获取基于屏幕原点的x x2 y y2的位置， 也可以获取对齐后的x1 x2 y y2位置

                          LVGL对象的盒子模型

                          简单介绍

                          LVGL`遵循 CSS 的 border-box 模型。 对象的“盒子”由以下部分构成:
                          • 边界(bounding):元素的宽度/高度围起来的区域(整个盒子)。
                          • 边框(border):边框有大小和颜色等属性(相当于盒子的厚度和它的颜色)。
                          • 填充(padding):对象两侧与其子对象之间的空间(盒子的填充物)。
                          • 内容(content):如果边界框按边框宽度和填充的大小缩小，则显示其大小的内容区域(盒子实际装东西的区域)。
                          • 轮廓(outline): LVGL中没有外边距(margin)的概念(盒子之间的距离)，确认代之的是轮廓(outline)。它是绘制于元素(盒子)周围的一条线，它不占据空间，位于边框边缘的外围，可起到突出元素(盒子)的作用。在浏览器里，当鼠标点击或使用Tab键让一个选项或者一个图片获得焦点的时候，这个元素就会多了一个轮廓框围绕。轮廓(outline)。
                          • LVGL的盒子模型是我们理解对象(部件)的组成，修改对象的样式，实现对对象的布局、处理对象排列等等的关键。
                          notion image

                          盒子模型通俗理解:

                          • 这些属性我们可以把它转移到我们日常生活中的盒子(箱子)上来理解，日常生活中所见的盒子也就是能装东西的一种箱子，也具有这些属性，所以叫它盒子模型。
                          • content就是盒子里装的东西，它有高度(height)和宽度(width),可以是图片，可以是文字或者小盒子嵌套，在现实中，内容不能大于盒子，内容大于盒子就会撑破盒子，在LVGL中盒子不会变化，会产生滚动条，我们可以滚动查看超出盒子的内容，盒子也可以是有弹性的，内容太大就会撑大盒子(自动调整大小)，但是不会损害盒子。
                          • padding即是填充，就好像我们为了保证盒子里的东西不损坏，填充了一些东西，比如泡沫或者塑料薄膜，填充物有 大有小，有软有硬。
                          • border就是再外一层的边框，因为边框有大小和颜色的属性，相当于盒子的厚度和它的颜色或者材料。marain外边距，就是我们的盒子与其他的盒子或者其他东西的距离。假如有很多盒子，margin就是盒子之间直接的距离，可以通风，也美观同时方便取出。
                          notion image
                           
                          💡
                          有关LVGL其他问题，欢迎您在底部评论区留言，一起交流~
                          ]]>