Extract reusable device protocols, ports and logic analyzers from SETGUI
This commit is contained in:
623
python/set_devices/can485_board.py
Normal file
623
python/set_devices/can485_board.py
Normal file
@@ -0,0 +1,623 @@
|
||||
"""@file can485_board.py
|
||||
@brief Плата WeAct CAN485 DevBoard V1 (ESP32): её текстовый вывод и пакеты RS485.
|
||||
|
||||
Прошивка ``CAN_Parser`` печатает в USB-UART разобранные кадры CAN и RS485
|
||||
строками, а CAN-кадры также выкладывает в RS485 пакетами по 17 байт. Здесь
|
||||
разбор обоих форматов, сборка команд управления платой и генератор демо-трафика.
|
||||
|
||||
Перенесено из отдельного tkinter-приложения ``Tools/CanMonitorGUI``
|
||||
репозитория платы. Модуль не импортирует Qt: разбор переносим и проверяется
|
||||
host-тестами.
|
||||
|
||||
Строка кадра::
|
||||
|
||||
[ 12.345] EXT 0x18FEE000 DLC=8 DATA=01 02 03 04 05 06 07 08 |........|
|
||||
|
||||
Пакет RS485::
|
||||
|
||||
AA 55 | FLAGS | ID[4] big-endian | DLC | DATA[8] | CRC8
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import csv
|
||||
import random
|
||||
import re
|
||||
import time
|
||||
from collections import deque
|
||||
from dataclasses import dataclass, field
|
||||
from itertools import chain
|
||||
from typing import Iterable
|
||||
|
||||
#: Распространённые скорости UART для подключения платы и RS485-приёмника.
|
||||
UART_BAUDS = (
|
||||
"1200", "2400", "4800", "9600", "14400", "19200", "38400", "57600",
|
||||
"115200", "128000", "230400", "256000", "460800", "500000", "512000",
|
||||
"576000", "921600", "1000000", "1152000", "1500000", "2000000",
|
||||
"3000000", "4000000",
|
||||
)
|
||||
#: Скорости USB-UART платы и скорость по умолчанию для ESP32.
|
||||
USB_BAUDS = UART_BAUDS[8:]
|
||||
DEFAULT_USB_BAUD = "921600"
|
||||
#: Скорости шины CAN, кбит/с. Список закрытый: прошивка проверяет значение.
|
||||
CAN_BITRATES = ["25", "50", "100", "125", "250", "500", "800", "1000"]
|
||||
#: Режимы контроллера: имя и код команды ``M``.
|
||||
MODES = (("normal", 0), ("listen-only", 1), ("no-ack", 2))
|
||||
#: Маршруты прошивки 1.6: бит 0 — CAN→RS485, бит 1 — RS485→CAN.
|
||||
ROUTES = (("Выкл", 0), ("CAN→RS485", 1), ("RS485→CAN", 2), ("Оба", 3))
|
||||
#: Скорости встроенного UART RS485 платы и значение по умолчанию.
|
||||
RS485_BAUDS = UART_BAUDS
|
||||
DEFAULT_RS485_BAUD = "512000"
|
||||
|
||||
#: Синхробайты и длина пакета RS485.
|
||||
RS485_SYNC = b"\xAA\x55"
|
||||
RS485_LEN = 17
|
||||
|
||||
#: Строка кадра: время, тип идентификатора, сам идентификатор и хвост.
|
||||
FRAME_RE = re.compile(
|
||||
r"^\[\s*(\d+)\.(\d{3})\]\s+(?:(RS485)\s+)?"
|
||||
r"(EXT|STD)\s+0x([0-9A-Fa-f]+)\s+(.*)$"
|
||||
)
|
||||
RTR_RE = re.compile(r"^RTR\s+DLC=(\d)")
|
||||
DATA_RE = re.compile(r"^DLC=(\d)\s*(?:DATA=([0-9A-Fa-f ]*))?")
|
||||
HEX_BYTE_RE = re.compile(r"(?i)(?<![0-9a-f])[0-9a-f]{2}(?![0-9a-f])")
|
||||
|
||||
|
||||
def crc8(data: bytes) -> int:
|
||||
"""@brief CRC-8, полином 0x07, начальное значение 0 — как в прошивке."""
|
||||
crc = 0
|
||||
for byte in data:
|
||||
crc ^= byte
|
||||
for _ in range(8):
|
||||
crc = ((crc << 1) ^ 0x07) & 0xFF if crc & 0x80 else (crc << 1) & 0xFF
|
||||
return crc
|
||||
|
||||
|
||||
def to_ascii(data: bytes) -> str:
|
||||
"""Печатные байты как есть, остальные точкой."""
|
||||
return "".join(chr(byte) if 0x20 <= byte < 0x7F else "." for byte in data)
|
||||
|
||||
|
||||
def j1939(can_id: int) -> str:
|
||||
"""@brief Короткий разбор 29-битного идентификатора по J1939.
|
||||
|
||||
@param can_id Идентификатор кадра.
|
||||
@return Приоритет, PGN и адрес источника одной строкой.
|
||||
"""
|
||||
priority = (can_id >> 26) & 0x07
|
||||
pdu_format = (can_id >> 16) & 0xFF
|
||||
source = can_id & 0xFF
|
||||
pgn = (can_id >> 8) & 0x3FFFF
|
||||
if pdu_format < 240:
|
||||
# PDU1: младший байт PGN — адрес получателя, а не часть номера группы.
|
||||
pgn &= 0x3FF00
|
||||
return "P%d PGN %05X SA %02X" % (priority, pgn, source)
|
||||
|
||||
|
||||
@dataclass
|
||||
class BoardFrame:
|
||||
"""@brief Один кадр шины, пришедший от платы."""
|
||||
|
||||
timestamp: float
|
||||
extended: bool
|
||||
identifier: int
|
||||
rtr: bool
|
||||
dlc: int
|
||||
data: bytes
|
||||
source: str = "CAN"
|
||||
|
||||
@property
|
||||
def key(self) -> tuple[bool, int]:
|
||||
"""Ключ агрегирования в таблице «по ID»."""
|
||||
return (self.extended, self.identifier)
|
||||
|
||||
def id_str(self) -> str:
|
||||
return ("0x%08X" if self.extended else "0x%03X") % self.identifier
|
||||
|
||||
def data_str(self) -> str:
|
||||
return "RTR" if self.rtr else " ".join("%02X" % byte for byte in self.data)
|
||||
|
||||
def ascii_str(self) -> str:
|
||||
return "" if self.rtr else to_ascii(self.data)
|
||||
|
||||
def rs485_packet(self) -> bytes:
|
||||
"""@brief Пакет RS485, каким его выложила бы плата.
|
||||
|
||||
Нужен и для показа сырых байт, и для демо-потока: генератор отдаёт
|
||||
те же байты, что придут с железа, поэтому проверяется весь разбор.
|
||||
"""
|
||||
flags = (1 if self.extended else 0) | (2 if self.rtr else 0)
|
||||
body = (bytes([flags])
|
||||
+ (self.identifier & 0x1FFFFFFF).to_bytes(4, "big")
|
||||
+ bytes([self.dlc])
|
||||
+ self.data.ljust(8, b"\x00")[:8])
|
||||
return RS485_SYNC + body + bytes([crc8(body)])
|
||||
|
||||
|
||||
def parse_frame_line(line: str, timestamp: float) -> BoardFrame | None:
|
||||
"""@brief Разбирает строку кадра из USB-вывода прошивки.
|
||||
|
||||
@param line Строка без завершающего перевода строки.
|
||||
@param timestamp Время приёма на стороне ПК.
|
||||
@return Кадр либо ``None``, если строка не про кадр.
|
||||
"""
|
||||
match = FRAME_RE.match(line)
|
||||
if not match:
|
||||
return None
|
||||
source = "RS485" if match.group(3) else "CAN"
|
||||
extended = match.group(4) == "EXT"
|
||||
identifier = int(match.group(5), 16)
|
||||
rest = match.group(6)
|
||||
|
||||
remote = RTR_RE.match(rest)
|
||||
if remote:
|
||||
return BoardFrame(timestamp, extended, identifier, True,
|
||||
int(remote.group(1)), b"", source=source)
|
||||
|
||||
payload = DATA_RE.match(rest)
|
||||
if not payload:
|
||||
return None
|
||||
dlc = int(payload.group(1))
|
||||
# Хвост строки может нести ASCII-колонку в вертикальных чертах.
|
||||
hex_part = (payload.group(2) or "").split("|")[0]
|
||||
try:
|
||||
data = bytes(int(item, 16) for item in hex_part.split())
|
||||
except ValueError:
|
||||
return None
|
||||
return BoardFrame(timestamp, extended, identifier, False, dlc, data[:8],
|
||||
source=source)
|
||||
|
||||
|
||||
@dataclass
|
||||
class SdLogImport:
|
||||
"""Результат безопасного импорта журнала, снятого с TF/SD-карты."""
|
||||
|
||||
frames: list[BoardFrame]
|
||||
rows_seen: int
|
||||
skipped_rows: int
|
||||
truncated: bool
|
||||
format_name: str
|
||||
|
||||
|
||||
def _header_key(value: str) -> str:
|
||||
"""Нормализует русские и английские заголовки CSV для сопоставления."""
|
||||
return re.sub(r"[^a-zа-я0-9]+", "", value.strip().lower().lstrip("\ufeff"))
|
||||
|
||||
|
||||
def _column_index(header: list[str], *aliases: str) -> int | None:
|
||||
keys = [_header_key(value) for value in header]
|
||||
wanted = {_header_key(alias) for alias in aliases}
|
||||
return next((index for index, key in enumerate(keys) if key in wanted), None)
|
||||
|
||||
|
||||
def _parse_log_timestamp(value: str, reference: float, milliseconds: bool) -> float:
|
||||
"""Читает epoch, millis() либо часы из CSV без требования даты в файле."""
|
||||
text = value.strip()
|
||||
clock = re.fullmatch(r"(\d{1,2}):(\d{2}):(\d{2})(?:[.,](\d{1,6}))?", text)
|
||||
if clock:
|
||||
fraction = float("0." + (clock.group(4) or "0"))
|
||||
local = time.localtime(reference)
|
||||
midnight = time.mktime((local.tm_year, local.tm_mon, local.tm_mday,
|
||||
0, 0, 0, local.tm_wday, local.tm_yday,
|
||||
local.tm_isdst))
|
||||
return midnight + int(clock.group(1)) * 3600 + int(clock.group(2)) * 60 \
|
||||
+ int(clock.group(3)) + fraction
|
||||
numeric = float(text.replace(",", "."))
|
||||
if numeric >= 100_000_000_000:
|
||||
return numeric / 1000.0
|
||||
if numeric >= 1_000_000_000:
|
||||
return numeric
|
||||
return numeric / 1000.0 if milliseconds else numeric
|
||||
|
||||
|
||||
def _parse_bool(value: str) -> bool:
|
||||
return value.strip().lower() in {"1", "true", "yes", "ext", "e", "29"}
|
||||
|
||||
|
||||
def _parse_csv_frame(
|
||||
row: list[str], header: list[str] | None, reference: float,
|
||||
) -> tuple[BoardFrame, bool]:
|
||||
"""Разбирает одну строку SD CSV; второй результат отмечает относительное время."""
|
||||
if header is None:
|
||||
if len(row) < 5:
|
||||
raise ValueError("слишком мало колонок")
|
||||
time_index, type_index, id_index, dlc_index, data_index = 0, 1, 2, 3, 4
|
||||
rtr_index = None
|
||||
time_key = "ms"
|
||||
else:
|
||||
time_index = _column_index(header, "Время", "time", "timestamp", "ms",
|
||||
"millis", "time_ms", "timestamp_ms",
|
||||
"uptime_ms", "elapsed_ms", "t_ms")
|
||||
type_index = _column_index(header, "Тип", "type", "format", "fmt", "ide", "ext")
|
||||
id_index = _column_index(header, "ID", "identifier", "can_id", "canid",
|
||||
"ID (29 бит)")
|
||||
dlc_index = _column_index(header, "DLC", "len", "length")
|
||||
data_index = _column_index(header, "Данные (hex)", "data", "payload",
|
||||
"data_hex", "bytes", "DATA (8 байт)")
|
||||
rtr_index = _column_index(header, "RTR", "remote")
|
||||
if None in (time_index, id_index, dlc_index, data_index):
|
||||
raise ValueError("нет обязательных колонок")
|
||||
time_key = _header_key(header[time_index])
|
||||
|
||||
required = [time_index, id_index, dlc_index, data_index]
|
||||
if any(index is None or index >= len(row) for index in required):
|
||||
raise ValueError("короткая строка")
|
||||
type_text = row[type_index].strip() if type_index is not None and type_index < len(row) else ""
|
||||
id_text = row[id_index].strip().lower().replace("0x", "")
|
||||
identifier = int(id_text, 16)
|
||||
type_upper = type_text.upper()
|
||||
if type_upper in {"EXT", "E", "29", "TRUE", "YES", "1"}:
|
||||
extended = True
|
||||
elif type_upper in {"STD", "S", "11", "FALSE", "NO", "0"}:
|
||||
extended = False
|
||||
else:
|
||||
extended = identifier > 0x7FF
|
||||
if not 0 <= identifier <= (0x1FFFFFFF if extended else 0x7FF):
|
||||
raise ValueError("ID вне диапазона")
|
||||
|
||||
dlc_text = row[dlc_index].strip()
|
||||
dlc = int(dlc_text, 16 if dlc_text.lower().startswith("0x") else 10)
|
||||
if not 0 <= dlc <= 8:
|
||||
raise ValueError("DLC вне диапазона")
|
||||
rtr = (type_text.upper() == "RTR" or row[data_index].strip().upper() == "RTR"
|
||||
or (rtr_index is not None and rtr_index < len(row) and _parse_bool(row[rtr_index])))
|
||||
|
||||
data = b""
|
||||
if not rtr:
|
||||
# У SD-прошивки байты могут идти одной колонкой или отдельными полями.
|
||||
joined = (row[data_index] if header is not None
|
||||
else " ".join(row[data_index:]))
|
||||
compact = re.sub(r"(?i)0x|[^0-9a-f]", "", joined)
|
||||
if compact and len(compact) % 2 == 0:
|
||||
data = bytes.fromhex(compact)
|
||||
else:
|
||||
data = bytes(int(value, 16) for value in HEX_BYTE_RE.findall(joined))
|
||||
if len(data) < dlc:
|
||||
raise ValueError("данных меньше DLC")
|
||||
data = data[:dlc]
|
||||
|
||||
milliseconds = time_key in {
|
||||
"ms", "millis", "timems", "timestampms", "uptimems", "elapsedms",
|
||||
"tms",
|
||||
}
|
||||
stamp = _parse_log_timestamp(row[time_index], reference, milliseconds)
|
||||
relative = stamp < 1_000_000_000 and not ":" in row[time_index]
|
||||
return BoardFrame(stamp, extended, identifier, rtr, dlc, data, source="SD"), relative
|
||||
|
||||
|
||||
def parse_sd_log(
|
||||
lines: Iterable[str], reference_timestamp: float | None = None,
|
||||
limit: int = 5000,
|
||||
) -> SdLogImport:
|
||||
"""Разбирает SD-журнал CAN485 без загрузки неограниченного файла в память.
|
||||
|
||||
Поддерживаются текстовые строки ``CAN_Parser``, его компактный CSV
|
||||
``ms,type,id,dlc,data`` и CSV, сохранённый самим SETGUI. В память попадают
|
||||
только последние ``limit`` корректных кадров.
|
||||
"""
|
||||
if limit <= 0:
|
||||
raise ValueError("limit должен быть положительным")
|
||||
reference = time.time() if reference_timestamp is None else reference_timestamp
|
||||
source_lines = iter(lines)
|
||||
first = ""
|
||||
found_data = False
|
||||
for candidate in source_lines:
|
||||
first = candidate.strip("\r\n\ufeff")
|
||||
if first.strip() and not first.lstrip().startswith("#"):
|
||||
found_data = True
|
||||
break
|
||||
if not found_data:
|
||||
return SdLogImport([], 0, 0, False, "empty")
|
||||
|
||||
rows_seen = 0
|
||||
skipped = 0
|
||||
total_frames = 0
|
||||
relative_flags: deque[bool] = deque(maxlen=limit)
|
||||
frames: deque[BoardFrame] = deque(maxlen=limit)
|
||||
|
||||
def add(frame: BoardFrame | None, relative: bool = False) -> None:
|
||||
nonlocal skipped, total_frames
|
||||
if frame is None:
|
||||
skipped += 1
|
||||
return
|
||||
frames.append(frame)
|
||||
relative_flags.append(relative)
|
||||
total_frames += 1
|
||||
|
||||
if first.lstrip().startswith("["):
|
||||
format_name = "CAN_Parser text"
|
||||
for line in chain((first,), source_lines):
|
||||
stripped = line.strip()
|
||||
if not stripped or stripped.startswith("#"):
|
||||
continue
|
||||
rows_seen += 1
|
||||
match = FRAME_RE.match(stripped)
|
||||
relative = False
|
||||
stamp = reference
|
||||
if match:
|
||||
stamp = int(match.group(1)) + int(match.group(2)) / 1000.0
|
||||
relative = True
|
||||
add(parse_frame_line(stripped, stamp), relative)
|
||||
else:
|
||||
delimiter = ";" if first.count(";") >= first.count(",") else ","
|
||||
reader = csv.reader(chain((first,), source_lines), delimiter=delimiter)
|
||||
first_row = next(reader, [])
|
||||
id_column = _column_index(first_row, "ID", "identifier", "can_id", "canid",
|
||||
"ID (29 бит)")
|
||||
header = first_row if id_column is not None else None
|
||||
format_name = "SETGUI CSV" if header and _column_index(
|
||||
header, "Данные (hex)") is not None else "CAN_Parser CSV"
|
||||
data_rows = reader if header is not None else chain((first_row,), reader)
|
||||
for row in data_rows:
|
||||
if not row or not any(value.strip() for value in row):
|
||||
continue
|
||||
rows_seen += 1
|
||||
try:
|
||||
frame, relative = _parse_csv_frame(row, header, reference)
|
||||
except (ValueError, TypeError, IndexError):
|
||||
add(None)
|
||||
else:
|
||||
add(frame, relative)
|
||||
|
||||
imported = list(frames)
|
||||
flags = list(relative_flags)
|
||||
relative_stamps = [frame.timestamp for frame, relative in zip(imported, flags) if relative]
|
||||
if relative_stamps:
|
||||
# millis()/время от старта не имеет календаря: конец журнала привязываем
|
||||
# ко времени изменения файла на карте, сохраняя интервалы между кадрами.
|
||||
shift = reference - max(relative_stamps)
|
||||
imported = [BoardFrame(frame.timestamp + shift if relative else frame.timestamp,
|
||||
frame.extended, frame.identifier, frame.rtr,
|
||||
frame.dlc, frame.data, frame.source)
|
||||
for frame, relative in zip(imported, flags)]
|
||||
return SdLogImport(imported, rows_seen, skipped, total_frames > limit, format_name)
|
||||
|
||||
|
||||
def parse_status(line: str) -> dict[str, str]:
|
||||
"""@brief Разбирает поля ``#STAT`` или ``#OK`` в словарь «ключ — значение»."""
|
||||
values: dict[str, str] = {}
|
||||
for item in line.split()[1:]:
|
||||
if "=" in item:
|
||||
key, value = item.split("=", 1)
|
||||
values[key] = value
|
||||
return values
|
||||
|
||||
|
||||
class LineAssembler:
|
||||
"""@brief Собирает строки из кусков потока USB-UART.
|
||||
|
||||
Куски приходят как попало — QSerialPort отдаёт то, что успело прийти,
|
||||
поэтому остаток без перевода строки хранится до следующего вызова.
|
||||
"""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._buffer = bytearray()
|
||||
|
||||
def feed(self, chunk: bytes) -> list[str]:
|
||||
"""@brief Добавляет кусок и возвращает завершённые строки."""
|
||||
self._buffer += chunk
|
||||
lines: list[str] = []
|
||||
while True:
|
||||
end = self._buffer.find(b"\n")
|
||||
if end < 0:
|
||||
break
|
||||
raw = bytes(self._buffer[:end])
|
||||
del self._buffer[:end + 1]
|
||||
lines.append(raw.decode("utf-8", "replace").rstrip("\r"))
|
||||
return lines
|
||||
|
||||
def reset(self) -> None:
|
||||
self._buffer.clear()
|
||||
|
||||
|
||||
class Rs485PacketParser:
|
||||
"""@brief Выделяет из потока RS485 пакеты по 17 байт и проверяет CRC."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._buffer = bytearray()
|
||||
#: Счётчики: принято пакетов и отброшено по несходимости CRC.
|
||||
self.stats = {"packets": 0, "crc_errors": 0}
|
||||
|
||||
def feed(self, chunk: bytes, timestamp: float | None = None) -> list[BoardFrame]:
|
||||
"""@brief Добавляет кусок потока и возвращает разобранные кадры."""
|
||||
self._buffer += chunk
|
||||
now = time.time() if timestamp is None else timestamp
|
||||
frames: list[BoardFrame] = []
|
||||
while len(self._buffer) >= RS485_LEN:
|
||||
start = self._buffer.find(RS485_SYNC)
|
||||
if start < 0:
|
||||
# Синхробайт может быть разорван между кусками: последний байт
|
||||
# оставляем, вдруг это первая половина AA 55.
|
||||
del self._buffer[:-1]
|
||||
break
|
||||
if start:
|
||||
del self._buffer[:start]
|
||||
continue
|
||||
packet = bytes(self._buffer[:RS485_LEN])
|
||||
if crc8(packet[2:16]) != packet[16]:
|
||||
self.stats["crc_errors"] += 1
|
||||
del self._buffer[:2]
|
||||
continue
|
||||
del self._buffer[:RS485_LEN]
|
||||
self.stats["packets"] += 1
|
||||
flags = packet[2]
|
||||
identifier = int.from_bytes(packet[3:7], "big") & 0x1FFFFFFF
|
||||
dlc = min(packet[7], 8)
|
||||
frames.append(BoardFrame(now, bool(flags & 1), identifier,
|
||||
bool(flags & 2), dlc, packet[8:8 + dlc],
|
||||
source="RS485"))
|
||||
return frames
|
||||
|
||||
def reset(self) -> None:
|
||||
self._buffer.clear()
|
||||
self.stats.update(packets=0, crc_errors=0)
|
||||
|
||||
|
||||
# ==========================================================================
|
||||
# Команды прошивки
|
||||
# ==========================================================================
|
||||
|
||||
def command_bitrate(kbps: str | int) -> str:
|
||||
"""Скорость шины CAN, кбит/с."""
|
||||
return "S%s" % kbps
|
||||
|
||||
|
||||
def command_mode(mode: int) -> str:
|
||||
"""Режим контроллера: 0 normal, 1 listen-only, 2 no-ack."""
|
||||
return "M%d" % mode
|
||||
|
||||
|
||||
def command_rs485(enabled: bool) -> str:
|
||||
"""Только CAN→RS485; в прошивке 1.6 обратный маршрут не меняется."""
|
||||
return "R1" if enabled else "R0"
|
||||
|
||||
|
||||
def command_route(route: int) -> str:
|
||||
"""Маршрут прошивки 1.6: 0 выкл, 1 CAN→RS485, 2 RS485→CAN, 3 оба."""
|
||||
if route not in (0, 1, 2, 3):
|
||||
raise ValueError("маршрут должен быть 0..3")
|
||||
return "Q%d" % route
|
||||
|
||||
|
||||
def command_rs485_baud(baud: str | int) -> str:
|
||||
"""Скорость физического интерфейса RS485 на плате."""
|
||||
value = int(baud)
|
||||
if not 1200 <= value <= 3_000_000:
|
||||
raise ValueError("скорость RS485 должна быть 1200..3000000 бод")
|
||||
return "B%d" % value
|
||||
|
||||
|
||||
def command_rs485_transmit(packet: bytes) -> str:
|
||||
"""Передача готового 17-байтового пакета в RS485 через USB платы."""
|
||||
if len(packet) != RS485_LEN or not packet.startswith(RS485_SYNC):
|
||||
raise ValueError("ожидается 17-байтовый пакет RS485 AA 55")
|
||||
if crc8(packet[2:16]) != packet[16]:
|
||||
raise ValueError("неверный CRC8 пакета RS485")
|
||||
return "X," + packet.hex().upper()
|
||||
|
||||
|
||||
def command_sd_logging(enabled: bool) -> str:
|
||||
"""Запуск или остановка записи CAN-кадров на TF-карту."""
|
||||
return "L1" if enabled else "L0"
|
||||
|
||||
|
||||
def command_sd_list() -> str:
|
||||
"""Запрос списка файлов TF-карты через USB-UART платы."""
|
||||
return "D"
|
||||
|
||||
|
||||
def normalize_sd_log_name(name: str) -> str:
|
||||
"""Разрешает загрузку только корневых CSV-журналов ``can_*``."""
|
||||
value = name.strip()
|
||||
if value.startswith("/"):
|
||||
value = value[1:]
|
||||
if not re.fullmatch(r"(?i)can_[a-z0-9_-]+\.csv", value):
|
||||
raise ValueError("допустим только корневой журнал can_*.csv")
|
||||
return "/" + value
|
||||
|
||||
|
||||
def command_sd_download(name: str, offset: int = 0) -> str:
|
||||
"""Запрос содержимого выбранного файла карты через текстовый протокол."""
|
||||
if not 0 <= offset <= 0xFFFFFFFF:
|
||||
raise ValueError("смещение SD-журнала вне uint32")
|
||||
command = "G," + normalize_sd_log_name(name)
|
||||
return command if offset == 0 else command + "," + str(offset)
|
||||
|
||||
|
||||
def parse_sd_file_entry(line: str) -> tuple[str, int] | None:
|
||||
"""Разбирает строку списка ``#SD file <name> <size>`` прошивки."""
|
||||
match = re.fullmatch(r"#SD file\s+(\S+)\s+(\d+)\s*", line)
|
||||
if match is None:
|
||||
return None
|
||||
return normalize_sd_log_name(match.group(1)), int(match.group(2))
|
||||
|
||||
|
||||
def command_filter(identifier: str = "", mask: str = "") -> str:
|
||||
"""@brief Аппаратный фильтр по идентификатору и маске (hex).
|
||||
|
||||
Без аргументов фильтр снимается: прошивка так и понимает голую ``F``.
|
||||
"""
|
||||
identifier = identifier.strip()
|
||||
mask = mask.strip()
|
||||
if not identifier and not mask:
|
||||
return "F"
|
||||
return "F%s,%s" % (identifier or "0", mask or "0")
|
||||
|
||||
|
||||
def command_transmit(extended: bool, identifier: str, dlc: int, data: str) -> str:
|
||||
"""@brief Передача кадра в шину.
|
||||
|
||||
@param extended 29-битный идентификатор вместо 11-битного.
|
||||
@param identifier Идентификатор в hex, с ``0x`` или без.
|
||||
@param dlc Число байт данных, 0..8.
|
||||
@param data Байты данных в hex; пробелы игнорируются.
|
||||
"""
|
||||
clean_id = identifier.strip().replace("0x", "").replace("0X", "") or "0"
|
||||
clean_data = "".join(data.split())
|
||||
return "T,%s,%s,%d,%s" % ("E" if extended else "S", clean_id, dlc, clean_data)
|
||||
|
||||
|
||||
#: Команда обнуления счётчиков прошивки.
|
||||
COMMAND_CLEAR_COUNTERS = "Z"
|
||||
#: Команда «представься»: версия, распиновка и текущее состояние.
|
||||
COMMAND_VERSION = "V"
|
||||
#: Запрос текущего маршрута (прошивка 1.6 и новее).
|
||||
COMMAND_ROUTE = "Q"
|
||||
#: Команда вывода списка команд.
|
||||
COMMAND_HELP = "?"
|
||||
|
||||
|
||||
# ==========================================================================
|
||||
# Демонстрационный поток
|
||||
# ==========================================================================
|
||||
|
||||
@dataclass
|
||||
class DemoTraffic:
|
||||
"""Порция демо-трафика: строки USB и пакеты RS485 за один такт."""
|
||||
|
||||
lines: list[str] = field(default_factory=list)
|
||||
packets: list[bytes] = field(default_factory=list)
|
||||
|
||||
|
||||
class BoardDemoSource:
|
||||
"""@brief Генератор трафика платы: интерфейс проверяется без железа.
|
||||
|
||||
Строки собираются ровно в формате прошивки, пакеты RS485 — с настоящим
|
||||
CRC, поэтому демо-режим проходит через тот же разбор, что и железо.
|
||||
"""
|
||||
|
||||
#: Идентификаторы, по которым генератор идёт по кругу.
|
||||
IDS = ((True, 0x18FEE000), (True, 0x0CF00400), (False, 0x123), (False, 0x7DF))
|
||||
|
||||
def __init__(self, rng: random.Random | None = None) -> None:
|
||||
self._rng = rng or random.Random()
|
||||
self._count = 0
|
||||
self._start = time.time()
|
||||
|
||||
def next_traffic(self) -> DemoTraffic:
|
||||
"""@brief Очередной такт: кадр в обоих видах, раз в 20 тактов — ``#STAT``."""
|
||||
extended, identifier = self.IDS[self._count % len(self.IDS)]
|
||||
dlc = 8 if extended else 3
|
||||
data = bytes(self._rng.randrange(256) for _ in range(dlc))
|
||||
elapsed_ms = int((time.time() - self._start) * 1000)
|
||||
id_text = ("0x%08X" if extended else "0x%03X ") % identifier
|
||||
line = "[%4d.%03d] %s %s DLC=%d DATA=%s" % (
|
||||
elapsed_ms // 1000, elapsed_ms % 1000, "EXT" if extended else "STD",
|
||||
id_text, dlc, " ".join("%02X" % byte for byte in data))
|
||||
|
||||
frame = BoardFrame(time.time(), extended, identifier, False, dlc, data,
|
||||
source="RS485")
|
||||
traffic = DemoTraffic(lines=[line], packets=[frame.rs485_packet()])
|
||||
|
||||
self._count += 1
|
||||
if self._count % 20 == 0:
|
||||
traffic.lines.append(
|
||||
"#STAT state=RUNNING bitrate=500 mode=normal rx=%d shown=%d tx=0 "
|
||||
"buserr=0 miss=0 txerr=0 rxerr=0 dropusb=0 droprs=0 rs485=on "
|
||||
"route=3 rsrx=%d rscrc=0 rstx=%d dropcan=0 "
|
||||
"baud=512000 vin=12180 up=%d sd=rec sdfile=/can_demo.csv "
|
||||
"sdkb=1 sdlines=%d dropsd=0"
|
||||
% (self._count, self._count, self._count, self._count,
|
||||
int(time.time() - self._start),
|
||||
self._count))
|
||||
return traffic
|
||||
Reference in New Issue
Block a user