Merge origin/ump-v4 into main

Combine Flash CAN updates, signal processing and HOPE pin fixes with current Modbus/GAS, STM32 ports and CCS release exports. Resolve protocol, documentation and Qt conflicts; deduplicate Android JNI sources and include gauge/IGBT sources in host builds.
This commit is contained in:
2026-11-07 01:32:27 +03:00
136 changed files with 8828 additions and 821 deletions
+123
View File
@@ -0,0 +1,123 @@
# Декодеры DSView для шин 96-контактного интерфейса
Два независимых декодера: **Plates PBus** и **Plates SBus**. Показывают
адрес устройства, регистр, сырые 16-битные данные, результат проверок
и итог каждого обращения. Повторные одинаковые обращения выводятся отдельно.
Декодеры устанавливаются в DSView и разбирают цифровой захват шин,
используемых с SETGUI. Формат взят из `ParallelBusSlave_ver_2_0.vhd`
и `SerialBusSlave_ver_2_0.vhd` из `ip_repo` репозитория PlatesSim. Зависимости
от установленного SETGUI или PlatesConf нет. Число 96 относится
к разъёму; ширина данных PBus составляет 16 бит.
## Установка
1. Закрыть DSView.
2. Скопировать обе папки `plates_pbus` и `plates_sbus` из `decoders`
в каталог `decoders` используемой установки DSView. Внутри каждой
папки должны непосредственно лежать `__init__.py` и `pd.py`.
3. Открыть DSView, загрузить захват или получить новый.
4. В списке декодеров выбрать **Plates PBus** либо **Plates SBus**
и назначить соответствующие каналы анализатора. При одновременном
захвате обеих шин добавить оба декодера.
Используется sigrok API 3 и синтаксис Python 3.6+. Формат декодеров
сверён со штатными пакетами установленного DSView и
[исходниками DSView](https://github.com/DreamSourceLab/DSView/tree/master/libsigrokdecode4DSL/decoders).
Общие сведения о пользовательских декодерах — в
[инструкции производителя](https://dreamsourcelab.cn/logic-analyzer/protocol_decoder_howto/).
## Каналы PBus
| Сигнал декодера | Подключение | Назначение |
| --- | --- | --- |
| PBCE | `pbce` | Низкий уровень разрешает транзакцию |
| PBACK | `pback` | Подтверждения адреса, данных и инверсии |
| D0…D15 | `pbdata[0]`…`pbdata[15]` | Все 16 разрядов общей двунаправленной шины |
| PBCLK | `pbclk`, необязательно | Проверка уровня тактовой линии в фазах ответа |
Для полного декодирования PBus требуется **18 каналов**, с PBCLK — 19.
Анализатор на 16 каналов не захватит полный набор одновременно.
Назначать D0…D15 по номерам разрядов шины, а номера контактов
96-контактного разъёма брать из схемы конкретной платы.
Операция начинается со спада PBCE. Первый спад PBACK подтверждает адрес:
`PBDATA[15:8] = dev*16 + reg`, `PBDATA[7:0] = ~PBDATA[15:8]`.
Следующий подъём PBACK подтверждает 16-битные данные; следующий спад —
их 16-битную инверсию. При назначенном PBCLK данные должны подтверждаться
при CLK=0, инверсия — при CLK=1. Выборка слов выполняется по ACK.
Неверная инверсия адреса, неверная инверсия ответа, нарушение фазы CLK
и незавершённое ожидание ACK выводятся отдельными предупреждениями.
Снятие CE до завершения или конец захвата сохраняют частичную операцию
с признаком `complete=False`. Начальный фрагмент захвата с уже низким CE
пропускается до следующего полного начала транзакции.
## Каналы SBus
| Сигнал декодера | Подключение | Направление |
| --- | --- | --- |
| SBCLK | `sbclk` | Тактовая линия мастера |
| SBDATAIN | `sbdatain` | ТМС → платы |
| SBDATAOUT | `sbdataout` | Платы → ТМС |
Для SBus достаточно **трёх каналов**. Имена IN/OUT соответствуют
входу и выходу ведомого блока в HDL.
Кадр содержит 29 бит старшим вперёд: направление (0 — чтение,
1 — запись), устройство (4), регистр (4), данные (16), CRC (4).
Декодер выбирает биты по нарастающим фронтам SBCLK. Заголовок и данные
записи идут по SBDATAIN; данные чтения и CRC ответа — по SBDATAOUT.
CRC учитывает все 25 бит направления, адреса и данных, а затем
четыре завершающие единицы по алгоритму HDL. Это собственный алгоритм,
его нельзя заменять произвольным штатным CRC-4.
| Параметр | По умолчанию | Смысл |
| --- | --- | --- |
| Frame gap (us) | 3,6 мкс | Минимальное время неподвижного CLK для синхронизации нового кадра |
| Write ACK sampling delay (us) | 0,5 мкс | Задержка выборки SBDATAOUT после последнего бита CRC записи |
Пауза учитывается при обоих уровнях CLK. Значение 3,6 мкс взято
из текущих COUNT_RESET=180 и частоты блока SBus 50 МГц.
Задержка ACK 0,5 мкс — настраиваемая точка наблюдения после проверки CRC
и до сброса по паузе. Для другого ведомого или других времён обмена
параметры нужно согласовать с захватом. Межкадровая пауза должна превышать
длительность обычного неподвижного участка CLK внутри кадра;
задержка ACK должна быть положительной и меньше межкадровой паузы.
Низкий SBDATAOUT в точке выборки подтверждает запись. Высокий уровень
помечается `ACK HIGH (NACK / no response)`: по одному уровню нельзя
отличить отказ от отсутствия платы. CRC и ACK показываются независимо.
ACK frontend PlatesSim подтверждает CRC, но не доказывает помещение
команды в FIFO или её применение CPU1.
Если файл закончился до выборки ACK, полная запись сохраняется с `ack=None`.
Частичный кадр отмечается числом полученных битов; следующий кадр
синхронизируется после паузы. В начале захвата SBus ожидает наблюдаемую
паузу, чтобы фрагмент уже идущего обмена не стал ложным заголовком.
При записи включать в захват паузу перед первым кадром и время после CRC.
## Проверки и границы подтверждённого
Из корня репозитория:
```powershell
python -m unittest discover -s tools/dsview/tests -p test_plates_buses.py -v # Проверка декодеров на цифровых трассах без запуска DSView.
```
21 тест проверяет оба направления SBus, CRC, отдельную выборку ACK,
повторы, паузы обоих уровней, восстановление синхронизации, края диапазонов
PBus, обе инверсные проверки, фазы ACK, отсутствие каналов и обрывы захвата.
Среда тестов исполняет рабочие методы `decode()` и `end()` через подмену
API ожидания событий; сигналы формируются независимо от автоматов декодеров.
Дополнительно проверены синтаксис Python 3.6 и UTF-8 исходников.
Загрузка новых пакетов в интерфейсе DSView и захват физического обмена
с SETGUI пока не проверены. Номера контактов разъёма и соответствие каналам
анализатора задаются по фактическому подключению. Модели отдельных линий
TK/PWM/ACK в эти декодеры не входят.
Python-выход каждого декодера содержит `['FRAME', словарь]`. Общие поля:
`bus`, `operation`, `dev`, `reg`, `value`. У SBus отдельно доступны `crc`,
`crc_expected`, `crc_ok`, `ack`; у PBus — `address_word`, `address_ok`,
`inverse`, `inverse_ok`, `errors`, `complete`, `ok`.
+54
View File
@@ -103,6 +103,41 @@ segmentation, timing-profile and sigrok API boundary tests. SETGUI's
decoder dialogs, single/all removal with Yes/No, stacking and child lifetime.
The check saves decoder dialog screenshots alongside the report.
## Application protocols from templates
SET CAN includes the current shared parsers and dictionaries. Select
`Protocol / протокол` in the decoder settings:
- `protocan` / `devboard`: ProtoCAN/SETCAN, GAS, Settings, boot services,
discrete and analog messages, device names and assigned GAS IDs.
- `balsam`: Balsam 167, including the actual rotating wire-word order and
separate operator-panel IDs.
- `ump-protocan`: UMP 1/2 with the explicitly selected `gas167` local map or
`assigned` global IDs. Assigned IDs do not imply firmware support.
- `deif`: DEIF XDi-192 / CANopen with STD CAN frames and physical values.
- `legacy`: explicitly select a project from the shared catalog:
Буксир, СЭДБМ, Ледокол, Бальзам, 23550, 23550.X, 23550.2, Янтарь, 23550 БСУ.
- `set-v2`: segmented SET v2, with CRC, sequence and timeout checks.
- `auto`: Balsam IDs, the SET v2 transport prefix, otherwise ProtoCAN.
Project-specific legacy formats and UMP maps always require explicit selection.
Frames, Fields, Registers, Payload and Errors are separate annotation rows.
SET UART can apply the same non-segmented CAN profiles inside the AA55 bridge;
its Bridge settings select the profile, project and UMP map/node.
TMS UART stacks on UART and reads `TMS_TO_TERMINAL` using the shared terminal
parser. Choose a preset layout or `custom` with discrete-byte/analog-word
counts, plus MODBUS or CCITT-FALSE CRC. For a 22220 reply, select `custom`,
70 discrete bytes and 80 analog words. RX/TX buffers are independent;
UART errors and configured gaps discard incomplete data. Only frames with
valid CRC are emitted. This decoder covers terminal telemetry layouts;
variable-length TMS bootloader/memory exchanges are not terminal telemetry.
`protocol-files.json` is the single payload manifest for the embedded builder
and the standalone installer. Canonical Python modules and JSON maps are
copied unchanged into the private decoder runtime; no GUI imports or external
Python packages are required. Restart DSView after updating the decoders.
## Annotation search
The patch searches every enabled result column of the selected decoder and
@@ -171,3 +206,22 @@ The decoder selector starts with **Пользовательские**: IGBT 1SP/
Transistor pair, SET UART, SET CAN and PM35 UART. **Стандартные** contains the remaining
decoders. Search matches names and IDs in both sections and hides empty
section headings. The changes are packaged in `decoder-panel.patch`.
## Шины 96-контактного интерфейса: Plates PBus / Plates SBus
В общую ведомость поставки включены `plates_pbus` и `plates_sbus`.
Они устанавливаются вместе с остальными анализаторами, включаются в
будущую сборку embedded DSView и работают непосредственно с logic-каналами.
Назначение сигналов, формат обмена, параметры CRC/ACK и ограничения захвата
описаны в [PLATES_BUSES.md](PLATES_BUSES.md).
В checkout SETGUI запуск `buildb_bat/INSTALL_DSVIEW_DECODERS.bat` без
параметров выбирает `dist/dsview`; при отсутствии полного компонента там
проверяется `src/gui_desktop/native/dsview`. Выбранный путь печатается до
копирования. Для отдельной установки передать `-DsViewPath` с её каталогом.
Для записи в защищённый Program Files требуются права администратора;
обновление декодеров не требует записи в сам `DSView.exe`.
Перед установкой закрыть целевой DSView, затем открыть его снова.
Добавление пакетов обновляет Python-декодеры без пересборки EXE;
изменение раздела «Пользовательские» применяется при следующей нативной сборке.
+16 -10
View File
@@ -15,13 +15,21 @@ import subprocess
REVISION = '2e9e2c8e'
def protocol_payload(): # Одна ведомость управляет упаковкой переносимых декодеров и их зависимостей.
recipe = Path(__file__).resolve().parent # Рецепт находится в tools/dsview относительно закреплённого templates.
python = recipe.parents[1] / 'python' # Исходники прикладных протоколов берутся из того же checkout, что адаптеры.
manifest = json.loads((recipe / 'protocol-files.json').read_text(encoding='utf-8')) # JSON также читает установщик standalone DSView.
files = [(recipe / 'decoders' / name / leaf, Path(name) / leaf) for name in manifest['adapters'] for leaf in ('__init__.py', 'pd.py')] # Каждый адаптер имеет стандартную точку входа и реализацию sigrok.
files += [(python / 'logic_analyzer/decoders' / (name + '.py'), Path('common/setgui_decoders') / (name + '.py')) for name in manifest['cores']] # Ядра устанавливаются с прежним пространством имён common.setgui_decoders.
files += [(python / name, Path('common/setgui_decoders/templates') / name) for name in manifest['template_files']] # Переносимые библиотеки и карты копируются без изменения исходных файлов.
return files # Пары исходник/назначение используются и для контрольной суммы, и для копирования.
def recipe_digest():
"""Identify the patch, packaging recipe, adapters and their shared cores."""
recipe = Path(__file__).resolve().parent
core = recipe.parents[1] / 'python/logic_analyzer/decoders'
inputs = [recipe / 'build.py', recipe / 'setgui-host.patch', recipe / 'gate-pair-checkbox.patch', recipe / 'decoder-panel.patch', recipe / 'driver-summary.patch', recipe / 'windows-usb-events.patch', recipe / 'native/gate_summary.h']
inputs += sorted((recipe / 'decoders').rglob('*.py'))
inputs += [core / (name + '.py') for name in ('gate_timing', 'transistor_pair', 'set_uart', 'set_can', 'pm35_uart')]
inputs = [recipe / 'build.py', recipe / 'protocol-files.json', recipe / 'setgui-host.patch', recipe / 'gate-pair-checkbox.patch', recipe / 'decoder-panel.patch', recipe / 'driver-summary.patch', recipe / 'windows-usb-events.patch', recipe / 'native/gate_summary.h'] # Ведомость и нативные патчи входят в версию рецепта.
inputs += [source for source, _ in protocol_payload()] # Изменение парсера, адаптера или JSON-карты делает установленный компонент устаревшим.
digest = hashlib.sha256()
for item in inputs:
digest.update(item.relative_to(recipe.parents[1]).as_posix().encode('utf-8') + b'\0')
@@ -46,12 +54,10 @@ def package_decoders(output):
decoders = Path(output) / 'decoders'
shutil.copytree(recipe / 'decoders', decoders, dirs_exist_ok=True,
ignore=shutil.ignore_patterns('__pycache__'))
common = decoders / 'common/setgui_decoders'
common.mkdir(parents=True, exist_ok=True)
(common / '__init__.py').write_text('', encoding='utf-8')
core = recipe.parents[1] / 'python/logic_analyzer/decoders'
for name in ('gate_timing', 'transistor_pair', 'set_uart', 'set_can', 'pm35_uart'):
shutil.copy2(core / (name + '.py'), common / (name + '.py'))
for source, relative in protocol_payload(): # Декодеры, ядра и карты устанавливаются по единой ведомости.
destination = decoders / relative # Все файлы остаются внутри выбранного каталога декодеров.
destination.parent.mkdir(parents=True, exist_ok=True) # Новые переносимые пакеты получают собственные подкаталоги.
shutil.copy2(source, destination) # Канонические реализации templates копируются побайтно без отдельного форка протокола.
def main():
+2 -2
View File
@@ -93,14 +93,14 @@
- {
- srd_decoder *dec = (srd_decoder *)(info->_data_handle);
- panel->AddDataItem(QString(dec->id), QString(dec->name), info);
+ const QStringList customIds = {"gate_driver_timing", "transistor_pair", "set_uart", "set_can", "pm35_uart"};
+ const QStringList customIds = {"gate_driver_timing", "transistor_pair", "set_uart", "set_can", "pm35_uart", "tms_uart", "plates_pbus", "plates_sbus"}; // При сборке пользовательский раздел включает анализаторы обеих шин 96-контактного интерфейса.
+ for (bool custom : {true, false}) {
+ for (auto info : _decoderInfoList) {
+ srd_decoder *dec = (srd_decoder *)(info->_data_handle);
+ if (customIds.contains(QString(dec->id)) != custom)
+ continue;
+ panel->AddDataItem(QString(dec->id), QString(dec->name), info,
+ custom ? QString::fromUtf8("Пользовательские") : QString::fromUtf8("Стандартные"));
+ custom ? QStringLiteral("Пользовательские") : QStringLiteral("Стандартные")); // Unicode-заголовок выбирается по принадлежности декодера; QStringLiteral сохраняет кириллицу без преобразования через системную кодировку Windows.
+ }
}
@@ -0,0 +1,2 @@
"""Декодер параллельной шины 96-контактного интерфейса.""" # Описание пакета доступно загрузчику декодеров DSView.
from .pd import Decoder # Экспорт класса нужен штатному загрузчику libsigrokdecode.
+140
View File
@@ -0,0 +1,140 @@
"""PBus по ParallelBusSlave_ver_2_0.vhd; Python 3.6+, sigrok API 3.""" # Времена выборки определяются ACK аппаратного ведомого.
import sigrokdecode as srd # DSView предоставляет цифровые отсчёты и выходные аннотации.
# CE ограничивает транзакцию, три перехода ACK подтверждают адрес, данные и их инверсию.
class Decoder(srd.Decoder): # Протокол работает непосредственно с захватом логических уровней.
api_version = 3 # API ожидания событий поддерживается libsigrokdecode4DSL.
id = 'plates_pbus' # Имя пакета не пересекается со штатным parallel.
name = 'Plates PBus' # Название в списке протоколов DSView.
longname = 'Plates 96-pin PBus' # Название связывает декодер с интерфейсом плат.
desc = 'PBus reads with address complement, ACK and inverted data checks.' # Текущий HDL реализует внешнее чтение PBus.
license = 'gplv3+' # Допустимый идентификатор лицензии libsigrokdecode.
inputs = ['logic'] # Входные данные — цифровые каналы анализатора.
outputs = ['plates_pbus'] # Структурированные результаты доступны следующему уровню.
tags = ['Embedded/industrial'] # Категория промышленного обмена.
channels = ( # Обязательные сигналы не подменяются нулём при отсутствии захвата.
{'id': 'ce', 'name': 'PBCE', 'desc': 'Active-low transaction enable'}, # Индекс 0: CE=0 разрешает обмен согласно HDL.
{'id': 'ack', 'name': 'PBACK', 'desc': 'Address / data / inverse acknowledge'}, # Индекс 1: переходы 0,1,0 задают три фазы.
) + tuple({'id': 'd%d' % i, 'name': 'D%d' % i, 'desc': 'PBDATA bit %d' % i} for i in range(16)) # Индексы 2…17 соответствуют физическим разрядам D0…D15.
optional_channels = ( # Для выборки достаточно ACK, поэтому тактовая линия необязательна.
{'id': 'clk', 'name': 'PBCLK', 'desc': 'Optional phase validation clock'}, # Индекс 18: данные ожидаются при CLK=0, инверсия — при CLK=1.
) # При наличии CLK проверяется согласованность фаз с текущим HDL.
annotations = ( # Числовые типы совместимы с форматом аннотаций DSView.
('1', 'device', 'Device'), # Индекс 0: старшая тетрада восьмибитного адреса.
('2', 'register', 'Register'), # Индекс 1: младшая тетрада адреса.
('3', 'data', 'Data'), # Индекс 2: прочитанное 16-битное значение.
('4', 'check', 'Checks'), # Индекс 3: инверсная защита адреса и ответа.
('5', 'frame', 'Transaction'), # Индекс 4: итог полного или оборванного обращения.
('1000', 'warning', 'Warnings'), # Индекс 5: ошибки адреса, ответа, фаз и отсутствующих ACK.
) # Индекс класса в put() отличается от числового типа в первом поле.
annotation_rows = ( # Раздельные строки сохраняют читаемость при перекрытии полей.
('device', 'Device', (0,)), # Устройство и регистр передаются одновременно.
('register', 'Register', (1,)), # Поэтому регистр располагается на своей строке.
('data', 'Data', (2,)), # Данные видны рядом с проверкой инверсной копии.
('checks', 'Checks', (3,)), # Результаты проверок не теряются за итогом кадра.
('frames', 'Transactions', (4,)), # Итог содержит адрес, значение и состояние обмена.
('warnings', 'Warnings', (5,)), # Ошибки выделяются штатным типом DSView.
) # Все поля выводятся без зависимости от карт регистров PlatesConf.
# Экземпляр декодера начинает без активной транзакции.
def __init__(self): # Вызывается загрузчиком протоколов.
self.reset() # Повторный проход использует такой же сброс.
# Незавершённое состояние предыдущего захвата не переносится в следующий.
def reset(self): # Сбрасывает только внутренний автомат.
self.packet = None # Словарь операции появляется на спаде CE.
self.phase = None # Ожидаемая фаза: address, data, inverse или done.
self.ss = 0 # Начало транзакции задаётся в отсчётах захвата.
self.phase_start = 0 # Начало текущего ожидания нужно для границ аннотаций.
# Аннотации и структурированные кадры регистрируются до обработки сигналов.
def start(self): # Вызывается средой DSView при запуске декодирования.
self.out_ann = self.register(srd.OUTPUT_ANN) # Текстовые поля отображаются над захватом.
self.out_python = self.register(srd.OUTPUT_PYTHON) # Пакеты сохраняют сырые значения и результаты проверок.
# Каждая аннотация привязана к фактическим границам текущей фазы.
def annotate(self, start, end, kind, text): # kind — индекс annotations, а не числовой тип DSView.
self.put(start, max(start, end), self.out_ann, [kind, [text]]) # Одноточечные переходы также допустимы.
# Порядок назначения каналов DSView задаёт значение разрядов без перестановки байтов.
def word(self, pins): # На входе полный набор сигналов текущего отсчёта.
return sum(pins[2 + i] << i for i in range(16)) # D0 имеет вес 1, D15 — 32768; результат беззнаковый.
# Ошибка добавляется и в выходной пакет, и в видимую строку предупреждений.
def warning(self, text, end): # end обозначает отсчёт обнаружения ошибки.
self.packet['errors'].append(text) # Причины остаются доступны потребителю Python-выхода.
self.annotate(self.phase_start, end, 5, text) # Предупреждение относится к текущей фазе обмена.
# Адрес находится в старшем байте; младший должен быть его инверсией согласно HDL.
def address(self, word, end): # Выборка выполняется на первом низком ACK либо при закрытии запроса без ACK.
address = word >> 8 # Ровно восемь бит делятся на два четырёхбитных адреса.
self.packet.update(dev=address >> 4, reg=address & 15, address_word=word, address_ok=((word & 255) == (address ^ 255))) # Маска 255 ограничивает инверсию одним байтом.
self.annotate(self.ss, end, 0, 'DEV 0x%X' % self.packet['dev']) # Старшая тетрада определяет устройство 0…15.
self.annotate(self.ss, end, 1, 'REG 0x%X' % self.packet['reg']) # Младшая тетрада определяет регистр 0…15.
self.annotate(self.ss, end, 3, 'ADDR 0x%04X %s' % (word, 'OK' if self.packet['address_ok'] else 'BAD')) # Видна и исходная инверсная копия адреса.
if not self.packet['address_ok']: # Несогласованность байтов не маскируется правильными данными ответа.
self.warning('Address complement mismatch', end) # На исправном ведомом такой адрес не должен получать ACK.
# Итог формируется даже при обрыве, но неполная операция никогда не считается успешной.
def emit_frame(self, end, complete): # complete означает получение всех трёх фаз ACK.
self.packet['complete'] = complete # Полнота отделена от результата проверок содержимого.
self.packet['ok'] = complete and not self.packet['errors'] # Любая ошибка проверки остаётся явной.
value = self.packet['value'] # При отсутствии фазы данных значение остаётся None.
text = 'READ %X:%X = %s %s' % (self.packet['dev'], self.packet['reg'], '?' if value is None else '0x%04X' % value, 'OK' if self.packet['ok'] else 'BAD / incomplete') # Формат не выдаёт предположение за данные шины.
self.annotate(self.ss, end, 4, text) # Итог покрывает весь интервал обращения.
self.put(self.ss, end, self.out_python, ['FRAME', self.packet]) # Даже повторное чтение того же значения остаётся отдельной операцией.
# Возврат CE либо конец захвата закрывает незаконченное ожидание ACK.
def close(self, end): # Завершённая операция уже выведена на ACK инверсии и не дублируется.
if self.packet is not None and self.phase != 'done': # Пустой захват или уже завершённый кадр не создают ошибок.
if self.phase == 'address': # При отсутствии первого ACK сохраняем хотя бы запрос на спаде CE.
self.address(self.packet['address_word'], end) # Это наблюдавшийся адрес, а не восстановление по ответу.
self.warning('Incomplete PBus: missing %s ACK' % self.phase, end) # Сообщение различает отсутствие адресного ответа, данных и инверсии.
self.emit_frame(end, False) # Частичные данные доступны с complete=False.
self.packet = None # После закрытия CE предыдущая операция больше не активна.
self.phase = None # Новая операция должна начаться новым спадом CE.
# Последний незакрытый запрос виден и при обрыве самого файла захвата.
def end(self): # Метод вызывается DSView после последнего блока данных.
self.close(getattr(self, 'last_samplenum', getattr(self, 'samplenum', 0))) # Используем последнюю известную границу захвата.
# Состояния автомата соответствуют аппаратной последовательности ACK 0 -> 1 -> 0.
def decode(self): # Ожидание событий завершается самой средой декодирования.
if not all(self.has_channel(i) for i in range(18)): # Для полного слова обязательны CE, ACK и все 16 разрядов данных.
raise ValueError('PBus requires PBCE, PBACK and all D0..D15 channels') # Отсутствующий разряд не заменяется ложным нулём.
have_clock = self.has_channel(18) # PBCLK улучшает диагностику, но не нужен для выборки по ACK.
previous = self.wait({}) # Начало посреди активного CE игнорируется до следующей полной операции.
while True: # Изменения самих данных не вызывают лишние пробуждения декодера.
pins = self.wait([{0: 'e'}, {1: 'e'}]) # Фазы ограничиваются только CE и ACK, а данные читаются в точке подтверждения.
now = self.samplenum # Все границы аннотаций задаются в отсчётах.
if pins[0]: # CE=1 завершает текущий обмен независимо от уровня ACK.
self.close(now) # Незаконченная фаза становится явной ошибкой.
else: # Только низкий CE разрешает принимать ACK ведомого.
if previous[0]: # Спад CE начинает новую операцию даже при одновременном переходе ACK.
self.ss = self.phase_start = now # Начало фазы адреса совпадает с разрешением обмена.
self.packet = {'bus': 'PBus', 'operation': 'read', 'dev': None, 'reg': None, 'address_word': self.word(pins), 'address_ok': None, 'value': None, 'inverse': None, 'inverse_ok': None, 'errors': []} # Пропущенные фазы имеют явное значение None.
self.phase = 'address' # Первым ожидается низкий адресный ACK.
falling = previous[1] == 1 and pins[1] == 0 # ACK=0 подтверждает адрес или инверсную копию в зависимости от фазы.
rising = previous[1] == 0 and pins[1] == 1 # ACK=1 подтверждает прямые данные ответа.
if self.packet is not None and self.phase == 'address' and falling: # Первый спад ACK фиксирует защищённый адрес.
self.address(self.word(pins), now) # Адрес читается после готовности приёмника, а не по произвольному фронту CLK.
self.phase, self.phase_start = 'data', now # Следующий ACK должен стать высоким при готовности данных.
elif self.packet is not None and self.phase == 'data' and rising: # Высокий ACK отмечает прямое слово ответа.
self.packet['value'] = self.word(pins) # Сохраняется всё 16-битное значение PBus.
self.annotate(self.phase_start, now, 2, 'DATA 0x%04X' % self.packet['value']) # Число показывается в шестнадцатеричном виде с ведущими нулями.
if have_clock and pins[18] != 0: # В HDL TransmitData выдаёт ACK только при низком PBCLK.
self.warning('Data ACK while PBCLK is not low', now) # Ошибка фазы помогает выявить неверное подключение либо нарушение обмена.
self.phase, self.phase_start = 'inverse', now # Далее ожидается низкий ACK инверсного слова.
elif self.packet is not None and self.phase == 'inverse' and falling: # Последний спад ACK завершает проверяемый обмен.
inverse = self.word(pins) # Инверсия выбирается отдельно от прямых данных.
valid = inverse == (self.packet['value'] ^ 65535) # Маска 65535 ограничивает инверсию ровно 16 разрядами HDL.
self.packet.update(inverse=inverse, inverse_ok=valid) # Сохраняем и сырое слово, и результат проверки.
self.annotate(self.phase_start, now, 3, 'INVERSE 0x%04X %s' % (inverse, 'OK' if valid else 'BAD')) # Проверяем содержимое, а не только наличие третьего ACK.
if not valid: # Повреждённый ответ не становится успешным из-за полного числа фаз.
self.warning('Data complement mismatch', now) # Ошибка относится к данным ответа.
if have_clock and pins[18] != 1: # В HDL TransmitCheck выдаёт ACK при высоком PBCLK.
self.warning('Inverse ACK while PBCLK is not high', now) # Проверка включается только при назначении необязательного канала.
self.emit_frame(now, True) # Итог доступен сразу после третьего подтверждения.
self.phase = 'done' # Возврат CE в единицу не должен дублировать кадр.
previous = pins # Следующий переход сравнивается с фактическими последними уровнями CE и ACK.
@@ -0,0 +1,2 @@
"""Декодер последовательной шины 96-контактного интерфейса.""" # Описание пакета доступно загрузчику декодеров DSView.
from .pd import Decoder # Экспорт класса нужен штатному загрузчику libsigrokdecode.
+172
View File
@@ -0,0 +1,172 @@
"""SBus по SerialBusSlave_ver_2_0.vhd; Python 3.6+, sigrok API 3.""" # Формат берётся из HDL, без зависимости от приложения SETGUI.
import math # Округление длительностей вверх исключает преждевременное срабатывание таймеров.
import sigrokdecode as srd # Среда DSView предоставляет входные отсчёты и выходные аннотации.
# CRC повторяет параллельные присваивания HDL, включая четыре завершающие единицы.
def frame_crc(direction, address, value): # В расчёт входят направление, восьмибитный адрес и 16 бит данных.
word = (direction << 24) | (address << 16) | value # Поля образуют 25 бит в порядке передачи от старшего к младшему.
crc = 0 # Начальное состояние регистра CRC равно x"0" в SerialBusSlave_ver_2_0.vhd.
for bit in [((word >> shift) & 1) for shift in range(24, -1, -1)] + [1] * 4: # После 25 бит HDL подаёт четыре единицы.
c3, c2, c1, c0 = [(crc >> shift) & 1 for shift in (3, 2, 1, 0)] # Все новые разряды используют прежнее состояние CRC.
crc = ((c2 ^ c3) << 3) | ((c1 ^ c0) << 2) | (c0 << 1) | (bit ^ c1) # Это точная обратная связь HDL, а не стандартный CRC-4.
return crc # На провод передаются четыре бита результата, начиная с бита 3.
# Декодер разделяет кадры по паузе любого уровня CLK и выбирает линию данных по направлению.
class Decoder(srd.Decoder): # Базовый класс реализован встроенным модулем DSView.
api_version = 3 # API 3 позволяет ждать фронтов и временных интервалов без перебора всех отсчётов.
id = 'plates_sbus' # Уникальное имя не пересекается со штатными декодерами.
name = 'Plates SBus' # Короткое название отображается при выборе протокола.
longname = 'Plates 96-pin SBus' # Уточнение отличает шину от других последовательных протоколов.
desc = 'SBus: direction, device, register, data, CRC and write ACK.' # Краткое описание доступно в диалоге DSView.
license = 'gplv3+' # Это допустимый идентификатор лицензии для libsigrokdecode.
inputs = ['logic'] # Декодер получает цифровые сигналы анализатора.
outputs = ['plates_sbus'] # Python-пакеты можно использовать в следующем уровне декодирования.
tags = ['Embedded/industrial'] # Категория соответствует промышленной шине плат.
channels = ( # Направления линий указаны относительно мастера ТМС.
{'id': 'clk', 'name': 'SBCLK', 'desc': 'Serial clock'}, # CLK задаёт границы битов и паузы между кадрами.
{'id': 'tx', 'name': 'SBDATAIN', 'desc': 'TMS -> plates'}, # На этой линии находятся запрос и данные записи.
{'id': 'rx', 'name': 'SBDATAOUT', 'desc': 'Plates -> TMS'}, # На этой линии находятся данные чтения и активный низкий ACK записи.
) # Все три линии обязательны для проверки обоих направлений.
options = ( # Времена задаются в микросекундах и пересчитываются по частоте захвата.
{'id': 'idle_us', 'desc': 'Frame gap (us)', 'default': 3.6}, # В текущем HDL COUNT_RESET=180 при 50 МГц: 180/50=3,6 мкс.
{'id': 'ack_us', 'desc': 'Write ACK sampling delay (us)', 'default': 0.5}, # Полмикросекунды после CRC оставляют запас для логики проверки до сброса по паузе.
) # Параметры можно изменить для реального захвата другой аппаратуры.
annotations = ( # Первое поле задаёт числовой тип DSView; индекс кортежа используется в put().
('1', 'direction', 'Direction'), # Индекс 0: чтение или запись со стороны ТМС.
('2', 'device', 'Device'), # Индекс 1: адрес устройства 0…15.
('3', 'register', 'Register'), # Индекс 2: адрес регистра 0…15.
('4', 'data', 'Data'), # Индекс 3: сырое 16-битное значение без выдуманных единиц.
('5', 'crc', 'CRC'), # Индекс 4: принятая и рассчитанная контрольные суммы.
('6', 'ack', 'Write ACK'), # Индекс 5: подтверждение записи, отдельное от проверки CRC.
('7', 'frame', 'Transaction'), # Индекс 6: итог операции целиком.
('1000', 'warning', 'Warnings'), # Индекс 7: CRC, отказ и незавершённые кадры.
) # Числовой тип 1000 соответствует предупреждениям в DSView.
annotation_rows = ( # Параллельные строки позволяют видеть поля и итог кадра одновременно.
('fields', 'Fields', (0, 1, 2, 3)), # Неперекрывающиеся поля запроса и данных.
('checks', 'CRC / ACK', (4, 5)), # Независимые проверки целостности и ответа платы.
('frames', 'Transactions', (6,)), # Сводная строка удобна для поиска обращений.
('warnings', 'Warnings', (7,)), # Ошибки видны независимо от масштаба остальных строк.
) # Индексы соответствуют annotations выше.
# Новый экземпляр должен начинаться без синхронизации с границей кадра.
def __init__(self): # Загрузчик создаёт экземпляр при добавлении декодера.
self.reset() # Единый сброс используется также при повторном декодировании.
# Сбрасываем только состояние захвата, не значения обязательных входных каналов.
def reset(self): # Вызывается средой при начале нового прохода.
self.samplerate = None # Частота захвата будет передана через metadata().
self.bits = [] # Элементы содержат номер отсчёта и значение бита текущего кадра.
self.pending = None # Завершённая запись ждёт отдельного момента выборки ACK.
self.ack_at = None # Номер отсчёта выборки ACK существует только при pending.
# Выходы регистрируются после сброса до обработки первых отсчётов.
def start(self): # API DSView вызывает этот метод перед decode().
self.out_ann = self.register(srd.OUTPUT_ANN) # Текстовые поля и предупреждения рисуются над захватом.
self.out_python = self.register(srd.OUTPUT_PYTHON) # Структурированные кадры сохраняют независимые CRC и ACK.
# Частота нужна для отделения кадров по реальному времени, а не количеству битов.
def metadata(self, key, value): # Среда передаёт метаданные захвата независимо от фронтов.
if key == srd.SRD_CONF_SAMPLERATE: # Другие метаданные не влияют на разбор шины.
self.samplerate = value # Единица измерения — отсчёты в секунду.
# Обёртка сохраняет допустимый порядок границ даже для одноточечной аннотации.
def annotate(self, start, end, kind, text): # kind — индекс annotations, text — содержимое над сигналом.
self.put(start, max(start, end), self.out_ann, [kind, [text]]) # Одноточечные поля направления допустимы API.
# Поля передаются старшим битом вперёд; срез не включает правую границу.
def field(self, start, end): # Параметры задают позиции битов внутри 29-битного кадра.
value = 0 # Аккумулятор формируется заново для каждого поля.
for _, bit in self.bits[start:end]: # Номер отсчёта не влияет на числовое значение.
value = (value << 1) | bit # Следующий бит занимает младший разряд после сдвига.
return value # Значение сохраняется без знакового преобразования.
# Итог записи отделяет хороший CRC от ACK; ACK не доказывает применение команды CPU1.
def emit_frame(self, packet, end): # packet уже содержит все поля и результаты доступных проверок.
ack = packet['ack'] # Для чтения и необследованного ответа записи значение остаётся None.
suffix = '' if packet['operation'] == 'read' else ' ACK ' + ('?' if ack is None else ('OK' if ack else 'HIGH')) # Высокий уровень не различает NACK и отсутствие платы.
status = 'OK' if packet['crc_ok'] else 'BAD' # Целостность CRC показывается независимо от подтверждения.
text = '%s %X:%X = 0x%04X CRC %s%s' % (packet['operation'].upper(), packet['dev'], packet['reg'], packet['value'], status, suffix) # Адреса и данные удобны для сверки с регистрами проекта.
self.annotate(self.bits[0][0], end, 6, text) # Сводная аннотация покрывает весь кадр и ожидание ACK.
self.put(self.bits[0][0], end, self.out_python, ['FRAME', packet]) # Структурированный выход не теряет повторные одинаковые команды.
# Бит принимается только по нарастающему фронту, когда ответ ведомого уже установлен после спада.
def receive_bit(self, pins): # pins имеет порядок CLK, запрос ТМС, ответ платы.
index = len(self.bits) # Первый бит — направление, следующие восемь — адрес.
if index >= 29: # Кадр содержит 1+8+16+4 бита; лишние такты до паузы не становятся новым запросом.
return # Синхронизация нового кадра требует паузы на CLK.
source = 1 if index < 9 or self.bits[0][1] else 2 # Заголовок и запись идут от ТМС; данные чтения и CRC — от платы.
self.bits.append((self.samplenum, pins[source])) # Сохраняем точное положение каждого принятого бита.
count = len(self.bits) # Поле выводится сразу после последнего составляющего бита.
if count == 1: # Направление 0 означает чтение, 1 означает запись в HDL.
self.annotate(self.samplenum, self.samplenum, 0, 'WRITE' if self.bits[0][1] else 'READ') # Операция указана относительно ТМС.
for size, begin, kind, label, width in ((5, 1, 1, 'DEV', 1), (9, 5, 2, 'REG', 1), (25, 9, 3, 'DATA', 4)): # Границы определены ширинами адреса и данных HDL.
if count == size: # Одно поле выводится только один раз за кадр.
self.annotate(self.bits[begin][0], self.samplenum, kind, '%s 0x%0*X' % (label, width, self.field(begin, size))) # Нулевые старшие разряды данных сохраняются.
if count != 29: # Проверка CRC возможна только при полном кадре.
return # Неполные кадры будут отмечены по паузе или концу захвата.
direction, address, value = self.field(0, 1), self.field(1, 9), self.field(9, 25) # Восьмибитный адрес делится на устройство и регистр.
actual, expected = self.field(25, 29), frame_crc(direction, address, value) # CRC рассчитывается над теми же данными, которые видны на проводе.
packet = {'bus': 'SBus', 'operation': 'write' if direction else 'read', 'dev': address >> 4, 'reg': address & 15, 'value': value, 'crc': actual, 'crc_expected': expected, 'crc_ok': actual == expected, 'ack': None} # Неизвестное подтверждение не подменяется успешным.
self.annotate(self.bits[25][0], self.samplenum, 4, 'CRC %X / %X %s' % (actual, expected, 'OK' if actual == expected else 'BAD')) # Оба значения помогают диагностировать ошибку захвата.
if actual != expected: # Ошибка видна и в отдельной строке предупреждений.
self.annotate(self.bits[25][0], self.samplenum, 7, 'CRC mismatch') # Повреждённый кадр всё равно выводится для диагностики.
if direction: # Запись подтверждается после проверки CRC ведомым.
self.pending = packet # Выход кадра откладывается до выборки ACK.
self.ack_at = self.samplenum + self.ack_samples # Задержка отсчитывается от последнего бита CRC.
else: # У чтения после CRC нет отдельного подтверждения ведомого.
self.emit_frame(packet, self.samplenum) # Полное чтение доступно без ожидания межкадровой паузы.
# Частичный заголовок не выдаётся за достоверную операцию.
def close_partial(self, end): # Вызывается на паузе и при завершении захвата.
if self.pending is not None: # Захват может закончиться до заданного времени выборки ACK.
self.annotate(self.bits[-1][0], end, 7, 'Write ACK not sampled: capture ended') # Наблюдений недостаточно для вывода о подтверждении.
self.emit_frame(self.pending, end) # Полные данные сохраняются с ack=None.
self.pending = None # Повторный end() не должен дублировать кадр.
if 0 < len(self.bits) < 29: # Полный кадр уже выведен и не считается обрывом.
self.annotate(self.bits[0][0], end, 7, 'Incomplete SBus frame: %d/29 bits' % len(self.bits)) # Число бит помогает найти место потери синхронизации.
self.bits = [] # Следующая операция начинает собственный независимый буфер.
# end() поддерживает диагностику обрыва даже без следующего фронта или полной паузы.
def end(self): # DSView передаёт last_samplenum после последнего блока захвата.
self.close_partial(getattr(self, 'last_samplenum', getattr(self, 'samplenum', 0))) # Резервная граница полезна в средах без last_samplenum.
# Ожидаем фронты и ближайший таймер; тихий участок захвата не требует перебора отсчётов.
def decode(self): # Бесконечное ожидание завершается самой средой libsigrokdecode.
if not self.samplerate or not all(self.has_channel(i) for i in range(3)): # Для времени и обоих направлений нужны частота захвата и три сигнала.
raise ValueError('SBus requires samplerate, SBCLK, SBDATAIN and SBDATAOUT') # Ошибка настройки отличается от повреждённого кадра.
idle_us, ack_us = self.options['idle_us'], self.options['ack_us'] # Настройки относятся к временной шкале захвата.
if not math.isfinite(idle_us) or not math.isfinite(ack_us) or not 0 < ack_us < idle_us: # ACK должен наблюдаться раньше сброса при паузе.
raise ValueError('Require finite 0 < ACK delay < frame gap') # Неверные интервалы не должны создавать ложную диагностику.
gap = max(1, int(math.ceil(self.samplerate * idle_us / 1000000.0))) # Миллион переводит микросекунды в секунды.
self.ack_samples = max(1, int(math.ceil(self.samplerate * ack_us / 1000000.0))) # Округление вверх обеспечивает минимум один отсчёт ожидания.
if self.ack_samples >= gap: # При грубой дискретизации разные времена могут попасть в один отсчёт.
raise ValueError('Samplerate too low to separate ACK sampling and frame gap') # Такой захват не позволяет выполнить заданную временную проверку.
pins = self.wait({}) # Первый отсчёт задаёт уровень CLK без выдуманного фронта.
previous, last_edge, armed = pins[0], self.samplenum, False # Начало посреди кадра игнорируется до наблюдаемой паузы.
while True: # Каждый проход обрабатывает фронт или один ближайший таймер.
deadlines = [] if armed else [last_edge + gap] # После подтверждённой паузы достаточно дождаться следующего фронта.
if self.pending is not None: # Отдельный таймер ACK не зависит от дальнейших тактов CLK.
deadlines.append(self.ack_at) # Последний CRC может быть последним тактом в захвате.
conditions = [{0: 'e'}] # Учитываются оба фронта, поскольку сброс HDL отсчитывается от любого изменения CLK.
if deadlines: # Таймер задаётся относительно текущего положения декодера.
conditions.append({'skip': max(1, min(deadlines) - self.samplenum)}) # Минимум один отсчёт исключает ожидание в той же точке.
pins = self.wait(conditions) # Значения линий доступны и при срабатывании временного условия.
now = self.samplenum # Номер отсчёта общий для фронтов и таймеров.
if self.pending is not None and now >= self.ack_at: # ACK измеряется после CRC, а не на его последнем фронте.
self.pending['ack'] = pins[2] == 0 # В HDL низкий SBDATAOUT подтверждает запись; высокий означает отказ либо отсутствие ответа.
self.annotate(self.bits[-1][0], now, 5, 'ACK' if self.pending['ack'] else 'ACK HIGH (NACK / no response)') # Уровень ответа не скрывается даже при плохом CRC.
if not self.pending['ack']: # Отсутствие низкого ACK является отдельной проблемой обмена.
self.annotate(self.bits[-1][0], now, 7, 'No low write ACK') # Это не доказательство конкретной причины отказа.
self.emit_frame(self.pending, now) # Повторные записи выводятся отдельными кадрами.
self.pending = None # Таймер подтверждения больше не нужен.
if not armed and now - last_edge >= gap: # Пауза допустима как при высоком, так и при низком CLK.
self.close_partial(now) # Незавершённый предыдущий кадр отмечается до повторной синхронизации.
armed = True # Первый следующий нарастающий фронт начинает заголовок.
if pins[0] != previous: # Срабатывание одного таймера не должно создавать фиктивный бит.
if pins[0] and (armed or self.bits): # После паузы начинаем кадр; внутри кадра продолжаем сбор.
armed = False # До следующей длинной паузы новый заголовок запрещён.
self.receive_bit(pins) # Бит выбирается с нужной линии с учётом направления.
last_edge = now # Любой фронт перезапускает измерение неподвижного CLK.
previous = pins[0] # Следующий таймер сравнивается с последним реальным уровнем.
+64 -65
View File
@@ -1,71 +1,70 @@
# Сегментация SET v2 и интерпретация CAN-данных зависят от выбранного слоя. Адрес и номер
# сегмента должны проверяться до объединения данных; classic CAN-пакет ограничен восемью
# байтами. Этот адаптер переводит события libsigrokdecode в аннотации DSView; координаты
# выборок пересчитываются с учётом частоты захвата.
import sigrokdecode as srd # API sigrok передаёт кадры базового CAN-декодера и принимает аннотации.
from common.setgui_decoders.set_can import Reassembler # Существующий сборщик проверяет сегментацию и тайм-аут SET v2.
from common.setgui_decoders.template_protocols import CAN_PROFILES, LEGACY_PROJECTS, decode_can # Профили и каталоги определяются общими библиотеками templates.
import sigrokdecode as srd
from common.setgui_decoders.set_can import Reassembler, legacy
class Decoder(srd.Decoder): # Стековый анализатор добавляет прикладные дорожки к физическому CAN.
api_version = 3 # Версия интерфейса соответствует поставляемому libsigrokdecode4DSL.
id = 'set_can' # Стабильный ID сохраняет совместимость записей и меню SETGUI.
name = 'SET CAN' # Короткое имя используется в дорожках и диалоге выбора.
longname = 'SET CAN / ProtoCAN / Balsam / UMP / DEIF / legacy' # Подпись перечисляет подключённые семейства протоколов.
desc = 'Templates protocols, application fields, registers and SET v2 reassembly.' # Описывает результат прикладного разбора.
license = 'gplv2+' # Лицензия адаптера соответствует остальным декодерам SET.
inputs = ['can'] # Источник — базовый декодер CAN, а не сырые логические уровни.
outputs = ['set'] # Тип структурированного выхода сохранён для совместимости стека.
tags = ['Embedded/industrial'] # Категория для штатного каталога DSView.
options = ( # Несовместимые карты адресов выбираются явно.
{'id': 'protocol', 'desc': 'Protocol / протокол', 'default': 'protocan', 'values': CAN_PROFILES}, # Прежнее значение по умолчанию сохраняет настройки существующих записей.
{'id': 'project', 'desc': 'Legacy CAN project / проект', 'default': LEGACY_PROJECTS[0], 'values': LEGACY_PROJECTS}, # Проект применяется в режиме legacy.
{'id': 'ump_map', 'desc': 'UMP map / карта УМП', 'default': 'gas167', 'values': ('gas167', 'assigned')}, # Локальная карта отделена от назначенных глобальных GAS ID.
{'id': 'ump_node', 'desc': 'UMP node / номер УМП', 'default': 1, 'values': (1, 2)}, # Локальные адреса 167/v1 не содержат номер УМП.
) # Неприменимые к профилю настройки игнорируются.
annotations = (('frame', 'Frame'), ('payload', 'Payload'), ('error', 'Error'), ('field', 'Field'), ('register', 'Register')) # Первые три индекса сохраняют прежние дорожки.
annotation_rows = (('frames', 'Frames', (0,)), ('payload', 'Payload', (1,)), ('errors', 'Errors', (2,)), ('fields', 'Fields', (3,)), ('registers', 'Registers', (4,))) # Поля и регистры получают самостоятельные строки.
def __init__(self): # Каждый экземпляр имеет независимое состояние разбора.
self.reset() # Незавершённые сегменты не переходят между записями.
class Decoder(srd.Decoder):
api_version = 3
id = 'set_can'
name = 'SET CAN'
longname = 'SET v2 CAN / ProtoCAN / Balsam'
desc = 'Application fields and segmented SET packets over classic CAN.'
license = 'gplv2+'
inputs = ['can']
outputs = ['set']
tags = ['Embedded/industrial']
options = ({'id': 'protocol', 'desc': 'CAN protocol (select explicitly)',
'default': 'protocan', 'values': ('protocan', 'set-v2', 'balsam')},)
annotations = (('frame', 'Frame'), ('payload', 'Payload'), ('error', 'Error'))
annotation_rows = (('frames', 'Frames', (0,)), ('payload', 'Payload', (1,)), ('errors', 'Errors', (2,)))
def reset(self): # Перезапуск освобождает память сборщика.
self.reassembler = Reassembler() # Машина ограничивает число параллельных пакетов и проверяет порядок сегментов.
self.samplerate = None # Частота поступает событием metadata.
def __init__(self):
self.reset()
def metadata(self, key, value): # Метаданные задают шкалу времени сборки пакетов.
if key == srd.SRD_CONF_SAMPLERATE: # Прочие метаданные не влияют на тайм-ауты.
self.samplerate = value # Частота выражена в отсчётах в секунду.
# Состояние принадлежит одному запуску декодера. Сброс не должен
# переносить незавершённый кадр или частоту из предыдущей записи.
def reset(self):
self.reassembler = Reassembler()
self.samplerate = None
def start(self): # Выходы регистрируются в штатной фазе запуска sigrok.
self.out_ann = self.register(srd.OUTPUT_ANN) # Аннотации предназначены для дорожек и поиска DSView.
self.out_python = self.register(srd.OUTPUT_PYTHON) # Словарь полей доступен последующим слоям стека.
# DSView передаёт время в номерах отсчётов. Частота нужна общему ядру
# для перевода тайм-аутов и измерений в физические единицы.
def metadata(self, key, value):
if key == srd.SRD_CONF_SAMPLERATE:
self.samplerate = value
# Выходы регистрируются в жизненном цикле sigrok, а не в конструкторе.
# Аннотации предназначены для дорожек, структурированные события — для стека.
def start(self):
self.out_ann = self.register(srd.OUTPUT_ANN)
self.out_python = self.register(srd.OUTPUT_PYTHON)
def decode(self, ss, es, data):
frame_type, ident, rtr, dlc, payload = data
if frame_type != 'extended' or rtr == 'remote':
return
mode = self.options['protocol']
if not 0 <= dlc <= 8 or len(payload) != dlc:
events = [(ss, es, None, 'Invalid classic CAN DLC')]
# Сегментированный SET v2 требует времени для тайм-аута сборки.
# Идентификатор, порядок сегментов и CRC проверяет общее ядро.
elif mode == 'set-v2':
if not self.samplerate:
raise ValueError('SET CAN requires samplerate for reassembly timeout')
events = self.reassembler.feed(ident, payload, ss, es, es * 1000.0 / self.samplerate)
else:
try:
result = legacy(ident, payload, mode)
events = [(ss, es, result, None)] if result else []
except ValueError as exc:
events = [(ss, es, None, str(exc))]
for start, end, result, error in events:
self.put(start, end, self.out_ann, [2 if error else 0, [error or result['summary']]])
if result:
result['can_id'] = ident
self.put(start, end, self.out_python, ['FRAME', result])
if events and payload:
self.put(ss, es, self.out_ann, [1, [' '.join('%02X' % b for b in payload)]])
def decode(self, ss, es, data): # Границы входного CAN-кадра выражены в отсчётах.
frame_type, ident, rtr, dlc, payload = data # Кортеж соответствует выходу штатного CAN-декодера.
mode = self.options['protocol'] # Профиль определяет формат ID и полезной нагрузки.
if frame_type not in ('extended', 'standard') or rtr == 'remote': # RTR не содержит прикладных данных.
return # Такие кадры остаются в базовых дорожках CAN.
if frame_type == 'standard' and mode != 'deif': # DEIF использует STD CANopen, остальные подключённые протоколы — EXT.
return # Предотвращает интерпретацию 11-битного ID как адреса ProtoCAN.
if not 0 <= dlc <= 8 or len(payload) != dlc: # Classic CAN ограничивает нагрузку восемью байтами и требует совпадения длины с DLC.
events = [(ss, es, None, 'Invalid classic CAN DLC')] # Повреждённый кадр показывается как ошибка.
elif mode == 'set-v2' or mode == 'auto' and ident >> 24 == 0x12: # Авто распознаёт зарезервированный префикс SET v2 без угадывания проекта.
if not self.samplerate: # Частота нужна для корректного тайм-аута сборки.
raise ValueError('SET CAN requires samplerate for reassembly timeout') # Движок получает явную ошибку конфигурации.
events = self.reassembler.feed(ident, payload, ss, es, es * 1000.0 / self.samplerate) # Перевод отсчётов в миллисекунды соответствует контракту сборщика.
else: # Несегментированные протоколы обрабатывают каждый кадр независимо.
try: # Ошибка одного кадра не должна прекращать разбор записи.
result = decode_can(ident, payload, mode, extended=frame_type == 'extended', ump_map=self.options['ump_map'], ump_node=self.options['ump_node'], project=self.options['project']) # Подключает текущий парсер templates и выбранную карту.
events = [(ss, es, result, None)] if result else [] # Чужой ID не создаёт ложных событий выбранного проекта.
except ValueError as exc: # Проверки DLC, диапазонов и форматов возвращают диагностический текст.
events = [(ss, es, None, str(exc))] # Следующий кадр продолжит обрабатываться.
for start, end, result, error in events: # Сборщик может выдать несколько событий за один кадр.
self.put(start, end, self.out_ann, [2 if error else 0, [error or result['summary']]]) # Сводка попадает на дорожку Frames либо Errors.
if result: # Подробности выдаются для распознанного сообщения.
for title, value in result.get('fields', []): # Названия и единицы определены общим парсером.
self.put(start, end, self.out_ann, [3, ['%s: %s' % (title, value)]]) # Поля доступны для просмотра и поиска.
for address, value in result.get('registers') or []: # Отсутствующая регистровая нагрузка отличается от пустого запроса.
self.put(start, end, self.out_ann, [4, ['R%04X = %04X (%d)' % (address, value, value)]]) # Адрес и слово показаны в HEX, значение также в десятичной системе.
for warning in result.get('warnings', []): # Замечания общего парсера сохраняются вместе с корректными полями.
self.put(start, end, self.out_ann, [2, [warning]]) # Предупреждения видны в строке ошибок.
result['can_id'] = ident # ID остаётся доступным последующим слоям.
self.put(start, end, self.out_python, ['FRAME', result]) # Передаёт полную модель события.
if events and payload: # Сырые байты позволяют сопоставить расшифровку с исходным CAN.
self.put(ss, es, self.out_ann, [1, [' '.join('%02X' % byte for byte in payload)]]) # Порядок байтов совпадает с захватом.
+22 -7
View File
@@ -5,6 +5,7 @@
import sigrokdecode as srd
from common.setgui_decoders.set_uart import StreamParser
from common.setgui_decoders.template_protocols import LEGACY_PROJECTS # Проекты CAN внутри моста выбираются из того же каталога templates.
class Decoder(srd.Decoder):
@@ -21,9 +22,13 @@ class Decoder(srd.Decoder):
{'id': 'protocol', 'desc': 'Protocol', 'default': 'auto',
'values': ('auto', 'v2', 'v1', 'bridge')},
{'id': 'gap_ms', 'desc': 'Reset incomplete frame after gap (ms, 0 disables)', 'default': 100},
{'id': 'can_protocol', 'desc': 'Bridge CAN protocol', 'default': 'protocan', 'values': ('protocan', 'auto', 'devboard', 'balsam', 'ump-protocan', 'deif', 'legacy')}, # Профиль применяется к прикладным кадрам, переданным транспортом AA55.
{'id': 'project', 'desc': 'Bridge legacy CAN project', 'default': LEGACY_PROJECTS[0], 'values': LEGACY_PROJECTS}, # Исторический проект выбирается явно, поскольку его ID могут пересекаться с другими форматами.
{'id': 'ump_map', 'desc': 'Bridge UMP map', 'default': 'gas167', 'values': ('gas167', 'assigned')}, # Разделяет текущую локальную карту и назначенные глобальные GAS ID.
{'id': 'ump_node', 'desc': 'Bridge UMP node', 'default': 1, 'values': (1, 2)}, # Номер УМП задаётся отдельно от локального адреса регистра.
)
annotations = (('frame', 'Frame'), ('payload', 'Payload'), ('error', 'Error'))
annotation_rows = (('frames', 'Frames', (0,)), ('payload', 'Payload', (1,)), ('errors', 'Errors', (2,)))
annotations = (('frame', 'Frame'), ('payload', 'Payload'), ('error', 'Error'), ('field', 'Field')) # Индексы прежних аннотаций сохранены, подробные поля добавлены в конец.
annotation_rows = (('frames', 'Frames', (0,)), ('payload', 'Payload', (1,)), ('errors', 'Errors', (2,)), ('fields', 'Fields', (3,))) # Поля прикладного парсера видны на отдельной дорожке.
def __init__(self):
self.reset()
@@ -52,27 +57,37 @@ class Decoder(srd.Decoder):
prefix = ('RX', 'TX')[direction] + ' '
self.put(ss, es, self.out_ann, [2 if error else 0, [prefix + (error or frame['summary'])]])
if frame:
if frame['protocol'] == 'ProtoCAN bridge' and frame['flags'] & 1 and not frame['flags'] & 10:
if frame['protocol'] == 'ProtoCAN bridge' and not frame['flags'] & 10: # Флаги RTR и ERR исключают прикладные данные; STD допускается для профиля DEIF.
# Imported only at decode time: both packages are installed together.
from common.setgui_decoders.set_can import legacy
from common.setgui_decoders.template_protocols import decode_can # Мост использует те же прикладные парсеры, что анализатор SET CAN.
try:
application = legacy(frame['can_id'], frame['payload'])
application = decode_can(frame['can_id'], frame['payload'], self.options['can_protocol'], extended=bool(frame['flags'] & 1), project=self.options['project'], ump_map=self.options['ump_map'], ump_node=self.options['ump_node']) # Флаг IDE и выбранные настройки передаются общему парсеру без изменения wire-данных.
frame['application'] = application
self.put(ss, es, self.out_ann, [0, [application['summary']]])
if application: # Выбранный профиль может не распознать чужой CAN ID.
self.put(ss, es, self.out_ann, [0, [application['summary']]]) # Прикладная сводка дополняет сведения о транспортном кадре моста.
for title, value in application.get('fields', []): # Детали CAN внутри UART берутся из того же результата templates.
self.put(ss, es, self.out_ann, [3, ['%s: %s' % (title, value)]]) # Поля доступны без отдельного импорта записи в CAN-монитор.
except ValueError as exc:
self.put(ss, es, self.out_ann, [2, [str(exc)]])
for title, value in frame.get('fields', []): # Стековые UART-профили могут возвращать готовые прикладные поля.
self.put(ss, es, self.out_ann, [3, [prefix + '%s: %s' % (title, value)]]) # Префикс RX/TX сохраняет направление каждого значения.
frame['direction'] = direction
self.put(ss, es, self.out_python, ['FRAME', frame])
if frame['payload']:
self.put(ss, es, self.out_ann, [1, [prefix + ' '.join('%02X' % b for b in frame['payload'])]])
def make_parser(self): # Фабрика позволяет использовать ту же UART-границу с другим переносимым потоковым парсером.
return StreamParser(self.options['protocol']) # Каждый экземпляр хранит байты только одного направления.
def decode(self, ss, es, data):
kind, direction, payload = data
if direction not in (0, 1):
return
# RX и TX имеют независимые парсеры: перемежающиеся байты двух направлений
# нельзя объединять в один прикладной кадр.
parser = self.parsers.setdefault(direction, StreamParser(self.options['protocol']))
if direction not in self.parsers: # В отличие от setdefault, проверка не создаёт и не отбрасывает парсер на каждом UART-событии.
self.parsers[direction] = self.make_parser() # Парсер создаётся один раз на направление и сохраняет незавершённый кадр.
parser = self.parsers[direction] # RX и TX продолжают использовать независимые буферы.
if kind in ('INVALID STOPBIT', 'INVALID STARTBIT', 'PARITY ERROR', 'BREAK'):
self.emit(parser.flush(), direction)
self.put(ss, es, self.out_ann, [2, [kind]])
@@ -0,0 +1 @@
from .pd import Decoder # Экспортирует стандартную точку входа анализатора libsigrokdecode.
+18
View File
@@ -0,0 +1,18 @@
from set_uart.pd import Decoder as SetUartDecoder # Общий адаптер уже разделяет RX/TX, учитывает паузы и отклоняет ошибки UART.
from common.setgui_decoders.tms_uart import LAYOUTS, TmsStreamParser, tms # Подключает существующий парсер и каталог раскладок templates.
class Decoder(SetUartDecoder): # Использует проверенную UART-границу вместо второй реализации обработки байтов sigrok.
id = 'tms_uart' # Отдельный ID позволяет одновременно анализировать SET и исторический терминальный обмен.
name = 'TMS UART' # Короткое имя отображается в меню и дорожках.
longname = 'TMS terminal / TMS_TO_TERMINAL' # Полное имя соответствует структуре действующего протокола терминала.
desc = 'Templates TMS terminal frames, analog values, discrete bits and CRC.' # Подсказка перечисляет доступные поля расшифровки.
options = ( # Параметры раскладки повторяют возможности общего парсера терминала.
{'id': 'layout', 'desc': 'Layout / раскладка', 'default': tms.DEFAULT_PRESET, 'values': LAYOUTS}, # Готовые раскладки поступают из единого каталога templates.
{'id': 'digit_bytes', 'desc': 'Custom discrete bytes / байт дискретов', 'default': 38}, # В custom задаётся длина дискретной части в байтах.
{'id': 'analog_count', 'desc': 'Custom analog words / слов аналогов', 'default': 34}, # В custom задаётся число знаковых 16-битных аналоговых слов.
{'id': 'crc', 'desc': 'CRC variant', 'default': tms.DEFAULT_CRC, 'values': tuple(tms.CRC_VARIANTS)}, # Неподтверждённые CRC кадры общий парсер не выдаёт.
{'id': 'gap_ms', 'desc': 'Reset after gap (ms, 0 disables)', 'default': 100}, # Пауза 100 мс по умолчанию отделяет незавершённые посылки.
) # Опции протокола SET здесь не требуются.
def make_parser(self): # Базовый адаптер создаёт отдельный парсер для каждого направления UART.
return TmsStreamParser(self.options['layout'], self.options['digit_bytes'], self.options['analog_count'], self.options['crc']) # Общая модель проверяет диапазоны и рассчитывает длину кадра.
+36 -11
View File
@@ -63,7 +63,8 @@ if (-not (Test-Path -LiteralPath (Join-Path $decoderRoot 'common') -PathType Con
# An explicit allowlist excludes tests, bytecode and unrelated modules.
# The private common/setgui_decoders layout matches the embedded build.
$files = @()
foreach ($name in @('gate_driver_timing', 'transistor_pair', 'set_uart', 'set_can', 'pm35_uart')) {
$manifest = Get-Content -LiteralPath (Join-Path $PSScriptRoot 'protocol-files.json') -Encoding UTF8 -Raw | ConvertFrom-Json # Общая ведомость совпадает с рецептом встроенного DSView.
foreach ($name in $manifest.adapters) { # Список включает все поставляемые анализаторы без отдельного перечня в установщике.
foreach ($leaf in @('__init__.py', 'pd.py')) {
$files += [pscustomobject]@{
Source = Join-Path $PSScriptRoot "decoders/$name/$leaf"
@@ -71,12 +72,18 @@ foreach ($name in @('gate_driver_timing', 'transistor_pair', 'set_uart', 'set_ca
}
}
}
foreach ($name in @('__init__', 'gate_timing', 'transistor_pair', 'set_uart', 'set_can', 'pm35_uart')) {
foreach ($name in $manifest.cores) { # Общие ядра и адаптеры устанавливаются из одной закреплённой версии templates.
$files += [pscustomobject]@{
Source = Join-Path $templateRoot "python/logic_analyzer/decoders/$name.py"
Relative = "common/setgui_decoders/$name.py"
}
}
foreach ($name in $manifest.template_files) { # Подключённым парсерам нужны исходные модули и JSON-словари протоколов.
$files += [pscustomobject]@{ # Новые зависимости проходят те же проверки, резервное копирование и откат, что существующие ядра.
Source = Join-Path $templateRoot "python/$name" # Источник всегда находится в общем templates, независимо от текущего каталога.
Relative = "common/setgui_decoders/templates/$name" # Закрытый каталог не создаёт лишних анализаторов в списке sigrok.
} # Исходные пакеты сохраняют собственные относительные импорты и не требуют внешнего Python.
} # Все зависимости включены в транзакцию до первого изменения установленного декодера.
# Validate the entire payload and destination before changing any decoder.
foreach ($file in $files) {
if (-not (Test-Path -LiteralPath $file.Source -PathType Leaf)) {
@@ -97,13 +104,31 @@ if ($CheckOnly) {
Write-Output "Validated $($files.Count) files for $targetRoot. No files changed."
return
}
# A mapped/running Windows EXE cannot be opened for writing. Never terminate DSView.
try {
$handle = [IO.File]::Open($exe, [IO.FileMode]::Open, [IO.FileAccess]::ReadWrite, [IO.FileShare]::Read)
$handle.Dispose()
} catch {
throw "Close DSView and check write permissions for '$targetRoot'. For Program Files, run PowerShell as administrator. $($_.Exception.Message)"
}
# Проверяем запущенный процесс отдельно: установка декодеров не требует права записи в DSView.exe.
foreach ($process in @(Get-Process -Name 'DSView' -ErrorAction SilentlyContinue)) { # Другие экземпляры DSView не мешают обновлению выбранного каталога.
try { # Доступ к пути процесса может быть ограничен правами владельца.
$processPath = $process.MainModule.FileName # Путь определяет принадлежность процесса конкретной установке.
} catch { # Без пути нельзя достоверно исключить работу целевого компонента.
throw 'Cannot inspect a running DSView process. Close DSView before installing decoders.' # Установщик не завершает процесс и не прерывает захват.
} # Ошибка просмотра процесса отделена от отсутствия права копировать файлы.
if ($processPath -and [string]::Equals([IO.Path]::GetFullPath($processPath), $exe, [StringComparison]::OrdinalIgnoreCase)) { # Регистр Windows-пути не влияет на совпадение.
throw "Close DSView before updating decoders in '$targetRoot'." # После закрытия требуется повторный запуск того же установщика.
} # Работа другой установки DSView допускается.
} # Проверка выполняется только при настоящем копировании, после CheckOnly.
# Пробные файлы проверяют реальные каталоги назначения и резервных копий, не затрагивая EXE.
foreach ($directory in @($targetRoot, $decoderRoot)) { # Резервные копии создаются рядом с EXE, а новые модули — внутри decoders.
$probe = Join-Path $directory ('.set-decoder-write-' + [guid]::NewGuid().ToString('N') + '.tmp') # Уникальное имя исключает перезапись пользовательского файла.
$handle = $null # Дескриптор освобождается и при неудачном создании файла.
try { # Права записи проверяются до резервного копирования и замены первого декодера.
$handle = [IO.File]::Open($probe, [IO.FileMode]::CreateNew, [IO.FileAccess]::Write, [IO.FileShare]::None) # Пробный файл проверяет создание в выбранном каталоге.
} catch { # Защищённый Program Files требует повышения прав либо выбора доступной установки.
throw "No write access to '$directory'. Select a writable DSView directory or run PowerShell as administrator for Program Files. $($_.Exception.Message)" # Сообщение называет каталог, а не ошибочно запущенный EXE.
} finally { # Временные проверки не должны оставлять файлы после успешного или неуспешного запуска.
if ($null -ne $handle) { $handle.Dispose() } # Закрываем только дескриптор созданного нами файла.
if ([IO.File]::Exists($probe)) { [IO.File]::Delete($probe) } # Удаляется только уникальный файл текущей проверки, без обхода каталогов.
} # Исходные декодеры на этом этапе ещё не изменены.
} # Дальнейшая транзакция сохраняет существующую политику резервного копирования и отката.
# Keep each previous version outside decoder discovery directories.
# Retain backups after success for manual recovery, not only after errors.
@@ -150,6 +175,6 @@ try {
}
throw $failure
}
Write-Output "Installed: IGBT 1SP/1SD, SET UART, SET CAN, PM35 UART in $decoderRoot"
Write-Output "Installed: $($manifest.adapters -join ', ') in $decoderRoot" # Список формируется по общей ведомости, включая Plates PBus и Plates SBus.
if (Test-Path -LiteralPath $backup) { Write-Output "Previous files retained in: $backup" }
Write-Output 'Restart DSView. Add UART/CAN first, then stack the corresponding SET decoder. No external Python is required.'
Write-Output 'Restart DSView. Plates PBus/SBus use logic channels directly; SET UART/CAN decoders stack over UART/CAN. No external Python is required.' # Подключение шинных анализаторов отличается от надстроек над UART/CAN.
+17
View File
@@ -0,0 +1,17 @@
{
"adapters": ["gate_driver_timing", "transistor_pair", "set_uart", "set_can", "pm35_uart", "tms_uart", "plates_pbus", "plates_sbus"],
"cores": ["__init__", "gate_timing", "transistor_pair", "set_uart", "set_can", "pm35_uart", "template_protocols", "tms_uart"],
"template_files": [
"protocan/__init__.py",
"protocan/native.py",
"protocan/protocan.py",
"protocan/balsam.py",
"protocan/legacycan.py",
"protocan/gas_167.py",
"protocan/gas_167_registers.json",
"set_devices/__init__.py",
"set_devices/deif_xdi.py",
"set_devices/ump_can.py",
"set_devices/tms_terminal.py"
]
}
+3 -3
View File
@@ -597,8 +597,8 @@ index 648eb5b8..1a023707 100644
+ const auto after = _protocol_lay_items.size();
+ ok = phase % 2 == 0 ? after == before : after == (phase == 1 ? before - 1 : 0);
+ }
+ } else if (phase < 8) {
+ const QString id = QStringList({"gate_driver_timing", "set_uart", "set_can", "pm35_uart"})[phase - 4];
+ } else if (phase < 9) { // Проверяем также новый парсер терминальных UART-посылок ТМС.
+ const QString id = QStringList({"gate_driver_timing", "set_uart", "set_can", "pm35_uart", "tms_uart"})[phase - 4]; // Индекс отсчитывается после четырёх проверок удаления анализаторов.
+ if (get_protocol_index_by_id(id) < 0) ok = false;
+ else {
+ QTimer::singleShot(80, this, [report, id]() {
@@ -618,7 +618,7 @@ index 648eb5b8..1a023707 100644
+ ok = QString(trace->decoder()->stack().back()->decoder()->id) == id;
+ }
+ }
+ } else if (phase == 8) {
+ } else if (phase == 9) { // После пяти прикладных анализаторов проверяем удаление всего набора дорожек.
+ answer(QMessageBox::Yes);
+ on_del_all_protocol();
+ ok = _protocol_lay_items.empty() && _session->get_decode_signals().empty();
+81 -1
View File
@@ -58,6 +58,9 @@ try:
gate = importlib.import_module('gate_driver_timing.pd')
pair_decoder = importlib.import_module('transistor_pair.pd')
pmcore = importlib.import_module('common.setgui_decoders.pm35_uart')
templates_core = importlib.import_module('common.setgui_decoders.template_protocols') # Новый прикладной слой импортируется из изолированного runtime.
tms_decoder = importlib.import_module('tms_uart.pd') # Проверяет контракт точки входа нового UART-анализатора.
tms_core = importlib.import_module('common.setgui_decoders.tms_uart') # Потоковый адаптер использует поставленные общие раскладки терминала.
finally:
sys.path.pop(0)
if previous is None:
@@ -225,7 +228,7 @@ class CanTests(unittest.TestCase):
cancore.legacy(0x1b530010, b'\x00')
def test_balsam_mask_and_endianness(self):
result = cancore.legacy(0xba0010, bytes.fromhex('a01012340000ffff'), 'balsam')
result = cancore.legacy(0xba0010, bytes.fromhex('0000ffffa0101234'), 'balsam') # Реальная прошивка передаёт value2, value3, header, value1; отмечены первое и третье слова.
self.assertEqual(result['registers'], [(16, 0x1234), (18, 0xffff)])
self.assertIsNone(cancore.legacy(0xba000f, bytes(8), 'balsam'))
@@ -241,6 +244,83 @@ class CanTests(unittest.TestCase):
self.assertIn('status=0', cancore.legacy(0x1b5c0702, bytes.fromhex('00ff000000000000'))['summary'])
class TemplateProtocolTests(unittest.TestCase): # Сверяет прикладные события DSView с действующими парсерами templates.
def test_every_legacy_project_uses_its_wire_layout(self): # Все проекты проверяются настоящими кодировщиками обоих исторических форматов.
for project in templates_core.legacycan.PROJECTS: # Каталог включает Буксир, СЭДБМ, Ледокол, Бальзам, 23550, Янтарь и варианты формата.
with self.subTest(project=project.name): # Ошибка сообщает конкретный несовместимый профиль.
node = project.nodes[0] # Достаточно одного узла для проверки раскладки выбранного проекта.
packet = templates_core.legacycan.encode_write(project.format, node.rx_id, 16, (0x1234, 0xffff)) # Различающиеся байты выявляют ошибку порядка слов и байтов.
result = templates_core.decode_can(packet.can_id, packet.data, 'legacy', project=project.name) # Разбор выполняется тем же путём, что у адаптера sigrok.
self.assertEqual(result['registers'], [(16, 0x1234), (17, 0xffff)]) # Оба wire-формата должны восстанавливать одинаковые адреса и значения.
self.assertIn(node.name, result['summary']) # Вывод включает имя устройства из актуального каталога проекта.
def test_balsam_real_wire_order_and_pult(self): # Регрессия неправильного положения адресного слова в прежнем адаптере.
for ident in (0xba0004, 0xba0014, 0x745009, 0x745019): # Проверяются УМП в обоих направлениях и отдельная пара ID пульта.
result = templates_core.decode_can(ident, bytes.fromhex('11223344e07f8000'), 'balsam') # Маска 111 в header=E07F отмечает три слова начиная с командного регистра 127.
self.assertEqual(result['registers'], [(127, 0x8000), (128, 0x1122), (129, 0x3344)]) # В wire сначала идут второе и третье слова, а первое находится в конце.
self.assertIsNone(templates_core.decode_can(0xba000f, bytes(8), 'balsam')) # Отсутствующий узел не выдаётся за сообщение Balsam.
def test_ump_maps_keep_nodes_and_assigned_ids_separate(self): # Локальная карта 167/v1 и новые глобальные ID не должны смешиваться.
local = templates_core.decode_can(0x1b53007f, b'\x80\x00', 'ump-protocan', ump_node=2) # Бит 7 командного регистра означает пуск УМП в локальной карте.
self.assertIn('УМП 2', local['summary']) # Локальный адрес не теряет выбранный вручную номер устройства.
self.assertIn('cUMPstart', local['summary']) # Имена команд берутся из действующей карты, а не остаются сырым HEX.
assigned = templates_core.decode_can(0x1b530000 | 6000, b'\x01\x00', 'ump-protocan', ump_map='assigned') # Десятичный GAS ID 6000 относится к назначенной карте второго УМП.
self.assertIn('sens_error[0]', assigned['summary']) # Параметр получает имя из JSON-словаря templates.
def test_deif_standard_can_and_physical_value(self): # DEIF должен получать STD-кадры, которые прежний SET CAN отбрасывал.
decoder = instance(can, protocol='deif') # Выбор DEIF явно разрешает стандартный CANopen ID.
raw = bytes.fromhex('010130027b000000') # Объект 0x3001:02 содержит RAW=123, соответствующий углу 12.3 градуса.
decoder.decode(10, 90, ('standard', 0x201, 'data', len(raw), raw)) # Вектор проходит реальную границу адаптера sigrok.
result = frames(decoder)[0] # Результат доступен и в Python-выходе, и в аннотациях.
self.assertIn('12.3', result['summary']) # Масштаб задаёт существующий DEIF-парсер.
self.assertTrue(any(item[2] == 0 and item[3][0] == 3 for item in decoder.emitted)) # Проверяет фактическое появление подробных полей на новой дорожке.
def test_can_auto_routes_set_v2_and_balsam(self): # Авто ограничено проверяемыми сигнатурами и не угадывает исторические проекты.
decoder = instance(can, protocol='auto') # Профиль использует прежний сборщик SET v2 и общий парсер Balsam.
for index, payload in enumerate(CanTests().segments()): # Документированный SET PING разбивается штатным тестовым транспортом.
decoder.decode(index * 1000, index * 1000 + 900, ('extended', 0x122a0000, 'data', len(payload), payload)) # Номер отсчёта обеспечивает проверяемый тайм-аут сборки.
self.assertEqual(frames(decoder)[-1]['raw'], PING) # Авто должен вернуть исходный CRC-подтверждённый SET v2 пакет.
raw = bytes.fromhex('0000000080101234') # Заголовок отмечает первое слово по адресу 16, находящееся в конце CAN-данных.
decoder.decode(4000, 4900, ('extended', 0xba0014, 'data', 8, raw)) # ID относится к ответу первого УМП Balsam 167.
self.assertEqual(frames(decoder)[-1]['registers'], [(16, 0x1234)]) # Авто не интерпретирует Balsam как Boot Data ProtoCAN.
def test_uart_bridge_uses_selected_can_profile(self): # Проверяет перенос общего CAN-разбора через UART-транспорт AA55.
for profile, ident, flags, payload in (('balsam', 0xba0014, 1, bytes.fromhex('0000000080101234')), ('deif', 0x201, 0, bytes.fromhex('010130027b000000'))): # Векторы охватывают EXT Balsam и STD DEIF с разным значением IDE.
decoder = instance(uart, can_protocol=profile) # Выбор профиля моста не меняет основной потоковый формат SET UART.
body = bytes([6 + len(payload), 1, flags]) + struct.pack('<I', ident) + payload # Длина охватывает seq, flags, 32-битный ID и полезные данные моста.
raw = b'\xaa\x55' + body + struct.pack('<H', wire.crc16(body)) # CRC-16/CCITT-FALSE покрывает поле длины и весь транспортный кадр после сигнатуры.
uart_bytes(decoder, raw) # Передаёт только обычные UART-события, как настоящий базовый декодер.
result = frames(decoder)[0]['application'] # Структурированный кадр содержит результат вложенного прикладного парсера.
self.assertEqual(result['protocol'], 'Balsam' if profile == 'balsam' else 'DEIF XDi-192') # IDE и выбранный профиль должны дойти до соответствующего общего парсера.
def test_tms_noise_coordinates_and_independent_directions(self): # Проверяет потоковый поиск по CRC и сохранение координат после шума.
decoder = instance(tms_decoder) # Используются стандартная раскладка message2.h и CRC MODBUS.
tms = tms_core.tms # Тестовый кодировщик и декодер получают один канонический контракт.
layout = tms.default_layout() # Длина определяется текущими числами дискретных байтов и аналоговых слов.
raw = tms.build(2, 67, bytes([1]) + bytes(layout.digit_bytes - 1), [-123] + [0] * (layout.analog_count - 1), layout) # Ответ CMD_STD_ANS содержит первый дискрет и отрицательный аналог.
uart_bytes(decoder, b'noise' + raw) # Предшествующие байты должны быть пропущены по CRC без сдвига границ события.
uart_bytes(decoder, raw, direction=1) # Второе направление обрабатывается независимым парсером.
results = frames(decoder) # Извлекает только структурированные события готовых кадров.
self.assertEqual([item['direction'] for item in results], [0, 1]) # RX и TX не объединяются в один буфер.
self.assertEqual(results[0]['analogs'][0], -123) # Знаковый int16 сохраняется без преобразования в беззнаковое слово.
event = next(item for item in decoder.emitted if item[2] == 1) # Находит временные границы первого подтверждённого пакета.
self.assertEqual((event[0], event[1]), (500, (len(raw) + 4) * 100 + 90)) # Пять байтов шума занимают 500 отсчётов при шаге 100 в тестовом UART.
def test_tms_gap_and_crc_reject_incomplete_frames(self): # CRC и пауза должны исключать ложную выдачу неполного пакета.
decoder = instance(tms_decoder, layout='custom', digit_bytes=70, analog_count=80) # Индивидуальная раскладка поддерживает текущую посылку 22220 размером 235 байт.
tms = tms_core.tms # Источник CRC и структуры совпадает с общим парсером терминала.
layout = tms.Layout(70, 80) # 2 байта заголовка, 70 дискретов, 160 байт аналогов и 3 байта хвоста.
raw = tms.build(1, 67, bytes(70), [0] * 80, layout) # Формирует полностью корректный пакет известной длины.
damaged = bytearray(raw) # Изменение одного байта позволяет проверить обязательность CRC.
damaged[-2] ^= 1 # Повреждается старший байт CRC, а формат и длина сохраняются.
uart_bytes(decoder, damaged) # Повреждённый кадр не должен давать прикладного события.
self.assertFalse(frames(decoder)) # Подтверждает отсутствие ложного пакета при несовпадении CRC.
uart_bytes(decoder, raw[:40], base=200000) # Начало кадра поступает после паузы и сбрасывает прежний шум.
uart_bytes(decoder, raw, base=400000) # Новая пауза отбрасывает хвост и позволяет разобрать полный кадр.
self.assertEqual(len(frames(decoder)), 1) # Только последний полный пакет проходит проверку границ и CRC.
self.assertEqual(frames(decoder)[0]['raw'], raw) # Событие сохраняет точные исходные байты записи.
class PM35Tests(unittest.TestCase):
def test_single_wire_auto(self):
reader = pmcore.PM35Parser('auto')
+38 -1
View File
@@ -48,12 +48,18 @@ sys.path.insert(0, str(root))
stub = types.ModuleType('sigrokdecode')
stub.Decoder = type('Decoder', (), {})
sys.modules['sigrokdecode'] = stub
for name in ('gate_driver_timing', 'transistor_pair', 'set_uart', 'set_can', 'pm35_uart'):
for name in ('gate_driver_timing', 'transistor_pair', 'set_uart', 'set_can', 'pm35_uart', 'tms_uart', 'plates_pbus', 'plates_sbus'): # Все анализаторы, включая обе 96-контактные шины, загружаются без установленного SETGUI.
module = importlib.import_module(name + '.pd')
assert module.Decoder.api_version == 3
core = importlib.import_module('common.setgui_decoders.gate_timing')
pathlib.Path(core.__file__).resolve().relative_to(root)
assert '1SP0635' in core.PROFILES
protocols = importlib.import_module('common.setgui_decoders.template_protocols') # Проверяет прикладные парсеры в чистом процессе Python с флагом -I.
result = protocols.decode_can(0xBA0014, bytes.fromhex('0000000080101234'), 'balsam') # Вектор использует фактическое положение адресного слова Balsam.
assert result['registers'] == [(16, 0x1234)] # Импорт должен завершаться реальным прикладным разбором, а не только обнаружением модуля.
for dependency in (protocols.pc, protocols.balsam, protocols.ump_can): # Канонические библиотеки должны поступать из установленной копии декодеров.
pathlib.Path(dependency.__file__).resolve().relative_to(root) # Исключает случайный успех за счёт пакетов рабочего checkout.
assert len(protocols.LEGACY_PROJECTS) == 9 # Установка включает весь текущий каталог исторических проектов.
'''
check = subprocess.run([sys.executable, '-I', '-c', code, str(self.app/'decoders')],
cwd=self.app, capture_output=True, text=True)
@@ -72,6 +78,37 @@ assert '1SP0635' in core.PROFILES
self.assertEqual((self.app/('decoders/common/setgui_decoders/'+name+'.py')).read_bytes(),
(ROOT.parents[1]/('python/logic_analyzer/decoders/'+name+'.py')).read_bytes())
# Права на EXE не должны требоваться при обновлении только Python-декодеров.
def test_read_only_executable_is_supported(self): # Повторяет причину ложного отказа старой проверки DSView.exe.
import stat # Атрибут read-only выставляется без изменения содержимого EXE.
executable = self.app / 'DSView.exe' # Используется фиктивная установка, не установленный DSView.
executable.chmod(stat.S_IREAD) # Только EXE недоступен для записи; каталоги декодеров доступны.
try: # Атрибут обязательно снимается перед очисткой временной папки.
result = self.run_installer() # Установщик должен проверять каталоги, а не открывать EXE на запись.
self.assertEqual(result.returncode, 0, result.stdout + result.stderr) # Read-only EXE не мешает копированию декодеров.
self.assertTrue((self.app / 'decoders/plates_pbus/pd.py').is_file()) # Ведомость действительно включает PBus.
self.assertTrue((self.app / 'decoders/plates_sbus/pd.py').is_file()) # Ведомость действительно включает SBus.
self.assertEqual(executable.read_bytes(), b'fixture, not executable') # Содержимое EXE остаётся исходным.
self.assertEqual(list(self.app.rglob('.set-decoder-write-*.tmp')), []) # Пробные файлы не остаются после проверки прав.
finally: # Windows запрещает удалить read-only файл обычной очисткой TemporaryDirectory.
executable.chmod(stat.S_IREAD | stat.S_IWRITE) # Возвращаем право удаления только временной фикстуре.
# Запущенная целевая установка должна обнаруживаться без обращения к EXE на запись.
def test_running_target_is_rejected_before_copy(self): # Подмена процесса исключает запуск настоящего приложения.
runner = Path(self.temp.name) / 'running-target.ps1' # Обёртка существует только внутри тестовой папки.
runner.write_text('''
param([string]$Installer, [string]$Target) # Пути приходят от временной фикстуры теста.
function Get-Process { # Подмена ограничена текущим тестовым процессом PowerShell.
param([string]$Name, [string]$ErrorAction) # Параметры соответствуют вызову установщика.
[pscustomobject]@{ MainModule = [pscustomobject]@{ FileName = (Join-Path $Target 'DSView.exe') } } # Фиктивный процесс относится к выбранной установке.
} # Настоящие процессы не запускаются и не завершаются.
& $Installer -DsViewPath $Target # Общий установщик должен отвергнуть работу до копирования.
''', encoding='utf-8') # Сценарий хранится в UTF-8, как остальные исходники проекта.
result = subprocess.run([SHELL, '-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', str(runner), '-Installer', str(ROOT / 'install_decoders.ps1'), '-Target', str(self.app)], capture_output=True, text=True) # Изолированное выполнение сохраняет состояние настоящего DSView.
self.assertNotEqual(result.returncode, 0) # Запущенный целевой процесс требует закрытия приложения.
self.assertFalse((self.app / 'decoders/plates_pbus').exists()) # Первый новый анализатор ещё не должен появиться.
self.assertFalse((self.app / 'set-decoder-backups').exists()) # Резервное копирование также не должно начаться.
def test_check_only_does_not_install(self):
result = self.run_installer('-CheckOnly')
self.assertEqual(result.returncode, 0, result.stderr)
+322
View File
@@ -0,0 +1,322 @@
"""Проверки потоковых декодеров на цифровых трассах без установленного sigrokdecode.""" # Подмена только среды позволяет исполнять настоящий decode().
import ast # Проверка синтаксиса сохраняет совместимость с Python 3.6 в DSView.
import copy # Выходы фиксируются в момент put(), как при передаче данных в C-библиотеку.
import importlib # Пакеты загружаются тем же экспортируемым именем Decoder, что и в DSView.
from pathlib import Path # Пути вычисляются относительно теста, без зависимости от установки пользователя.
import sys # Временная подмена sigrokdecode нужна только на время импорта пакетов.
import types # Модуль-заглушка содержит минимальную поверхность API среды.
import unittest # Тесты запускаются стандартным Python без внешних зависимостей.
# Конец входных данных прерывает бесконечный decode(), как завершение потока в среде.
class EndOfCapture(Exception): # Отдельный тип не скрывает реальные ошибки декодеров.
pass # Дополнительных полей исключению не требуется.
# Эта среда реализует ожидание фронтов и таймеров, но не знает формата PBus или SBus.
class Runtime: # Декодеры наследуют её вместо встроенного C-класса только в тестах.
def register(self, output): # Идентификаторы выходов достаточно различать по их типу.
return output # Каждый декодер регистрирует один выход каждого используемого типа.
def has_channel(self, index): # Подключённость каналов задаётся конкретным тестом.
return index in self.connected # Необязательный PBCLK можно оставить неподключённым.
def put(self, start, end, output, data): # Проверяем контракт выходов независимо от содержимого кадров.
assert 0 <= start <= end < len(self.samples), (start, end, len(self.samples)) # Аннотации не должны уходить за границы захвата.
if output == 0: # В заглушке ноль соответствует OUTPUT_ANN.
assert 0 <= data[0] < len(self.annotations) and data[1] # Класс должен быть объявлен и иметь хотя бы один текст.
self.result.append((start, end, output, copy.deepcopy(data))) # Дальнейшая работа автомата не меняет уже выведенные пакеты.
def wait(self, conditions): # Поддерживаем только документированные условия, реально используемые декодерами.
if conditions == {}: # Пустое условие получает исходный отсчёт без фиктивного фронта.
self.samplenum = 0 # Первый отсчёт соответствует началу трассы.
return self.samples[0] # Возвращаются все логические каналы в порядке объявления.
conditions = conditions if isinstance(conditions, list) else [conditions] # Список условий означает логическое ИЛИ.
origin = self.samplenum # skip отсчитывается от последней точки возврата wait().
for sample in range(origin + 1, len(self.samples)): # Фронт не должен повторно срабатывать на прежнем отсчёте.
matched = 0 # Маска совпадений соответствует поведению libsigrokdecode4DSL.
for index, condition in enumerate(conditions): # Условие-словарь объединяет свои элементы через И.
valid = True # Пустое множество ограничений не запрещает совпадение.
for channel, edge in condition.items(): # Проверяем таймер либо изменение канала.
if channel == 'skip': # Временное условие задаётся числом отсчётов.
valid = valid and sample >= origin + edge # Таймер может совпасть с фронтом в той же точке.
else: # Цифровой канал имеет уровень 0 или 1.
before, after = self.samples[sample - 1][channel], self.samples[sample][channel] # Сравниваются соседние отсчёты, а не соседние пробуждения.
valid = valid and before != after and (edge == 'e' or (edge == 'r' and after == 1) or (edge == 'f' and after == 0)) # Разрешены оба фронта или отдельное направление.
if valid: # Несколько альтернатив могут совпасть одновременно.
matched |= 1 << index # DSView представляет matched целочисленной маской.
if matched: # Возвращаем ближайшее подходящее событие, не пропуская таймеры.
self.samplenum, self.matched = sample, matched # Атрибуты обновляются до возврата уровней.
return self.samples[sample] # Декодер видит уровни именно в точке события.
raise EndOfCapture() # Отсутствие событий до конца захвата завершает поток.
# Импорт не должен оставлять ложный sigrokdecode в окружении остальных тестов проекта.
def load_decoders(): # Возвращает модули для доступа к классам и проверяемому CRC.
root = Path(__file__).resolve().parents[1] / 'decoders' # Оба независимых пакета лежат в соседней папке decoders.
stub = types.ModuleType('sigrokdecode') # Создаём подмену только для импорта зависимых классов.
stub.Decoder, stub.OUTPUT_ANN, stub.OUTPUT_PYTHON, stub.SRD_CONF_SAMPLERATE = Runtime, 0, 1, 2 # Значения констант согласованы с Runtime.
original = sys.modules.get('sigrokdecode') # Ранее импортированный настоящий модуль нужно сохранить.
sys.modules['sigrokdecode'] = stub # Классы декодеров получают тестовую реализацию базового API.
sys.path.insert(0, str(root)) # Пакеты импортируются без копирования исходников.
try: # Восстановление окружения обязательно и при ошибке импорта.
return importlib.import_module('plates_sbus.pd'), importlib.import_module('plates_pbus.pd') # Проверяется и экспорт из __init__.py.
finally: # Другие тесты не должны зависеть от нашей подмены.
sys.path.remove(str(root)) # Убираем только путь, добавленный этим импортом.
if original is None: # При отсутствии настоящего модуля восстанавливаем его отсутствие.
del sys.modules['sigrokdecode'] # Ссылки внутри декодеров уже удерживают тестовую среду.
else: # В окружении с sigrokdecode возвращаем исходный объект.
sys.modules['sigrokdecode'] = original # Чужие импорты продолжают работать штатно.
SBUS, PBUS = load_decoders() # Все проверки исполняют рабочие файлы, а не копии алгоритмов.
# Трасса хранит уровни на каждом отсчёте, поэтому среда независимо обнаруживает реальные фронты.
class Trace: # Частота тестовых трасс SBus равна 100 МГц: один отсчёт — 10 нс.
def __init__(self, levels): # Начальные уровни задаются до первого сохранённого отсчёта.
self.levels, self.samples = list(levels), [] # Текущие уровни отделены от уже записанного захвата.
def hold(self, count, updates=None): # Удерживаем сигналы count отсчётов после применения изменений.
for channel, level in (updates or {}).items(): # Незаданные сигналы сохраняют прежнее состояние.
self.levels[channel] = level # Канал индексируется в порядке объявления декодера.
self.samples.extend([tuple(self.levels)] * count) # Кортежи исключают случайное изменение истории при следующем фронте.
# Кадры задаются фиксированными полями и CRC, без обращения к реализации расчёта в декодере.
def serial_frame(trace, direction=1, address=0x32, value=0x1234, crc=1, ack=0, limit=29, tail=1000, tail_clock=0): # Полный формат содержит 29 нарастающих фронтов.
frame = (direction << 28) | (address << 20) | (value << 4) | crc # Временная разметка независима от внутреннего буфера декодера.
for index, shift in enumerate(range(28, 28 - limit, -1)): # limit позволяет оборвать кадр на любом поле.
bit = (frame >> shift) & 1 # Каждый бит передаётся старшим вперёд.
tx, rx = (bit, 1) if index < 9 or direction else (1, bit) # При чтении TX заполнен единицами, чтобы обнаружить выбор неверной линии.
trace.hold(14, {0: 0, 1: tx, 2: rx}) # Ведомое устанавливает ответ на спаде CLK за 140 нс до выборки.
trace.hold(14, {0: 1}) # Полупериод 140 нс совпадает с существующим HDL-тестом.
if tail: # Отсутствие хвоста моделирует конец файла непосредственно после последнего бита.
trace.hold(tail, {0: tail_clock, 2: ack if direction else trace.levels[2]}) # ACK появляется после последнего CRC, а затем CLK может оставаться неподвижным.
# Формирование PBus не использует состояния декодера: задаётся только последовательность физических уровней.
def parallel_frame(trace, address=0x32, value=0x1234, inverse=None, bad_address=False, phases=3, clock_ok=True, simultaneous=False): # phases ограничивает число полученных подтверждений.
word = (address << 8) | ((address ^ 255) ^ int(bad_address)) # Адрес защищён побитовой инверсией младшего байта.
data = {2 + bit: (word >> bit) & 1 for bit in range(16)} # D0…D15 записываются на отдельные физические каналы.
trace.hold(10, data) # Адрес устанавливается до разрешения CE.
trace.hold(10, {0: 0, 1: 0 if simultaneous and phases else 1, 18: 1}) # Возможен одновременный спад CE и адресного ACK в одном отсчёте.
if phases: # Адресный ACK опускается только при наличии ответа.
trace.hold(10, {1: 0}) # Первый низкий ACK подтверждает приём адреса.
if phases >= 2: # Прямые данные передаются только после адресного подтверждения.
trace.hold(10, {2 + bit: (value >> bit) & 1 for bit in range(16)}) # Данные становятся стабильны заранее.
trace.hold(10, {1: 1, 18: 0 if clock_ok else 1}) # Высокий ACK подтверждает прямые данные при низком CLK.
if phases >= 3: # Полное чтение должно получить независимое инверсное слово.
inverse = (value ^ 65535) if inverse is None else inverse # Аргумент позволяет повредить контрольную копию.
trace.hold(10, {2 + bit: (inverse >> bit) & 1 for bit in range(16)}) # Инверсия устанавливается до своего ACK.
trace.hold(10, {1: 0, 18: 1 if clock_ok else 0}) # Последний низкий ACK отмечает готовность контрольного слова.
trace.hold(10, {0: 1, 1: 1}) # CE возвращается в неактивное состояние, ведомое отпускает ACK.
# Настройка окружения одинакова для всех трасс и не зависит от алгоритма протокола.
def run_decoder(module, trace, options=None, connected=None, samplerate=100000000): # Временная шкала по умолчанию соответствует 10 нс на отсчёт.
decoder = module.Decoder() # Исполняется штатный конструктор и reset().
decoder.samples, decoder.result, decoder.samplenum = trace.samples, [], 0 # Состояние тестовой среды хранится отдельно от автомата шины.
decoder.connected = set(range(len(trace.levels))) if connected is None else set(connected) # При необходимости можно отключать отдельные входы.
decoder.options = {item['id']: item['default'] for item in getattr(decoder, 'options', ())} # Среда применяет объявленные значения по умолчанию.
decoder.options.update(options or {}) # Тест может изменить интервалы выборки.
decoder.start() # Выходы должны быть зарегистрированы до первой аннотации.
if samplerate is not None and hasattr(decoder, 'metadata'): # PBus не требует частоту для выборки по ACK.
decoder.metadata(2, samplerate) # Константа 2 соответствует SRD_CONF_SAMPLERATE заглушки.
try: # Только штатный конец захвата перехватывается как успешное завершение.
decoder.decode() # Проверяется настоящий цикл wait(), а не отдельно вызванные внутренние методы.
except EndOfCapture: # Любое другое исключение делает тест ошибочным.
decoder.last_samplenum = len(trace.samples) - 1 # Последний отсчёт нужен для корректного end().
decoder.end() # Незавершённые операции должны быть выведены при конце файла.
packets = [data[1] for _, _, output, data in decoder.result if output == 1] # Извлекаем структурированные FRAME-пакеты.
warnings = [data[1][0] for _, _, output, data in decoder.result if output == 0 and data[0] == len(decoder.annotations) - 1] # Последний класс обоих декодеров содержит предупреждения.
return packets, warnings # Проверяем одновременно данные операций и явную диагностику.
# Набор проверяет содержимое кадров, повторную синхронизацию, границы и настройку каналов.
class DecoderTests(unittest.TestCase): # unittest позволяет запускать тесты без GUI и библиотек DSView.
def serial(self): # Готовим заведомо достаточную паузу перед первым запросом.
trace = Trace((0, 1, 1)) # Мастер держит низкий CLK, обе линии данных отпущены в единицу.
trace.hold(1000) # Десять микросекунд превышают 3,6 мкс reset в HDL.
return trace # Дальнейшие фронты добавляются конкретным тестом.
def parallel(self): # PBus стартует в неактивной фазе CE.
trace = Trace((1, 1) + (0,) * 16 + (1,)) # CE и ACK высокие, D0…D15 нулевые, CLK высокий.
trace.hold(10) # Первый wait() увидит исходные уровни до спада CE.
return trace # Физический запрос добавляется независимо от декодера.
def test_write_and_delayed_ack_without_more_clocks(self): # Проверяем отдельный таймер ACK после последнего такта.
trace = self.serial() # Начальная пауза обеспечивает синхронизацию.
serial_frame(trace, tail_clock=1) # После CRC CLK остаётся высоким без новых фронтов.
packets, warnings = run_decoder(SBUS, trace) # Декодируется весь цифровой поток.
self.assertEqual((packets[0]['dev'], packets[0]['reg'], packets[0]['value']), (3, 2, 0x1234)) # Поля должны совпасть с запросом.
self.assertTrue(packets[0]['crc_ok'] and packets[0]['ack']) # Хороший CRC и низкий ACK проверяются независимо.
self.assertEqual(warnings, []) # Полный корректный кадр не содержит предупреждений.
def test_read_uses_response_line(self): # TX после заголовка специально не содержит полезных данных чтения.
trace = self.serial() # Пауза позволяет принять первый бит направления.
serial_frame(trace, direction=0, value=0xCAFE, crc=7) # Контрольный вектор ответа отличается от всех единиц на TX.
packets, warnings = run_decoder(SBUS, trace) # Читаем по нарастающим фронтам после установки RX на спаде.
self.assertEqual((packets[0]['operation'], packets[0]['value'], packets[0]['ack']), ('read', 0xCAFE, None)) # У чтения нет ACK записи.
self.assertTrue(packets[0]['crc_ok']) # Контрольная сумма включает заголовок с TX и данные с RX.
self.assertEqual(warnings, []) # Правильное переключение линий не создаёт ошибок.
def test_repeated_writes_and_both_idle_levels(self): # Повтор одинакового значения остаётся отдельной командой.
trace = self.serial() # Первый кадр начинается после начальной паузы.
serial_frame(trace, tail_clock=1) # Первая межкадровая пауза держит CLK высоким.
serial_frame(trace, tail_clock=0) # Вторая пауза держит CLK низким.
packets, warnings = run_decoder(SBUS, trace) # Оба уровня паузы должны разрешать синхронизацию.
self.assertEqual([packet['value'] for packet in packets], [0x1234, 0x1234]) # Никакой дедупликации по значению быть не должно.
self.assertEqual(warnings, []) # Повторная команда и высокий idle являются допустимыми.
def test_crc_error_does_not_hide_ack(self): # ACK не заменяет проверку целостности принятого кадра.
trace = self.serial() # Создаём синхронизированный поток.
serial_frame(trace, crc=0, ack=0) # Один бит CRC повреждён, но ответ линии низкий.
packets, warnings = run_decoder(SBUS, trace) # Кадр должен остаться доступным для диагностики.
self.assertFalse(packets[0]['crc_ok']) # Расчёт CRC обнаруживает повреждение.
self.assertTrue(packets[0]['ack']) # Наблюдавшийся ACK сохраняется независимо от CRC.
self.assertIn('CRC mismatch', warnings) # Ошибка присутствует в отдельной строке.
def test_high_ack_is_not_success(self): # Высокий RX может означать отказ или отсутствие ведомого.
trace = self.serial() # Подготавливаем запрос с правильным CRC.
serial_frame(trace, ack=1) # Плата не подтверждает запись низким уровнем.
packets, warnings = run_decoder(SBUS, trace) # Разбор не должен путать CRC и успешность ответа.
self.assertTrue(packets[0]['crc_ok']) # Данные на запросе не повреждены.
self.assertFalse(packets[0]['ack']) # Высокий ответ не считается подтверждением.
self.assertIn('No low write ACK', warnings) # Причина обмена отмечается явно без предположений о плате.
def test_partial_frame_resynchronizes_after_gap(self): # Потерянные биты не должны сдвигать все последующие кадры.
trace = self.serial() # Создаём начало корректно синхронизированного кадра.
serial_frame(trace, limit=12) # Обрываем кадр после заголовка и части данных.
serial_frame(trace) # Следующий кадр начинается после достаточной паузы.
packets, warnings = run_decoder(SBUS, trace) # Автомат должен восстановиться независимо от остатка первого запроса.
self.assertEqual(len(packets), 1) # Частичный кадр не выдаётся за полную команду.
self.assertEqual(packets[0]['value'], 0x1234) # Следующий кадр читается без смещения.
self.assertTrue(any('12/29' in text for text in warnings)) # Обрыв первого кадра остаётся виден.
def test_capture_starting_mid_frame_waits_for_gap(self): # В начале файла может отсутствовать заголовок.
trace = Trace((0, 1, 1)) # Предварительной паузы здесь намеренно нет.
trace.hold(1) # Захват начинается непосредственно перед неизвестным тактом.
serial_frame(trace, limit=15) # Эти биты нельзя надёжно считать первым заголовком.
serial_frame(trace) # После паузы можно декодировать полную операцию.
packets, warnings = run_decoder(SBUS, trace) # Начальный фрагмент игнорируется до синхронизации.
self.assertEqual(len(packets), 1) # Ложный первый кадр не создаётся.
self.assertEqual(warnings, []) # Непроверяемый начальный фрагмент не объявляется ошибкой протокола.
def test_capture_ends_in_data(self): # end() должен диагностировать обрыв без следующего события.
trace = self.serial() # Первый кадр начнётся после паузы.
serial_frame(trace, limit=20, tail=0) # Захват заканчивается внутри 16-битных данных.
packets, warnings = run_decoder(SBUS, trace) # Единственный способ закрыть фрагмент — end().
self.assertEqual(packets, []) # Частичное значение не публикуется как полное.
self.assertTrue(any('20/29' in text for text in warnings)) # Сообщение содержит фактическое количество наблюдавшихся битов.
def test_capture_ends_before_ack_sampling(self): # Нельзя считать неизвестный ACK ни положительным, ни отрицательным.
trace = self.serial() # Кадр полностью помещается после паузы.
serial_frame(trace, tail=0) # Конец захвата наступает раньше таймера ACK.
packets, warnings = run_decoder(SBUS, trace) # end() сохраняет полный запрос.
self.assertIsNone(packets[0]['ack']) # Подтверждение осталось ненаблюдавшимся.
self.assertIn('Write ACK not sampled: capture ended', warnings) # Причина неизвестности указана явно.
def test_serial_bad_configuration(self): # Ошибки настройки должны выявляться до разбора потока.
for options in ({'ack_us': 0}, {'ack_us': 4}, {'idle_us': float('nan')}): # Проверяем нулевой, чрезмерный и нечисловой интервалы.
with self.subTest(options=options), self.assertRaises(ValueError): # Каждый неверный набор обязан быть отвергнут.
run_decoder(SBUS, self.serial(), options=options) # Не требуется наличие команды на входе.
with self.assertRaises(ValueError): # Отсутствие RX нельзя подменять единицей либо нулём.
run_decoder(SBUS, self.serial(), connected=(0, 1)) # Чтение и ACK требуют физического ответного канала.
with self.assertRaises(ValueError): # Без частоты захвата микросекунды не переводятся в отсчёты.
run_decoder(SBUS, self.serial(), samplerate=None) # Произвольные предполагаемые частоты недопустимы.
with self.assertRaises(ValueError): # Слишком редкие отсчёты сливают ACK и межкадровую паузу.
run_decoder(SBUS, self.serial(), samplerate=100000) # При 100 кГц один отсчёт равен 10 мкс.
def test_crc_fixed_vectors(self): # Дополнительные контрольные значения охватывают направления и крайние адреса.
for direction, address, value, expected in ((1, 0, 0, 1), (0, 0, 0, 12), (1, 255, 65535, 1), (0, 255, 65535, 12), (0, 0x32, 0xCAFE, 7), (1, 0x57, 0, 7)): # Векторы фиксированы и не вычисляются генератором трассы.
with self.subTest(direction=direction, address=address, value=value): # Ошибка укажет конкретный вектор.
self.assertEqual(SBUS.frame_crc(direction, address, value), expected) # Проверяем в том числе четыре завершающие единицы HDL.
def test_parallel_full_words_and_optional_clock(self): # Проверяем края диапазонов и сохранение старшего разряда данных.
for address, value in ((0, 0), (255, 65535), (0x32, 0x1234), (0x8F, 0x8001)): # Адрес и данные не должны превращаться в знаковые числа.
for connected in (range(18), range(19)): # PBCLK может отсутствовать либо участвовать в проверке фаз.
with self.subTest(address=address, value=value, clock=len(connected) == 19): # Каждый вариант проверяется независимо.
trace = self.parallel() # Готовим неактивные исходные уровни.
parallel_frame(trace, address=address, value=value) # На провод подаётся полная последовательность ACK.
packets, warnings = run_decoder(PBUS, trace, connected=connected) # Выборка идёт по реальным переходам ACK.
self.assertEqual((packets[0]['dev'], packets[0]['reg'], packets[0]['value']), (address >> 4, address & 15, value)) # Разделение адреса должно сохранять все биты.
self.assertTrue(packets[0]['ok'] and packets[0]['complete']) # Успешность требует полноты и правильной защиты.
self.assertEqual(warnings, []) # Корректный обмен не должен вызывать ложные ошибки.
def test_parallel_bad_address_with_and_without_ack(self): # Повреждение адреса видно и при молчании ведомого.
for phases in (0, 3): # Проверяем отсутствие ответа и ошибочно подтверждённый адрес.
trace = self.parallel() # Начинаем отдельный захват для каждого случая.
parallel_frame(trace, bad_address=True, phases=phases) # Инвертируем один бит защитной копии адреса.
packets, warnings = run_decoder(PBUS, trace) # Декодер сохраняет наблюдавшийся запрос.
self.assertFalse(packets[0]['address_ok'] or packets[0]['ok']) # Хорошие данные ответа не исправляют неверный запрос.
self.assertIn('Address complement mismatch', warnings) # Ошибка защиты адреса должна остаться явной.
def test_parallel_bad_inverse(self): # Последний ACK сам по себе не доказывает целостности данных.
trace = self.parallel() # Подготавливаем обычный адрес и прямые данные.
parallel_frame(trace, inverse=0) # Контрольное слово намеренно не равно инверсии 0x1234.
packets, warnings = run_decoder(PBUS, trace) # Все фазы обмена всё же присутствуют.
self.assertTrue(packets[0]['complete']) # Полнота и правильность являются разными свойствами.
self.assertFalse(packets[0]['inverse_ok'] or packets[0]['ok']) # Повреждённая копия делает обмен ошибочным.
self.assertIn('Data complement mismatch', warnings) # Есть понятная причина ошибки.
def test_parallel_missing_each_ack(self): # Место обрыва различается по ожидаемой фазе.
for phases, missing in ((0, 'address'), (1, 'data'), (2, 'inverse')): # Проверяем все три точки ожидания.
with self.subTest(phases=phases): # Диагностика должна назвать нужную фазу.
trace = self.parallel() # Каждый запрос имеет свой неактивный префикс.
parallel_frame(trace, phases=phases) # CE снимается до завершения операции.
packets, warnings = run_decoder(PBUS, trace) # Закрытие по CE обязано выдать частичный результат.
self.assertFalse(packets[0]['complete'] or packets[0]['ok']) # Неполная операция никогда не успешна.
self.assertIn('Incomplete PBus: missing %s ACK' % missing, warnings) # Указана конкретная отсутствующая фаза.
def test_parallel_capture_ends_before_inverse(self): # Отсутствие возврата CE не должно терять частичный запрос.
trace = self.parallel() # Создаём начало запроса и два подтверждения.
parallel_frame(trace, phases=2) # Генератор завершает CE, но ниже этот хвост удаляется.
trace.samples = trace.samples[:-10] # Обрываем файл при ещё активном CE.
packets, warnings = run_decoder(PBUS, trace) # end() должен закрыть ожидаемую инверсию.
self.assertEqual(packets[0]['value'], 0x1234) # Наблюдавшиеся прямые данные сохраняются.
self.assertIn('Incomplete PBus: missing inverse ACK', warnings) # Отсутствие последнего подтверждения остаётся явным.
def test_parallel_phase_checks_only_with_clock(self): # Необязательный CLK усиливает диагностику, не меняя данные.
trace = self.parallel() # Одинаковые уровни используются в двух конфигурациях каналов.
parallel_frame(trace, clock_ok=False) # ACK данных и инверсии приходят при неверных уровнях CLK.
packets, warnings = run_decoder(PBUS, trace) # Подключённый CLK должен выявить обе ошибки.
self.assertFalse(packets[0]['ok']) # Данные правильные, но протокол фаз нарушен.
self.assertEqual(len(warnings), 2) # Ошибки прямой и инверсной фазы независимы.
packets, warnings = run_decoder(PBUS, trace, connected=range(18)) # Без захвата CLK его уровень не интерпретируется.
self.assertTrue(packets[0]['ok']) # Доступные проверки CE, ACK и содержимого проходят.
self.assertEqual(warnings, []) # Нельзя жаловаться на незахваченный сигнал.
def test_parallel_repeats_and_simultaneous_enable_ack(self): # Фронты CE и ACK могут попасть в один отсчёт анализатора.
trace = self.parallel() # До первого запроса видны исходные высокие CE и ACK.
parallel_frame(trace, simultaneous=True) # Адресный ACK совпадает со спадом CE.
parallel_frame(trace) # Повтор того же чтения обязан оставаться отдельной операцией.
packets, warnings = run_decoder(PBUS, trace) # Оба способа начала проходят один автомат.
self.assertEqual(len(packets), 2) # Ни один запрос не теряется и не дублируется.
self.assertTrue(all(packet['ok'] for packet in packets)) # Оба кадра содержат полные корректные проверки.
self.assertEqual(warnings, []) # Совпадение фронтов само по себе не ошибка.
def test_parallel_start_in_active_transaction(self): # Начальная активная CE не доказывает наличие полного адреса.
trace = self.parallel() # Сначала строим полный физический обмен.
parallel_frame(trace) # Часть начала будет удалена из файла захвата.
trace.samples = trace.samples[45:] # Первый видимый отсчёт находится внутри активной операции.
parallel_frame(trace) # Следующий полный запрос должен декодироваться нормально.
packets, warnings = run_decoder(PBUS, trace) # Начальный фрагмент игнорируется до следующего спада CE.
self.assertEqual(len(packets), 1) # Частичное начало не порождает ложной операции.
self.assertEqual(warnings, []) # Нельзя диагностировать отсутствующий в файле адрес.
def test_parallel_requires_every_data_bit(self): # Один незахваченный разряд делает 16-битное слово недостоверным.
with self.assertRaises(ValueError): # Декодер обязан отвергнуть неполное назначение каналов.
run_decoder(PBUS, self.parallel(), connected=range(17)) # Здесь отсутствует обязательный D15.
def test_python36_syntax_and_line_comments(self): # Стиль проекта требует комментарий к каждой строке нового кода.
for path in Path(__file__).resolve().parents[1].glob('decoders/plates_*/*.py'): # Проверяются устанавливаемые Python-файлы обеих шин, без чужих декодеров при переносе в SETGUI.
source = path.read_text(encoding='utf-8') # Некорректная кодировка должна сразу приводить к ошибке.
ast.parse(source, filename=str(path), feature_version=(3, 6)) # DSView использует Python 3.6, поэтому более новый синтаксис запрещён.
for number, line in enumerate(source.splitlines(), 1): # Номер строки помогает исправить нарушение стиля.
if line.strip() and not line.lstrip().startswith('#'): # Пустые строки и отдельные комментарии не содержат исполняемый код.
self.assertIn('#', line, '%s:%d' % (path, number)) # Каждая строка кода сопровождается пояснением.
if __name__ == '__main__': # Разрешаем запуск как файла и через unittest discovery.
unittest.main() # Стандартный запуск выдаёт количество проверок и подробности ошибок.
+7 -5
View File
@@ -43,14 +43,13 @@ class RuntimeTests(unittest.TestCase):
with tempfile.TemporaryDirectory() as temporary:
root = Path(temporary)
recipe = root / 'tools/dsview'
core = root / 'python/logic_analyzer/decoders'
core.mkdir(parents=True)
(recipe / 'decoders/gate_driver_timing').mkdir(parents=True)
(recipe / 'native').mkdir()
recipe.mkdir(parents=True) # Временный рецепт воспроизводит относительную структуру закреплённого templates.
(recipe / 'protocol-files.json').write_bytes(RECIPE.with_name('protocol-files.json').read_bytes()) # Реальная ведомость гарантирует включение новых зависимостей и карт.
files = [recipe / 'build.py', recipe / 'setgui-host.patch', recipe / 'gate-pair-checkbox.patch', recipe / 'decoder-panel.patch', recipe / 'driver-summary.patch', recipe / 'windows-usb-events.patch', recipe / 'native/gate_summary.h',
recipe / 'decoders/gate_driver_timing/pd.py']
files += [core / (name + '.py') for name in ('gate_timing', 'transistor_pair', 'set_uart', 'set_can', 'pm35_uart')]
files += [root / item.relative_to(RECIPE.parents[2]) for item, _ in BUILD.protocol_payload()] # Проверка охватывает все канонические модули и JSON-карты, перечисленные в поставке.
for item in files:
item.parent.mkdir(parents=True, exist_ok=True) # Для каждого переносимого пакета создаются вложенные каталоги.
item.write_text('initial')
with patch.object(BUILD, '__file__', str(recipe / 'build.py')):
initial = BUILD.recipe_digest()
@@ -60,3 +59,6 @@ class RuntimeTests(unittest.TestCase):
self.assertNotEqual(initial, BUILD.recipe_digest())
item.write_text('initial')
self.assertEqual(initial, BUILD.recipe_digest())
with (recipe / 'protocol-files.json').open('a', encoding='utf-8') as output: # Пробел меняет хеш, сохраняя корректность JSON-ведомости.
output.write('\n') # Изменение самого состава поставки также должно требовать обновления runtime.
self.assertNotEqual(initial, BUILD.recipe_digest()) # Устаревшая ведомость не допускается к упаковке незаметно.