Files
templates/c/uart-usb/uart_usb.c
T

65 lines
11 KiB
C

#include "uart_usb.h" /* Подключает общий формат, размеры буферов и публичный ABI. */
#include <string.h> /* Использует стандартное копирование памяти без зависимости от MCU или ОС. */
static int valid_type(uint8_t type) { /* Ограничивает типы реальными командами и ответами версии 1. */
return (type >= UB_CONFIG && type <= UB_TX) || (type >= UB_ACK && type <= UB_STATS); /* Отвергает свободные значения тега, чтобы раньше восстановить границу. */
} /* Завершает проверку допустимых типов. */
uint16_t ub_encode(uint8_t type, uint8_t channel, const uint8_t *data, uint16_t length, uint8_t *out) { /* Формирует единственный wire-формат для прошивки и GUI. */
if (!out || !valid_type(type) || channel > 4U || length > UB_PAYLOAD || (length && !data)) return 0U; /* Проверяет указатели и границы до обращения к памяти. */
out[0] = UB_MAGIC; /* Отмечает начало записи выбранным байтом синхронизации 0xA7. */
out[1] = (uint8_t)((type << 4U) | channel); /* Упаковывает тип и номер канала в старшую и младшую тетрады. */
out[2] = (uint8_t)length; /* Записывает младший байт длины данных в байтах. */
out[3] = 0U; /* Старший байт длины равен нулю при ограничении payload до 60 байт. */
if (length && data != out + 4U) memcpy(out + 4U, data, length); /* Сохраняет бинарные значения и допускает уже заполненную полезную область выходного буфера. */
return (uint16_t)(length + 4U); /* Возвращает длину USB-записи вместе с заголовком. */
} /* Завершает построение записи без CRC, поскольку целостность обеспечивает USB. */
uint16_t ub_feed(ub_parser *parser, const uint8_t *data, uint16_t length, ub_frame *frame) { /* Разбирает фрагменты потока и выдаёт не более одной записи за вызов. */
uint16_t offset = 0U; /* Начинает счёт потреблённых байтов нового входного фрагмента. */
frame->type = 0U; /* Явно обозначает отсутствие полного результата до накопления всей записи. */
while (offset < length) { /* Ограничивает чтение фактической длиной входного USB-пакета. */
uint8_t byte = data[offset++]; /* Потребляет очередной байт ровно один раз. */
if (!parser->used && byte != UB_MAGIC) continue; /* Пропускает шум до начала следующей записи. */
parser->bytes[parser->used++] = byte; /* Сохраняет очередной байт в ограниченном буфере записи. */
while (parser->used >= 4U && (!valid_type(parser->bytes[1] >> 4U) || (parser->bytes[1] & 15U) > 4U || parser->bytes[2] > UB_PAYLOAD || parser->bytes[3])) { /* Отбрасывает заголовки с неизвестными типами, каналами и длинами. */
memmove(parser->bytes, parser->bytes + 1U, --parser->used); /* Сдвигает окно на байт, сохраняя возможное начало корректного заголовка. */
while (parser->used && parser->bytes[0] != UB_MAGIC) { /* Ищет синхронизацию только среди уже полученных байтов. */
memmove(parser->bytes, parser->bytes + 1U, --parser->used); /* Удаляет префикс шума без потери следующего служебного байта. */
} /* Завершает повторную синхронизацию внутри ошибочного заголовка. */
} /* Завершает проверку накопленного заголовка. */
if (parser->used >= 4U && parser->used == (uint16_t)(4U + parser->bytes[2])) { /* Выдаёт запись только после получения всех заявленных данных. */
frame->type = parser->bytes[1] >> 4U; /* Извлекает тип из старшей тетрады тега. */
frame->channel = parser->bytes[1] & 15U; /* Извлекает логический номер канала из младшей тетрады. */
frame->length = parser->bytes[2]; /* Возвращает проверенную длину не более 60 байт. */
memcpy(frame->data, parser->bytes + 4U, frame->length); /* Копирует данные, чтобы следующий USB-пакет не изменил результат. */
parser->used = 0U; /* Готовит parser к следующей записи в том же входном фрагменте. */
break; /* Позволяет вызывающему обработать результат и затем передать остаток потока. */
} /* Завершает выдачу одного полного сообщения. */
} /* Завершает обработку доступного фрагмента. */
return offset; /* Позволяет без потерь продолжить разбор оставшихся байтов входного буфера. */
} /* Завершает потоковый parser без heap и системных вызовов. */
uint32_t ub_get_u32(const uint8_t *data) { /* Читает значение без невыровненных обращений к uint32_t. */
return (uint32_t)data[0] | ((uint32_t)data[1] << 8U) | ((uint32_t)data[2] << 16U) | ((uint32_t)data[3] << 24U); /* Собирает little-endian значение из четырёх байтов. */
} /* Завершает чтение скорости или счётчика. */
void ub_put_u32(uint8_t *data, uint32_t value) { /* Записывает числовые поля в общий wire-формат. */
for (uint8_t i = 0U; i < 4U; ++i) data[i] = (uint8_t)(value >> (8U * i)); /* Выделяет четыре последовательных байта от младшего к старшему. */
} /* Завершает переносимое преобразование endian. */
uint16_t ub_make_config(uint8_t channel, uint32_t baud, uint8_t *out) { /* Строит целую команду настройки одним общим вызовом C. */
uint8_t data[4]; ub_put_u32(data, baud); /* Представляет скорость в четырёх little-endian байтах. */
return ub_encode(UB_CONFIG, channel, data, sizeof(data), out); /* Передаёт проверку границ канала и построение заголовка единственному кодеку. */
} /* Завершает создание конфигурационной команды для настольного клиента. */
uint16_t ub_make_start(uint8_t *out) { return ub_encode(UB_START, 0U, 0, 0U, out); } /* Общий канал 0 и пустой payload однозначно запускают все входы. */
uint16_t ub_make_stop(uint8_t *out) { return ub_encode(UB_STOP, 0U, 0, 0U, out); } /* Общий канал 0 и пустой payload однозначно останавливают все входы. */
uint16_t ub_make_tx(const uint8_t *data, uint16_t length, uint8_t *out) { return length ? ub_encode(UB_TX, 1U, data, length, out) : 0U; } /* Не допускает пустую передачу и всегда выбирает только канал 1. */
int ub_describe(const ub_frame *frame, ub_event *event) { /* Декодирует смысл служебных payload в общем C вместо отдельных реализаций GUI. */
if (!frame || !event || frame->channel > 4U || frame->length > UB_PAYLOAD) return 0; /* Проверяет публичные ABI аргументы даже при прямом вызове без потокового parser. */
memset(event, 0, sizeof(*event)); /* Не оставляет поля предыдущего события при коротком или ошибочном ответе. */
event->channel = frame->channel; /* Передаёт уже проверенный parser логический номер канала. */
if (frame->type == UB_RX && frame->channel && frame->length) { /* RX допускает только существующий номер и непустые бинарные данные. */
event->kind = 1U; event->length = frame->length; memcpy(event->data, frame->data, frame->length); /* ABI событие 1 содержит только полученные байты без служебного заголовка. */
} else if (frame->type == UB_ACK && frame->length == 4U && frame->data[0] >= UB_CONFIG && frame->data[0] <= UB_TX && frame->data[1] <= UB_BUSY && frame->data[2] >= 2U && frame->data[2] <= 4U && frame->data[3] == 1U) { /* Проверяет длину, исходную команду, статус и объявленные возможности G474. */
event->kind = 2U; event->command = frame->data[0]; event->status = frame->data[1]; event->channels = frame->data[2]; event->tx_channel = frame->data[3]; /* ABI событие 2 передаёт поля подтверждения без знания смещений в Python. */
} else if (frame->type == UB_STATS && frame->channel && frame->length == 8U) { /* Статистика содержит ровно два 32-битных счётчика отдельного канала. */
event->kind = 3U; event->lost = ub_get_u32(frame->data); event->errors = ub_get_u32(frame->data + 4U); /* ABI событие 3 возвращает готовые числовые значения. */
} /* Другие записи не являются корректными ответами USB терминалу. */
return event->kind != 0U; /* Отрицательный семантический результат не маскируется под пустой RX. */
} /* Завершает единый разбор служебных полей протокола. */