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