Skip to content

L
LTA_mcu
Commit 1c1e2bb5 authored by Александр Пчелин's avatar Александр Пчелин
Browse files
Options

Рефакторинг 

Переименование
Убраны лишние выводы
Добавлены новые выводы
Добавлены пояснения для команд
Команды (6 штук):
T00 – открыть соединение
T01 – закрыть соединение
T02 – ping
T0A – информация об устройстве
T14 – чтение памяти
T15 – запись памяти
parent 747938cc
Hide whitespace changes
Inline Side-by-side
Showing with 258 additions and 191 deletions
src/cli_protocol/cli_protocol.c
View file @ 1c1e2bb5
//*********************************************************************************************************** //***********************************************************************************************************
//! @file lta_protocol.c //! @file cli_protocol.c
//! @brief Реализация протокола LTA (CLI Protocol 1.1) //! @brief Реализация протокола CLI (Protocol 1.1)
//! @version v1.1.0 //! @version v1.0.0
//! @date 31.03.2026 //! @date 06.04.2026
//*********************************************************************************************************** //***********************************************************************************************************
#include "lta_protocol.h" //******************************************** Включаемые файлы *********************************************
#include "cli_protocol.h"
#include "ring_buffer.h" #include "ring_buffer.h"
#include "lmcal.h" #include "lmcal.h"
#include "tcp.h" #include "tcp.h"
...@@ -15,28 +16,34 @@ ...@@ -15,28 +16,34 @@
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdio.h>
#define LTA_CMD_PREFIX 'T' //******************************************** Локальные константы *******************************************
#define LTA_RESPONSE_PREFIX 't' #define CLI_CMD_PREFIX 'T'
#define LTA_ERROR_PREFIX 'e' #define CLI_RESPONSE_PREFIX 't'
#define LTA_MSG_TERMINATOR '\r' #define CLI_ERROR_PREFIX 'e'
#define CLI_MSG_TERMINATOR '\r'
#define HEX_CHAR_TO_NIBBLE(c) (((c) >= '0' && (c) <= '9') ? ((c) - '0') : \ #define HEX_CHAR_TO_NIBBLE(c) (((c) >= '0' && (c) <= '9') ? ((c) - '0') : \
((c) >= 'A' && (c) <= 'F') ? ((c) - 'A' + 10) : \ ((c) >= 'A' && (c) <= 'F') ? ((c) - 'A' + 10) : \
((c) >= 'a' && (c) <= 'f') ? ((c) - 'a' + 10) : 0xFF) ((c) >= 'a' && (c) <= 'f') ? ((c) - 'a' + 10) : 0xFF)
//************************************* Локальные (приватные) переменные ************************************
static ringbuf_t fifo_rx; static ringbuf_t fifo_rx;
static u8 fifo_rx_buf[LTA_CMD_BUFFER_SIZE]; static u8 fifo_rx_buf[CLI_CMD_BUFFER_SIZE];
static char lta_cmd_buffer[LTA_CMD_BUFFER_SIZE]; static char cli_cmd_buffer[CLI_CMD_BUFFER_SIZE];
static u16 lta_cmd_index = 0; static u16 cli_cmd_index = 0;
static bool lta_connected = false; static bool cli_connected = false;
static u32 lta_last_activity = 0; static u32 cli_last_activity = 0;
static u32 (*lta_get_tick)(void) = NULL; static u32 (*cli_get_tick)(void) = NULL;
static lta_device_info_t lta_device_info; static cli_device_info_t cli_device_info;
static char lta_password[16] = "1357"; static char cli_password[16] = CLI_DEFAULT_PASSWORD;
//*********************************** Локальные (статические) функции ****************************************
//-----------------------------------------------------------------------------------------------------------
// Преобразование байта в 2 HEX символа
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
static inline void byte_to_hex(u8 byte, char* hex) static inline void byte_to_hex(u8 byte, char* hex)
{ {
...@@ -45,6 +52,8 @@ static inline void byte_to_hex(u8 byte, char* hex) ...@@ -45,6 +52,8 @@ static inline void byte_to_hex(u8 byte, char* hex)
hex[1] = d[byte & 0x0F]; hex[1] = d[byte & 0x0F];
} }
//-----------------------------------------------------------------------------------------------------------
// Преобразование 2 HEX символов в байт
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
static u8 hex_to_byte(const char* hex) static u8 hex_to_byte(const char* hex)
{ {
...@@ -54,22 +63,26 @@ static u8 hex_to_byte(const char* hex) ...@@ -54,22 +63,26 @@ static u8 hex_to_byte(const char* hex)
} }
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
void lta_send_string(const char* str) // Отправка строки через UART
//-----------------------------------------------------------------------------------------------------------
void cli_send_string(const char* str)
{ {
if (!str) return; if (!str) return;
while (*str) { while (*str) {
lmcal_uart_write(LTA_UART_CHANNEL, (u16)*str); lmcal_uart_write(CLI_UART_CHANNEL, (u16)*str);
str++; str++;
} }
} }
//-----------------------------------------------------------------------------------------------------------
// Отправка ответа на команду
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
static void send_response(u8 cmd, const u8* data, u8 len) static void send_response(u8 cmd, const u8* data, u8 len)
{ {
u8 buf[LTA_CMD_BUFFER_SIZE]; u8 buf[CLI_CMD_BUFFER_SIZE];
u16 idx = 0; u16 idx = 0;
buf[idx++] = LTA_RESPONSE_PREFIX; buf[idx++] = CLI_RESPONSE_PREFIX;
byte_to_hex(cmd, (char*)&buf[idx]); byte_to_hex(cmd, (char*)&buf[idx]);
idx += 2; idx += 2;
...@@ -78,40 +91,42 @@ static void send_response(u8 cmd, const u8* data, u8 len) ...@@ -78,40 +91,42 @@ static void send_response(u8 cmd, const u8* data, u8 len)
idx += 2; idx += 2;
} }
buf[idx++] = LTA_MSG_TERMINATOR; buf[idx++] = CLI_MSG_TERMINATOR;
for (u16 i = 0; i < idx; i++) { for (u16 i = 0; i < idx; i++) {
lmcal_uart_write(LTA_UART_CHANNEL, buf[i]); lmcal_uart_write(CLI_UART_CHANNEL, buf[i]);
} }
} }
//-----------------------------------------------------------------------------------------------------------
// Отправка ошибки
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
static void send_error(u8 cmd, u8 err) static void send_error(u8 cmd, u8 err)
{ {
u8 buf[6]; u8 buf[6];
buf[0] = LTA_ERROR_PREFIX; buf[0] = CLI_ERROR_PREFIX;
byte_to_hex(cmd, (char*)&buf[1]); byte_to_hex(cmd, (char*)&buf[1]);
byte_to_hex(err, (char*)&buf[3]); byte_to_hex(err, (char*)&buf[3]);
buf[5] = LTA_MSG_TERMINATOR; buf[5] = CLI_MSG_TERMINATOR;
for (u16 i = 0; i < 6; i++) { for (u16 i = 0; i < 6; i++) {
lmcal_uart_write(LTA_UART_CHANNEL, buf[i]); lmcal_uart_write(CLI_UART_CHANNEL, buf[i]);
} }
} }
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
// T00 - открыть соединение (пароль "1357") // T00 - открыть соединение
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
static void handle_cmd_open(void) static void handle_cmd_open(void)
{ {
if (lta_connected) { if (cli_connected) {
send_error(LTA_CMD_OPEN, LTA_ERR_INTERNAL); send_error(CLI_CMD_OPEN, CLI_ERR_INTERNAL);
return; return;
} }
lta_connected = true; cli_connected = true;
if (lta_get_tick) lta_last_activity = lta_get_tick(); if (cli_get_tick) cli_last_activity = cli_get_tick();
send_response(LTA_CMD_OPEN, NULL, 0); send_response(CLI_CMD_OPEN, NULL, 0);
} }
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
...@@ -119,11 +134,10 @@ static void handle_cmd_open(void) ...@@ -119,11 +134,10 @@ static void handle_cmd_open(void)
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
static void handle_cmd_close(void) static void handle_cmd_close(void)
{ {
lta_connected = false; cli_connected = false;
send_response(LTA_CMD_CLOSE, NULL, 0); send_response(CLI_CMD_CLOSE, NULL, 0);
cli_cmd_index = 0;
lta_cmd_index = 0; memset(cli_cmd_buffer, 0, sizeof(cli_cmd_buffer));
memset(lta_cmd_buffer, 0, sizeof(lta_cmd_buffer));
} }
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
...@@ -131,15 +145,15 @@ static void handle_cmd_close(void) ...@@ -131,15 +145,15 @@ static void handle_cmd_close(void)
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
static void handle_cmd_ping(const u8* data, u8 len) static void handle_cmd_ping(const u8* data, u8 len)
{ {
if (!lta_connected) { if (!cli_connected) {
send_error(LTA_CMD_PING, LTA_ERR_NOT_CONNECTED); send_error(CLI_CMD_PING, CLI_ERR_NOT_CONNECTED);
return; return;
} }
if (len > 0) { if (len > 0) {
send_response(LTA_CMD_PING, data, len); send_response(CLI_CMD_PING, data, len);
} else { } else {
send_response(LTA_CMD_PING, NULL, 0); send_response(CLI_CMD_PING, NULL, 0);
} }
} }
...@@ -148,30 +162,30 @@ static void handle_cmd_ping(const u8* data, u8 len) ...@@ -148,30 +162,30 @@ static void handle_cmd_ping(const u8* data, u8 len)
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
static void handle_cmd_get_info(void) static void handle_cmd_get_info(void)
{ {
if (!lta_connected) { if (!cli_connected) {
send_error(LTA_CMD_GET_INFO, LTA_ERR_NOT_CONNECTED); send_error(CLI_CMD_GET_INFO, CLI_ERR_NOT_CONNECTED);
return; return;
} }
u8 buf[LTA_DATA_MAX_SIZE]; u8 buf[CLI_DATA_MAX_SIZE];
u16 idx = 0; u16 idx = 0;
u8 len; u8 len;
// Board ID // Board ID
buf[idx++] = lta_device_info.board_id; buf[idx++] = cli_device_info.board_id;
// Имя // Имя
len = strlen(lta_device_info.name); len = strlen(cli_device_info.name);
if (len > 31) len = 31; if (len > 31) len = 31;
buf[idx++] = len; buf[idx++] = len;
memcpy(&buf[idx], lta_device_info.name, len); memcpy(&buf[idx], cli_device_info.name, len);
idx += len; idx += len;
// Серийный номер // Серийный номер
len = strlen(lta_device_info.serial); len = strlen(cli_device_info.serial);
if (len > 15) len = 15; if (len > 15) len = 15;
buf[idx++] = len; buf[idx++] = len;
memcpy(&buf[idx], lta_device_info.serial, len); memcpy(&buf[idx], cli_device_info.serial, len);
idx += len; idx += len;
// Версия ПО // Версия ПО
...@@ -183,7 +197,7 @@ static void handle_cmd_get_info(void) ...@@ -183,7 +197,7 @@ static void handle_cmd_get_info(void)
memcpy(&buf[idx], ver, len); memcpy(&buf[idx], ver, len);
idx += len; idx += len;
send_response(LTA_CMD_GET_INFO, buf, idx); send_response(CLI_CMD_GET_INFO, buf, idx);
} }
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
...@@ -191,13 +205,13 @@ static void handle_cmd_get_info(void) ...@@ -191,13 +205,13 @@ static void handle_cmd_get_info(void)
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
static void handle_cmd_read_mem(const u8* data, u8 len) static void handle_cmd_read_mem(const u8* data, u8 len)
{ {
if (!lta_connected) { if (!cli_connected) {
send_error(LTA_CMD_READ_MEM, LTA_ERR_NOT_CONNECTED); send_error(CLI_CMD_READ_MEM, CLI_ERR_NOT_CONNECTED);
return; return;
} }
if (len != 5) { if (len != 5) {
send_error(LTA_CMD_READ_MEM, LTA_ERR_INVALID_ARG); send_error(CLI_CMD_READ_MEM, CLI_ERR_INVALID_ARG);
return; return;
} }
...@@ -207,20 +221,20 @@ static void handle_cmd_read_mem(const u8* data, u8 len) ...@@ -207,20 +221,20 @@ static void handle_cmd_read_mem(const u8* data, u8 len)
} }
u8 size = data[4]; u8 size = data[4];
if (size > LTA_DATA_MAX_SIZE) { if (size > CLI_DATA_MAX_SIZE) {
send_error(LTA_CMD_READ_MEM, LTA_ERR_INVALID_ARG); send_error(CLI_CMD_READ_MEM, CLI_ERR_INVALID_ARG);
return; return;
} }
if ((addr >= 0x08000000 && addr < 0x08200000) || if ((addr >= 0x08000000 && addr < 0x08200000) ||
(addr >= 0x20000000 && addr < 0x20020000)) { (addr >= 0x20000000 && addr < 0x20020000)) {
u8 buf[LTA_DATA_MAX_SIZE]; u8 buf[CLI_DATA_MAX_SIZE];
for (u8 i = 0; i < size; i++) { for (u8 i = 0; i < size; i++) {
buf[i] = *(volatile u8*)(addr + i); buf[i] = *(volatile u8*)(addr + i);
} }
send_response(LTA_CMD_READ_MEM, buf, size); send_response(CLI_CMD_READ_MEM, buf, size);
} else { } else {
send_error(LTA_CMD_READ_MEM, LTA_ERR_INVALID_ADDR); send_error(CLI_CMD_READ_MEM, CLI_ERR_INVALID_ADDR);
} }
} }
...@@ -229,13 +243,13 @@ static void handle_cmd_read_mem(const u8* data, u8 len) ...@@ -229,13 +243,13 @@ static void handle_cmd_read_mem(const u8* data, u8 len)
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
static void handle_cmd_write_mem(const u8* data, u8 len) static void handle_cmd_write_mem(const u8* data, u8 len)
{ {
if (!lta_connected) { if (!cli_connected) {
send_error(LTA_CMD_WRITE_MEM, LTA_ERR_NOT_CONNECTED); send_error(CLI_CMD_WRITE_MEM, CLI_ERR_NOT_CONNECTED);
return; return;
} }
if (len < 5) { if (len < 5) {
send_error(LTA_CMD_WRITE_MEM, LTA_ERR_INVALID_ARG); send_error(CLI_CMD_WRITE_MEM, CLI_ERR_INVALID_ARG);
return; return;
} }
...@@ -249,201 +263,241 @@ static void handle_cmd_write_mem(const u8* data, u8 len) ...@@ -249,201 +263,241 @@ static void handle_cmd_write_mem(const u8* data, u8 len)
for (u8 i = 0; i < size; i++) { for (u8 i = 0; i < size; i++) {
*(volatile u8*)(addr + i) = data[4 + i]; *(volatile u8*)(addr + i) = data[4 + i];
} }
send_response(LTA_CMD_WRITE_MEM, NULL, 0); send_response(CLI_CMD_WRITE_MEM, NULL, 0);
} else { } else {
send_error(LTA_CMD_WRITE_MEM, LTA_ERR_INVALID_ADDR); send_error(CLI_CMD_WRITE_MEM, CLI_ERR_INVALID_ADDR);
} }
} }
//-----------------------------------------------------------------------------------------------------------
// Парсинг и выполнение команды
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
static void parse_and_execute(void) static void parse_and_execute(void)
{ {
char* buf = lta_cmd_buffer; char* buf = cli_cmd_buffer;
u16 len = lta_cmd_index; u16 len = cli_cmd_index;
if (len < 3) { if (len < 3) {
lta_cmd_index = 0; cli_cmd_index = 0;
return; return;
} }
if (buf[0] != LTA_CMD_PREFIX) { if (buf[0] != CLI_CMD_PREFIX) {
lta_cmd_index = 0; cli_cmd_index = 0;
return; return;
} }
if (buf[len - 1] != LTA_MSG_TERMINATOR) { if (buf[len - 1] != CLI_MSG_TERMINATOR) {
return; return;
} }
// Парсим код команды
u8 cmd = hex_to_byte(&buf[1]); u8 cmd = hex_to_byte(&buf[1]);
if (cmd == 0xFF) { if (cmd == 0xFF) {
lta_cmd_index = 0; cli_cmd_index = 0;
return; return;
} }
// Парсим данные (HEX) u8 data[CLI_DATA_MAX_SIZE + 4];
u8 data[LTA_DATA_MAX_SIZE + 4];
u8 data_len = 0; u8 data_len = 0;
if (len > 4) { if (len > 4) {
u16 chars = len - 4; u16 chars = len - 4;
if ((chars % 2) != 0) { if ((chars % 2) != 0) {
send_error(cmd, LTA_ERR_INVALID_ARG); send_error(cmd, CLI_ERR_INVALID_ARG);
lta_cmd_index = 0; cli_cmd_index = 0;
return; return;
} }
data_len = chars / 2; data_len = chars / 2;
if (data_len > (LTA_DATA_MAX_SIZE + 4)) { if (data_len > (CLI_DATA_MAX_SIZE + 4)) {
send_error(cmd, LTA_ERR_INVALID_ARG); send_error(cmd, CLI_ERR_INVALID_ARG);
lta_cmd_index = 0; cli_cmd_index = 0;
return; return;
} }
for (u8 i = 0; i < data_len; i++) { for (u8 i = 0; i < data_len; i++) {
data[i] = hex_to_byte(&buf[3 + i * 2]); data[i] = hex_to_byte(&buf[3 + i * 2]);
if (data[i] == 0xFF) { if (data[i] == 0xFF) {
send_error(cmd, LTA_ERR_INVALID_ARG); send_error(cmd, CLI_ERR_INVALID_ARG);
lta_cmd_index = 0; cli_cmd_index = 0;
return; return;
} }
} }
} }
if (lta_get_tick) lta_last_activity = lta_get_tick(); if (cli_get_tick) cli_last_activity = cli_get_tick();
// Обработка команд
switch (cmd) { switch (cmd) {
case LTA_CMD_OPEN: case CLI_CMD_OPEN:
handle_cmd_open(); handle_cmd_open();
break; break;
case CLI_CMD_CLOSE:
case LTA_CMD_CLOSE:
handle_cmd_close(); handle_cmd_close();
break; break;
case CLI_CMD_PING:
case LTA_CMD_PING:
handle_cmd_ping(data, data_len); handle_cmd_ping(data, data_len);
break; break;
case CLI_CMD_GET_INFO:
case LTA_CMD_GET_INFO:
handle_cmd_get_info(); handle_cmd_get_info();
break; break;
case CLI_CMD_READ_MEM:
case LTA_CMD_READ_MEM:
handle_cmd_read_mem(data, data_len); handle_cmd_read_mem(data, data_len);
break; break;
case CLI_CMD_WRITE_MEM:
case LTA_CMD_WRITE_MEM:
handle_cmd_write_mem(data, data_len); handle_cmd_write_mem(data, data_len);
break; break;
default: default:
send_error(cmd, LTA_ERR_UNKNOWN_CMD); send_error(cmd, CLI_ERR_UNKNOWN_CMD);
break; break;
} }
lta_cmd_index = 0; cli_cmd_index = 0;
} }
//-----------------------------------------------------------------------------------------------------------
// Колбек прерывания по приему байта
//----------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------
static void uart_rx_cb(void) static void uart_rx_cb(void)
{ {
u16 rx = lmcal_uart_read(LTA_UART_CHANNEL); u16 rx = lmcal_uart_read(CLI_UART_CHANNEL);
u8 ch = (u8)(rx & 0xFF); u8 ch = (u8)(rx & 0xFF);
rb_add_item(&fifo_rx, &ch); rb_add_item(&fifo_rx, &ch);
} }
//************************************ Публичные функции **************************************************** //***********************************************************************************************************
//******************************* Определения глобальных (публичных) функций ********************************
//***********************************************************************************************************
fun_res_t lta_protocol_init(void) //-----------------------------------------------------------------------------------------------------------
// Инициализация протокола
//-----------------------------------------------------------------------------------------------------------
fun_res_t cli_protocol_init(void)
{ {
fifo_rx.item_size = sizeof(u8); fifo_rx.item_size = sizeof(u8);
rb_init(&fifo_rx, fifo_rx_buf, sizeof(fifo_rx_buf)); rb_init(&fifo_rx, fifo_rx_buf, sizeof(fifo_rx_buf));
rb_clear(&fifo_rx); rb_clear(&fifo_rx);
lmcal_uart_set_callback(LTA_UART_CHANNEL, CB_INT_RX_CALLBACK, uart_rx_cb); lmcal_uart_set_callback(CLI_UART_CHANNEL, CB_INT_RX_CALLBACK, uart_rx_cb);
lta_cmd_index = 0; cli_cmd_index = 0;
lta_connected = false; cli_connected = false;
lta_last_activity = 0; cli_last_activity = 0;
lta_get_tick = NULL; cli_get_tick = NULL;
memset(lta_cmd_buffer, 0, sizeof(lta_cmd_buffer)); memset(cli_cmd_buffer, 0, sizeof(cli_cmd_buffer));
strcpy(lta_device_info.name, "LTA Device"); strcpy(cli_device_info.name, "CLI Device");
strcpy(lta_device_info.serial, "00000000"); strcpy(cli_device_info.serial, "00000000");
strcpy(lta_device_info.version, "1.0.0"); strcpy(cli_device_info.version, "1.0.0");
lta_device_info.board_id = 0; cli_device_info.board_id = 0;
lta_send_string("\r\n========================================\r\n"); // Приветствие
lta_send_string("LTA Protocol v1.1 Ready\r\n"); cli_send_string("\r\n>----- LTA PROTOCOL ENABLE -----<\r\n");
lta_send_string("========================================\r\n");
lta_send_string("Commands:\r\n"); // Список доступных команд
lta_send_string(" T00 - Open connection (password: 1357)\r\n"); cli_send_string("> T00 - Open connection\r\n");
lta_send_string(" T01 - Close connection\r\n"); cli_send_string("> T01 - Close connection\r\n");
lta_send_string(" T02 - Ping\r\n"); cli_send_string("> T02 - Ping\r\n");
lta_send_string(" T0A - Get device info\r\n"); cli_send_string("> T0A - Get device info\r\n");
lta_send_string(" T14[addr][size] - Read memory\r\n"); cli_send_string("> T14 - Read memory (addr:4B HEX, size:1B HEX)\r\n");
lta_send_string(" T15[addr][data] - Write memory\r\n"); cli_send_string("> T15 - Write memory (addr:4B HEX, data:HEX)\r\n");
lta_send_string("========================================\r\n");
lta_send_string("> "); // Приглашение для ввода
cli_send_string("> ");
return ERR_OK; return ERR_OK;
} }
fun_res_t lta_protocol_deinit(void) //-----------------------------------------------------------------------------------------------------------
// Деинициализация протокола
//-----------------------------------------------------------------------------------------------------------
fun_res_t cli_protocol_deinit(void)
{ {
lmcal_uart_set_callback(LTA_UART_CHANNEL, CB_INT_RX_CALLBACK, NULL); lmcal_uart_set_callback(CLI_UART_CHANNEL, CB_INT_RX_CALLBACK, NULL);
lta_connected = false; cli_connected = false;
return ERR_OK; return ERR_OK;
} }
void lta_protocol_process(void) //-----------------------------------------------------------------------------------------------------------
// Основной цикл обработки
//-----------------------------------------------------------------------------------------------------------
void cli_protocol_process(void)
{ {
while (rb_get_items_qty(&fifo_rx) > 0) { while (rb_get_items_qty(&fifo_rx) > 0) {
u8 ch; u8 ch;
if (rb_get_item(&fifo_rx, &ch) != RB_RES_OK) continue; if (rb_get_item(&fifo_rx, &ch) != RB_RES_OK) continue;
// Игнорируем пустые символы в начале if (cli_cmd_index == 0 && (ch == '\r' || ch == '\n')) {
if (lta_cmd_index == 0 && (ch == '\r' || ch == '\n')) {
continue; continue;
} }
if (ch == '\r' || ch == '\n') { if (ch == '\r' || ch == '\n') {
if (lta_cmd_index > 0) { if (cli_cmd_index > 0) {
lta_cmd_buffer[lta_cmd_index] = LTA_MSG_TERMINATOR; cli_cmd_buffer[cli_cmd_index] = CLI_MSG_TERMINATOR;
lta_cmd_index++; cli_cmd_index++;
parse_and_execute(); parse_and_execute();
lta_send_string("> "); cli_send_string("> ");
} }
// Сбрасываем индекс после Enter cli_cmd_index = 0;
lta_cmd_index = 0; } else if (cli_cmd_index < CLI_CMD_BUFFER_SIZE - 1) {
} else if (lta_cmd_index < LTA_CMD_BUFFER_SIZE - 1) { cli_cmd_buffer[cli_cmd_index++] = ch;
lta_cmd_buffer[lta_cmd_index++] = ch;
} else { } else {
lta_cmd_index = 0; cli_cmd_index = 0;
memset(lta_cmd_buffer, 0, sizeof(lta_cmd_buffer)); memset(cli_cmd_buffer, 0, sizeof(cli_cmd_buffer));
lta_send_string("\r\nERROR: Buffer overflow\r\n> ");
} }
} }
if (lta_connected && lta_get_tick) { if (cli_connected && cli_get_tick) {
if ((lta_get_tick() - lta_last_activity) > LTA_CONNECTION_TIMEOUT_MS) { if ((cli_get_tick() - cli_last_activity) > CLI_CONNECTION_TIMEOUT_MS) {
lta_connected = false; cli_connected = false;
} }
} }
} }
fun_res_t lta_protocol_set_device_info(const char* name, const char* serial, const char* ver, u8 board_id) //-----------------------------------------------------------------------------------------------------------
// Установка информации об устройстве
//-----------------------------------------------------------------------------------------------------------
fun_res_t cli_protocol_set_device_info(const char* name, const char* serial, const char* ver, u8 board_id)
{ {
if (name) strncpy(lta_device_info.name, name, sizeof(lta_device_info.name) - 1); if (name) strncpy(cli_device_info.name, name, sizeof(cli_device_info.name) - 1);
if (serial) strncpy(lta_device_info.serial, serial, sizeof(lta_device_info.serial) - 1); if (serial) strncpy(cli_device_info.serial, serial, sizeof(cli_device_info.serial) - 1);
if (ver) strncpy(lta_device_info.version, ver, sizeof(lta_device_info.version) - 1); if (ver) strncpy(cli_device_info.version, ver, sizeof(cli_device_info.version) - 1);
lta_device_info.board_id = board_id; cli_device_info.board_id = board_id;
return ERR_OK; return ERR_OK;
} }
//-----------------------------------------------------------------------------------------------------------
// Установка board_id
//-----------------------------------------------------------------------------------------------------------
fun_res_t cli_protocol_set_board_id(u8 board_id)
{
cli_device_info.board_id = board_id;
return ERR_OK;
}
//-----------------------------------------------------------------------------------------------------------
// Получение board_id
//-----------------------------------------------------------------------------------------------------------
u8 cli_protocol_get_board_id(void)
{
return cli_device_info.board_id;
}
//-----------------------------------------------------------------------------------------------------------
// Установка пароля
//-----------------------------------------------------------------------------------------------------------
void cli_protocol_set_password(const char* pass)
{
if (pass) {
strncpy(cli_password, pass, sizeof(cli_password) - 1);
cli_password[sizeof(cli_password) - 1] = '\0';
}
}
//-----------------------------------------------------------------------------------------------------------
// Проверка пароля
//-----------------------------------------------------------------------------------------------------------
bool cli_protocol_verify_password(const char* pass)
{
if (!pass) return false;
return (strcmp(pass, cli_password) == 0);
}
\ No newline at end of file
src/cli_protocol/cli_protocol.h
View file @ 1c1e2bb5
#ifndef LTA_PROTOCOL_H #ifndef CLI_PROTOCOL_H
#define LTA_PROTOCOL_H #define CLI_PROTOCOL_H
#include "lta_protocol_cfg.h" #include "cli_protocol_cfg.h"
#include "l_macro_types.h" #include "l_macro_types.h"
#include <stdbool.h> #include <stdbool.h>
//************************************ Коды команд (по протоколу 1.1) ************************************* //************************************ Коды команд (по протоколу 1.1) *************************************
typedef enum { typedef enum {
LTA_CMD_OPEN = 0x00U, // T00 - открыть соединение (с паролем) CLI_CMD_OPEN = 0x00U, // T00 - открыть соединение
LTA_CMD_CLOSE = 0x01U, // T01 - закрыть соединение CLI_CMD_CLOSE = 0x01U, // T01 - закрыть соединение
LTA_CMD_PING = 0x02U, // T02 - проверка соединения CLI_CMD_PING = 0x02U, // T02 - проверка соединения
LTA_CMD_GET_INFO = 0x0AU, // T0A - информация об устройстве CLI_CMD_GET_INFO = 0x0AU, // T0A - информация об устройстве
LTA_CMD_READ_MEM = 0x14U, // T14 - чтение памяти CLI_CMD_READ_MEM = 0x14U, // T14 - чтение памяти
LTA_CMD_WRITE_MEM = 0x15U, // T15 - запись памяти CLI_CMD_WRITE_MEM = 0x15U, // T15 - запись памяти
} lta_cmd_t; } cli_cmd_t;
//************************************ Коды ошибок ********************************************************** //************************************ Коды ошибок **********************************************************
typedef enum { typedef enum {
LTA_ERR_NONE = 0x00U, CLI_ERR_NONE = 0x00U,
LTA_ERR_UNKNOWN_CMD = 0x01U, CLI_ERR_UNKNOWN_CMD = 0x01U,
LTA_ERR_INVALID_ARG = 0x02U, CLI_ERR_INVALID_ARG = 0x02U,
LTA_ERR_INTERNAL = 0x03U, CLI_ERR_INTERNAL = 0x03U,
LTA_ERR_NOT_CONNECTED = 0x04U, CLI_ERR_NOT_CONNECTED = 0x04U,
LTA_ERR_MEMORY = 0x05U, CLI_ERR_MEMORY = 0x05U,
LTA_ERR_INVALID_ADDR = 0x06U, CLI_ERR_INVALID_ADDR = 0x06U,
LTA_ERR_INVALID_PASS = 0x07U, // Неверный пароль CLI_ERR_INVALID_PASS = 0x07U,
} lta_error_t; } cli_error_t;
//************************************ Информация об устройстве ********************************************** //************************************ Информация об устройстве **********************************************
typedef struct { typedef struct {
char name[32]; char name[32];
char serial[16]; char serial[16];
char version[16]; char version[16];
u8 board_id; // Идентификатор платы (0-255) u8 board_id;
} lta_device_info_t; } cli_device_info_t;
//************************************ Публичные функции **************************************************** //************************************ Публичные функции ****************************************************
fun_res_t lta_protocol_init(void); // Инициализация протокола
fun_res_t lta_protocol_deinit(void); fun_res_t cli_protocol_init(void);
void lta_protocol_process(void);
void lta_send_string(const char* str); // Деинициализация протокола
fun_res_t lta_protocol_set_device_info(const char* name, const char* serial, const char* ver, u8 board_id); fun_res_t cli_protocol_deinit(void);
fun_res_t lta_protocol_set_board_id(u8 board_id);
u8 lta_protocol_get_board_id(void); // Основной цикл обработки
void lta_protocol_set_password(const char* pass); void cli_protocol_process(void);
bool lta_protocol_verify_password(const char* pass);
// Отправка строки
void cli_send_string(const char* str);
// Установка информации об устройстве
fun_res_t cli_protocol_set_device_info(const char* name, const char* serial, const char* ver, u8 board_id);
// Управление board_id
fun_res_t cli_protocol_set_board_id(u8 board_id);
u8 cli_protocol_get_board_id(void);
// Управление паролем
void cli_protocol_set_password(const char* pass);
bool cli_protocol_verify_password(const char* pass);
#endif #endif
\ No newline at end of file
src/cli_protocol/cli_protocol_cfg.h
View file @ 1c1e2bb5
#ifndef LTA_PROTOCOL_CFG_H #ifndef CLI_PROTOCOL_CFG_H
#define LTA_PROTOCOL_CFG_H #define CLI_PROTOCOL_CFG_H
#include "lmcal_uart.h" #include "lmcal_uart.h"
//************************************ Конфигурация UART **************************************************** //************************************ Конфигурация UART ****************************************************
#define LTA_UART_CHANNEL (LMCAL_UART_CHANNEL1) #define CLI_UART_CHANNEL (LMCAL_UART_CHANNEL1)
//************************************ Размеры буферов ****************************************************** //************************************ Размеры буферов ******************************************************
#define LTA_CMD_BUFFER_SIZE (128) // Размер буфера команды #define CLI_CMD_BUFFER_SIZE (128) // Размер буфера команды
#define LTA_DATA_MAX_SIZE (64) // Максимальный размер данных #define CLI_DATA_MAX_SIZE (64) // Максимальный размер данных
//************************************ Таймауты ************************************************************ //************************************ Таймауты ************************************************************
#define LTA_CONNECTION_TIMEOUT_MS (20000U) // Таймаут соединения 20 секунд #define CLI_CONNECTION_TIMEOUT_MS (20000U) // Таймаут соединения 20 секунд
//************************************ Пароль по умолчанию ************************************************** //************************************ Пароль по умолчанию **************************************************
#define LTA_DEFAULT_PASSWORD "1357" #define CLI_DEFAULT_PASSWORD "1357"
#endif #endif
\ No newline at end of file
src/main.c
View file @ 1c1e2bb5
...@@ -30,8 +30,8 @@ void main(void) ...@@ -30,8 +30,8 @@ void main(void)
//cli_init(); //cli_init();
// Инициализация LTA протокола // Инициализация LTA протокола
lta_protocol_init(); cli_protocol_init();
lta_protocol_set_device_info("LTA27 MCU", "LTA27V2-001", "1.0.0", 0x01); cli_protocol_set_device_info("LTA27 MCU", "LTA27V2-001", "1.0.0", 0x01);
while(1) while(1)
{ {
...@@ -40,13 +40,13 @@ void main(void) ...@@ -40,13 +40,13 @@ void main(void)
tcp_loop(); tcp_loop();
// Обработка команд // Обработка команд
lta_protocol_process(); cli_protocol_process();
if (bsp_loop()) break; if (bsp_loop()) break;
} }
//cli_deinit(); //cli_deinit();
lta_protocol_deinit(); cli_protocol_deinit();
streams_deinit(); streams_deinit();
bsp_deinit(); bsp_deinit();
bsp_jump_to_boot(); bsp_jump_to_boot();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment