From 508b684fdf114ecc1ba0ffea480e9e0c1cfc9210 Mon Sep 17 00:00:00 2001 From: simon Date: Tue, 19 May 2026 21:18:18 +0200 Subject: [PATCH] Add UART LED_RING command for progress bar, digits, and clear. Stop the main-loop digit demo so host-driven display persists; expose clear/progress/digit modes with RGB and intensity via protobuf and goTool. Co-authored-by: Cursor --- goTool/README.md | 1 + goTool/client_api.go | 27 +++ goTool/cmd_led_ring.go | 56 ++++++ goTool/main.go | 7 +- goTool/pb/uart_messages.pb.go | 321 ++++++++++++++++++++++++++++----- main/CMakeLists.txt | 1 + main/README.md | 27 ++- main/cmd_handler.c | 2 + main/cmd_led_ring.c | 125 +++++++++++++ main/cmd_led_ring.h | 6 + main/led_ring.c | 13 +- main/led_ring.h | 9 +- main/powerpod.c | 14 +- main/proto/uart_messages.pb.c | 6 + main/proto/uart_messages.pb.h | 75 +++++++- main/proto/uart_messages.proto | 25 +++ 16 files changed, 649 insertions(+), 66 deletions(-) create mode 100644 goTool/cmd_led_ring.go create mode 100644 main/cmd_led_ring.c create mode 100644 main/cmd_led_ring.h diff --git a/goTool/README.md b/goTool/README.md index c01668b..910fa1c 100644 --- a/goTool/README.md +++ b/goTool/README.md @@ -29,6 +29,7 @@ go run . -port /dev/ttyUSB0 clients | `serve` | — | Web dashboard at `http://localhost:8080` (WebSocket live updates) | | `ota` | 16–19 | UART firmware upload to master; firmware then pushes to slaves via ESP-NOW | | `ota-progress` | 21 | Query per-slave ESP-NOW OTA progress on the master (`-client N`, default all) | +| `led-ring` | 8 | LED ring: `-mode clear\|progress\|digit`, `-progress`, `-digit`, RGB, `-intensity` | `clients` requires slaves to have responded to master discover broadcasts first. diff --git a/goTool/client_api.go b/goTool/client_api.go index 39fdd02..62340a1 100644 --- a/goTool/client_api.go +++ b/goTool/client_api.go @@ -172,6 +172,33 @@ func (s *serialPort) espnowUnicastTest(clientID, seq uint32) (*pb.EspNowUnicastT return r, nil } +func (s *serialPort) ledRingProgress(req *pb.LedRingProgressRequest) (*pb.LedRingProgressResponse, error) { + msg := &pb.UartMessage{ + Type: pb.MessageType_LED_RING, + Payload: &pb.UartMessage_LedRingProgressRequest{ + LedRingProgressRequest: req, + }, + } + body, err := proto.Marshal(msg) + if err != nil { + return nil, fmt.Errorf("encode: %w", err) + } + payload := append([]byte{byte(pb.MessageType_LED_RING)}, body...) + respPayload, err := s.exchangePayload(payload, "LED_RING") + if err != nil { + return nil, err + } + var respMsg pb.UartMessage + if err := proto.Unmarshal(respPayload[1:], &respMsg); err != nil { + return nil, fmt.Errorf("decode: %w", err) + } + r := respMsg.GetLedRingProgressResponse() + if r == nil { + return nil, fmt.Errorf("missing led_ring_progress_response") + } + return r, nil +} + func (s *serialPort) GetVersion() (*pb.VersionResponse, error) { return s.getVersion() } func (s *serialPort) ListClients() ([]*pb.ClientInfo, error) { return s.listClients() } diff --git a/goTool/cmd_led_ring.go b/goTool/cmd_led_ring.go new file mode 100644 index 0000000..34f9624 --- /dev/null +++ b/goTool/cmd_led_ring.go @@ -0,0 +1,56 @@ +package main + +import ( + "flag" + "fmt" + + "powerpod/gotool/pb" +) + +const ( + ledRingModeClear = 0 + ledRingModeProgress = 1 + ledRingModeDigit = 2 +) + +func runLedRing(sp *serialPort, args []string) error { + fs := flag.NewFlagSet("led-ring", flag.ExitOnError) + mode := fs.String("mode", "progress", "clear, progress, or digit") + progress := fs.Uint("progress", 0, "fill level 0–100 (mode=progress)") + digit := fs.Uint("digit", 0, "digit 0–10 (mode=digit)") + r := fs.Uint("r", 0, "red 0–255") + g := fs.Uint("g", 255, "green 0–255") + b := fs.Uint("b", 0, "blue 0–255") + intensity := fs.Uint("intensity", 255, "brightness 0–255") + if err := fs.Parse(args); err != nil { + return err + } + + var modeVal uint32 + switch *mode { + case "clear": + modeVal = ledRingModeClear + case "progress": + modeVal = ledRingModeProgress + case "digit": + modeVal = ledRingModeDigit + default: + return fmt.Errorf("unknown -mode %q (clear, progress, digit)", *mode) + } + + resp, err := sp.ledRingProgress(&pb.LedRingProgressRequest{ + Mode: modeVal, + Progress: uint32(*progress), + Digit: uint32(*digit), + R: uint32(*r), + G: uint32(*g), + B: uint32(*b), + Intensity: uint32(*intensity), + }) + if err != nil { + return err + } + fmt.Printf("success=%v mode=%d progress=%d digit=%d\n", + resp.GetSuccess(), resp.GetMode(), resp.GetProgress(), resp.GetDigit()) + return nil +} diff --git a/goTool/main.go b/goTool/main.go index b10b7a1..31da6fa 100644 --- a/goTool/main.go +++ b/goTool/main.go @@ -20,7 +20,8 @@ func usage() { fmt.Fprintf(os.Stderr, " test run automated scenario (see testdata/)\n") fmt.Fprintf(os.Stderr, " serve web dashboard (Bootstrap + WebSocket)\n") fmt.Fprintf(os.Stderr, " ota UART OTA upload (A/B partitions)\n") - fmt.Fprintf(os.Stderr, " ota-progress query per-slave ESP-NOW OTA progress on master\n\n") + fmt.Fprintf(os.Stderr, " ota-progress query per-slave ESP-NOW OTA progress on master\n") + fmt.Fprintf(os.Stderr, " led-ring set LED ring progress bar (0–100%%, rgb, intensity)\n\n") flag.PrintDefaults() } @@ -47,7 +48,7 @@ func main() { os.Exit(2) } runErr = runServe(*portName, *baud, flag.Args()[1:]) - case "version", "clients", "client-info", "deadzone", "accel-deadzone", "unicast-test", "unicast_test", "ota", "ota-progress", "ota_progress": + case "version", "clients", "client-info", "deadzone", "accel-deadzone", "unicast-test", "unicast_test", "led-ring", "led_ring", "ota", "ota-progress", "ota_progress": if *portName == "" { fmt.Fprintf(os.Stderr, "command %q requires -port\n\n", cmd) usage() @@ -67,6 +68,8 @@ func main() { runErr = runDeadzone(sp, flag.Args()[1:]) case "unicast-test", "unicast_test": runErr = runUnicastTest(sp, flag.Args()[1:]) + case "led-ring", "led_ring": + runErr = runLedRing(sp, flag.Args()[1:]) case "ota": runErr = runOTA(sp, flag.Args()[1:]) case "ota-progress", "ota_progress": diff --git a/goTool/pb/uart_messages.pb.go b/goTool/pb/uart_messages.pb.go index f738ee7..3e91d77 100644 --- a/goTool/pb/uart_messages.pb.go +++ b/goTool/pb/uart_messages.pb.go @@ -32,6 +32,7 @@ const ( MessageType_CLIENT_INPUT MessageType = 5 MessageType_ACCEL_DEADZONE MessageType = 6 MessageType_ESPNOW_UNICAST_TEST MessageType = 7 + MessageType_LED_RING MessageType = 8 MessageType_OTA_START MessageType = 16 MessageType_OTA_PAYLOAD MessageType = 17 MessageType_OTA_END MessageType = 18 @@ -51,6 +52,7 @@ var ( 5: "CLIENT_INPUT", 6: "ACCEL_DEADZONE", 7: "ESPNOW_UNICAST_TEST", + 8: "LED_RING", 16: "OTA_START", 17: "OTA_PAYLOAD", 18: "OTA_END", @@ -67,6 +69,7 @@ var ( "CLIENT_INPUT": 5, "ACCEL_DEADZONE": 6, "ESPNOW_UNICAST_TEST": 7, + "LED_RING": 8, "OTA_START": 16, "OTA_PAYLOAD": 17, "OTA_END": 18, @@ -123,6 +126,8 @@ type UartMessage struct { // *UartMessage_EspnowUnicastTestResponse // *UartMessage_OtaSlaveProgressRequest // *UartMessage_OtaSlaveProgressResponse + // *UartMessage_LedRingProgressRequest + // *UartMessage_LedRingProgressResponse Payload isUartMessage_Payload `protobuf_oneof:"payload"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -307,6 +312,24 @@ func (x *UartMessage) GetOtaSlaveProgressResponse() *OtaSlaveProgressResponse { return nil } +func (x *UartMessage) GetLedRingProgressRequest() *LedRingProgressRequest { + if x != nil { + if x, ok := x.Payload.(*UartMessage_LedRingProgressRequest); ok { + return x.LedRingProgressRequest + } + } + return nil +} + +func (x *UartMessage) GetLedRingProgressResponse() *LedRingProgressResponse { + if x != nil { + if x, ok := x.Payload.(*UartMessage_LedRingProgressResponse); ok { + return x.LedRingProgressResponse + } + } + return nil +} + type isUartMessage_Payload interface { isUartMessage_Payload() } @@ -371,6 +394,14 @@ type UartMessage_OtaSlaveProgressResponse struct { OtaSlaveProgressResponse *OtaSlaveProgressResponse `protobuf:"bytes,16,opt,name=ota_slave_progress_response,json=otaSlaveProgressResponse,proto3,oneof"` } +type UartMessage_LedRingProgressRequest struct { + LedRingProgressRequest *LedRingProgressRequest `protobuf:"bytes,17,opt,name=led_ring_progress_request,json=ledRingProgressRequest,proto3,oneof"` +} + +type UartMessage_LedRingProgressResponse struct { + LedRingProgressResponse *LedRingProgressResponse `protobuf:"bytes,18,opt,name=led_ring_progress_response,json=ledRingProgressResponse,proto3,oneof"` +} + func (*UartMessage_AckPayload) isUartMessage_Payload() {} func (*UartMessage_EchoPayload) isUartMessage_Payload() {} @@ -401,6 +432,10 @@ func (*UartMessage_OtaSlaveProgressRequest) isUartMessage_Payload() {} func (*UartMessage_OtaSlaveProgressResponse) isUartMessage_Payload() {} +func (*UartMessage_LedRingProgressRequest) isUartMessage_Payload() {} + +func (*UartMessage_LedRingProgressResponse) isUartMessage_Payload() {} + type Ack struct { state protoimpl.MessageState `protogen:"open.v1"` unknownFields protoimpl.UnknownFields @@ -1033,6 +1068,171 @@ func (x *EspNowUnicastTestResponse) GetSeq() uint32 { return 0 } +// Host → device: LED ring display (progress bar, digit, or clear). +// mode: 0=clear, 1=progress (0–100 %), 2=digit (0–10, same layout as firmware digit maps). +type LedRingProgressRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Mode uint32 `protobuf:"varint,1,opt,name=mode,proto3" json:"mode,omitempty"` + // * 0–100: fraction of ring LEDs to light (mode=progress) + Progress uint32 `protobuf:"varint,2,opt,name=progress,proto3" json:"progress,omitempty"` + // * 0–10 (mode=digit) + Digit uint32 `protobuf:"varint,3,opt,name=digit,proto3" json:"digit,omitempty"` + R uint32 `protobuf:"varint,4,opt,name=r,proto3" json:"r,omitempty"` + G uint32 `protobuf:"varint,5,opt,name=g,proto3" json:"g,omitempty"` + B uint32 `protobuf:"varint,6,opt,name=b,proto3" json:"b,omitempty"` + // * 0–255 brightness scale applied to r/g/b + Intensity uint32 `protobuf:"varint,7,opt,name=intensity,proto3" json:"intensity,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *LedRingProgressRequest) Reset() { + *x = LedRingProgressRequest{} + mi := &file_uart_messages_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *LedRingProgressRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LedRingProgressRequest) ProtoMessage() {} + +func (x *LedRingProgressRequest) ProtoReflect() protoreflect.Message { + mi := &file_uart_messages_proto_msgTypes[12] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LedRingProgressRequest.ProtoReflect.Descriptor instead. +func (*LedRingProgressRequest) Descriptor() ([]byte, []int) { + return file_uart_messages_proto_rawDescGZIP(), []int{12} +} + +func (x *LedRingProgressRequest) GetMode() uint32 { + if x != nil { + return x.Mode + } + return 0 +} + +func (x *LedRingProgressRequest) GetProgress() uint32 { + if x != nil { + return x.Progress + } + return 0 +} + +func (x *LedRingProgressRequest) GetDigit() uint32 { + if x != nil { + return x.Digit + } + return 0 +} + +func (x *LedRingProgressRequest) GetR() uint32 { + if x != nil { + return x.R + } + return 0 +} + +func (x *LedRingProgressRequest) GetG() uint32 { + if x != nil { + return x.G + } + return 0 +} + +func (x *LedRingProgressRequest) GetB() uint32 { + if x != nil { + return x.B + } + return 0 +} + +func (x *LedRingProgressRequest) GetIntensity() uint32 { + if x != nil { + return x.Intensity + } + return 0 +} + +type LedRingProgressResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` + Mode uint32 `protobuf:"varint,2,opt,name=mode,proto3" json:"mode,omitempty"` + Progress uint32 `protobuf:"varint,3,opt,name=progress,proto3" json:"progress,omitempty"` + Digit uint32 `protobuf:"varint,4,opt,name=digit,proto3" json:"digit,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *LedRingProgressResponse) Reset() { + *x = LedRingProgressResponse{} + mi := &file_uart_messages_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *LedRingProgressResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LedRingProgressResponse) ProtoMessage() {} + +func (x *LedRingProgressResponse) ProtoReflect() protoreflect.Message { + mi := &file_uart_messages_proto_msgTypes[13] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LedRingProgressResponse.ProtoReflect.Descriptor instead. +func (*LedRingProgressResponse) Descriptor() ([]byte, []int) { + return file_uart_messages_proto_rawDescGZIP(), []int{13} +} + +func (x *LedRingProgressResponse) GetSuccess() bool { + if x != nil { + return x.Success + } + return false +} + +func (x *LedRingProgressResponse) GetMode() uint32 { + if x != nil { + return x.Mode + } + return 0 +} + +func (x *LedRingProgressResponse) GetProgress() uint32 { + if x != nil { + return x.Progress + } + return 0 +} + +func (x *LedRingProgressResponse) GetDigit() uint32 { + if x != nil { + return x.Digit + } + return 0 +} + // Host → device: begin UART OTA (erase inactive OTA slot; device replies OTA_STATUS). type OtaStartPayload struct { state protoimpl.MessageState `protogen:"open.v1"` @@ -1043,7 +1243,7 @@ type OtaStartPayload struct { func (x *OtaStartPayload) Reset() { *x = OtaStartPayload{} - mi := &file_uart_messages_proto_msgTypes[12] + mi := &file_uart_messages_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1055,7 +1255,7 @@ func (x *OtaStartPayload) String() string { func (*OtaStartPayload) ProtoMessage() {} func (x *OtaStartPayload) ProtoReflect() protoreflect.Message { - mi := &file_uart_messages_proto_msgTypes[12] + mi := &file_uart_messages_proto_msgTypes[14] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1068,7 +1268,7 @@ func (x *OtaStartPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use OtaStartPayload.ProtoReflect.Descriptor instead. func (*OtaStartPayload) Descriptor() ([]byte, []int) { - return file_uart_messages_proto_rawDescGZIP(), []int{12} + return file_uart_messages_proto_rawDescGZIP(), []int{14} } func (x *OtaStartPayload) GetTotalSize() uint32 { @@ -1089,7 +1289,7 @@ type OtaPayload struct { func (x *OtaPayload) Reset() { *x = OtaPayload{} - mi := &file_uart_messages_proto_msgTypes[13] + mi := &file_uart_messages_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1101,7 +1301,7 @@ func (x *OtaPayload) String() string { func (*OtaPayload) ProtoMessage() {} func (x *OtaPayload) ProtoReflect() protoreflect.Message { - mi := &file_uart_messages_proto_msgTypes[13] + mi := &file_uart_messages_proto_msgTypes[15] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1114,7 +1314,7 @@ func (x *OtaPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use OtaPayload.ProtoReflect.Descriptor instead. func (*OtaPayload) Descriptor() ([]byte, []int) { - return file_uart_messages_proto_rawDescGZIP(), []int{13} + return file_uart_messages_proto_rawDescGZIP(), []int{15} } func (x *OtaPayload) GetSeq() uint32 { @@ -1140,7 +1340,7 @@ type OtaEndPayload struct { func (x *OtaEndPayload) Reset() { *x = OtaEndPayload{} - mi := &file_uart_messages_proto_msgTypes[14] + mi := &file_uart_messages_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1152,7 +1352,7 @@ func (x *OtaEndPayload) String() string { func (*OtaEndPayload) ProtoMessage() {} func (x *OtaEndPayload) ProtoReflect() protoreflect.Message { - mi := &file_uart_messages_proto_msgTypes[14] + mi := &file_uart_messages_proto_msgTypes[16] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1165,7 +1365,7 @@ func (x *OtaEndPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use OtaEndPayload.ProtoReflect.Descriptor instead. func (*OtaEndPayload) Descriptor() ([]byte, []int) { - return file_uart_messages_proto_rawDescGZIP(), []int{14} + return file_uart_messages_proto_rawDescGZIP(), []int{16} } // Device → host status (also used as ACK after each 4 KiB written). @@ -1182,7 +1382,7 @@ type OtaStatusPayload struct { func (x *OtaStatusPayload) Reset() { *x = OtaStatusPayload{} - mi := &file_uart_messages_proto_msgTypes[15] + mi := &file_uart_messages_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1194,7 +1394,7 @@ func (x *OtaStatusPayload) String() string { func (*OtaStatusPayload) ProtoMessage() {} func (x *OtaStatusPayload) ProtoReflect() protoreflect.Message { - mi := &file_uart_messages_proto_msgTypes[15] + mi := &file_uart_messages_proto_msgTypes[17] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1207,7 +1407,7 @@ func (x *OtaStatusPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use OtaStatusPayload.ProtoReflect.Descriptor instead. func (*OtaStatusPayload) Descriptor() ([]byte, []int) { - return file_uart_messages_proto_rawDescGZIP(), []int{15} + return file_uart_messages_proto_rawDescGZIP(), []int{17} } func (x *OtaStatusPayload) GetStatus() uint32 { @@ -1248,7 +1448,7 @@ type OtaSlaveProgressRequest struct { func (x *OtaSlaveProgressRequest) Reset() { *x = OtaSlaveProgressRequest{} - mi := &file_uart_messages_proto_msgTypes[16] + mi := &file_uart_messages_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1260,7 +1460,7 @@ func (x *OtaSlaveProgressRequest) String() string { func (*OtaSlaveProgressRequest) ProtoMessage() {} func (x *OtaSlaveProgressRequest) ProtoReflect() protoreflect.Message { - mi := &file_uart_messages_proto_msgTypes[16] + mi := &file_uart_messages_proto_msgTypes[18] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1273,7 +1473,7 @@ func (x *OtaSlaveProgressRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use OtaSlaveProgressRequest.ProtoReflect.Descriptor instead. func (*OtaSlaveProgressRequest) Descriptor() ([]byte, []int) { - return file_uart_messages_proto_rawDescGZIP(), []int{16} + return file_uart_messages_proto_rawDescGZIP(), []int{18} } func (x *OtaSlaveProgressRequest) GetClientId() uint32 { @@ -1297,7 +1497,7 @@ type OtaSlaveProgressEntry struct { func (x *OtaSlaveProgressEntry) Reset() { *x = OtaSlaveProgressEntry{} - mi := &file_uart_messages_proto_msgTypes[17] + mi := &file_uart_messages_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1309,7 +1509,7 @@ func (x *OtaSlaveProgressEntry) String() string { func (*OtaSlaveProgressEntry) ProtoMessage() {} func (x *OtaSlaveProgressEntry) ProtoReflect() protoreflect.Message { - mi := &file_uart_messages_proto_msgTypes[17] + mi := &file_uart_messages_proto_msgTypes[19] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1322,7 +1522,7 @@ func (x *OtaSlaveProgressEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use OtaSlaveProgressEntry.ProtoReflect.Descriptor instead. func (*OtaSlaveProgressEntry) Descriptor() ([]byte, []int) { - return file_uart_messages_proto_rawDescGZIP(), []int{17} + return file_uart_messages_proto_rawDescGZIP(), []int{19} } func (x *OtaSlaveProgressEntry) GetClientId() uint32 { @@ -1373,7 +1573,7 @@ type OtaSlaveProgressResponse struct { func (x *OtaSlaveProgressResponse) Reset() { *x = OtaSlaveProgressResponse{} - mi := &file_uart_messages_proto_msgTypes[18] + mi := &file_uart_messages_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1385,7 +1585,7 @@ func (x *OtaSlaveProgressResponse) String() string { func (*OtaSlaveProgressResponse) ProtoMessage() {} func (x *OtaSlaveProgressResponse) ProtoReflect() protoreflect.Message { - mi := &file_uart_messages_proto_msgTypes[18] + mi := &file_uart_messages_proto_msgTypes[20] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1398,7 +1598,7 @@ func (x *OtaSlaveProgressResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use OtaSlaveProgressResponse.ProtoReflect.Descriptor instead. func (*OtaSlaveProgressResponse) Descriptor() ([]byte, []int) { - return file_uart_messages_proto_rawDescGZIP(), []int{18} + return file_uart_messages_proto_rawDescGZIP(), []int{20} } func (x *OtaSlaveProgressResponse) GetActive() bool { @@ -1440,7 +1640,8 @@ var File_uart_messages_proto protoreflect.FileDescriptor const file_uart_messages_proto_rawDesc = "" + "\n" + - "\x13uart_messages.proto\x12\x04alox\x1a\fnanopb.proto\"\x8b\t\n" + + "\x13uart_messages.proto\x12\x04alox\x1a\fnanopb.proto\"\xc4\n" + + "\n" + "\vUartMessage\x12%\n" + "\x04type\x18\x01 \x01(\x0e2\x11.alox.MessageTypeR\x04type\x12,\n" + "\vack_payload\x18\x02 \x01(\v2\t.alox.AckH\x00R\n" + @@ -1461,7 +1662,9 @@ const file_uart_messages_proto_rawDesc = "" + "\x1bespnow_unicast_test_request\x18\r \x01(\v2\x1e.alox.EspNowUnicastTestRequestH\x00R\x18espnowUnicastTestRequest\x12b\n" + "\x1cespnow_unicast_test_response\x18\x0e \x01(\v2\x1f.alox.EspNowUnicastTestResponseH\x00R\x19espnowUnicastTestResponse\x12\\\n" + "\x1aota_slave_progress_request\x18\x0f \x01(\v2\x1d.alox.OtaSlaveProgressRequestH\x00R\x17otaSlaveProgressRequest\x12_\n" + - "\x1bota_slave_progress_response\x18\x10 \x01(\v2\x1e.alox.OtaSlaveProgressResponseH\x00R\x18otaSlaveProgressResponseB\t\n" + + "\x1bota_slave_progress_response\x18\x10 \x01(\v2\x1e.alox.OtaSlaveProgressResponseH\x00R\x18otaSlaveProgressResponse\x12Y\n" + + "\x19led_ring_progress_request\x18\x11 \x01(\v2\x1c.alox.LedRingProgressRequestH\x00R\x16ledRingProgressRequest\x12\\\n" + + "\x1aled_ring_progress_response\x18\x12 \x01(\v2\x1d.alox.LedRingProgressResponseH\x00R\x17ledRingProgressResponseB\t\n" + "\apayload\"\x05\n" + "\x03Ack\"!\n" + "\vEchoPayload\x12\x12\n" + @@ -1504,7 +1707,20 @@ const file_uart_messages_proto_rawDesc = "" + "\x03seq\x18\x02 \x01(\rR\x03seq\"G\n" + "\x19EspNowUnicastTestResponse\x12\x18\n" + "\asuccess\x18\x01 \x01(\bR\asuccess\x12\x10\n" + - "\x03seq\x18\x02 \x01(\rR\x03seq\"0\n" + + "\x03seq\x18\x02 \x01(\rR\x03seq\"\xa6\x01\n" + + "\x16LedRingProgressRequest\x12\x12\n" + + "\x04mode\x18\x01 \x01(\rR\x04mode\x12\x1a\n" + + "\bprogress\x18\x02 \x01(\rR\bprogress\x12\x14\n" + + "\x05digit\x18\x03 \x01(\rR\x05digit\x12\f\n" + + "\x01r\x18\x04 \x01(\rR\x01r\x12\f\n" + + "\x01g\x18\x05 \x01(\rR\x01g\x12\f\n" + + "\x01b\x18\x06 \x01(\rR\x01b\x12\x1c\n" + + "\tintensity\x18\a \x01(\rR\tintensity\"y\n" + + "\x17LedRingProgressResponse\x12\x18\n" + + "\asuccess\x18\x01 \x01(\bR\asuccess\x12\x12\n" + + "\x04mode\x18\x02 \x01(\rR\x04mode\x12\x1a\n" + + "\bprogress\x18\x03 \x01(\rR\bprogress\x12\x14\n" + + "\x05digit\x18\x04 \x01(\rR\x05digit\"0\n" + "\x0fOtaStartPayload\x12\x1d\n" + "\n" + "total_size\x18\x01 \x01(\rR\ttotalSize\":\n" + @@ -1535,7 +1751,7 @@ const file_uart_messages_proto_rawDesc = "" + "\x0faggregate_bytes\x18\x03 \x01(\rR\x0eaggregateBytes\x12\x1f\n" + "\vslave_count\x18\x04 \x01(\rR\n" + "slaveCount\x12:\n" + - "\x06slaves\x18\x05 \x03(\v2\x1b.alox.OtaSlaveProgressEntryB\x05\x92?\x02\x10\x10R\x06slaves*\xf5\x01\n" + + "\x06slaves\x18\x05 \x03(\v2\x1b.alox.OtaSlaveProgressEntryB\x05\x92?\x02\x10\x10R\x06slaves*\x83\x02\n" + "\vMessageType\x12\v\n" + "\aUNKNOWN\x10\x00\x12\a\n" + "\x03ACK\x10\x01\x12\b\n" + @@ -1544,7 +1760,8 @@ const file_uart_messages_proto_rawDesc = "" + "\vCLIENT_INFO\x10\x04\x12\x10\n" + "\fCLIENT_INPUT\x10\x05\x12\x12\n" + "\x0eACCEL_DEADZONE\x10\x06\x12\x17\n" + - "\x13ESPNOW_UNICAST_TEST\x10\a\x12\r\n" + + "\x13ESPNOW_UNICAST_TEST\x10\a\x12\f\n" + + "\bLED_RING\x10\b\x12\r\n" + "\tOTA_START\x10\x10\x12\x0f\n" + "\vOTA_PAYLOAD\x10\x11\x12\v\n" + "\aOTA_END\x10\x12\x12\x0e\n" + @@ -1566,7 +1783,7 @@ func file_uart_messages_proto_rawDescGZIP() []byte { } var file_uart_messages_proto_enumTypes = make([]protoimpl.EnumInfo, 1) -var file_uart_messages_proto_msgTypes = make([]protoimpl.MessageInfo, 19) +var file_uart_messages_proto_msgTypes = make([]protoimpl.MessageInfo, 21) var file_uart_messages_proto_goTypes = []any{ (MessageType)(0), // 0: alox.MessageType (*UartMessage)(nil), // 1: alox.UartMessage @@ -1581,13 +1798,15 @@ var file_uart_messages_proto_goTypes = []any{ (*AccelDeadzoneResponse)(nil), // 10: alox.AccelDeadzoneResponse (*EspNowUnicastTestRequest)(nil), // 11: alox.EspNowUnicastTestRequest (*EspNowUnicastTestResponse)(nil), // 12: alox.EspNowUnicastTestResponse - (*OtaStartPayload)(nil), // 13: alox.OtaStartPayload - (*OtaPayload)(nil), // 14: alox.OtaPayload - (*OtaEndPayload)(nil), // 15: alox.OtaEndPayload - (*OtaStatusPayload)(nil), // 16: alox.OtaStatusPayload - (*OtaSlaveProgressRequest)(nil), // 17: alox.OtaSlaveProgressRequest - (*OtaSlaveProgressEntry)(nil), // 18: alox.OtaSlaveProgressEntry - (*OtaSlaveProgressResponse)(nil), // 19: alox.OtaSlaveProgressResponse + (*LedRingProgressRequest)(nil), // 13: alox.LedRingProgressRequest + (*LedRingProgressResponse)(nil), // 14: alox.LedRingProgressResponse + (*OtaStartPayload)(nil), // 15: alox.OtaStartPayload + (*OtaPayload)(nil), // 16: alox.OtaPayload + (*OtaEndPayload)(nil), // 17: alox.OtaEndPayload + (*OtaStatusPayload)(nil), // 18: alox.OtaStatusPayload + (*OtaSlaveProgressRequest)(nil), // 19: alox.OtaSlaveProgressRequest + (*OtaSlaveProgressEntry)(nil), // 20: alox.OtaSlaveProgressEntry + (*OtaSlaveProgressResponse)(nil), // 21: alox.OtaSlaveProgressResponse } var file_uart_messages_proto_depIdxs = []int32{ 0, // 0: alox.UartMessage.type:type_name -> alox.MessageType @@ -1596,24 +1815,26 @@ var file_uart_messages_proto_depIdxs = []int32{ 4, // 3: alox.UartMessage.version_response:type_name -> alox.VersionResponse 6, // 4: alox.UartMessage.client_info_response:type_name -> alox.ClientInfoResponse 8, // 5: alox.UartMessage.client_input_response:type_name -> alox.ClientInputResponse - 13, // 6: alox.UartMessage.ota_start:type_name -> alox.OtaStartPayload - 14, // 7: alox.UartMessage.ota_payload:type_name -> alox.OtaPayload - 15, // 8: alox.UartMessage.ota_end:type_name -> alox.OtaEndPayload - 16, // 9: alox.UartMessage.ota_status:type_name -> alox.OtaStatusPayload + 15, // 6: alox.UartMessage.ota_start:type_name -> alox.OtaStartPayload + 16, // 7: alox.UartMessage.ota_payload:type_name -> alox.OtaPayload + 17, // 8: alox.UartMessage.ota_end:type_name -> alox.OtaEndPayload + 18, // 9: alox.UartMessage.ota_status:type_name -> alox.OtaStatusPayload 9, // 10: alox.UartMessage.accel_deadzone_request:type_name -> alox.AccelDeadzoneRequest 10, // 11: alox.UartMessage.accel_deadzone_response:type_name -> alox.AccelDeadzoneResponse 11, // 12: alox.UartMessage.espnow_unicast_test_request:type_name -> alox.EspNowUnicastTestRequest 12, // 13: alox.UartMessage.espnow_unicast_test_response:type_name -> alox.EspNowUnicastTestResponse - 17, // 14: alox.UartMessage.ota_slave_progress_request:type_name -> alox.OtaSlaveProgressRequest - 19, // 15: alox.UartMessage.ota_slave_progress_response:type_name -> alox.OtaSlaveProgressResponse - 5, // 16: alox.ClientInfoResponse.clients:type_name -> alox.ClientInfo - 7, // 17: alox.ClientInputResponse.clients:type_name -> alox.ClientInput - 18, // 18: alox.OtaSlaveProgressResponse.slaves:type_name -> alox.OtaSlaveProgressEntry - 19, // [19:19] is the sub-list for method output_type - 19, // [19:19] is the sub-list for method input_type - 19, // [19:19] is the sub-list for extension type_name - 19, // [19:19] is the sub-list for extension extendee - 0, // [0:19] is the sub-list for field type_name + 19, // 14: alox.UartMessage.ota_slave_progress_request:type_name -> alox.OtaSlaveProgressRequest + 21, // 15: alox.UartMessage.ota_slave_progress_response:type_name -> alox.OtaSlaveProgressResponse + 13, // 16: alox.UartMessage.led_ring_progress_request:type_name -> alox.LedRingProgressRequest + 14, // 17: alox.UartMessage.led_ring_progress_response:type_name -> alox.LedRingProgressResponse + 5, // 18: alox.ClientInfoResponse.clients:type_name -> alox.ClientInfo + 7, // 19: alox.ClientInputResponse.clients:type_name -> alox.ClientInput + 20, // 20: alox.OtaSlaveProgressResponse.slaves:type_name -> alox.OtaSlaveProgressEntry + 21, // [21:21] is the sub-list for method output_type + 21, // [21:21] is the sub-list for method input_type + 21, // [21:21] is the sub-list for extension type_name + 21, // [21:21] is the sub-list for extension extendee + 0, // [0:21] is the sub-list for field type_name } func init() { file_uart_messages_proto_init() } @@ -1637,6 +1858,8 @@ func file_uart_messages_proto_init() { (*UartMessage_EspnowUnicastTestResponse)(nil), (*UartMessage_OtaSlaveProgressRequest)(nil), (*UartMessage_OtaSlaveProgressResponse)(nil), + (*UartMessage_LedRingProgressRequest)(nil), + (*UartMessage_LedRingProgressResponse)(nil), } type x struct{} out := protoimpl.TypeBuilder{ @@ -1644,7 +1867,7 @@ func file_uart_messages_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_uart_messages_proto_rawDesc), len(file_uart_messages_proto_rawDesc)), NumEnums: 1, - NumMessages: 19, + NumMessages: 21, NumExtensions: 0, NumServices: 0, }, diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt index b62d67c..bb0050c 100644 --- a/main/CMakeLists.txt +++ b/main/CMakeLists.txt @@ -19,6 +19,7 @@ idf_component_register( "cmd_client_info.c" "cmd_accel_deadzone.c" "cmd_espnow_unicast_test.c" + "cmd_led_ring.c" "cmd_ota.c" "cmd_ota_slave_progress.c" "ota_uart.c" diff --git a/main/README.md b/main/README.md index 19fae5d..6bbf7c1 100644 --- a/main/README.md +++ b/main/README.md @@ -202,6 +202,8 @@ Host and master speak nanopb-encoded `UartMessage` inside UART frames (byte 0 = | 4 | `CLIENT_INFO` | Implemented (`cmd_client_info.c`) — slave list from registry | | 5 | `CLIENT_INPUT` | Planned | | 6 | `ACCEL_DEADZONE` | Implemented (`cmd_accel_deadzone.c`) — get/set accel filter LSB | +| 7 | `ESPNOW_UNICAST_TEST` | Implemented (`cmd_espnow_unicast_test.c`) | +| 8 | `LED_RING` | Implemented (`cmd_led_ring.c`) — ring progress bar (0–100 %, RGB, intensity) | | 16 | `OTA_START` | Implemented (`cmd_ota.c`) — begin UART OTA on inactive slot | | 17 | `OTA_PAYLOAD` | Implemented — up to 200 B per frame; device buffers 4 KiB | | 18 | `OTA_END` | Implemented — flush, `esp_ota_end`, push image to slaves via ESP-NOW, set boot | @@ -309,6 +311,28 @@ Minimal master→slave ESP-NOW unicast check (no BMA456). Use this before debugg **Firmware logs:** master `unicast TEST to … seq=N`; slave `UNICAST TEST OK from master … seq=N`. +### LED_RING command + +Control the 95-LED ring from the host. The firmware **does not** animate digits locally; only UART updates the display. + +**Request:** framed `08` + `led_ring_progress_request`: + +| Field | Meaning | +|-------|---------| +| `mode` | `0` = clear, `1` = progress bar, `2` = digit | +| `progress` | 0–100 (% of ring lit, mode `1`) | +| `digit` | 0–10 (mode `2`, same segment maps as built-in digits) | +| `r`, `g`, `b` | Color 0–255 | +| `intensity` | Brightness 0–255 (scaled into RGB; `0` → 255) | + +**Response:** `led_ring_progress_response` (`success`, `mode`, `progress`, `digit`). + +```bash +go run . -port /dev/ttyUSB0 led-ring -mode progress -progress 75 -g 80 -b 255 +go run . -port /dev/ttyUSB0 led-ring -mode digit -digit 7 -r 255 -g 200 +go run . -port /dev/ttyUSB0 led-ring -mode clear +``` + ### CLIENT_INFO command **Request:** framed payload `04` only (`MessageType.CLIENT_INFO`). @@ -393,7 +417,8 @@ Target: ESP32-S3. Close serial monitor on the UART adapter port before running ` | `client_registry.c/h` | Registered slave table | | `bosch456.c/h` | BMA456H I2C driver, accel poll, tap INT, deadzone filter | | `board_input.c/h` | Taster GPIO12, LiPo ADC on GPIO1 / GPIO12 | -| `led_ring.c/h` | LED digit display | +| `led_ring.c/h` | LED ring (digit display, progress bar) | +| `cmd_led_ring.c` | UART `LED_RING` progress command | | `proto/uart_messages.proto` | UART protocol schema | | `proto/esp_now_messages.proto` | ESP-NOW protocol schema | | `esp_now_proto.c/h` | Encode/decode `EspNowMessage` | diff --git a/main/cmd_handler.c b/main/cmd_handler.c index b259177..630dae0 100644 --- a/main/cmd_handler.c +++ b/main/cmd_handler.c @@ -30,6 +30,8 @@ static const char *message_type_name(uint16_t id) { return "ACCEL_DEADZONE"; case alox_MessageType_ESPNOW_UNICAST_TEST: return "ESPNOW_UNICAST_TEST"; + case alox_MessageType_LED_RING: + return "LED_RING"; case alox_MessageType_OTA_START: return "OTA_START"; case alox_MessageType_OTA_PAYLOAD: diff --git a/main/cmd_led_ring.c b/main/cmd_led_ring.c new file mode 100644 index 0000000..c9b3b14 --- /dev/null +++ b/main/cmd_led_ring.c @@ -0,0 +1,125 @@ +#include "cmd_led_ring.h" +#include "esp_log.h" +#include "led_ring.h" +#include "uart_cmd.h" + +static const char *TAG = "[LED_RING_CMD]"; + +#define LED_RING_MODE_CLEAR 0 +#define LED_RING_MODE_PROGRESS 1 +#define LED_RING_MODE_DIGIT 2 + +static uint8_t clamp_u8(uint32_t v) { + if (v > 255) { + return 255; + } + return (uint8_t)v; +} + +static uint8_t clamp_progress(uint32_t v) { + if (v > 100) { + return 100; + } + return (uint8_t)v; +} + +static void apply_intensity(uint8_t *r, uint8_t *g, uint8_t *b, uint8_t intensity) { + if (intensity == 0) { + return; + } + *r = (uint16_t)(*r) * intensity / 255; + *g = (uint16_t)(*g) * intensity / 255; + *b = (uint16_t)(*b) * intensity / 255; +} + +static void reply(bool success, uint32_t mode, uint32_t progress, uint32_t digit) { + alox_UartMessage response; + uart_cmd_init_response(&response, alox_MessageType_LED_RING, + alox_UartMessage_led_ring_progress_response_tag); + response.payload.led_ring_progress_response.success = success; + response.payload.led_ring_progress_response.mode = mode; + response.payload.led_ring_progress_response.progress = progress; + response.payload.led_ring_progress_response.digit = digit; + uart_cmd_send(&response, TAG); +} + +static void handle_led_ring(const uint8_t *data, size_t len) { + alox_UartMessage uart_msg; + alox_LedRingProgressRequest req = alox_LedRingProgressRequest_init_zero; + + if (uart_cmd_decode(data, len, &uart_msg) != ESP_OK) { + ESP_LOGW(TAG, "decode failed"); + reply(false, 0, 0, 0); + return; + } + + const alox_LedRingProgressRequest *req_ptr = UART_CMD_REQ( + &uart_msg, alox_UartMessage_led_ring_progress_request_tag, + led_ring_progress_request); + if (req_ptr != NULL) { + req = *req_ptr; + } + + uint32_t mode = req.mode; + uint8_t r = clamp_u8(req.r); + uint8_t g = clamp_u8(req.g); + uint8_t b = clamp_u8(req.b); + uint8_t intensity = clamp_u8(req.intensity); + if (intensity == 0) { + intensity = 255; + } + apply_intensity(&r, &g, &b, intensity); + + led_command_t cmd = {0}; + + switch (mode) { + case LED_RING_MODE_CLEAR: + cmd.mode = LED_CMD_CLEAR; + led_ring_send_command(&cmd); + ESP_LOGI(TAG, "clear"); + reply(true, mode, 0, 0); + return; + + case LED_RING_MODE_PROGRESS: { + uint8_t progress = clamp_progress(req.progress); + cmd.mode = LED_CMD_PROGRESS; + cmd.progress = progress; + cmd.r = r; + cmd.g = g; + cmd.b = b; + cmd.intensity = intensity; + led_ring_send_command(&cmd); + ESP_LOGI(TAG, "progress %u%% rgb=%u,%u,%u", (unsigned)progress, + (unsigned)r, (unsigned)g, (unsigned)b); + reply(true, mode, progress, 0); + return; + } + + case LED_RING_MODE_DIGIT: { + if (req.digit > 10) { + ESP_LOGW(TAG, "digit %lu out of range", (unsigned long)req.digit); + reply(false, mode, 0, req.digit); + return; + } + cmd.mode = LED_CMD_SET_DIGIT; + cmd.value = (uint8_t)req.digit; + cmd.r = r; + cmd.g = g; + cmd.b = b; + led_ring_send_command(&cmd); + ESP_LOGI(TAG, "digit %u rgb=%u,%u,%u", (unsigned)cmd.value, (unsigned)r, + (unsigned)g, (unsigned)b); + reply(true, mode, 0, req.digit); + return; + } + + default: + ESP_LOGW(TAG, "unknown mode %lu", (unsigned long)mode); + reply(false, mode, 0, 0); + return; + } +} + +void cmd_led_ring_register(void) { + uart_cmd_register(alox_MessageType_LED_RING, handle_led_ring); +} diff --git a/main/cmd_led_ring.h b/main/cmd_led_ring.h new file mode 100644 index 0000000..89b2487 --- /dev/null +++ b/main/cmd_led_ring.h @@ -0,0 +1,6 @@ +#ifndef CMD_LED_RING_H +#define CMD_LED_RING_H + +void cmd_led_ring_register(void); + +#endif diff --git a/main/led_ring.c b/main/led_ring.c index f945de8..5ca21c9 100644 --- a/main/led_ring.c +++ b/main/led_ring.c @@ -67,10 +67,11 @@ void vTaskLedRing(void *pvParameters) { led_command_t cmd; while (1) { if (xQueueReceive(led_queue, &cmd, portMAX_DELAY)) { - // Clear all LEDS led_strip_clear(led_ring); - if (cmd.mode == LED_CMD_SET_DIGIT && cmd.value <= 10) { + if (cmd.mode == LED_CMD_CLEAR) { + /* ring already cleared */ + } else if (cmd.mode == LED_CMD_SET_DIGIT && cmd.value <= 10) { digit_definition_t digit = digit_lookup[cmd.value]; for (int i = 0; i < digit.count; i++) { @@ -78,6 +79,14 @@ void vTaskLedRing(void *pvParameters) { led_strip_set_pixel(led_ring, RING_LEDS - digit.leds[i], cmd.r, cmd.g, cmd.b); } + } else if (cmd.mode == LED_CMD_PROGRESS) { + uint32_t lit = ((uint32_t)cmd.progress * RING_LEDS + 50) / 100; + if (lit > RING_LEDS) { + lit = RING_LEDS; + } + for (uint32_t i = 0; i < lit; i++) { + led_strip_set_pixel(led_ring, i, cmd.r, cmd.g, cmd.b); + } } led_strip_refresh(led_ring); } diff --git a/main/led_ring.h b/main/led_ring.h index 72ce130..f6b9716 100644 --- a/main/led_ring.h +++ b/main/led_ring.h @@ -1,11 +1,18 @@ #include -typedef enum { LED_CMD_CLEAR, LED_CMD_SET_DIGIT, LED_CMD_SET_COLOR } led_mode_t; +typedef enum { + LED_CMD_CLEAR, + LED_CMD_SET_DIGIT, + LED_CMD_SET_COLOR, + LED_CMD_PROGRESS +} led_mode_t; typedef struct { led_mode_t mode; uint8_t value; uint8_t r, g, b; + uint8_t intensity; + uint8_t progress; } led_command_t; void led_ring_send_command(led_command_t *cmd); diff --git a/main/powerpod.c b/main/powerpod.c index d3cdd56..adc42d0 100644 --- a/main/powerpod.c +++ b/main/powerpod.c @@ -6,6 +6,7 @@ #include "cmd_version.h" #include "cmd_ota.h" #include "cmd_ota_slave_progress.h" +#include "cmd_led_ring.h" #include "esp_now_comm.h" #include "powerpod.h" #include "driver/gpio.h" @@ -168,20 +169,13 @@ void app_main(void) { cmd_client_info_register(); cmd_accel_deadzone_register(); cmd_espnow_unicast_test_register(); + cmd_led_ring_register(); cmd_ota_register(); cmd_ota_slave_progress_register(); } - uint8_t current_digit = 10; + ESP_LOGI(TAG, "LED ring: UART LED_RING commands only (no local demo loop)"); while (1) { - led_command_t cmd = {.mode = LED_CMD_SET_DIGIT, - .value = current_digit, - .r = 5, - .g = 5, - .b = 0}; - - led_ring_send_command(&cmd); - current_digit = (current_digit + 1) % 11; - vTaskDelay(pdMS_TO_TICKS(500)); + vTaskDelay(portMAX_DELAY); } } diff --git a/main/proto/uart_messages.pb.c b/main/proto/uart_messages.pb.c index cc3f4cb..2cecb45 100644 --- a/main/proto/uart_messages.pb.c +++ b/main/proto/uart_messages.pb.c @@ -42,6 +42,12 @@ PB_BIND(alox_EspNowUnicastTestRequest, alox_EspNowUnicastTestRequest, AUTO) PB_BIND(alox_EspNowUnicastTestResponse, alox_EspNowUnicastTestResponse, AUTO) +PB_BIND(alox_LedRingProgressRequest, alox_LedRingProgressRequest, AUTO) + + +PB_BIND(alox_LedRingProgressResponse, alox_LedRingProgressResponse, AUTO) + + PB_BIND(alox_OtaStartPayload, alox_OtaStartPayload, AUTO) diff --git a/main/proto/uart_messages.pb.h b/main/proto/uart_messages.pb.h index da7f3c3..d181cbf 100644 --- a/main/proto/uart_messages.pb.h +++ b/main/proto/uart_messages.pb.h @@ -19,6 +19,7 @@ typedef enum _alox_MessageType { alox_MessageType_CLIENT_INPUT = 5, alox_MessageType_ACCEL_DEADZONE = 6, alox_MessageType_ESPNOW_UNICAST_TEST = 7, + alox_MessageType_LED_RING = 8, alox_MessageType_OTA_START = 16, alox_MessageType_OTA_PAYLOAD = 17, alox_MessageType_OTA_END = 18, @@ -95,6 +96,28 @@ typedef struct _alox_EspNowUnicastTestResponse { uint32_t seq; } alox_EspNowUnicastTestResponse; +/* Host → device: LED ring display (progress bar, digit, or clear). + mode: 0=clear, 1=progress (0–100 %), 2=digit (0–10, same layout as firmware digit maps). */ +typedef struct _alox_LedRingProgressRequest { + uint32_t mode; + /* * 0–100: fraction of ring LEDs to light (mode=progress) */ + uint32_t progress; + /* * 0–10 (mode=digit) */ + uint32_t digit; + uint32_t r; + uint32_t g; + uint32_t b; + /* * 0–255 brightness scale applied to r/g/b */ + uint32_t intensity; +} alox_LedRingProgressRequest; + +typedef struct _alox_LedRingProgressResponse { + bool success; + uint32_t mode; + uint32_t progress; + uint32_t digit; +} alox_LedRingProgressResponse; + /* Host → device: begin UART OTA (erase inactive OTA slot; device replies OTA_STATUS). */ typedef struct _alox_OtaStartPayload { uint32_t total_size; @@ -163,6 +186,8 @@ typedef struct _alox_UartMessage { alox_EspNowUnicastTestResponse espnow_unicast_test_response; alox_OtaSlaveProgressRequest ota_slave_progress_request; alox_OtaSlaveProgressResponse ota_slave_progress_response; + alox_LedRingProgressRequest led_ring_progress_request; + alox_LedRingProgressResponse led_ring_progress_response; } payload; } alox_UartMessage; @@ -195,6 +220,8 @@ extern "C" { + + /* Initializer values for message structs */ @@ -210,6 +237,8 @@ extern "C" { #define alox_AccelDeadzoneResponse_init_default {0, 0, 0, 0} #define alox_EspNowUnicastTestRequest_init_default {0, 0} #define alox_EspNowUnicastTestResponse_init_default {0, 0} +#define alox_LedRingProgressRequest_init_default {0, 0, 0, 0, 0, 0, 0} +#define alox_LedRingProgressResponse_init_default {0, 0, 0, 0} #define alox_OtaStartPayload_init_default {0} #define alox_OtaPayload_init_default {0, {0, {0}}} #define alox_OtaEndPayload_init_default {0} @@ -229,6 +258,8 @@ extern "C" { #define alox_AccelDeadzoneResponse_init_zero {0, 0, 0, 0} #define alox_EspNowUnicastTestRequest_init_zero {0, 0} #define alox_EspNowUnicastTestResponse_init_zero {0, 0} +#define alox_LedRingProgressRequest_init_zero {0, 0, 0, 0, 0, 0, 0} +#define alox_LedRingProgressResponse_init_zero {0, 0, 0, 0} #define alox_OtaStartPayload_init_zero {0} #define alox_OtaPayload_init_zero {0, {0, {0}}} #define alox_OtaEndPayload_init_zero {0} @@ -267,6 +298,17 @@ extern "C" { #define alox_EspNowUnicastTestRequest_seq_tag 2 #define alox_EspNowUnicastTestResponse_success_tag 1 #define alox_EspNowUnicastTestResponse_seq_tag 2 +#define alox_LedRingProgressRequest_mode_tag 1 +#define alox_LedRingProgressRequest_progress_tag 2 +#define alox_LedRingProgressRequest_digit_tag 3 +#define alox_LedRingProgressRequest_r_tag 4 +#define alox_LedRingProgressRequest_g_tag 5 +#define alox_LedRingProgressRequest_b_tag 6 +#define alox_LedRingProgressRequest_intensity_tag 7 +#define alox_LedRingProgressResponse_success_tag 1 +#define alox_LedRingProgressResponse_mode_tag 2 +#define alox_LedRingProgressResponse_progress_tag 3 +#define alox_LedRingProgressResponse_digit_tag 4 #define alox_OtaStartPayload_total_size_tag 1 #define alox_OtaPayload_seq_tag 1 #define alox_OtaPayload_data_tag 2 @@ -301,6 +343,8 @@ extern "C" { #define alox_UartMessage_espnow_unicast_test_response_tag 14 #define alox_UartMessage_ota_slave_progress_request_tag 15 #define alox_UartMessage_ota_slave_progress_response_tag 16 +#define alox_UartMessage_led_ring_progress_request_tag 17 +#define alox_UartMessage_led_ring_progress_response_tag 18 /* Struct field encoding specification for nanopb */ #define alox_UartMessage_FIELDLIST(X, a) \ @@ -319,7 +363,9 @@ X(a, STATIC, ONEOF, MESSAGE, (payload,accel_deadzone_response,payload.acce X(a, STATIC, ONEOF, MESSAGE, (payload,espnow_unicast_test_request,payload.espnow_unicast_test_request), 13) \ X(a, STATIC, ONEOF, MESSAGE, (payload,espnow_unicast_test_response,payload.espnow_unicast_test_response), 14) \ X(a, STATIC, ONEOF, MESSAGE, (payload,ota_slave_progress_request,payload.ota_slave_progress_request), 15) \ -X(a, STATIC, ONEOF, MESSAGE, (payload,ota_slave_progress_response,payload.ota_slave_progress_response), 16) +X(a, STATIC, ONEOF, MESSAGE, (payload,ota_slave_progress_response,payload.ota_slave_progress_response), 16) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,led_ring_progress_request,payload.led_ring_progress_request), 17) \ +X(a, STATIC, ONEOF, MESSAGE, (payload,led_ring_progress_response,payload.led_ring_progress_response), 18) #define alox_UartMessage_CALLBACK NULL #define alox_UartMessage_DEFAULT NULL #define alox_UartMessage_payload_ack_payload_MSGTYPE alox_Ack @@ -337,6 +383,8 @@ X(a, STATIC, ONEOF, MESSAGE, (payload,ota_slave_progress_response,payload. #define alox_UartMessage_payload_espnow_unicast_test_response_MSGTYPE alox_EspNowUnicastTestResponse #define alox_UartMessage_payload_ota_slave_progress_request_MSGTYPE alox_OtaSlaveProgressRequest #define alox_UartMessage_payload_ota_slave_progress_response_MSGTYPE alox_OtaSlaveProgressResponse +#define alox_UartMessage_payload_led_ring_progress_request_MSGTYPE alox_LedRingProgressRequest +#define alox_UartMessage_payload_led_ring_progress_response_MSGTYPE alox_LedRingProgressResponse #define alox_Ack_FIELDLIST(X, a) \ @@ -414,6 +462,25 @@ X(a, STATIC, SINGULAR, UINT32, seq, 2) #define alox_EspNowUnicastTestResponse_CALLBACK NULL #define alox_EspNowUnicastTestResponse_DEFAULT NULL +#define alox_LedRingProgressRequest_FIELDLIST(X, a) \ +X(a, STATIC, SINGULAR, UINT32, mode, 1) \ +X(a, STATIC, SINGULAR, UINT32, progress, 2) \ +X(a, STATIC, SINGULAR, UINT32, digit, 3) \ +X(a, STATIC, SINGULAR, UINT32, r, 4) \ +X(a, STATIC, SINGULAR, UINT32, g, 5) \ +X(a, STATIC, SINGULAR, UINT32, b, 6) \ +X(a, STATIC, SINGULAR, UINT32, intensity, 7) +#define alox_LedRingProgressRequest_CALLBACK NULL +#define alox_LedRingProgressRequest_DEFAULT NULL + +#define alox_LedRingProgressResponse_FIELDLIST(X, a) \ +X(a, STATIC, SINGULAR, BOOL, success, 1) \ +X(a, STATIC, SINGULAR, UINT32, mode, 2) \ +X(a, STATIC, SINGULAR, UINT32, progress, 3) \ +X(a, STATIC, SINGULAR, UINT32, digit, 4) +#define alox_LedRingProgressResponse_CALLBACK NULL +#define alox_LedRingProgressResponse_DEFAULT NULL + #define alox_OtaStartPayload_FIELDLIST(X, a) \ X(a, STATIC, SINGULAR, UINT32, total_size, 1) #define alox_OtaStartPayload_CALLBACK NULL @@ -474,6 +541,8 @@ extern const pb_msgdesc_t alox_AccelDeadzoneRequest_msg; extern const pb_msgdesc_t alox_AccelDeadzoneResponse_msg; extern const pb_msgdesc_t alox_EspNowUnicastTestRequest_msg; extern const pb_msgdesc_t alox_EspNowUnicastTestResponse_msg; +extern const pb_msgdesc_t alox_LedRingProgressRequest_msg; +extern const pb_msgdesc_t alox_LedRingProgressResponse_msg; extern const pb_msgdesc_t alox_OtaStartPayload_msg; extern const pb_msgdesc_t alox_OtaPayload_msg; extern const pb_msgdesc_t alox_OtaEndPayload_msg; @@ -495,6 +564,8 @@ extern const pb_msgdesc_t alox_OtaSlaveProgressResponse_msg; #define alox_AccelDeadzoneResponse_fields &alox_AccelDeadzoneResponse_msg #define alox_EspNowUnicastTestRequest_fields &alox_EspNowUnicastTestRequest_msg #define alox_EspNowUnicastTestResponse_fields &alox_EspNowUnicastTestResponse_msg +#define alox_LedRingProgressRequest_fields &alox_LedRingProgressRequest_msg +#define alox_LedRingProgressResponse_fields &alox_LedRingProgressResponse_msg #define alox_OtaStartPayload_fields &alox_OtaStartPayload_msg #define alox_OtaPayload_fields &alox_OtaPayload_msg #define alox_OtaEndPayload_fields &alox_OtaEndPayload_msg @@ -517,6 +588,8 @@ extern const pb_msgdesc_t alox_OtaSlaveProgressResponse_msg; #define alox_ClientInput_size 22 #define alox_EspNowUnicastTestRequest_size 12 #define alox_EspNowUnicastTestResponse_size 8 +#define alox_LedRingProgressRequest_size 42 +#define alox_LedRingProgressResponse_size 20 #define alox_OtaEndPayload_size 0 #define alox_OtaPayload_size 209 #define alox_OtaSlaveProgressEntry_size 30 diff --git a/main/proto/uart_messages.proto b/main/proto/uart_messages.proto index da19a47..dc04666 100644 --- a/main/proto/uart_messages.proto +++ b/main/proto/uart_messages.proto @@ -13,6 +13,7 @@ enum MessageType { CLIENT_INPUT = 5; ACCEL_DEADZONE = 6; ESPNOW_UNICAST_TEST = 7; + LED_RING = 8; OTA_START = 16; OTA_PAYLOAD = 17; OTA_END = 18; @@ -39,6 +40,8 @@ message UartMessage { EspNowUnicastTestResponse espnow_unicast_test_response = 14; OtaSlaveProgressRequest ota_slave_progress_request = 15; OtaSlaveProgressResponse ota_slave_progress_response = 16; + LedRingProgressRequest led_ring_progress_request = 17; + LedRingProgressResponse led_ring_progress_response = 18; } } @@ -107,6 +110,28 @@ message EspNowUnicastTestResponse { uint32 seq = 2; } +// Host → device: LED ring display (progress bar, digit, or clear). +// mode: 0=clear, 1=progress (0–100 %), 2=digit (0–10, same layout as firmware digit maps). +message LedRingProgressRequest { + uint32 mode = 1; + /** 0–100: fraction of ring LEDs to light (mode=progress) */ + uint32 progress = 2; + /** 0–10 (mode=digit) */ + uint32 digit = 3; + uint32 r = 4; + uint32 g = 5; + uint32 b = 6; + /** 0–255 brightness scale applied to r/g/b */ + uint32 intensity = 7; +} + +message LedRingProgressResponse { + bool success = 1; + uint32 mode = 2; + uint32 progress = 3; + uint32 digit = 4; +} + // Host → device: begin UART OTA (erase inactive OTA slot; device replies OTA_STATUS). message OtaStartPayload { uint32 total_size = 1;