skiinder/blinky
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(ble): 添加BLE NUS模块替换原有的BLE串口功能

Browse Source 
- 将ble_serial_module替换为ble_nus_module以使用标准的BLE NUS服务
- 移除不再使用的cdc_wrapper_module和相关事件处理
- 更新协议传输层抽象，支持USB CDC和BLE NUS两种传输方式
- 创建统一的proto_rx_event和proto_tx_event替代专用的串行通信事件
- 添加proto_common.h定义传输类型枚举
- 修改protocol_module接口以支持多传输方式
- 在prj.conf中启用CONFIG_BT_ZEPHYR_NUS配置选项
This commit is contained in:
skiinder
2026-04-15 10:23:12 +08:00
parent c4b205b8a1
commit bc42a4dd63
25 changed files with 538 additions and 1499 deletions
Download Patch File Download Diff File Expand all files Collapse all files

377
src/protocol_module.c
View File

@@ -18,14 +18,9 @@
#include <proto/device_comm.pb.h>
#include "theme_rgb_update_event.h"
#include "time_sync_event.h"
#include "cdc_proto_tx_event.h"
#include "function_bitmap_update_event.h"
#include "hid_led_event.h"
#include "key_function_event.h"
#include "proto_rx_event.h"
#include "proto_tx_event.h"
#include "protocol_module.h"
#include "usb_state_event.h"
LOG_MODULE_REGISTER(MODULE, LOG_LEVEL_INF);
@@ -34,39 +29,12 @@ LOG_MODULE_REGISTER(MODULE, LOG_LEVEL_INF);
#define PROTOCOL_PRODUCT_ID 0x52F0U
#define PROTOCOL_FIRMWARE_MAJOR 0U
#define PROTOCOL_FIRMWARE_MINOR 0U
#define PROTOCOL_CAPABILITY_FLAGS (BIT(0) | BIT(1) | BIT(2) | BIT(3))
#define PROTOCOL_CAPABILITY_FLAGS 0U
#define PROTOCOL_MAX_MSG_LEN 128U
static bool initialized;
static bool running;
static bool keyboard_core_ready;
static bool usb_active;
static bool hello_done;
static bool type_matches_body(uint8_t type, const CdcPacketBody *body)
{
switch (type) {
case CDC_PROTO_TYPE_HELLO_REQ:
return body->which_body == CdcPacketBody_hello_req_tag;
case CDC_PROTO_TYPE_HELLO_RSP:
return body->which_body == CdcPacketBody_hello_rsp_tag;
case CDC_PROTO_TYPE_BITMAP:
return body->which_body == CdcPacketBody_bitmap_tag;
case CDC_PROTO_TYPE_FUNCTION_KEY_EVENT:
return body->which_body == CdcPacketBody_function_key_event_tag;
case CDC_PROTO_TYPE_LED_STATE:
return body->which_body == CdcPacketBody_led_state_tag;
case CDC_PROTO_TYPE_TIME_SYNC:
return body->which_body == CdcPacketBody_time_sync_tag;
case CDC_PROTO_TYPE_THEME_RGB:
return body->which_body == CdcPacketBody_theme_rgb_tag;
case CDC_PROTO_TYPE_ACK:
return body->which_body == CdcPacketBody_ack_tag;
case CDC_PROTO_TYPE_ERROR:
return body->which_body == CdcPacketBody_error_tag;
default:
return false;
}
}
static bool hello_done[PROTO_TRANSPORT_COUNT];
static int decode_body(const uint8_t *payload, size_t payload_len,
CdcPacketBody *body)
@@ -123,94 +91,12 @@ static int encode_hello_rsp(uint8_t *rsp_payload, size_t rsp_payload_buf_size,
return encode_body(&body, rsp_payload, rsp_payload_buf_size, rsp_payload_len);
}
static int encode_ack(uint8_t acked_type, uint8_t *rsp_payload,
size_t rsp_payload_buf_size, size_t *rsp_payload_len)
{
CdcPacketBody body = CdcPacketBody_init_zero;
body.which_body = CdcPacketBody_ack_tag;
body.body.ack.acked_type = acked_type;
return encode_body(&body, rsp_payload, rsp_payload_buf_size, rsp_payload_len);
}
static int encode_error(uint8_t error_type, ErrorCode error_code,
uint8_t *rsp_payload, size_t rsp_payload_buf_size,
size_t *rsp_payload_len)
{
CdcPacketBody body = CdcPacketBody_init_zero;
body.which_body = CdcPacketBody_error_tag;
body.body.error.error_type = error_type;
body.body.error.error_code = error_code;
return encode_body(&body, rsp_payload, rsp_payload_buf_size, rsp_payload_len);
}
static int encode_function_key_event(uint16_t usage, uint8_t action,
uint8_t *payload,
size_t payload_buf_size,
size_t *payload_len)
{
CdcPacketBody body = CdcPacketBody_init_zero;
body.which_body = CdcPacketBody_function_key_event_tag;
body.body.function_key_event.usage = usage;
body.body.function_key_event.action = (KeyAction)action;
return encode_body(&body, payload, payload_buf_size, payload_len);
}
static int encode_led_state(uint32_t led_mask, uint8_t *payload,
size_t payload_buf_size, size_t *payload_len)
{
CdcPacketBody body = CdcPacketBody_init_zero;
body.which_body = CdcPacketBody_led_state_tag;
body.body.led_state.led_mask = led_mask;
return encode_body(&body, payload, payload_buf_size, payload_len);
}
static int encode_error_response(uint8_t req_type, ErrorCode error_code,
uint8_t *rsp_type, uint8_t *rsp_payload,
size_t rsp_payload_buf_size,
size_t *rsp_payload_len)
{
int err;
err = encode_error(req_type, error_code, rsp_payload,
rsp_payload_buf_size, rsp_payload_len);
if (err) {
return err;
}
*rsp_type = CDC_PROTO_TYPE_ERROR;
return 0;
}
static int encode_ack_response(uint8_t acked_type, uint8_t *rsp_type,
uint8_t *rsp_payload,
size_t rsp_payload_buf_size,
size_t *rsp_payload_len)
{
int err;
err = encode_ack(acked_type, rsp_payload, rsp_payload_buf_size,
rsp_payload_len);
if (err) {
return err;
}
*rsp_type = CDC_PROTO_TYPE_ACK;
return 0;
}
static int module_init(void)
{
keyboard_core_ready = false;
usb_active = false;
hello_done = false;
for (size_t i = 0; i < ARRAY_SIZE(hello_done); i++) {
hello_done[i] = false;
}
return 0;
}
@@ -230,22 +116,34 @@ static void module_pause(void)
return;
}
hello_done = false;
for (size_t i = 0; i < ARRAY_SIZE(hello_done); i++) {
hello_done[i] = false;
}
running = false;
}
int protocol_module_process_cdc_packet(uint8_t req_type,
const uint8_t *req_payload,
size_t req_payload_len,
uint8_t *rsp_type,
uint8_t *rsp_payload,
size_t rsp_payload_buf_size,
size_t *rsp_payload_len)
void protocol_module_reset_transport_state(enum proto_transport transport)
{
if (transport >= PROTO_TRANSPORT_COUNT) {
return;
}
hello_done[transport] = false;
}
int protocol_module_process_message(enum proto_transport transport,
const uint8_t *req_payload,
size_t req_payload_len,
uint8_t *rsp_payload,
size_t rsp_payload_buf_size,
size_t *rsp_payload_len)
{
CdcPacketBody body;
int err;
if ((rsp_type == NULL) || (rsp_payload == NULL) || (rsp_payload_len == NULL)) {
if ((transport >= PROTO_TRANSPORT_COUNT) ||
(rsp_payload == NULL) || (rsp_payload_len == NULL)) {
return -EINVAL;
}
@@ -255,191 +153,53 @@ int protocol_module_process_cdc_packet(uint8_t req_type,
err = decode_body(req_payload, req_payload_len, &body);
if (err) {
return encode_error_response(req_type, ErrorCode_ERROR_CODE_INVALID_LENGTH,
rsp_type, rsp_payload,
rsp_payload_buf_size, rsp_payload_len);
return err;
}
if (!type_matches_body(req_type, &body)) {
LOG_WRN("CDC type/body mismatch type:0x%02x body_case:%d",
req_type, body.which_body);
return encode_error_response(req_type, ErrorCode_ERROR_CODE_INVALID_PARAM,
rsp_type, rsp_payload,
rsp_payload_buf_size, rsp_payload_len);
if (body.which_body != CdcPacketBody_hello_req_tag) {
LOG_WRN("Unsupported protobuf body case %d", body.which_body);
return -ENOTSUP;
}
switch (req_type) {
case CDC_PROTO_TYPE_HELLO_REQ:
LOG_INF("HelloReq protocol_version:%u",
LOG_INF("HelloReq transport:%u protocol_version:%u",
transport, body.body.hello_req.protocol_version);
if (body.body.hello_req.protocol_version != PROTOCOL_VERSION) {
LOG_WRN("Unexpected protocol version:%u",
body.body.hello_req.protocol_version);
if (body.body.hello_req.protocol_version != PROTOCOL_VERSION) {
LOG_WRN("Unexpected protocol version:%u",
body.body.hello_req.protocol_version);
}
hello_done = true;
err = encode_hello_rsp(rsp_payload, rsp_payload_buf_size, rsp_payload_len);
if (err) {
return err;
}
*rsp_type = CDC_PROTO_TYPE_HELLO_RSP;
return 0;
case CDC_PROTO_TYPE_BITMAP:
if (!hello_done) {
return encode_error_response(req_type, ErrorCode_ERROR_CODE_NOT_READY,
rsp_type, rsp_payload,
rsp_payload_buf_size,
rsp_payload_len);
}
if (!keyboard_core_ready) {
return encode_error_response(req_type, ErrorCode_ERROR_CODE_NOT_READY,
rsp_type, rsp_payload,
rsp_payload_buf_size,
rsp_payload_len);
}
if (body.body.bitmap.usage_bitmap.size != KEYBOARD_PROTOCOL_BITMAP_BYTES) {
LOG_WRN("Bitmap len:%u expected:%u",
(unsigned int)body.body.bitmap.usage_bitmap.size,
KEYBOARD_PROTOCOL_BITMAP_BYTES);
return encode_error_response(req_type, ErrorCode_ERROR_CODE_INVALID_LENGTH,
rsp_type, rsp_payload,
rsp_payload_buf_size,
rsp_payload_len);
}
err = submit_function_bitmap_update_event(
body.body.bitmap.usage_bitmap.bytes);
if (err) {
return encode_error_response(req_type, ErrorCode_ERROR_CODE_INVALID_PARAM,
rsp_type, rsp_payload,
rsp_payload_buf_size,
rsp_payload_len);
}
return encode_ack_response(req_type, rsp_type, rsp_payload,
rsp_payload_buf_size, rsp_payload_len);
case CDC_PROTO_TYPE_TIME_SYNC:
if (!hello_done) {
return encode_error_response(req_type, ErrorCode_ERROR_CODE_NOT_READY,
rsp_type, rsp_payload,
rsp_payload_buf_size,
rsp_payload_len);
}
if (body.body.time_sync.version != 1U) {
return encode_error_response(req_type, ErrorCode_ERROR_CODE_INVALID_PARAM,
rsp_type, rsp_payload,
rsp_payload_buf_size,
rsp_payload_len);
}
submit_time_sync_event(body.body.time_sync.version,
body.body.time_sync.flags,
body.body.time_sync.timezone_min,
body.body.time_sync.utc_ms,
body.body.time_sync.accuracy_ms);
return encode_ack_response(req_type, rsp_type, rsp_payload,
rsp_payload_buf_size, rsp_payload_len);
case CDC_PROTO_TYPE_THEME_RGB:
if (!hello_done) {
return encode_error_response(req_type, ErrorCode_ERROR_CODE_NOT_READY,
rsp_type, rsp_payload,
rsp_payload_buf_size,
rsp_payload_len);
}
if ((body.body.theme_rgb.red > 255U) ||
(body.body.theme_rgb.green > 255U) ||
(body.body.theme_rgb.blue > 255U)) {
return encode_error_response(req_type, ErrorCode_ERROR_CODE_INVALID_PARAM,
rsp_type, rsp_payload,
rsp_payload_buf_size,
rsp_payload_len);
}
submit_theme_rgb_update_event((struct theme_rgb) {
.r = (uint8_t)body.body.theme_rgb.red,
.g = (uint8_t)body.body.theme_rgb.green,
.b = (uint8_t)body.body.theme_rgb.blue,
});
return encode_ack_response(req_type, rsp_type, rsp_payload,
rsp_payload_buf_size, rsp_payload_len);
default:
LOG_WRN("Unsupported CDC protocol type:0x%02x", req_type);
return encode_error_response(req_type, ErrorCode_ERROR_CODE_UNKNOWN_TYPE,
rsp_type, rsp_payload,
rsp_payload_buf_size, rsp_payload_len);
}
hello_done[transport] = true;
return encode_hello_rsp(rsp_payload, rsp_payload_buf_size, rsp_payload_len);
}
static bool handle_key_function_event(const struct key_function_event *event)
static bool handle_proto_rx_event(const struct proto_rx_event *event)
{
uint8_t payload[64];
size_t payload_len;
uint8_t rsp_payload[PROTOCOL_MAX_MSG_LEN];
size_t rsp_payload_len = 0U;
int err;
if (!running || !usb_active || !hello_done) {
if (!running) {
return false;
}
err = encode_function_key_event(event->usage, event->action, payload,
sizeof(payload), &payload_len);
err = protocol_module_process_message(event->transport,
event->dyndata.data,
event->dyndata.size,
rsp_payload,
sizeof(rsp_payload),
&rsp_payload_len);
if (err) {
LOG_WRN("FunctionKeyEvent encode failed (%d)", err);
if (err != -ENOTSUP) {
LOG_WRN("Protocol processing failed (%d)", err);
}
return false;
}
err = submit_cdc_proto_tx_event(CDC_PROTO_TYPE_FUNCTION_KEY_EVENT,
payload, payload_len);
err = submit_proto_tx_event(event->transport, rsp_payload, rsp_payload_len);
if (err) {
LOG_WRN("FunctionKeyEvent submit failed (%d)", err);
}
return false;
}
static bool handle_hid_led_event(const struct hid_led_event *event)
{
uint8_t payload[64];
size_t payload_len;
int err;
if (!running || !usb_active || !hello_done) {
return false;
}
err = encode_led_state(event->led_bm, payload, sizeof(payload), &payload_len);
if (err) {
LOG_WRN("LedState encode failed (%d)", err);
return false;
}
err = submit_cdc_proto_tx_event(CDC_PROTO_TYPE_LED_STATE, payload, payload_len);
if (err) {
LOG_WRN("LedState submit failed (%d)", err);
}
return false;
}
static bool handle_usb_state_event(const struct usb_state_event *event)
{
if ((event->op != USB_STATE_EVENT_OP_SNAPSHOT) ||
(event->src_module_id != MODULE_ID(usb_device_module))) {
return false;
}
usb_active = (event->flags & USB_STATEF_ACTIVE) != 0U;
if (!usb_active) {
hello_done = false;
LOG_WRN("Proto TX submit failed (%d)", err);
}
return false;
@@ -447,16 +207,8 @@ static bool handle_usb_state_event(const struct usb_state_event *event)
static bool app_event_handler(const struct app_event_header *aeh)
{
if (is_key_function_event(aeh)) {
return handle_key_function_event(cast_key_function_event(aeh));
}
if (is_hid_led_event(aeh)) {
return handle_hid_led_event(cast_hid_led_event(aeh));
}
if (is_usb_state_event(aeh)) {
return handle_usb_state_event(cast_usb_state_event(aeh));
if (is_proto_rx_event(aeh)) {
return handle_proto_rx_event(cast_proto_rx_event(aeh));
}
if (is_module_state_event(aeh)) {
@@ -484,11 +236,6 @@ static bool app_event_handler(const struct app_event_header *aeh)
return false;
}
if (check_state(event, MODULE_ID(keyboard_core_module), MODULE_STATE_READY)) {
keyboard_core_ready = true;
return false;
}
return false;
}
@@ -519,9 +266,7 @@ static bool app_event_handler(const struct app_event_header *aeh)
}
APP_EVENT_LISTENER(MODULE, app_event_handler);
APP_EVENT_SUBSCRIBE(MODULE, hid_led_event);
APP_EVENT_SUBSCRIBE(MODULE, key_function_event);
APP_EVENT_SUBSCRIBE(MODULE, module_state_event);
APP_EVENT_SUBSCRIBE(MODULE, usb_state_event);
APP_EVENT_SUBSCRIBE(MODULE, proto_rx_event);
APP_EVENT_SUBSCRIBE_EARLY(MODULE, power_down_event);
APP_EVENT_SUBSCRIBE(MODULE, wake_up_event);