1. 代码开发工具:为什么工业嵌入式项目里,你写的“能跑”代码永远不是“能用”的代码?
在 STM32F103 这类 Flash 仅 64KB、RAM 不足 20KB 的单片机上,写一段 AES-128 加密逻辑,和在 PC 上用 Python 调 cryptography 库,根本不是同一件事。前者不是“实现算法”,而是在内存地址空间里做外科手术:不能 malloc,不能浮点,不能依赖 stdio.h 或 string.h 的任何函数,连 sizeof(int) 都得手动校验——因为 Keil MDK 和 IAR EWARM 对基础类型的定义可能不同。我见过太多开发者把 GitHub 上抄来的 C 语言 AES 实现直接塞进工程,编译通过、串口打印出密文,就以为搞定了。结果一上电运行 3 小时后死机,用逻辑分析仪抓到是某次 memcpy 越界踩坏了中断向量表;或者上位机用 OpenSSL 解密失败,查半天才发现是 ECB 模式下最后一块填充用了 PKCS#7,而单片机端手写的填充逻辑漏判了明文长度整除 16 的边界。这不是能力问题,是代码开发工具链的认知断层:你用的 IDE(Keil/IAR)、编译器(ARMCC/ARMGCC)、调试器(ST-Link/J-Link)共同构成一个黑匣子,它不报错,但会悄悄吞掉你的栈溢出、静默截断你的指针运算、甚至在优化等级 -O2 下重排你的轮密钥加载顺序。本文不讲密码学原理,只讲怎么用最朴素的 ANSI C,在真实工业约束下,写出可验证、可复位、可与上位机 100% 互操作的加密模块。适合正在做智能电表通信、BMS 密钥协商、PLC 指令校验的嵌入式工程师,以及需要把 C 模块封装成 DLL 供 C# 上位机调用的跨平台开发者。
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 工业级 C 加密模块的三道生死线:无 malloc、无浮点、无标准库依赖
工业现场的单片机不是开发板。它没有调试串口持续输出日志,没有看门狗自动复位,更没有内存管理单元(MMU)帮你拦截非法访问。一旦加密模块出错,轻则通信中断,重则固件锁死、设备离线。所以“能跑”的代码必须先过三道硬门槛——它们不是风格偏好,而是资源铁律。
2.1 为什么 malloc 是工业嵌入式开发的头号禁令?
在 STM32F103 上,RAM 总共 20KB,其中:
- 栈空间:默认 1KB(Keil MDK 中
STACK_SIZE),中断嵌套深时极易溢出; - 堆空间:若开启
__use_heap,需手动配置HEAP_SIZE,但工业固件严禁动态分配——因为malloc失败返回NULL,而你的加密函数不会检查这个返回值;更致命的是,碎片化堆在长期运行后必然导致后续分配失败,而单片机没有 GC 机制。
提示:所有 AES/SHA256 状态数组、轮密钥缓存、SML 报文缓冲区,必须声明为
static uint8_t buffer[16]或全局数组。例如 AES-128 的轮密钥扩展结果固定占 176 字节(11 轮 × 16 字节),直接定义static uint8_t round_keys[176],而非uint8_t *round_keys = malloc(176)。
2.2 浮点运算:你以为的精度,其实是定时炸弹
AES 的 S 盒(SubBytes)和 MixColumns 变换中,所有运算必须是整数位运算。但很多开源实现用 float 计算伽罗瓦域乘法逆元,或用 double 做模幂——这在 ARM Cortex-M3 上会触发 FPU 异常(即使你没开 FPU),因为默认编译器链接的是软浮点库(arm-none-eabi-gcc -mfloat-abi=soft),而软浮点函数(如 __aeabi_fadd)体积巨大(单个函数超 2KB),且严重拖慢执行速度。
注意:STM32F103 不带硬件 FPU,所有浮点指令都会陷入异常处理程序。用
objdump -t your.elf | grep float检查符号表,若出现__aeabi_fxxx系列符号,说明代码已污染浮点依赖,必须替换为查表法(S 盒预计算为const uint8_t sbox[256])或整数模乘(如gf_mul(a, b)用移位+异或实现)。
2.3 标准库的甜蜜陷阱:printf 和 memcpy 的双重幻觉
初学者常犯的错误是:在加密函数里加一句 printf("Key: %02X\n", key[0]) 调试,或用 memcpy(dst, src, 16) 拷贝密钥。问题在于:
printf依赖_sys_write底层实现,Keil MDK 默认将其映射到ITM_SendChar(需 SWO 引脚),若未接调试器,该函数会无限等待,导致整个加密流程卡死;memcpy在-O2优化下可能被内联为LDMIA/STMIA指令块,但若源/目标地址未对齐(如uint8_t*指向奇数地址),ARMv7-M 架构会触发UsageFault异常。
正确做法:
- 调试信息改用
ITM_SendChar()直接发字符(需启用 ITM 和 SWO); - 内存拷贝全部手写循环:
c复制// 替代 memcpy(dst, src, len),规避对齐风险
void safe_copy(uint8_t *dst, const uint8_t *src, uint32_t len) {
for (uint32_t i = 0; i < len; i++) {
dst[i] = src[i];
}
}
此函数体积仅 12 字节(ARM Thumb 指令),无分支,无对齐假设,且 -O2 下仍保持确定性行为。
3. AES-128 ECB 模式实战:从密钥扩展到字节替换的完整手写链路
ECB 模式虽不推荐用于长明文,但在单片机与上位机间传输短指令(如 16 字节的设备认证令牌)时,因其无 IV、无填充依赖、实现极简,仍是工业首选。本节带你手写一条零外部依赖、可静态链接、Keil/IAR/ARMGCC 全兼容的 AES-128 加密链路,重点落在三个不可跳过的环节:密钥扩展、状态矩阵变换、S 盒查表。
3.1 密钥扩展:为什么轮密钥必须预计算,而不是运行时生成?
AES-128 的 128 位主密钥需扩展为 11 组 128 位轮密钥(第 0 轮到第 10 轮)。若每次加密都重新扩展,需执行 10 次 Rcon 加法、30 次 S 盒查表、40 次异或,耗时约 1.2ms(STM32F103@72MHz)。而工业场景中,设备密钥通常固化在 Flash 中且极少变更,因此轮密钥应作为常量数组在编译期生成。
c复制// aes_key_expansion.h:由 Python 脚本预生成,非运行时计算
#ifndef AES_KEY_EXPANSION_H
#define AES_KEY_EXPANSION_H
// 主密钥(示例:0x2B7E151628AED2A6ABF7158809CF4F3C)
extern const uint8_t aes_master_key[16];
// 预计算轮密钥(11×16=176 字节)
extern const uint8_t aes_round_keys[176];
#endif
关键参数说明:
aes_round_keys[0..15]是第 0 轮密钥(即主密钥),aes_round_keys[16..31]是第 1 轮密钥,依此类推至aes_round_keys[160..175](第 10 轮)。此设计使加密函数完全无状态,无需malloc缓存轮密钥。
3.2 状态矩阵:如何用 uint8_t[4][4] 安全表示 AES 的 128 位状态?
AES 将 128 位明文视为 4×4 字节矩阵(State),行优先存储。但 C 语言二维数组 uint8_t state[4][4] 在内存中是连续的,而轮密钥加(AddRoundKey)需按列与轮密钥异或。错误做法是 state[i][j] ^= round_key[i*4+j]——这会因内存布局导致错位。正确方式是将 State 视为列向量数组:
c复制// 正确的状态矩阵定义(列优先视角)
typedef struct {
uint8_t col0[4]; // 第0列:state[0][0], state[1][0], state[2][0], state[3][0]
uint8_t col1[4]; // 第1列:state[0][1], state[1][1], state[2][1], state[3][1]
uint8_t col2[4]; // 第2列
uint8_t col3[4]; // 第3列
} aes_state_t;
// AddRoundKey:按列异或,避免索引混乱
void add_round_key(aes_state_t *state, const uint8_t *round_key) {
for (int i = 0; i < 4; i++) {
state->col0[i] ^= round_key[i];
state->col1[i] ^= round_key[4+i];
state->col2[i] ^= round_key[8+i];
state->col3[i] ^= round_key[12+i];
}
}
3.3 S 盒查表:为什么必须用 const uint8_t sbox[256] 而非实时计算?
AES 的 SubBytes 步骤需对每个字节查 S 盒(256 字节查找表)。实时计算需在伽罗瓦域 GF(2⁸) 中求乘法逆元,涉及多项式模约减,代码复杂且易出错。而查表法体积仅 256 字节,执行时间恒定(1 条 LDRB 指令),且 Keil/IAR 编译器会自动将其放入 Flash(.rodata 段),不占 RAM。
c复制// sbox.h:标准 AES S 盒(FIPS-197 Annex A)
const uint8_t sbox[256] = {
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, /* ... 全256字节 ... */
0x47, 0xf1, 0x18, 0x98, 0x9d, 0x3e, 0x2e, 0x4a
};
// SubBytes:对状态矩阵每字节查表
void sub_bytes(aes_state_t *state) {
for (int i = 0; i < 4; i++) {
state->col0[i] = sbox[state->col0[i]];
state->col1[i] = sbox[state->col1[i]];
state->col2[i] = sbox[state->col2[i]];
state->col3[i] = sbox[state->col3[i]];
}
}
避坑 / 常见问题 / 排查
现象 1:加密后密文全为 0x00
原因:S 盒数组未用const修饰,编译器将其放入.data段,而启动文件未初始化.data(_sidata指针未正确复制)。
解决:强制声明为const uint8_t sbox[256],确保链接到.rodata;检查启动汇编中CopyDataSection是否覆盖.rodata。现象 2:同一明文在 Keil 下加密结果正确,IAR 下错误
原因:IAR 默认启用--enum_is_int,导致enum {A,B}占 4 字节,而 Keil 用 1 字节;若结构体中混用enum和uint8_t,内存对齐不同,aes_state_t偏移错乱。
解决:在 IAR 中添加#pragma pack(1)包装结构体,或统一用uint8_t替代enum。现象 3:加密函数返回后,串口通信中断
原因:sub_bytes中未限制循环变量i类型,int i在 32 位系统中占 4 字节,但编译器可能将其优化为寄存器变量,若函数内联深度大,挤占了中断栈空间。
解决:显式声明uint8_t i,并用#pragma push降低优化等级:#pragma optimize=none保护该函数。现象 4:Keil MDK 编译警告 "L6218E: Undefined symbol __use_two_region_memory"
原因:工程启用了分散加载(Scatter Loading),但未在 scatter 文件中定义ARM_LIB_HEAP和ARM_LIB_STACK。
解决:在*.sct文件中添加:code复制LR_IROM1 0x08000000 0x00010000 { ; load region size_region ER_IROM1 0x08000000 0x00010000 { ; load address = execution address *.o (+RO) } RW_IRAM1 0x20000000 0x00005000 { ; RW data *.o (+RW +ZI) } }并在 Options → Linker → Use Memory Layout from Target Dialog 前打钩。
4. SHA256 摘要计算:如何在无 stdint.h 的古老编译器下安全处理 64 位整数
SHA256 的核心是 32 位字(word)的逻辑运算,但其消息填充要求:在原始消息后追加 0x80,再补 0x00 字节,最后附加 64 位(8 字节)的原始消息长度(bit 数)。问题来了:STM32F103 的 Keil MDK v4.7 附带的 ARMCC 编译器(ARM RealView Compiler)不支持 uint64_t,long long 类型也未完全实现。若强行用 unsigned long long 存储长度,会导致高位字节被截断,摘要值全错。
4.1 长度字段的双字拆分:用两个 uint32_t 模拟 64 位
SHA256 规范要求长度以 bit 为单位,最大支持 2⁶⁴ bit ≈ 2⁵⁶ 字节消息。对工业单片机,实际消息长度远小于此(如电表 SML 报文 ≤ 1KB),因此我们只需保证:
- 若消息长度
len_byte < 2³²/8 = 536,870,912 字节(≈512MB),则高位字len_high = 0; - 低位字
len_low = len_byte * 8(bit 数); - 填充时,先写
len_low(小端序,4 字节),再写len_high(小端序,4 字节)。
c复制// sha256_pad.c:安全填充函数
void sha256_pad(uint8_t *msg, uint32_t *len_byte, uint8_t *padded) {
uint32_t len_bit_low = (*len_byte) << 3; // ×8 得 bit 数
uint32_t len_bit_high = 0;
// 消息末尾加 0x80
padded[0] = 0x80;
uint32_t pad_len = 64 - ((*len_byte) % 64) - 1; // 减去 0x80 占位
if (pad_len < 8) { // 不够放 8 字节长度,需额外一区块
pad_len += 64;
}
// 填充 0x00
for (uint32_t i = 1; i < pad_len - 8; i++) {
padded[i] = 0x00;
}
// 写入长度(小端序:先低后高)
padded[pad_len - 8] = (uint8_t)(len_bit_low);
padded[pad_len - 7] = (uint8_t)(len_bit_low >> 8);
padded[pad_len - 6] = (uint8_t)(len_bit_low >> 16);
padded[pad_len - 5] = (uint8_t)(len_bit_low >> 24);
padded[pad_len - 4] = (uint8_t)(len_bit_high);
padded[pad_len - 3] = (uint8_t)(len_bit_high >> 8);
padded[pad_len - 2] = (uint8_t)(len_bit_high >> 16);
padded[pad_len - 1] = (uint8_t)(len_bit_high >> 24);
}
4.2 32 位字的旋转与移位:为什么 >> 和 << 必须用 & 0xFFFFFFFF 截断?
SHA256 的 Sigma0, sigma0 等函数需对 32 位字做循环右移(ROTR)和逻辑右移(SHR)。ARM Cortex-M3 的 LSR 指令对 >> 编译正确,但若变量类型为 int(Keil 中默认 32 位有符号),>> 会执行算术右移(符号位扩展),导致高位补 1。例如 0x80000000 >> 2 应得 0x20000000,但算术右移得 0xE0000000。
正确做法:所有位运算变量强制为 uint32_t,并在移位后 & 0xFFFFFFFF 显式截断:
c复制// sha256_ops.h:安全位运算宏
#define ROTR(x, n) (((x) >> (n)) | ((x) << (32-(n)))) & 0xFFFFFFFFUL
#define SHR(x, n) ((x) >> (n)) & 0xFFFFFFFFUL
#define SIGMA0(x) (ROTR(x,2) ^ ROTR(x,13) ^ ROTR(x,22))
#define sigma0(x) (ROTR(x,7) ^ ROTR(x,18) ^ SHR(x,3))
// 使用示例
uint32_t a = 0x80000000UL;
uint32_t b = ROTR(a, 2); // 正确:0x20000000
4.3 摘要输出:如何确保 256 位哈希值与 OpenSSL 完全一致?
SHA256 输出为 32 字节(256 位)摘要,按大端序排列。但常见错误是:
- 将
h[0]到h[7](8 个uint32_t)直接memcpy到输出缓冲区,忽略字节序; - 或在 Keil 中用
__rev指令反转字节序,但该指令仅在 ARMv7-M 支持,STM32F103 是 ARMv7-M,可用;
标准做法(兼容所有编译器):
c复制// sha256_final.c:安全输出摘要
void sha256_final(uint32_t h[8], uint8_t digest[32]) {
for (int i = 0; i < 8; i++) {
digest[i*4 + 0] = (uint8_t)(h[i] >> 24); // 大端序:最高字节在前
digest[i*4 + 1] = (uint8_t)(h[i] >> 16);
digest[i*4 + 2] = (uint8_t)(h[i] >> 8);
digest[i*4 + 3] = (uint8_t)(h[i]);
}
}
避坑 / 常见问题 / 排查
现象 1:SHA256 摘要与 OpenSSL 结果仅最后 4 字节不同
原因:h[i]未用uint32_t声明,而是int,在 Keil 中int为有符号,h[7]的最高位被解释为符号位,>> 24时算术右移补 1。
解决:全局搜索int h[8],替换为uint32_t h[8],并确认所有中间变量(a,b,c,...)均为uint32_t。现象 2:空字符串 "" 的 SHA256 摘要错误
原因:空消息长度len_byte = 0,len_bit_low = 0,但填充时pad_len = 64 - (0%64) -1 = 63,63-8=55字节填充区,但代码中for (i=1; i<pad_len-8; i++)的上限是54,导致padded[1]到padded[54]被置 0,而padded[55]到padded[62](长度字段前的 0x00)未初始化,残留垃圾值。
解决:将填充循环改为for (uint32_t i = 1; i <= pad_len-9; i++),确保padded[1]到padded[pad_len-9]全为 0。现象 3:Keil 编译警告 "C3017W: Implicit conversion from 'int' to 'uint32_t'"
原因:for (int i=0; i<8; i++)中i为int,参与digest[i*4+0]计算时隐式转换,可能引发符号扩展。
解决:显式声明uint32_t i,并启用 Keil 的--diag_warning=3017将其转为错误,强制修正。现象 4:IAR 编译报错 "Error[Pe147]: declaration is incompatible with previous declaration"
原因:IAR 的stdint.h中uint32_t定义为unsigned long,而 Keil 为unsigned int,若头文件混用(如先包含 IAR 的stdint.h,再包含 Keil 的core_cm3.h),类型冲突。
解决:删除所有#include <stdint.h>,直接定义:c复制typedef unsigned int uint32_t; typedef unsigned char uint8_t; #define UINT32_MAX 0xFFFFFFFFU
5. 上位机对接:C# P/Invoke 封装 DLL 的四步验证法
单片机端的加密代码再完美,若无法与上位机(C#/Python/LabVIEW)无缝互操作,就是废品。C# 是工业上位机最常用语言,而 P/Invoke 是调用 C DLL 的标准方式。但新手常卡在:DLL 导出函数不被识别、字符串传参乱码、返回值解析错误。本节给出一套可逐层验证的封装链路,确保从单片机到 C# 的每一环都 100% 可控。
5.1 DLL 导出规范:为什么必须用 __declspec(dllexport) 且禁用 C++ 名字修饰?
Keil/IAR 生成的 .lib 不能直接被 C# 调用,必须封装为 Windows DLL。关键点:
- 函数必须用
__declspec(dllexport)导出; - 调用约定必须为
__stdcall(C# P/Invoke 默认),而非__cdecl(Keil 默认); - 禁用 C++ 名字修饰(若用 C++ 编译器),否则导出函数名为
?aes_encrypt@@YAHPAE0H@Z,C# 无法解析。
c复制// aes_dll.c:Keil 工程中新增的 DLL 封装文件
#include "aes_ecb.h" // 单片机端 AES 实现
// 导出 AES 加密函数(CDECL 也可,但需 C# 显式声明 CallingConvention.Cdecl)
__declspec(dllexport) void __stdcall aes_encrypt_ecb(
const uint8_t *plaintext,
const uint8_t *key,
uint8_t *ciphertext) {
// 调用单片机端函数(已适配无 malloc/无浮点)
aes128_ecb_encrypt(plaintext, key, ciphertext);
}
// 导出 SHA256 摘要函数
__declspec(dllexport) void __stdcall sha256_digest(
const uint8_t *msg,
uint32_t len,
uint8_t *digest) {
sha256_calculate(msg, len, digest);
}
编译设置(Keil MDK):
- Output → Create Executable → 勾选 "Create Library"(生成
.lib);- 用 ARM GCC 工具链(
arm-none-eabi-gcc)链接:bash复制arm-none-eabi-gcc -shared -o aes_crypto.dll aes_dll.o aes_ecb.o \ --entry=__main -Wl,--undefined=__use_no_heap,--undefined=__use_no_heap_region
5.2 C# P/Invoke 声明:如何用 MarshalAs 控制字节数组内存布局?
C# 中 byte[] 是托管数组,P/Invoke 默认按值传递(copy-in/copy-out),但大数组拷贝耗时。工业场景需零拷贝,故用 IntPtr + Marshal.Copy 手动控制。
csharp复制// CSharpCrypto.cs
using System;
using System.Runtime.InteropServices;
public class AesCrypto
{
// DLL 路径需绝对路径或放在 exe 同目录
private const string DllPath = "aes_crypto.dll";
[DllImport(DllPath, CallingConvention = CallingConvention.StdCall)]
private static extern void aes_encrypt_ecb(
IntPtr plaintext, // 输入明文指针
IntPtr key, // 密钥指针
IntPtr ciphertext); // 输出密文指针
[DllImport(DllPath, CallingConvention = CallingConvention.StdCall)]
private static extern void sha256_digest(
IntPtr msg, // 输入消息指针
uint len, // 消息长度(字节)
IntPtr digest); // 输出摘要指针
public static byte[] Encrypt(byte[] plaintext, byte[] key)
{
if (plaintext.Length != 16 || key.Length != 16)
throw new ArgumentException("AES-128 requires 16-byte input and key");
var ciphertext = new byte[16];
var pPlain = Marshal.AllocHGlobal(16);
var pKey = Marshal.AllocHGlobal(16);
var pCipher = Marshal.AllocHGlobal(16);
try
{
Marshal.Copy(plaintext, 0, pPlain, 16);
Marshal.Copy(key, 0, pKey, 16);
aes_encrypt_ecb(pPlain, pKey, pCipher);
Marshal.Copy(pCipher, ciphertext, 0, 16);
return ciphertext;
}
finally
{
Marshal.FreeHGlobal(pPlain);
Marshal.FreeHGlobal(pKey);
Marshal.FreeHGlobal(pCipher);
}
}
}
5.3 四步验证法:从 DLL 加载到结果比对的完整闭环
不要等全部写完再测试!按以下顺序逐层验证,任一环节失败立即定位:
| 步骤 | 操作 | 预期结果 | 失败原因 |
|---|---|---|---|
| 1. DLL 加载 | C# 中 LoadLibrary("aes_crypto.dll") |
返回非零句柄 | DLL 依赖缺失(如 msvcr120.dll),用 Dependency Walker 检查 |
| 2. 函数地址获取 | GetProcAddress(hDll, "aes_encrypt_ecb") |
返回非零地址 | 函数名修饰错误(未加 __stdcall 或导出名不匹配) |
| 3. 内存读写 | 传入 plaintext=new byte[16] 全 0,key=new byte[16] 全 0 |
ciphertext 应为 0x66e94bd4ef8a2c3b884cfa59ca342b2e(AES-128 ECB 零密钥零明文标准向量) |
单片机端 aes128_ecb_encrypt 未正确实现,或内存越界破坏栈 |
| 4. 摘要一致性 | 传入 msg="abc",len=3 |
digest 应为 0xba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad(SHA256 标准向量) |
sha256_calculate 中长度字段未按 bit 计算,或填充逻辑错误 |
避坑 / 常见问题 / 排查
现象 1:C# 调用aes_encrypt_ecb后程序崩溃(AccessViolationException)
原因:DLL 中函数使用了printf或malloc,而 Windows DLL 环境无标准库支持。
解决:用arm-none-eabi-objdump -t aes_crypto.dll | grep printf检查符号,确保无printf相关符号;所有调试输出改用OutputDebugString。现象 2:C# 获取的
ciphertext与单片机串口打印值不一致
原因:单片机端用sprintf(buf, "%02X", cipher[i])打印,但sprintf依赖stdio.h,若未重定向_sys_write,会卡死在sprintf内部。
解决:单片机端改用ITM_SendChar逐字节发送十六进制字符,或用snprintf(需确保stdio已重定向)。现象 3:DLL 在 x64 C# 进程中加载失败,错误码 193(%1 不是有效的 Win32 应用程序)
原因:Keil 生成的是 ARM 二进制,而 Windows x64 进程只能加载 x86/x64 DLL。
解决:必须用 x86 工具链交叉编译 Windows DLL(如i686-w64-mingw32-gcc),而非 ARM 工具链。工业实践中,单片机代码与 DLL 封装代码分离:单片机端用 ARMCC,DLL 封装端用 MinGW 编译 x86 DLL,调用同一套 ANSI C 源码(aes_ecb.c)。现象 4:C# 中
Marshal.Copy后ciphertext全为 0
原因:DLL 函数参数为const uint8_t*,但 C# 传入IntPtr指向托管数组,若 GC 移动了该数组,指针失效。
解决:用fixed关键字固定内存:csharp复制fixed (byte* pPlain = plaintext) fixed (byte* pKey = key) fixed (byte* pCipher = ciphertext) { aes_encrypt_ecb((IntPtr)pPlain, (IntPtr)pKey, (IntPtr)pCipher); }
6. 工业现场的终极验证:用逻辑分析仪抓取 D0 接口握手波形,反向校验加密模块时序
所有软件验证都敌不过真实硬件信号。在智能电表项目中,ESP8266 通过 D0 接口与电表通信,其物理层是 RS-232 电平(±12V),但 ESP8266 GPIO 是 3.3V,需电平转换芯片(如 MAX3232)。此时,加密模块的执行时间直接影响 D0 握手时序——若 AES 计算耗时超过 100ms,电表在 BREAK
