695 lines
19 KiB
C
695 lines
19 KiB
C
#include <zephyr/kernel.h>
|
|
#include <zephyr/logging/log.h>
|
|
#include <zephyr/logging/log_ctrl.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <fs.h>
|
|
#include <app_version.h>
|
|
#include <zephyr/sys/crc.h>
|
|
#include <zephyr/dfu/mcuboot.h>
|
|
|
|
#include <utils.h>
|
|
#include <usb.h>
|
|
#include <protocol.h>
|
|
#include <audio.h>
|
|
|
|
#define PROTOCOL_VERSION 2
|
|
|
|
LOG_MODULE_REGISTER(protocol, LOG_LEVEL_DBG);
|
|
|
|
#define PROTOCOL_STACK_SIZE 2048
|
|
#define PROTOCOL_PRIORITY 6
|
|
#define BUFFER_SIZE 256
|
|
|
|
static uint8_t buffer[BUFFER_SIZE];
|
|
static volatile uint32_t rx_index = 0;
|
|
|
|
static protocol_state_t current_protocol_state = PS_WAITING_FOR_COMMAND;
|
|
static protocol_cmd_t current_command = CMD_INVALID;
|
|
|
|
void send_ok()
|
|
{
|
|
const char *response = "OK\n";
|
|
LOG_DBG("Sending response: OK");
|
|
usb_write_buffer((const uint8_t *)response, strlen(response));
|
|
}
|
|
|
|
static protocol_error_t protocol_map_error(int32_t rc)
|
|
{
|
|
if (rc == 0)
|
|
{
|
|
return P_ERR_NONE;
|
|
}
|
|
|
|
int32_t err = rc < 0 ? -rc : rc;
|
|
|
|
switch (err)
|
|
{
|
|
case ENOENT:
|
|
return P_ERR_FILE_NOT_FOUND;
|
|
case EEXIST:
|
|
return P_ERR_ALREADY_EXISTS;
|
|
case ENOTDIR:
|
|
return P_ERR_NOT_A_DIRECTORY;
|
|
case EISDIR:
|
|
return P_ERR_IS_A_DIRECTORY;
|
|
case EACCES:
|
|
case EPERM:
|
|
return P_ERR_ACCESS_DENIED;
|
|
case ENOSPC:
|
|
return P_ERR_NO_SPACE;
|
|
case EFBIG:
|
|
return P_ERR_FILE_TOO_LARGE;
|
|
case ETIMEDOUT:
|
|
return P_ERR_TIMEOUT;
|
|
case EMSGSIZE:
|
|
return P_ERR_COMMAND_TOO_LONG;
|
|
case EINVAL:
|
|
return P_ERR_INVALID_PARAMETERS;
|
|
case EILSEQ:
|
|
return P_ERR_INVALID_COMMAND;
|
|
case ECANCELED:
|
|
return P_ERR_TRANSFER_ABORTED;
|
|
case ENOSYS:
|
|
case ENOTSUP:
|
|
return P_ERR_NOT_SUPPORTED;
|
|
case EBUSY:
|
|
return P_ERR_BUSY;
|
|
case EBADMSG:
|
|
return P_ERR_CRC_MISMATCH;
|
|
case EIO:
|
|
return P_ERR_IO;
|
|
default:
|
|
return P_ERR_INTERNAL;
|
|
}
|
|
}
|
|
|
|
void send_error(protocol_error_t error_code)
|
|
{
|
|
char response[32];
|
|
snprintf(response, sizeof(response), "ERR %d\n", error_code);
|
|
LOG_DBG("Sending response: ERR %d", error_code);
|
|
usb_write_buffer((const uint8_t *)response, strlen(response));
|
|
}
|
|
|
|
int cmd_ls(const char *path)
|
|
{
|
|
struct fs_dir_t dirp;
|
|
struct fs_dirent entry;
|
|
const char *ls_path = (path == NULL || path[0] == '\0') ? "/" : path;
|
|
fs_dir_t_init(&dirp);
|
|
|
|
if (fs_pm_opendir(&dirp, ls_path) < 0)
|
|
{
|
|
LOG_ERR("Failed to open directory '%s'", ls_path);
|
|
return -ENOENT;
|
|
}
|
|
|
|
char tx_buffer[300];
|
|
while (fs_readdir(&dirp, &entry) == 0 && entry.name[0] != '\0')
|
|
{
|
|
snprintf(tx_buffer, sizeof(tx_buffer), "%s,%u,%s\n", entry.type == FS_DIR_ENTRY_FILE ? "F" : "D", entry.size, entry.name);
|
|
usb_write_buffer((const uint8_t *)tx_buffer, strlen(tx_buffer));
|
|
}
|
|
|
|
fs_pm_closedir(&dirp);
|
|
return 0;
|
|
}
|
|
|
|
int cmd_info()
|
|
{
|
|
char info[112];
|
|
struct fs_statvfs stat;
|
|
int rc = fs_pm_statvfs("/lfs", &stat);
|
|
if (rc)
|
|
{
|
|
LOG_ERR("Failed to get filesystem stats: %d", rc);
|
|
return rc;
|
|
}
|
|
snprintf(info, sizeof(info), "%u;%s;%lu;%lu;%lu;%s\n", PROTOCOL_VERSION, APP_VERSION_STRING, stat.f_frsize, stat.f_blocks, stat.f_bfree, boot_is_img_confirmed() ? "CONFIRMED" : "UNCONFIRMED");
|
|
usb_write_buffer((const uint8_t *)info, strlen(info));
|
|
return 0;
|
|
}
|
|
|
|
int cmd_put_binary_file(const char *filename, ssize_t filesize, uint32_t expected_crc32)
|
|
{
|
|
int rc;
|
|
ssize_t bytes_written = 0;
|
|
uint32_t running_crc32 = 0;
|
|
uint32_t retry_count = 0;
|
|
size_t accumulated = 0;
|
|
struct fs_file_t file;
|
|
bool firmware_update = false;
|
|
|
|
if (strcmp(filename, "update.bin") == 0 ||
|
|
strcmp(filename, "firmware.bin") == 0 ||
|
|
strcmp(filename, "update") == 0 ||
|
|
strcmp(filename, "firmware") == 0)
|
|
{
|
|
firmware_update = true;
|
|
LOG_INF("Firmware update requested with file '%s'", filename);
|
|
}
|
|
|
|
if (firmware_update)
|
|
{
|
|
slot_info_t slot1_info;
|
|
rc = flash_get_slot_info(&slot1_info);
|
|
if (rc < 0)
|
|
{
|
|
LOG_ERR("Failed to get slot 1 info: %d", rc);
|
|
return rc;
|
|
}
|
|
if (filesize > slot1_info.size)
|
|
{
|
|
LOG_ERR("File size %zd exceeds slot 1 size %zu", filesize, slot1_info.size);
|
|
return -EFBIG;
|
|
}
|
|
flash_init_firmware_upload();
|
|
}
|
|
else
|
|
{
|
|
fs_file_t_init(&file);
|
|
fs_pm_unlink(filename);
|
|
LOG_DBG("Opening file '%s' for writing (expected size: %zd bytes, expected CRC32: 0x%08x)", filename, filesize, expected_crc32);
|
|
rc = fs_pm_open(&file, filename, FS_O_CREATE | FS_O_WRITE);
|
|
if (rc < 0)
|
|
{
|
|
LOG_ERR("Failed to open file '%s' for writing: %d", filename, rc);
|
|
return rc;
|
|
}
|
|
}
|
|
usb_write_buffer((const uint8_t *)"READY\n", 6);
|
|
|
|
uint32_t start = k_uptime_get_32();
|
|
while (bytes_written < filesize)
|
|
{
|
|
/* Nur so viel lesen, wie in den restlichen Puffer passt (oder bis zum Dateiende) */
|
|
size_t remaining_file = filesize - bytes_written - accumulated;
|
|
size_t to_read = MIN(sizeof(buffer) - accumulated, remaining_file);
|
|
|
|
ssize_t read = usb_read_buffer(buffer + accumulated, to_read);
|
|
|
|
if (read < 0)
|
|
{
|
|
LOG_ERR("Error reading from USB: %d", read);
|
|
if (firmware_update)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
fs_pm_close(&file);
|
|
}
|
|
return (int)read;
|
|
}
|
|
else if (read == 0)
|
|
{
|
|
if (retry_count >= 10)
|
|
{
|
|
LOG_ERR("No data received from USB after multiple attempts");
|
|
if (firmware_update)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
fs_pm_close(&file);
|
|
}
|
|
return -ETIMEDOUT;
|
|
}
|
|
|
|
usb_resume_rx();
|
|
if ((bytes_written + accumulated) == 0)
|
|
{
|
|
usb_wait_for_data(K_SECONDS(1));
|
|
}
|
|
else
|
|
{
|
|
usb_wait_for_data(K_MSEC(100));
|
|
}
|
|
retry_count++;
|
|
continue;
|
|
}
|
|
|
|
/* Wir haben Daten bekommen: Zähler hochsetzen und USB weiterlauschen lassen */
|
|
accumulated += read;
|
|
retry_count = 0;
|
|
usb_resume_rx();
|
|
|
|
/* SCHREIBEN: Erst auf den Flash schreiben, wenn der Puffer voll ist (4096 Bytes)
|
|
ODER wenn wir das Ende der Datei erreicht haben. */
|
|
if (accumulated == sizeof(buffer) || (bytes_written + accumulated) == filesize)
|
|
{
|
|
if (firmware_update)
|
|
{
|
|
int rc = flash_write_firmware_block(buffer, accumulated, (bytes_written + accumulated) == filesize);
|
|
if (rc < 0)
|
|
{
|
|
LOG_ERR("Error writing to flash: %d", rc);
|
|
return rc;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ssize_t written = fs_write(&file, buffer, accumulated);
|
|
if (written < 0)
|
|
{
|
|
LOG_ERR("Error writing to file '%s': %d", filename, (int)written);
|
|
fs_pm_close(&file);
|
|
return (int)written;
|
|
}
|
|
}
|
|
/* CRC erst nach dem erfolgreichen Block-Schreiben berechnen */
|
|
running_crc32 = crc32_ieee_update(running_crc32, buffer, accumulated);
|
|
bytes_written += accumulated;
|
|
|
|
/* Puffer für die nächste Runde leeren */
|
|
accumulated = 0;
|
|
}
|
|
}
|
|
|
|
uint32_t duration = k_uptime_get_32() - start;
|
|
uint32_t kb_per_s = (filesize * 1000) / (duration * 1024 + 1);
|
|
LOG_DBG("Received file '%s' (%zd bytes) in %u ms (%u kb/s), CRC32: 0x%08x", filename, filesize, duration, kb_per_s, running_crc32);
|
|
if (firmware_update)
|
|
{
|
|
int rc;
|
|
rc = boot_request_upgrade(BOOT_UPGRADE_TEST);
|
|
if (rc < 0)
|
|
{
|
|
LOG_ERR("Failed to request firmware upgrade: %d", rc);
|
|
return rc;
|
|
}
|
|
send_ok();
|
|
LOG_INF("Firmware upgrade requested, rebooting into bootloader...");
|
|
reboot_with_status(REBOOT_STATUS_FIRMWARE_UPDATE);
|
|
}
|
|
else
|
|
{
|
|
fs_pm_close(&file);
|
|
LOG_DBG("Closed file '%s' after writing", filename);
|
|
}
|
|
|
|
if (running_crc32 != expected_crc32)
|
|
{
|
|
LOG_ERR("CRC32 mismatch for file '%s': expected 0x%08x, got 0x%08x", filename, expected_crc32, running_crc32);
|
|
return -EBADMSG;
|
|
}
|
|
LOG_DBG("File '%s' received successfully with matching CRC32", filename);
|
|
return 0;
|
|
}
|
|
|
|
int cmd_mkdir(const char *path)
|
|
{
|
|
int rc = fs_pm_mkdir(path);
|
|
if (rc < 0)
|
|
{
|
|
LOG_ERR("Failed to create directory '%s': %d", path, rc);
|
|
}
|
|
LOG_DBG("Directory '%s' created successfully", path);
|
|
return rc;
|
|
}
|
|
|
|
int cmd_rm(const char *path)
|
|
{
|
|
int rc = fs_pm_unlink(path);
|
|
if (rc < 0)
|
|
{
|
|
LOG_ERR("Failed to remove '%s': %d", path, rc);
|
|
}
|
|
LOG_DBG("'%s' removed successfully", path);
|
|
return rc;
|
|
}
|
|
|
|
int cmd_confirm_firmware()
|
|
{
|
|
if (!boot_is_img_confirmed())
|
|
{
|
|
int rc = boot_write_img_confirmed();
|
|
if (rc < 0)
|
|
{
|
|
LOG_ERR("Failed to confirm firmware: %d", rc);
|
|
return rc;
|
|
}
|
|
LOG_INF("Firmware confirmed successfully");
|
|
send_ok();
|
|
audio_play("/lfs/sys/confirm");
|
|
}
|
|
else
|
|
{
|
|
LOG_INF("Firmware is already confirmed, no action taken");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int cmd_reboot_device()
|
|
{
|
|
LOG_INF("Rebooting device as requested by host...");
|
|
send_ok();
|
|
reboot_with_status(REBOOT_STATUS_NORMAL);
|
|
return 0; // Dieser Code wird nie erreicht, aber wir geben ihn der Vollständigkeit halber zurück
|
|
}
|
|
|
|
void cmd_play(const char *filename)
|
|
{
|
|
LOG_DBG("Play command received with filename: '%s'", filename);
|
|
audio_stop();
|
|
audio_play(filename);
|
|
}
|
|
|
|
int cmd_check(const char *param)
|
|
{
|
|
LOG_DBG("Check command received with parameter: '%s'", param);
|
|
struct fs_file_t file;
|
|
fs_file_t_init(&file);
|
|
int rc = fs_pm_open(&file, param, FS_O_READ);
|
|
if (rc < 0)
|
|
{
|
|
LOG_ERR("Check failed: file '%s' not found", param);
|
|
return -ENOENT;
|
|
}
|
|
uint32_t crc32 = 0;
|
|
uint32_t start_time = k_uptime_get_32();
|
|
uint8_t buffer[256];
|
|
ssize_t read;
|
|
while ((read = fs_read(&file, buffer, sizeof(buffer))) > 0)
|
|
{
|
|
crc32 = crc32_ieee_update(crc32, buffer, read);
|
|
}
|
|
fs_pm_close(&file);
|
|
if (read < 0)
|
|
{
|
|
LOG_ERR("Check failed: error reading file '%s': %d", param, (int)read);
|
|
return (int)read;
|
|
}
|
|
uint32_t duration = k_uptime_get_32() - start_time;
|
|
LOG_DBG("Check successful: file '%s' has CRC32 0x%08x, check took %u ms", param, crc32, duration);
|
|
char response[64];
|
|
snprintf(response, sizeof(response), "CRC32 %s 0x%08x\n", param, crc32);
|
|
usb_write_buffer((const uint8_t *)response, strlen(response));
|
|
return 0;
|
|
}
|
|
|
|
void execute_current_command(void)
|
|
{
|
|
int rc;
|
|
switch (current_command)
|
|
{
|
|
case CMD_LS:
|
|
LOG_DBG("Executing LS command with parameters: '%s'", buffer);
|
|
rc = cmd_ls((char *)buffer);
|
|
if (rc == 0)
|
|
{
|
|
send_ok();
|
|
}
|
|
else
|
|
{
|
|
send_error(protocol_map_error(rc));
|
|
}
|
|
break;
|
|
case CMD_INFO:
|
|
if (buffer[0] != '\0')
|
|
{
|
|
LOG_WRN("INFO command received with unexpected parameters: '%s'", buffer);
|
|
}
|
|
LOG_DBG("Executing INFO command");
|
|
rc = cmd_info();
|
|
if (rc == 0)
|
|
{
|
|
send_ok();
|
|
}
|
|
else
|
|
{
|
|
send_error(protocol_map_error(rc));
|
|
}
|
|
break;
|
|
case CMD_PUT_BINARY_FILE:
|
|
char filename[128];
|
|
ssize_t filesize;
|
|
uint32_t crc32;
|
|
|
|
rc = sscanf((char *)buffer, "%127[^;];%zd;%i", filename, &filesize, &crc32);
|
|
if (rc != 3)
|
|
{
|
|
LOG_ERR("Invalid parameters for PUT_BINARY_FILE command (got %d): '%s'", rc, buffer);
|
|
send_error(P_ERR_INVALID_PARAMETERS);
|
|
break;
|
|
}
|
|
LOG_DBG("Executing PUT_BINARY_FILE command filename: '%s', filesize: %zd, crc32: 0x%08x", filename, filesize, crc32);
|
|
rc = cmd_put_binary_file(filename, filesize, crc32);
|
|
if (rc == 0)
|
|
{
|
|
send_ok();
|
|
audio_refresh_file_count(); // Nach erfolgreichem Upload die Anzahl der verfügbaren Audiodateien aktualisieren
|
|
}
|
|
else
|
|
{
|
|
usb_flush_rx();
|
|
send_error(protocol_map_error(rc));
|
|
}
|
|
break;
|
|
case CMD_MKDIR:
|
|
LOG_DBG("Executing MKDIR command with parameters: '%s'", buffer);
|
|
rc = cmd_mkdir((char *)buffer);
|
|
if (rc == 0)
|
|
{
|
|
send_ok();
|
|
}
|
|
else
|
|
{
|
|
send_error(protocol_map_error(rc));
|
|
}
|
|
break;
|
|
case CMD_RM:
|
|
LOG_DBG("Executing RM command with parameters: '%s'", buffer);
|
|
rc = cmd_rm((char *)buffer);
|
|
if (rc == 0)
|
|
{
|
|
send_ok();
|
|
audio_refresh_file_count(); // Nach erfolgreichem Löschen die Anzahl der verfügbaren Audiodateien aktualisieren
|
|
}
|
|
else
|
|
{
|
|
send_error(protocol_map_error(rc));
|
|
}
|
|
break;
|
|
case CMD_CONFIRM:
|
|
LOG_DBG("Executing CONFIRM command");
|
|
rc = cmd_confirm_firmware();
|
|
if (rc != 0)
|
|
{
|
|
send_error(protocol_map_error(rc));
|
|
break;
|
|
}
|
|
send_ok();
|
|
break;
|
|
case CMD_REBOOT:
|
|
LOG_DBG("Executing REBOOT command");
|
|
rc = cmd_reboot_device();
|
|
if (rc != 0)
|
|
{
|
|
send_error(protocol_map_error(rc));
|
|
}
|
|
break;
|
|
case CMD_PLAY:
|
|
LOG_DBG("Executing PLAY command");
|
|
cmd_play((char *)buffer);
|
|
send_ok();
|
|
break;
|
|
case CMD_CHECK:
|
|
LOG_DBG("Executing CHECK command");
|
|
rc = cmd_check((char *)buffer);
|
|
if (rc == 0)
|
|
{
|
|
send_ok();
|
|
}
|
|
else
|
|
{
|
|
send_error(protocol_map_error(rc));
|
|
}
|
|
break;
|
|
default:
|
|
LOG_ERR("No execution logic for command %d", current_command);
|
|
send_error(P_ERR_NOT_SUPPORTED);
|
|
break;
|
|
}
|
|
}
|
|
|
|
protocol_state_t waiting_for_command(uint8_t byte)
|
|
{
|
|
if (byte < 'a' || byte > 'z')
|
|
{
|
|
LOG_DBG("Ignoring non-command byte: 0x%02x", byte); // Nur aktivieren, wenn nötig!
|
|
rx_index = 0;
|
|
return PS_WAITING_FOR_COMMAND;
|
|
}
|
|
buffer[rx_index++] = byte;
|
|
return PS_READING_COMMAND;
|
|
}
|
|
|
|
protocol_state_t reading_command(uint8_t byte)
|
|
{
|
|
if (byte == ' ' || byte == '\n' || byte == '\r')
|
|
{
|
|
buffer[rx_index] = '\0';
|
|
rx_index = 0;
|
|
|
|
if (strcmp((char *)buffer, "ls") == 0)
|
|
{
|
|
LOG_DBG("Received LS command");
|
|
current_command = CMD_LS;
|
|
}
|
|
else if (strcmp((char *)buffer, "info") == 0)
|
|
{
|
|
LOG_DBG("Received INFO command");
|
|
current_command = CMD_INFO;
|
|
}
|
|
else if (strcmp((char *)buffer, "put") == 0)
|
|
{
|
|
LOG_DBG("Received PUT_BINARY_FILE command");
|
|
current_command = CMD_PUT_BINARY_FILE;
|
|
}
|
|
else if (strcmp((char *)buffer, "mkdir") == 0)
|
|
{
|
|
LOG_DBG("Received MKDIR command");
|
|
current_command = CMD_MKDIR;
|
|
}
|
|
else if (strcmp((char *)buffer, "rm") == 0)
|
|
{
|
|
LOG_DBG("Received RM command");
|
|
current_command = CMD_RM;
|
|
}
|
|
else if (strcmp((char *)buffer, "confirm") == 0)
|
|
{
|
|
LOG_DBG("Received CONFIRM command");
|
|
current_command = CMD_CONFIRM;
|
|
}
|
|
else if (strcmp((char *)buffer, "reboot") == 0)
|
|
{
|
|
LOG_DBG("Received REBOOT command");
|
|
current_command = CMD_REBOOT;
|
|
}
|
|
else if (strcmp((char *)buffer, "play") == 0)
|
|
{
|
|
LOG_DBG("Received PLAY command");
|
|
current_command = CMD_PLAY;
|
|
}
|
|
else if (strcmp((char *)buffer, "check") == 0)
|
|
{
|
|
LOG_DBG("Received CHECK command");
|
|
current_command = CMD_CHECK;
|
|
}
|
|
else
|
|
{
|
|
LOG_DBG("Unknown command: %s", buffer);
|
|
current_command = CMD_INVALID;
|
|
send_error(P_ERR_INVALID_COMMAND);
|
|
if (byte != '\n' && byte != '\r')
|
|
return PS_WAITING_FOR_END_OF_LINE;
|
|
return PS_WAITING_FOR_COMMAND;
|
|
}
|
|
|
|
if (byte == ' ')
|
|
{
|
|
rx_index = 0;
|
|
return PS_READING_PARAMETERS;
|
|
}
|
|
else
|
|
{
|
|
buffer[0] = '\0';
|
|
rx_index = 0;
|
|
execute_current_command();
|
|
return PS_WAITING_FOR_COMMAND;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (rx_index < BUFFER_SIZE - 1)
|
|
{
|
|
buffer[rx_index++] = byte;
|
|
}
|
|
else
|
|
{
|
|
send_error(P_ERR_COMMAND_TOO_LONG);
|
|
return PS_WAITING_FOR_END_OF_LINE;
|
|
}
|
|
}
|
|
return PS_READING_COMMAND;
|
|
}
|
|
|
|
protocol_state_t reading_parameters(uint8_t byte)
|
|
{
|
|
if (byte == '\n' || byte == '\r')
|
|
{
|
|
buffer[rx_index] = '\0';
|
|
rx_index = 0;
|
|
execute_current_command();
|
|
return PS_WAITING_FOR_COMMAND;
|
|
}
|
|
else
|
|
{
|
|
buffer[rx_index++] = byte;
|
|
if (rx_index >= BUFFER_SIZE)
|
|
{
|
|
rx_index = 0;
|
|
send_error(P_ERR_COMMAND_TOO_LONG);
|
|
return PS_WAITING_FOR_COMMAND;
|
|
}
|
|
return PS_READING_PARAMETERS;
|
|
}
|
|
}
|
|
|
|
protocol_state_t waiting_for_end_of_line(uint8_t byte)
|
|
{
|
|
if (byte == '\n' || byte == '\r')
|
|
{
|
|
return PS_WAITING_FOR_COMMAND;
|
|
}
|
|
else
|
|
{
|
|
return PS_WAITING_FOR_END_OF_LINE;
|
|
}
|
|
}
|
|
|
|
void protocol_thread_entry(void *p1, void *p2, void *p3)
|
|
{
|
|
uint8_t rx_byte;
|
|
|
|
LOG_DBG("Protocol thread started, waiting for data...");
|
|
|
|
while (1)
|
|
{
|
|
/* 1. Thread schläft, bis der USB-Interrupt triggert */
|
|
if (usb_wait_for_data(K_FOREVER))
|
|
{
|
|
|
|
while (usb_read_char(&rx_byte) > 0)
|
|
{
|
|
switch (current_protocol_state)
|
|
{
|
|
case PS_WAITING_FOR_COMMAND:
|
|
current_protocol_state = waiting_for_command(rx_byte);
|
|
break;
|
|
case PS_READING_COMMAND:
|
|
current_protocol_state = reading_command(rx_byte);
|
|
break;
|
|
case PS_READING_PARAMETERS:
|
|
current_protocol_state = reading_parameters(rx_byte);
|
|
break;
|
|
case PS_WAITING_FOR_END_OF_LINE:
|
|
current_protocol_state = waiting_for_end_of_line(rx_byte);
|
|
break;
|
|
default:
|
|
LOG_ERR("Invalid protocol state: %d", current_protocol_state);
|
|
current_protocol_state = PS_WAITING_FOR_COMMAND;
|
|
break;
|
|
}
|
|
}
|
|
|
|
usb_resume_rx();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Thread statisch definieren und automatisch starten lassen */
|
|
K_THREAD_DEFINE(protocol_tid, PROTOCOL_STACK_SIZE,
|
|
protocol_thread_entry, NULL, NULL, NULL,
|
|
PROTOCOL_PRIORITY, 0, 0); |