学习 / TSENGCHEN BLOG

Linux-Factory-Test--01-Linux-Factory-Test-C-Tutorial

01_Learning · 第 20 / 23 篇

按 Excel 编写板端 C 程序:UART 接收、执行与响应

板端代码只放在本文,供你自己写一遍;不另建板端 .c 文件。Windows 上位机已作为独立程序交付,不需要研究其实现。

1. 当前交付与边界

Windows 上位机目录:/home/user/workspace/factory_uart/。

文件用法
start_host.bat与下一文件一起复制到 Windows,双击打开图形上位机
factory_host.ps1Windows PowerShell 5.1 和系统 WinForms 实现,不需要 Python

窗口中自行选择 COM 串口和波特率,固定 8N1、无流控。选择指令后点击“发送一次”,显示原始 JSON 响应和 success/fail。连接动作不会自动发送命令;红灯操作发送前需要再次确认。

同目录提供 windows_host.zip,只包含上述两文件,方便复制到 Windows 解压。启动器仅对本次 PowerShell 进程使用执行策略参数,不修改系统持久策略;受组织策略限制的电脑仍需遵守其管理要求。

两端发送的是完整 JSON 对象,不追加换行、长度头、任务编号或其他业务字段。接收端积累串口数据,识别完整 JSON 对象后才处理,不能把一次 read() 当成一条完整请求。

这些是 UART 接入的配合方式,不是声称 Excel 规定了串口帧格式。两份表未定义波特率;上位机默认显示 115200 只是可修改的便利值,板端必须显式传入相同值。

目前只接入三条指令,不声称已经覆盖整份 Excel。 不修改 SDK、DTS、驱动或其他应用;不启用额外串口,不自动修改 MAC,也不判定整板 PASS。

2. 两份 Excel 的对应关系

文件均在 /home/user/workspace/:

  • rk3566+rk1828_产测指令_20260729.xlsx:请求和响应。
  • rk3566+rk1828_产测指令_20260729_RK.xlsx:Linux 操作和节点。

以下行号均为各文件 Sheet1 的 Excel 行号。

已实现指令普通表行号RK 表行号操作
读取 LAN MAC136读取 /sys/class/net/eth0/address
红灯打开189向 /sys/class/leds/work/brightness 写入 1
红灯关闭1910向同一节点写入 0

2.1 原始请求

上位机直接发送下面的三个 JSON,名称、大小写和字段不改:

{"cmd":"DEVICEINFO","action":"get","key":"lan_Mac"}
{"cmd":"STATUSLED","action":"on","key":"red"}
{"cmd":"STATUSLED","action":"off","key":"red"}

这里排成三行仅用于展示,不表示 UART 数据需要换行分隔。每次只发送所选的一条,收到响应或超时后才结束本次操作,不自动重发。

2.2 响应要求

MAC 响应包含 cmd/action/key/result/key_value。节点值去掉冒号并转大写;失败按表返回空字符串:

{"cmd":"DEVICEINFO","action":"get","key":"lan_Mac","result":"fail","key_value":""}

红灯响应仅包含 cmd/action/key/result:

{"cmd":"STATUSLED","action":"on","key":"red","result":"success"}
{"cmd":"STATUSLED","action":"off","key":"red","result":"success"}

写节点失败时 result 为 fail,不增加其他协议字段。success 只是该指令的执行结果,例如 LED 节点写入成功仍需确认实际发光。

仍待表格提供方确认: 普通表第 13 行的 MAC 成功示例 8C858071FC9A6 为 13 位,而实际 6 字节 MAC 去掉冒号为 12 位。本程序返回真实节点转换值,不硬编码该示例;上位机只校验响应字段,不自行判 MAC 的产品验收规则。

3. 完整板端 C 代码

自己保存为 factory_board.c 即可。使用 Linux/POSIX 和 json-c 0.15 或更新版本,需要目标环境的开发头文件和链接库。

第一版采用可扩展的四层结构:UART 收发 → JSON 公共解析 → 模块处理 → 响应对象。公共层只要求 cmd/action,把完整 JSON 交给模块;key、key_value、其他参数及其类型由具体指令校验,不按固定字段数拒绝请求。

模块表登记当前已有 DEVICEINFO 和 STATUSLED。同模块加指令只修改该模块处理函数;新增模块只写处理函数并登记一行,UART 主循环不改。响应由模块自行构造,可以按 Excel 返回字符串、数值或其他已有结构,不被 MAC 的响应形状限制。

这不表示第一版实现了全部 Excel 功能。功能范围仍只有读取 MAC、红灯开关;公共解析不设业务限制,不等于省略具体指令的参数校验。

/*
 * factory_board.c — 对应 Excel 普通表 13/18/19 行,RK 表 6/9/10 行。
 * 编译:cc -std=c11 -O2 -Wall -Wextra -Werror factory_board.c -ljson-c -o factory_board
 * 运行:./factory_board <实际UART设备> <波特率> [接收上限字节数]
 *
 * UART:8N1,无软/硬流控。收发原始 JSON,无附加换行。
 * 不要与 console/getty/其他应用共用 UART;不处理其他 Excel 指令。
 * 红灯请求会真正写节点,程序不会自行发送或自动执行测试序列。
 */
#define _DEFAULT_SOURCE
#define _POSIX_C_SOURCE 200809L
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
#include <json-c/json.h>

#define DEFAULT_FRAME_LIMIT 4096
static volatile sig_atomic_t stopping;
static void on_signal(int number) { (void)number; stopping = 1; }

/* 收包缓冲有安全上限,但上限可配置,不和业务字段数量绑定。 */
struct frame {
    char *text;
    size_t limit, used, depth;
    bool quoted, escaped, bad;
};
static void reset_frame(struct frame *f)
{
    f->used = f->depth = 0;
    f->quoted = f->escaped = f->bad = false;
    f->text[0] = 0;
}

/* 以下状态只在程序内部使用,不新增 Excel 响应字段。 */
enum dispatch_status {
    DISPATCH_ERROR = -1, DISPATCH_OK, DISPATCH_UNSUPPORTED, DISPATCH_INVALID
};
struct request {
    struct json_object *json; /* 只读借用,不得修改/释放;可读取所有业务参数。 */
    const char *cmd, *action;
};
typedef enum dispatch_status (*module_handler)(
    const struct request *, struct json_object **response);
struct module { const char *cmd; module_handler handle; };

/* 返回 1=完整对象,0=继续接收,-1=无效/超长。引号内的括号不计数。 */
static int feed_byte(struct frame *f, unsigned char c)
{
    if (f->depth == 0) {
        if (isspace(c)) return 0;
        if (c != '{') return -1;
        reset_frame(f);
        f->depth = 1;
        f->text[f->used++] = (char)c;
        return 0;
    }
    if (c == 0) f->bad = true;
    if (!f->bad && f->used < f->limit) f->text[f->used++] = (char)c;
    else f->bad = true;
    if (f->quoted) {
        if (f->escaped) f->escaped = false;
        else if (c == '\\') f->escaped = true;
        else if (c == '"') f->quoted = false;
    } else {
        if (c == '"') f->quoted = true;
        else if (c == '{') ++f->depth;
        else if (c == '}') --f->depth;
    }
    if (f->depth != 0) return 0;
    f->text[f->used] = '\0';
    return f->bad ? -1 : 1;
}

/* JSON 库负责解析;这里只检查字段存在、类型和字符串中的 NUL。 */
static const char *json_field(struct json_object *request, const char *name)
{
    struct json_object *item = NULL;
    if (!json_object_object_get_ex(request, name, &item) ||
        !json_object_is_type(item, json_type_string)) return NULL;
    const char *value = json_object_get_string(item);
    if (!value || strlen(value) != (size_t)json_object_get_string_len(item)) return NULL;
    return value;
}

/* RK 表第6行:直接读节点,转换成响应中的无冒号大写字符串。 */
static int read_mac(char mac[13])
{
    FILE *fp = fopen("/sys/class/net/eth0/address", "r");
    if (!fp) return -1;
    char raw[64];
    bool ok = fgets(raw, sizeof(raw), fp) != NULL;
    if (fclose(fp) != 0) ok = false;
    if (!ok) return -1;
    raw[strcspn(raw, "\r\n")] = 0;
    if (strlen(raw) != 17) return -1;
    size_t used = 0;
    for (size_t i = 0; i < 17; ++i) {
        if (i % 3 == 2) {
            if (raw[i] != ':') return -1;
        } else {
            if (!isxdigit((unsigned char)raw[i])) return -1;
            mac[used++] = (char)toupper((unsigned char)raw[i]);
        }
    }
    mac[used] = 0;
    return 0;
}

/* RK 表第9/10行:写入内容与 echo 1/0 的内容一致;不创建新节点。 */
static int set_red(bool on)
{
    int fd = open("/sys/class/leds/work/brightness", O_WRONLY);
    if (fd < 0) return -1;
    ssize_t written;
    do { written = write(fd, on ? "1\n" : "0\n", 2); }
    while (written < 0 && errno == EINTR && !stopping);
    int closed = close(fd);
    return written == 2 && closed == 0 ? 0 : -1;
}

/* UART write() 可能只写一部分,因此必须继续发送剩余字节。 */
static int send_text(int fd, const char *text)
{
    size_t left = strlen(text);
    while (left && !stopping) {
        ssize_t n = write(fd, text, left);
        if (n < 0 && errno == EINTR) continue;
        if (n <= 0) return -1;
        text += n;
        left -= (size_t)n;
    }
    return left == 0 ? 0 : -1;
}

/* 响应可以按各条 Excel 定义扩展,不固定只能返回一个字符串值。 */
static int response_string(struct json_object *response, const char *name,
                            const char *value)
{
    struct json_object *item = json_object_new_string(value);
    if (!item) return -1;
    if (json_object_object_add(response, name, item) != 0) {
        json_object_put(item);
        return -1;
    }
    return 0;
}

/* 常用响应助手;key 可省略。特殊响应也可以直接用 JSON API 构造。 */
static struct json_object *response_new(const char *cmd, const char *action,
                                       const char *key, bool success)
{
    struct json_object *response = json_object_new_object();
    if (!response) return NULL;
    const char *names[] = { "cmd", "action", "key", "result" };
    const char *values[] = { cmd, action, key, success ? "success" : "fail" };
    for (size_t i = 0; i < 4; ++i) {
        if (i == 2 && !key) continue;
        if (response_string(response, names[i], values[i]) != 0) {
            json_object_put(response);
            return NULL;
        }
    }
    return response;
}

/* DEVICEINFO 模块:你以后把 SN 等功能加到这里,不修改 UART 接收。 */
static enum dispatch_status handle_deviceinfo(const struct request *r,
                                              struct json_object **response)
{
    if (strcmp(r->action, "get") != 0) return DISPATCH_UNSUPPORTED;
    const char *key = json_field(r->json, "key");
    if (!key) return DISPATCH_INVALID;
    if (strcmp(key, "lan_Mac") != 0) return DISPATCH_UNSUPPORTED;
    char mac[13] = "";
    bool success = read_mac(mac) == 0;
    *response = response_new(r->cmd, r->action, key, success);
    if (!*response) return DISPATCH_ERROR;
    if (response_string(*response, "key_value", success ? mac : "") != 0)
        return DISPATCH_ERROR;
    return DISPATCH_OK;
}

/* STATUSLED 模块:只实现 RK 表已经给出操作依据的红灯开关。 */
static enum dispatch_status handle_statusled(const struct request *r,
                                             struct json_object **response)
{
    const char *key = json_field(r->json, "key");
    if (!key) return DISPATCH_INVALID;
    if (strcmp(key, "red") != 0 ||
        (strcmp(r->action, "on") != 0 && strcmp(r->action, "off") != 0))
        return DISPATCH_UNSUPPORTED;
    bool success = set_red(strcmp(r->action, "on") == 0) == 0;
    *response = response_new(r->cmd, r->action, key, success);
    return *response ? DISPATCH_OK : DISPATCH_ERROR;
}

/* 扩展入口:新增 Excel 模块时写处理函数,在此登记一行即可。 */
static const struct module modules[] = {
    { "DEVICEINFO", handle_deviceinfo },
    { "STATUSLED", handle_statusled }
};

/* 公共层只要求 cmd/action 字符串,不强制 key,不限制三个字段。 */
static enum dispatch_status dispatch_request(const char *text, size_t length,
                                             struct json_object **response)
{
    *response = NULL;
    if (length > INT_MAX) return DISPATCH_INVALID;
    struct json_tokener *parser = json_tokener_new();
    if (!parser) return DISPATCH_ERROR;
    json_tokener_set_flags(parser, JSON_TOKENER_STRICT | JSON_TOKENER_VALIDATE_UTF8);
    struct json_object *json = json_tokener_parse_ex(parser, text, (int)length);
    bool valid = json_tokener_get_error(parser) == json_tokener_success;
    size_t end = json_tokener_get_parse_end(parser);
    json_tokener_free(parser);
    while (end < length && isspace((unsigned char)text[end])) ++end;
    if (!valid || end != length || !json_object_is_type(json, json_type_object)) {
        json_object_put(json);
        return DISPATCH_INVALID;
    }
    struct request r = { json, json_field(json, "cmd"), json_field(json, "action") };
    enum dispatch_status result = DISPATCH_UNSUPPORTED;
    if (!r.cmd || !*r.cmd || !r.action || !*r.action) result = DISPATCH_INVALID;
    else {
        for (size_t i = 0; i < sizeof(modules) / sizeof(modules[0]); ++i) {
            if (strcmp(r.cmd, modules[i].cmd) == 0) {
                result = modules[i].handle(&r, response);
                break;
            }
        }
    }
    if (result == DISPATCH_OK && !json_object_is_type(*response, json_type_object))
        result = DISPATCH_ERROR;
    if (result != DISPATCH_OK) {
        json_object_put(*response); /* 清理模块部分构造的响应。 */
        *response = NULL;
    }
    json_object_put(json); /* 模块借用的字段到这里失效,不可异步保留指针。 */
    return result;
}

/* 传输层只序列化和发送响应,不关心是 MAC、LED 还是以后新增的模块。 */
static int uart_send_json(int fd, struct json_object *response)
{
    const char *text = json_object_to_json_string_ext(response, JSON_C_TO_STRING_PLAIN);
    return text ? send_text(fd, text) : -1;
}

/* 串口设置只是接入参数,不改变 Excel 的业务字段。 */
static int open_uart(const char *device, long baud, struct termios *original)
{
    speed_t speed;
    switch (baud) {
    case 9600: speed = B9600; break;
    case 19200: speed = B19200; break;
    case 38400: speed = B38400; break;
    case 57600: speed = B57600; break;
    case 115200: speed = B115200; break;
    case 230400: speed = B230400; break;
    default: errno = EINVAL; return -1;
    }
    int fd = open(device, O_RDWR | O_NOCTTY | O_CLOEXEC);
    if (fd < 0) return -1;
    if (tcgetattr(fd, original) != 0) { close(fd); return -1; }
    struct termios settings = *original;
    cfmakeraw(&settings); /* 关闭回显、行缓冲、输出换行转换。 */
    settings.c_cflag &= ~(CSIZE | PARENB | CSTOPB | CRTSCTS);
    settings.c_cflag |= CS8 | CLOCAL | CREAD;
    settings.c_iflag &= ~(IXON | IXOFF | IXANY);
    settings.c_cc[VMIN] = 0;
    settings.c_cc[VTIME] = 10; /* 1秒无新字节,丢弃未完成的对象;不是业务超时。 */
    if (cfsetispeed(&settings, speed) != 0 ||
        cfsetospeed(&settings, speed) != 0 ||
        tcsetattr(fd, TCSANOW, &settings) != 0) {
        close(fd);
        return -1;
    }
    return fd;
}

int main(int argc, char **argv)
{
    if (argc != 3 && argc != 4) {
        fprintf(stderr, "Usage: %s <UART device> <baud> [max_frame_bytes]\n", argv[0]);
        return 2;
    }
    char *end;
    errno = 0;
    long baud = strtol(argv[2], &end, 10);
    if (errno || end == argv[2] || *end) return 2;
    size_t limit = DEFAULT_FRAME_LIMIT;
    if (argc == 4) {
        for (const char *q = argv[3]; *q; ++q)
            if (!isdigit((unsigned char)*q)) return 2;
        errno = 0;
        unsigned long value = strtoul(argv[3], &end, 10);
        if (errno || end == argv[3] || *end || value == 0 || value > INT_MAX)
            return 2;
        limit = (size_t)value; /* json-c 长度参数为 int,所以不超过 INT_MAX。 */
    }
    struct sigaction action = {0};
    action.sa_handler = on_signal;
    sigemptyset(&action.sa_mask);
    if (sigaction(SIGINT, &action, NULL) != 0 ||
        sigaction(SIGTERM, &action, NULL) != 0) return 1;
    struct frame frame = { .limit = limit };
    frame.text = malloc(limit + 1);
    if (!frame.text) { perror("frame allocation"); return 1; }
    reset_frame(&frame);
    struct termios original;
    int fd = open_uart(argv[1], baud, &original);
    if (fd < 0) { perror("open_uart"); free(frame.text); return 1; }
    fprintf(stderr, "UART ready: %s, %ld, 8N1, frame limit=%zu\n", argv[1], baud, limit);
    int result = 0;
    while (!stopping) {
        unsigned char chunk[128];
        ssize_t count = read(fd, chunk, sizeof(chunk));
        if (count < 0 && errno == EINTR) continue;
        if (count < 0) { result = 1; break; }
        if (count == 0) {
            if (frame.depth != 0) {
                fprintf(stderr, "Incomplete UART frame discarded after idle timeout\n");
                reset_frame(&frame);
            }
            continue;
        }
        for (ssize_t i = 0; i < count && !stopping; ++i) {
            int complete = feed_byte(&frame, chunk[i]);
            if (complete < 0) { fprintf(stderr, "Invalid/oversized UART frame\n"); continue; }
            if (!complete) continue;
            struct json_object *response = NULL;
            enum dispatch_status status = dispatch_request(frame.text, frame.used, &response);
            if (status == DISPATCH_OK) {
                if (uart_send_json(fd, response) != 0) { result = 1; stopping = 1; }
                json_object_put(response);
            } else if (status == DISPATCH_ERROR) {
                fprintf(stderr, "Dispatch resource error\n");
                result = 1;
                stopping = 1;
            } else {
                /* 不编造 Excel 未规定的非法/未实现指令响应。 */
                fprintf(stderr, "Invalid or unsupported Excel request\n");
            }
        }
    }
    /* 正常退出或 Ctrl+C 时恢复串口参数;不会擅自恢复/改变 LED 状态。 */
    if (tcsetattr(fd, TCSANOW, &original) != 0) { perror("restore UART"); result = 1; }
    if (close(fd) != 0) result = 1;
    free(frame.text);
    return result;
}

4. 第一版的扩展位置

4.1 UART 层不包含业务

main() 和 feed_byte() 只负责收齐消息;uart_send_json() 只发送响应对象。它们不判断 lan_Mac 或 red,以后增加 SN、风扇等不应修改这层。

接收上限默认 4096 字节,可以用启动参数修改;这是内存安全配置,不是把所有业务限制为 1 KB。超过上限的帧丢弃,帧结束后还能继续接收。开始接收后 1 秒无新字节则丢弃未完成帧,串口消息不加其他头尾。

标准错误用于本地诊断,不要重定向到同一厂测 UART,以免混入非 JSON 数据。

4.2 公共解析只看 cmd/action

dispatch_request() 用 json-c 解析对象,只检查两个公共字段,再查模块表。它不要求每条指令必须有 key,也不强制三个字段,因此以后可承接 Excel 中的 key_value 以及 CMD 模块的无 key 请求。

模块得到 r->json,可以用 json_field() 取字符串,或用 JSON API 检查其他数据类型。字段名、类型、取值范围仍必须按那条 Excel 指令验证,不是收到什么就执行什么。

4.3 模块表与处理函数

modules[] 是扩展入口,不是将每条命令转成枚举。当前表内只登记 DEVICEINFO、STATUSLED。

  • 同模块扩展,例如以后加入 SN:修改 handle_deviceinfo(),读取那条指令的 key_value,按 RK 表执行。
  • 新模块扩展,例如风扇:写 handle_fan(),然后登记 FAN 与函数,公共解析、UART 接收不改。
  • DISPATCH_* 只是内部执行状态,不写入串口、不增加 Excel 响应字段。

内部状态含义:OK 表示已经构造完整响应;UNSUPPORTED 表示功能未实现;INVALID 表示请求不合法;ERROR 表示资源错误。硬件操作失败但成功构造 result=fail 响应,仍属于 OK,不要混淆业务失败与框架错误。

4.4 响应由业务模块构造

response_new() 只是常用助手,提供 cmd/action/key/result,key 可以省略。它不是所有指令都必须套用的唯一模板。

MAC 模块按 Excel 添加字符串 key_value;LED 不添加它。以后需要数值、不同字段或其他结构时,模块直接使用 JSON API 按表添加或构造完整对象。特殊响应的 key 若与请求不同,也由模块按 Excel 明确指定,不强制回显所有请求字段。

模块返回的响应由调用方发送并释放。原始请求是只读借用,模块不得修改或释放它。原始请求及借用的字符串在 dispatch_request() 返回后失效;异步任务如需保留请求,必须复制需要的参数,或取得 JSON 对象引用并明确负责释放。响应若直接引用请求中的 JSON 子对象,也需先通过 json_object_get() 取得自己的引用,避免请求释放后出现悬空引用。

4.5 如何加一项而不重写框架

  1. 找到普通表的请求、响应及 RK 表的对应操作,先核对存在冲突的单位或节点。
  2. 在已有模块中增加分支;如果是新模块,则增加处理函数和一条登记项。
  3. 在该分支读取并校验其必要参数,不改公共层来限制其他指令。
  4. 执行测试操作,构造该指令自己的成功或失败响应。
  5. 复验响应与 Excel,再按需要给上位机增加对应原始请求。

当前仍同步执行,适合 MAC、LED 这类短操作。NPU 老化等长耗时功能需要独立执行任务及请求生命周期管理;可围绕同一模块接口调整执行层,而不改 UART 或 JSON 业务字段。本版没有线程池,也不编造 Excel 未定义的任务编号和异步应答;它是可扩展基础,不是已经支持并发任务的产线服务。

未实现或非法指令当前只记录本地诊断,不伪造未知协议响应。后续新增模块必须同时补齐 Excel 中该项的失败响应,不能把没有响应当作正式处理完成。

5. 你自己编译与联动

5.1 编译板端程序

保存代码后,在具备对应编译器、json-c/json.h 及 libjson-c 的环境中执行:

cc -std=c11 -O2 -Wall -Wextra -Werror factory_board.c -ljson-c -o factory_board

若提示缺少 json-c/json.h,说明开发依赖不齐;若链接失败,则需确认库及架构。系统存在运行库不等于已经安装开发头文件。本文不自行安装依赖或修改 SDK rootfs 配置。

开发机的 cc 不等于板端交叉编译器。RK3566 部署前须确认精确 SDK、目标 Linux、工具链和产物架构;本文没有替你选 SDK、修改构建配置或向板卡拷贝程序。

5.2 板端 UART

选择一个实际存在、未被 console/getty 或其他应用占用的专用 UART。下面的设备名和波特率仅为用法示例,不能直接当成当前板卡事实:

./factory_board /dev/ttyS3 115200

需要改变接收上限时,可在设备和波特率后增加字节数,例如 ./factory_board /dev/ttyS3 115200 8192。参数仅为用法示例,并未实际打开串口。

程序会配置该 UART 的运行时串口参数,收到三条已支持请求才执行对应操作。Ctrl+C 正常退出时恢复原串口参数;强制杀死或掉电不保证恢复。不要用启动控制台直接承载厂测通信。

5.3 Windows 上位机

  1. 将 factory_host.ps1 和 start_host.bat 放入 Windows 同一个目录。
  2. 双击 start_host.bat,选择 USB 转串口对应 COM 口。
  3. 选择与板端一致的波特率,点击“连接”。连接不会发命令。
  4. 先选择读取 MAC,点击“发送一次”,核对原始响应。
  5. 确认允许改变 LED 状态后,再选择红灯打开或关闭并确认发送。

只连接匹配电平的 UART TX、RX、GND;不要把 RS232 电平直接接 TTL UART。上位机禁用流控和 DTR/RTS,建议物理上也不接 DTR/RTS,避免 USB 串口驱动的线路变化触发板卡复位。

上位机当前菜单仍只对应三条已实现指令,保持现有配合行为不变。新增模块或长耗时功能时,需要同步增加对应 Excel 请求,并按实际响应长度和耗时调整上位机接收配置;这属于必要配合,不修改业务字段。

上位机本地等待响应的上限为 5 秒,超时关闭连接,不自动重发。这是工具行为,不是新增 Excel 字段或板端业务命令。当前没有任务编号,所以一次只允许一个请求在途。

6. 尚未接入的表格功能

后续增加功能只按“普通表请求/响应 → RK 表操作 → 代码分支”的顺序,不自行增加业务。

功能仍需确认的依据
SN 读写vendor_storage 的实际输出格式及写入验收方式
Device ID表中 rknn-console rk1820 在目标 RK1828 环境的行为及 OTP 输出格式
风扇普通表第 42 行要求 RPM,RK 表第 23 行却读取 PWM,不能混用
性能模式三个 governor 的可用策略及 normal 对应值
NPU 老化普通表第 36 行未提供请求格式,不编造

7. 验证记录和未验证内容

源代码、边界识别及响应检查仅在临时目录执行,不新增持久板端 .c 文件,不打开真实串口,不运行 MAC 读取或 LED 写入。

本模块化版本重新检查,不沿用旧版数量:

检查结果与边界
临时 API 声明配合系统 json-c 0.15 运行库编译-Wall -Wextra -Werror 通过,不等同于正式开发头文件构建
38 项框架检查及 UBSan通过,包括模块分发、响应、参数类型、资源错误、可配置接收上限与超长帧恢复
扩展性检查测试副本仅增加模块处理函数和登记项,带 key_value、额外参数及无 key 的请求均可进入相应模块;UART 和公共分发不改
现有三条请求及成功/失败响应使用临时无硬件业务函数检查模板,与 Excel 对应字段一致,不证明节点操作正确
上位机压缩包 SHA-256与修改前一致,无需当前配合改动
Markdown 格式使用文档库 .mdl.rb 规则,mdl 通过

测试中的业务函数替身和扩展模块只存在于临时检查副本,不加入交付代码、不提供为板端测试项。临时 API 声明也不随文档交付。没有调用真实 open_uart()、read_mac()、set_red(),没有打开真实或虚拟串口。

开发机已发现 json-c 0.15 运行库,但没有正式开发头文件。标准头文件构建和目标板构建待具备相应开发依赖后复验。不得把临时 API 声明检查表述为正式开发头文件构建通过。

上位机及压缩包不修改;当前环境没有 Windows PowerShell,Windows 窗口、COM 打开及实机 UART 联动仍未验证。本文不是已验证工程案例。

01_Learning · 文档目录
上一篇RK3576-Industrial-Bus-Driver-Course--08-Debugging-and-Capstone下一篇Register