skruecken/esp_alox
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Added Test Data Message for Game Development Testing

Browse Source
This commit is contained in:
simon 2025-09-27 15:57:52 +02:00
parent df35def702
commit 7097e9e7ab
3 changed files with 123 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

87
goTool/main.go
View File

@ -6,7 +6,9 @@ import (
"flag"
"fmt"
"log"
"math"
"os"
"strconv"
"time"
"github.com/pterm/pterm"
@ -17,9 +19,10 @@ type ParserState int
const (
// MISC
UART_ECHO = 0x01
UART_VERSION = 0x02
UART_CLIENT_INFO = 0x03
UART_ECHO = 0x01
UART_VERSION = 0x02
UART_CLIENT_INFO = 0x03
UART_CLIENT_INPUT = 0x04
// OTA
UART_OTA_START = 0x10
@ -199,30 +202,63 @@ func parse_uart_client_info_payload(payloadBuffer []byte, payload_len int) {
}
}
func parse_uart_client_input(payloadBuffer []byte, payload_len int) {
clientCount := payloadBuffer[1]
fmt.Printf("Client Count %d\n", clientCount)
clientInputLen := 13
for i := 0; i < int(clientCount); i++ {
offset := 2 + (i * clientInputLen)
// --- Client ID (uint8) ---
clientID := payloadBuffer[offset]
offset += 1
fmt.Printf("Client: %d\n", clientID)
// --- Lage X (float32) ---
xBits := binary.LittleEndian.Uint32(payloadBuffer[offset : offset+4])
lageX := math.Float32frombits(xBits)
offset += 4
fmt.Printf("\tLAGE_X: %f\n", lageX)
// --- Lage Y (float32) ---
yBits := binary.LittleEndian.Uint32(payloadBuffer[offset : offset+4])
lageY := math.Float32frombits(yBits)
offset += 4
fmt.Printf("\tLAGE_Y: %f\n", lageY)
// --- Bitmask (int32) ---
maskBits := binary.LittleEndian.Uint32(payloadBuffer[offset : offset+4])
bitmask := uint32(maskBits)
offset += 4
fmt.Printf("\tBITMASK: %032b\n", bitmask)
}
}
func message_receive_callback(mr MessageReceive) {
log.Printf("Message Received: % 02X\n", mr.raw_message[:mr.raw_write_index])
switch mr.parsed_message[0] {
case byte(UART_ECHO):
break
case UART_VERSION:
parse_uart_version_payload(mr.parsed_message, mr.write_index)
break
case UART_CLIENT_INFO:
parse_uart_client_info_payload(mr.parsed_message, mr.write_index)
break
case UART_OTA_START:
OTA_UpdateHandler.NewOTAMessage <- mr
break
case UART_OTA_PAYLOAD:
parse_uart_ota_payload_payload(mr.parsed_message, mr.write_index)
OTA_UpdateHandler.NewOTAMessage <- mr
break
case UART_OTA_END:
OTA_UpdateHandler.NewOTAMessage <- mr
break
case UART_OTA_STATUS:
OTA_UpdateHandler.NewOTAMessage <- mr
break
case UART_CLIENT_INPUT:
parse_uart_client_input(mr.parsed_message, mr.write_index)
}
}
@ -240,7 +276,6 @@ func parseByte(mr *MessageReceive, pbyte byte) {
addByteToRawBuffer(mr, pbyte)
}
// ignore every other byte
break
case GET_MESSAGE_ID:
if pbyte == ESCAPE_BYTE {
mr.state = ESCAPED_MESSAGE_ID
@ -248,11 +283,9 @@ func parseByte(mr *MessageReceive, pbyte byte) {
addByteToParsedBuffer(mr, pbyte)
mr.state = IN_PAYLOD
}
break
case ESCAPED_MESSAGE_ID:
addByteToParsedBuffer(mr, pbyte)
mr.state = IN_PAYLOD
break
case IN_PAYLOD:
if pbyte == ESCAPE_BYTE {
mr.state = ESCAPED_PAYLOAD_BYTE
@ -277,11 +310,9 @@ func parseByte(mr *MessageReceive, pbyte byte) {
}
// normal case
addByteToParsedBuffer(mr, pbyte)
break
case ESCAPED_PAYLOAD_BYTE:
addByteToParsedBuffer(mr, pbyte)
mr.state = IN_PAYLOD
break
default:
panic(fmt.Sprintf("unexpected main.ParserState: %#v", mr.state))
}
@ -454,9 +485,11 @@ func main() {
for {
var input string
_, err := fmt.Scanln(&input)
var input2 string
_, err := fmt.Scanln(&input, &input2)
if err != nil {
log.Fatalf("Could not read from stdin")
log.Fatalf("Could not read from stdin %v", err)
return
}
fmt.Printf("Input %v", input)
@ -469,28 +502,24 @@ func main() {
payload_buffer[0] = UART_ECHO
n := buildMessage(payload_buffer, 1, send_buffer)
sendMessage(port, send_buffer[:n])
break
case "2":
payload_buffer := make([]byte, 1024)
send_buffer := make([]byte, 1024)
payload_buffer[0] = UART_VERSION
n := buildMessage(payload_buffer, 1, send_buffer)
sendMessage(port, send_buffer[:n])
break
case "3":
payload_buffer := make([]byte, 1024)
send_buffer := make([]byte, 1024)
payload_buffer[0] = UART_CLIENT_INFO
n := buildMessage(payload_buffer, 1, send_buffer)
sendMessage(port, send_buffer[:n])
break
case "4": // start update
payload_buffer := make([]byte, 1024)
send_buffer := make([]byte, 1024)
payload_buffer[0] = UART_OTA_START
n := buildMessage(payload_buffer, 1, send_buffer)
sendMessage(port, send_buffer[:n])
break
case "5": // send payload
payload_buffer := make([]byte, 1024)
send_buffer := make([]byte, 1024)
@ -500,15 +529,25 @@ func main() {
}
n := buildMessage(payload_buffer, 201, send_buffer)
sendMessage(port, send_buffer[:n])
break
case "6": // end update
case "7": // Start OTA for ESP-NOW clients
payload_buffer := make([]byte, 1024)
send_buffer := make([]byte, 1024)
payload_buffer[0] = UART_OTA_START_ESPNOW // Use the new constant
payload_buffer[0] = UART_OTA_START_ESPNOW
n := buildMessage(payload_buffer, 1, send_buffer)
sendMessage(port, send_buffer[:n])
break
case "8": // Get Fake Client Input
payload_buffer := make([]byte, 1024)
send_buffer := make([]byte, 1024)
payload_buffer[0] = UART_CLIENT_INPUT
seed, err := strconv.Atoi(input2)
if err != nil {
log.Printf("Could not parse %v to a number", input2)
return
}
payload_buffer[1] = byte(seed)
n := buildMessage(payload_buffer, 2, send_buffer)
sendMessage(port, send_buffer[:n])
default:
fmt.Printf("Not a valid input")
}

59
main/main.c
View File

@ -42,6 +42,64 @@ static ESP_MessageBrokerTaskParams_t esp_broker_task_params;
ClientList clientList = {.Clients = {{0}}, .ClientCount = 0};
size_t build_ClientInfoPart(uint8_t clientid, float_t lagex, float_t lagey,
int32_t bitmask, uint8_t *outputArray,
size_t outputArrayOffset, size_t outputArraySize) {
size_t offset = outputArrayOffset;
memcpy(&outputArray[offset], &clientid, sizeof(clientid));
offset += sizeof(clientid);
// lagex (typischerweise 4 Bytes)
memcpy(&outputArray[offset], &lagex, sizeof(lagex));
offset += sizeof(lagex);
// lagey (typischerweise 4 Bytes)
memcpy(&outputArray[offset], &lagey, sizeof(lagey));
offset += sizeof(lagey);
// bitmask (4 Bytes)
memcpy(&outputArray[offset], &bitmask, sizeof(bitmask));
offset += sizeof(bitmask);
return offset - outputArrayOffset;
}
void fakeDataCallback(uint8_t msgid, const uint8_t *payload, size_t payload_len,
uint8_t *send_payload_buffer,
size_t send_payload_buffer_size, uint8_t *send_buffer,
size_t send_buffer_size) {
uint8_t seed = payload[1];
ESP_LOGI(TAG, "Sending Fake Client Infos with seed %d", seed);
srand(seed);
size_t offset = 1;
send_payload_buffer[0] = 3; // Client Count
offset +=
build_ClientInfoPart(1, rand() * 1.0, rand() * 1.0, rand() * 1,
send_payload_buffer, 1, send_payload_buffer_size);
offset += build_ClientInfoPart(2, rand() * 2.0, rand() * 2.0, rand() * 2,
send_payload_buffer, offset,
send_payload_buffer_size);
offset += build_ClientInfoPart(3, rand() * 3.0, rand() * 3.0, rand() * 3,
send_payload_buffer, offset,
send_payload_buffer_size);
int len = build_message(UART_CLIENT_INPUT, send_payload_buffer, offset,
send_buffer, send_buffer_size);
if (len < 0) {
ESP_LOGE(TAG,
"Error Building UART Message: payload_len, %d, sendbuffer_size: "
"%d, mes_len(error): %d",
payload_len, send_buffer_size, len);
return;
}
uart_write_bytes(MASTER_UART, send_buffer, len);
}
void echoCallback(uint8_t msgid, const uint8_t *payload, size_t payload_len,
uint8_t *send_payload_buffer, size_t send_payload_buffer_size,
uint8_t *send_buffer, size_t send_buffer_size) {
@ -310,6 +368,7 @@ void app_main(void) {
RegisterCallback(0x01, echoCallback);
RegisterCallback(0x02, versionCallback);
RegisterCallback(0x03, clientInfoCallback);
RegisterCallback(0x04, fakeDataCallback);
RegisterCallback(UART_OTA_START_ESPNOW, start_ota_update_espnow);
init_ota();

1
main/uart_msg_ids.h
View File

@ -6,6 +6,7 @@ enum UART_MSG_IDS {
UART_ECHO = 0x01,
UART_VERSION = 0x02,
UART_CLIENT_INFO = 0x03,
UART_CLIENT_INPUT = 0x04,
// OTA
UART_OTA_START = 0x10,