Расширить DSView осциллографом и декодерами двигателя и сигма-дельта

This commit is contained in:
2026-11-12 15:00:41 +03:00
parent fa5ea166a9
commit 1fc88684d5
41 changed files with 4147 additions and 151 deletions
@@ -0,0 +1,44 @@
"""Проверка отдельного окна выбранного графика в настоящем встроенном DSView.""" # Сценарий использует готовую цифровую запись и не подключается к аппаратуре.
import argparse # Проверяемая сборка, запись и каталог результатов задаются явно.
import os # Изолированное окружение предотвращает смешение Qt6 родителя и Qt5 дочернего DSView.
from pathlib import Path # Абсолютные пути не зависят от рабочего каталога проверяемого компонента.
import subprocess # Сценарий управляет только собственным новым процессом DSView.
import time # Монотонные часы ограничивают ожидание нативной проверки и штатного завершения.
def main(): # Нативные действия выполняются встроенным тестовым обработчиком окна DSView.
parser = argparse.ArgumentParser(description=__doc__) # Описание доступно без создания окон через стандартный --help.
parser.add_argument('--runtime', type=Path, required=True) # Каталог должен содержать собранный DSView с decoder-scope.patch.
parser.add_argument('--capture', type=Path, required=True) # Сохранённая DSL-сессия содержит огибающую, коммутации и последний декодер pwm_motor.
parser.add_argument('--output', type=Path, required=True) # Отчёт, журнал и снимок выбранного графика помещаются отдельно от исходных данных.
parser.add_argument('--timeout', type=float, default=45) # Общий предел 45 секунд покрывает загрузку runtime, расчёт и пользовательские взаимодействия.
args = parser.parse_args() # Все обязательные параметры проверяются до запуска приложения.
from PySide6.QtWidgets import QApplication, QWidget # Родительское окно воспроизводит встраивание DSView в SETGUI через настоящий HWND.
runtime, capture, output = args.runtime.resolve(), args.capture.resolve(), args.output.resolve() # Проверка работает и при путях с пробелами без построения shell-команд.
output.mkdir(parents=True, exist_ok=True) # Каталог результатов создаётся в заданном пользователем месте.
report = output / 'decoder-scope.txt'; report.write_text('', encoding='utf-8') # Старый PASS не может скрыть провал нового запуска.
app = QApplication.instance() or QApplication([]); window = QWidget(); window.resize(1500, 1000); window.show() # Высота позволяет выбрать нижний график после цифровых входов NPC.
environment = {key: value for key, value in os.environ.items() if not key.startswith(('PYTHON', 'QT_', 'QML'))} # Нативный компонент загружает только собственные Python и плагины Qt.
environment.update(PATH=str(runtime) + os.pathsep + str(Path(os.environ['SystemRoot']) / 'System32'), DSVIEW_HOST_CHECK=str(report), DSVIEW_HOST_CHECK_SCOPE='1', DSVIEW_HOST_CHECK_DECODER_SCOPE='1') # Явные параметры включают только сценарий выбранного декодерного осциллографа.
with (output / 'decoder-scope.log').open('w', encoding='utf-8') as log: # Ошибки импорта и фактические размеры декодирования сохраняются для диагностики.
process = subprocess.Popen([str(runtime / 'DSView.exe'), '--loglevel', '3', '--embed-parent', str(int(window.winId())), str(capture)], cwd=runtime, env=environment, stdin=subprocess.PIPE, stdout=log, stderr=log, creationflags=subprocess.CREATE_NO_WINDOW) # Отдельный тестовый процесс не изменяет открытую рабочую сессию пользователя.
try: # Все пути завершения освобождают именно созданный этой проверкой процесс.
deadline = time.monotonic() + args.timeout # Ограниченное ожидание предотвращает бесконечную проверку при ошибке создания окна.
while process.poll() is None and not report.read_text(encoding='utf-8') and time.monotonic() < deadline: # Ожидается полный отчёт нативного взаимодействия, а не только открытие файла.
app.processEvents(); time.sleep(0.02) # Короткая пауза сохраняет обработку встраивания и штатных сообщений Qt.
result = report.read_text(encoding='utf-8') # Завершённый отчёт содержит результат выбора, масштаба, прокрутки, повторного открытия и удаления источника.
assert result.startswith('PASS '), result or 'Native scope check timed out' # Тайм-аут и частичный успех не признаются выполнением пользовательского сценария.
assert Path(str(report) + '.png').is_file(), 'No separate scope screenshot' # Проверка обязана сохранить настоящий снимок отдельной осциллограммы.
process.stdin.write(b'CLOSE\n'); process.stdin.flush(); deadline = time.monotonic() + 5 # Штатная команда закрывает только тестовый DSView после завершённых взаимодействий.
while process.poll() is None and time.monotonic() < deadline: # Родитель продолжает обрабатывать закрытие встроенного окна.
app.processEvents(); time.sleep(0.02) # Неблокирующий короткий опрос ограничивает задержку завершения.
assert process.poll() == 0, 'DSView did not close cleanly' # Ненулевой код выявляет повреждение жизненного цикла отдельного или основного окна.
text = (output / 'decoder-scope.log').read_text(encoding='utf-8', errors='replace') # Проверяется завершённый журнал после штатного выхода дочернего процесса.
assert 'Traceback (most recent call last)' not in text and text.count('Decoded sample count:120000') == 3, 'Expected one complete decode of each saved analyzer' # Три анализатора обрабатывают все отсчёты ровно один раз, включая все взаимодействия отдельного окна.
print(result.strip()); print(Path(str(report) + '.png')) # Краткий итог и путь к снимку позволяют быстро проверить результат.
finally: # Неудачная проверка не оставляет собственные окна DSView в фоне.
if process.poll() is None: process.terminate() # Чужие процессы и рабочие захваты пользователя не затрагиваются.
process.wait(timeout=5); window.close() # Освобождение системных дескрипторов завершается за ограниченное время.
if __name__ == '__main__': main() # Прямой запуск выполняет полный пользовательский сценарий в нативном приложении.
+125
View File
@@ -0,0 +1,125 @@
#include <QApplication> // Настоящий цикл Qt выявляет модальные окна и повторный вход при сетевом таймауте.
#include <QAbstractButton> // Нажатие штатной кнопки OK проверяет очистку указателя уведомления.
#include <QLabel> // Проверяем фактическую видимость текста ошибки, а не только существование оболочки уведомления.
#include <QMouseEvent> // Кнопка закрытия получает обычные события мыши после проверки её видимой геометрии.
#include <QStackedWidget> // Две страницы воспроизводят переход из DSView на другую вкладку SETGUI.
#include <QVBoxLayout> // Родительская страница задаёт настоящую область встраивания дочернего окна.
#include <QElapsedTimer> // Монотонное время ограничивает ожидание ответа и проверку отсутствия повторов.
#include <QPointer> // Уведомление может удалиться после OK, поэтому тест не хранит висячий указатель.
#include <QTimer> // Проверки выполняются в GUI-потоке одновременно с настоящим драйвером захвата.
#include "pv/appcontrol.h" // Используем штатную инициализацию libsigrok и сессии DSView.
#include "pv/config/appconfig.h" // Каталог записи направляется в отдельную папку проверки.
#include "pv/log.h" // Инициализация журнала необходима до запуска аппаратного ядра DSView.
#include "pv/mainframe.h" // Проверяем закрытие настоящего главного окна вместе с предупреждением.
#include "pv/sigsession.h" // Режимы Single, Repetitive и Loop запускаются обычным методом сессии.
#include "pv/ui/langresource.h" // Ресурсы сообщений загружаются так же, как в рабочем приложении.
#include <windows.h> // Win32-проверка учитывает скрытие панели другим процессом, которое не меняет внутренний флаг видимости Qt.
int main(int argc, char **argv) { // Исполняемый тест линкуется с теми же объектами, что и DSView, без его main.cpp.
QApplication application(argc, argv); // Цикл событий нужен для обработки сетевого завершения и показа уведомления.
application.setProperty("embeddedHost", true); // Закрытие кадра завершает тест и не записывает пользовательскую геометрию окна.
application.setQuitOnLastWindowClosed(false); // Закрытие отдельного уведомления не должно завершать встроенный DSView.
dsv_log_init(); // Подготавливаем штатную инфраструктуру диагностики до создания устройств.
auto &config = AppConfig::Instance(); // Профиль тестового EXE расположен в отдельном runtime.
config.LoadAll(); // Загружаем обязательные значения оформления и захвата.
config.userHistory.saveDir = QString::fromUtf8(qgetenv("DSVIEW_CAPTURE_DIR")); // Все записи остаются в каталоге артефактов проверки.
config.frameOptions.style = "dark"; // Снимок предупреждения использует тему SETGUI со скриншота ошибки.
LangResource::Instance()->Load(config.frameOptions.language); // Штатные строки интерфейса нужны конструктору главного окна.
auto *control = AppControl::Instance(); // Тест пользуется настоящей сессией, а не подменой алгоритма повтора.
if (!control->Init()) return 2; // Ошибка зависимости отличима от регрессии потери связи.
ds_device_handle handle = 0; // Публичный API возвращает найденный прибор, обслуживаемый локальным UDP-эмулятором.
if (ds_add_zynq_device("127.0.0.1", &handle) != SR_OK) return 3; // Реальная плата и Ethernet-сеть для проверки не нужны.
int result = 1; // Успех фиксируется только после всех трёх обрывов и штатного закрытия.
{ // Главное окно должно уничтожиться до освобождения аппаратного ядра.
pv::MainFrame frame; // Обычный кадр создаёт те же обработчики ошибок и панели, что и DSView.exe.
control->Start(); // Запускаем обработку сообщений сессии после создания главного окна.
auto *session = control->GetSession(); // Публичные методы позволяют запускать реальные захваты без имитации кнопок.
if (!session->set_device(handle)) return 4; // Захват должен относиться к найденному сетевому прибору.
QWidget host; // Отдельное окно моделирует оболочку SETGUI с несколькими страницами.
auto *host_layout = new QVBoxLayout(&host); // Область DSView следует размеру родительского окна.
auto *pages = new QStackedWidget(&host); // Переключение страницы должно скрывать всё содержимое DSView, включая сообщение об ошибке.
auto *dsview_page = new QWidget(pages); // Нативный HWND первой страницы становится родителем настоящего окна DSView.
pages->addWidget(dsview_page); // Первая страница отводится встроенному анализатору.
pages->addWidget(new QLabel(QStringLiteral("Другая вкладка SETGUI"), pages)); // Вторая страница воспроизводит экран Zynq с пользовательского скриншота.
host_layout->addWidget(pages); // Родительский layout задаёт видимые границы страниц.
host.resize(1100, 700); // Размер в логических пикселях оставляет видимыми панели и предупреждение.
host.show(); // Для реальной проверки видимости нужен показанный нативный родитель.
if (!frame.ShowEmbedded(static_cast<quintptr>(dsview_page->winId()))) return 6; // Используем штатное Win32-встраивание, а не отдельное окно DSView.
QTimer timer; // Один периодический таймер отслеживает конечное состояние трёх сценариев.
QElapsedTimer elapsed; // Общий дедлайн исключает зависание CI на регрессии модального окна.
elapsed.start(); // Срок включает таймауты драйвера и ожидание возможного автоповтора.
int scenario = 0; // Сначала Repetitive без данных, затем Repetitive с данными, в конце Loop без данных.
qint64 observed_at = -1; // Отрицательное значение означает, что уведомление текущего захвата ещё не появилось.
QPointer<QWidget> notice; // Отслеживаем стабильность уведомления независимо от реализации его оформления.
auto start = [&]() { // Каждый сценарий начинается явным ручным запуском, как после восстановления линка.
session->set_collect_mode(scenario == 2 ? pv::COLLECT_LOOP : pv::COLLECT_REPEAT); // Повтор и кольцевой режим должны останавливаться при одном обрыве.
session->set_repeat_intvl(0.01); // Интервал 10 мс провоцирует прежнюю гонку между END и обработчиком ошибки GUI.
if (scenario == 1) { // Во втором сценарии проверяем также штатное завершение дисковой записи после обрыва.
const QByteArray path = (config.userHistory.saveDir + "/partial-rj2.dsl").toUtf8(); // Имя относится только к изолированным артефактам текущего запуска.
if (!session->get_device()->set_config_uint64(SR_CONF_ZYNQ_RECORD_SAMPLES, 1000000)) return false; // Миллион отсчётов превышает посланный префикс 65 536 и позволяет дождаться сетевого таймаута.
if (!session->get_device()->set_config_string(SR_CONF_ZYNQ_RECORD_FILE, path.constData())) return false; // Передаём путь тем же публичным API, который вызывает кнопка Run после выбора файла.
} // Остальные сценарии проверяют потерю связи ещё до появления первого отсчёта.
observed_at = -1; // Новый захват должен самостоятельно выдать новое уведомление.
return session->start_capture(false); // Обычный захват использует реальный приём UDP и таймаут драйвера.
}; // Повторный запуск проверяет восстановление после сброса обработанной ошибки.
QObject::connect(&timer, &QTimer::timeout, &frame, [&]() { // Все обращения к виджетам выполняются в их GUI-потоке.
auto fail = [&](const char *reason) { // Ошибка теста выводит причину и прекращает дальнейшие проверки.
fprintf(stderr, "FAIL: %s\n", reason); // Журнал запуска остаётся пригодным для диагностики без скриншота.
application.exit(1); // Даже открытый модальный диалог не должен подвесить завершение теста.
}; // Единственный путь неуспеха сохраняет изначальное значение result.
if (elapsed.elapsed() > 30000) { fail("link loss timeout"); return; } // Предел 30 секунд превышает три аппаратных таймаута и окна наблюдения.
QList<QWidget *> visible; // Скрытые закрывающиеся объекты не считаются пользовательскими уведомлениями.
for (auto *widget : frame.findChildren<QWidget *>(QStringLiteral("networkCaptureError"))) if (widget->isVisible()) visible.append(widget); // Счётчик выявляет несколько предупреждений одной сетевой сессии.
if (visible.isEmpty()) return; // До аппаратного таймаута уведомления быть не должно.
if (visible.size() != 1) { fail("duplicate packet error dialogs"); return; } // Любое второе окно означает возврат исходной ошибки.
if (QApplication::activeModalWidget()) { fail("link error blocks the application"); return; } // Предупреждение должно оставлять доступными отключение и закрытие.
if (session->is_working() || session->get_device()->is_collecting()) { fail("capture restarted after link loss"); return; } // Завершение обязано остановить и сессию, и драйвер.
auto *current = visible.front(); // Геометрию и содержимое проверяем у единственного показанного уведомления.
QLabel *message = nullptr; // Одного заголовка Packet Error недостаточно: пользователь должен видеть причину обрыва.
for (auto *label : current->findChildren<QLabel *>()) if (label->isVisible() && label->text().contains(QStringLiteral("RJ2"))) message = label; // Ищем настоящий отображаемый текст аппаратной диагностики.
if (!message || message->visibleRegion().isEmpty()) { fail("packet error details are invisible"); return; } // Проверка воспроизводит пустую оболочку с пользовательского скриншота.
QAbstractButton *dismiss = nullptr; // Кнопка должна быть доступна мышью, а не только программным вызовом click.
for (auto *button : current->findChildren<QAbstractButton *>()) if (button->isVisible() && button->isEnabled() && !button->visibleRegion().isEmpty()) dismiss = button; // Отбрасываем скрытые кнопки вложенного QMessageBox.
if (!dismiss) { fail("packet error dismiss button is invisible"); return; } // Отсутствующий OK нельзя считать успешной неблокирующей диагностикой.
if (current->isWindow()) { fail("packet error escapes its DSView panel"); return; } // Самостоятельное окно остаётся поверх посторонних вкладок после скрытия нативного родителя.
const QRect bounds(current->mapTo(frame.GetMainWindow(), QPoint()), current->size()); // Сравниваем видимую геометрию в общей системе координат панели DSView.
if (!frame.GetMainWindow()->rect().contains(bounds)) { fail("packet error lies outside the DSView panel"); return; } // Уведомление не должно выходить за границы встроенного анализатора.
if (observed_at < 0) { // Первый тик после обрыва запоминает существующее уведомление.
notice = visible.front(); // Следующие тики проверят, что окно не было заменено новым.
observed_at = elapsed.elapsed(); // От этого момента выдерживаем паузу длиннее таймаута драйвера.
pages->setCurrentIndex(1); // Переходим на соседнюю вкладку, как на втором пользовательском скриншоте.
if (IsWindowVisible(reinterpret_cast<HWND>(current->winId()))) { fail("packet error remains above another tab"); return; } // Проверяем фактическую Win32-видимость после скрытия нативного родителя.
pages->setCurrentIndex(0); // Возврат должен восстановить анализатор и доступную кнопку предупреждения.
if (!IsWindowVisible(reinterpret_cast<HWND>(current->winId()))) { fail("packet error did not return with DSView"); return; } // Уведомление сохраняется до явного закрытия пользователем.
current->grab().save(config.userHistory.saveDir + QStringLiteral("/notice-%1.png").arg(scenario)); // Сохраняем само предупреждение с текстом и кнопкой для визуальной проверки.
for (int queued = 0; queued < 3; ++queued) QMetaObject::invokeMethod(frame.GetMainWindow(), "on_session_error", Qt::QueuedConnection); // Запоздавшие сигналы не должны создавать пустые сообщения Undefined Error.
} // Очередь событий обрабатывается между тиками настоящего Qt.
if (notice != visible.front()) { fail("packet error dialog was replaced"); return; } // Обновление не должно порождать цепочку новых объектов.
if (elapsed.elapsed() - observed_at < 3500) return; // Пауза 3,5 секунды превышает сетевой таймаут и обнаруживает скрытый автоповтор.
fprintf(stdout, "PASS scenario %d: stopped, one nonmodal notice\n", scenario); // Отдельный результат подтверждает каждый вариант обрыва.
fflush(stdout); // Внешний сценарий получает сообщение даже при последующей ошибке завершения.
if (scenario < 2) { // Первые два обрыва проверяют ручной запуск без перезапуска приложения.
QMouseEvent press(QEvent::MouseButtonPress, dismiss->rect().center(), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier); // Нажимаем в центре фактически видимой кнопки закрытия.
QApplication::sendEvent(dismiss, &press); // Используем штатный обработчик мыши кнопки, а не прямой вызов click.
QMouseEvent release(QEvent::MouseButtonRelease, dismiss->rect().center(), Qt::LeftButton, Qt::NoButton, Qt::NoModifier); // Отпускание в той же точке завершает пользовательское нажатие.
QApplication::sendEvent(dismiss, &release); // Закрытие предупреждения должно освободить его объект перед следующим обрывом.
++scenario; // Следующий сценарий меняет условия эмулятора по номеру новой UDP-сессии.
if (!start()) fail("manual restart after link loss failed"); // Восстановленный пользовательский запуск не должен блокироваться старой ошибкой.
return; // Новое уведомление ожидается на следующих тиках таймера.
} // В последнем сценарии предупреждение остаётся открытым до закрытия приложения.
frame.grab().save(QString::fromUtf8(qgetenv("DSVIEW_CAPTURE_DIR")) + "/link-loss.png"); // Сохраняем настоящий кадр остановленной сессии.
session->clear_store_confirm_flag(); // Принятый в предыдущем сценарии фрагмент уже проверяется на диске; тест подтверждает отказ от дополнительного сохранения.
timer.stop(); // Повторный тик не должен обращаться к закрывающемуся окну.
result = frame.close() ? 0 : 1; // Закрытие с открытым предупреждением обязано пройти штатный closeEvent.
application.exit(result); // Возвращаем проверенный результат, не ожидая принудительного завершения процесса.
}); // Обработчик живёт не дольше главного окна проверки.
timer.start(50); // Период 50 мс проверяет состояние интерфейса без занятого ожидания.
QTimer::singleShot(0, &frame, [&]() { if (!start()) application.exit(5); }); // Запуск откладывается до начала обычной обработки GUI-событий.
const int loop_result = application.exec(); // Нативные сетевые ошибки проходят через настоящий цикл событий DSView.
if (loop_result != 0) result = loop_result; // Код ошибки дедлайна или модальности не может превратиться в успешный результат.
control->Stop(); // Освобождаем аппаратную сессию до уничтожения дочерних виджетов.
} // Деструкторы проверяют также время жизни неблокирующего уведомления.
control->UnInit(); // Освобождаем декодеры и libsigrok после закрытия окон.
dsv_log_uninit(); // Закрываем штатный журнал перед возвратом результата теста.
return result; // Нулевой код подтверждает остановку, восстановление и штатное закрытие.
} // Тест не включается в пользовательский EXE и не добавляет в него скрытые команды.
+87
View File
@@ -0,0 +1,87 @@
"""Собирает нативную проверку и воспроизводит обрыв RJ2 на локальном UDP-эмуляторе.""" # Реальные GUI-объекты выявляют повторные окна, модальность и зависание закрытия.
import argparse # Явные пути позволяют проверить любой собранный runtime закреплённого DSView.
import json # Метаданные дисковой записи подтверждают точное число принятых до обрыва отсчётов.
import os # Окружение тестового процесса очищается от Python и Qt родительского приложения.
from pathlib import Path # Артефакты и исходники адресуются абсолютными путями.
import re # Выделяем объекты и библиотеки из созданного CMake файла Ninja.
import socket # Эмулятор использует тот же UDP-порт и little-endian протокол RJ2, что плата.
import struct # Заголовок ZLP состоит из четырёх 32-битных слов little endian.
import subprocess # Проверочный EXE линкуется с настоящими объектами текущей сборки.
import threading # Эмулятор отвечает параллельно с отдельным процессом Qt.
import time # Небольшой интервал между UDP-пакетами исключает случайное переполнение loopback.
import zipfile # После обрыва проверяем сохранённый непрерывный фрагмент аппаратной записи.
def main(): # Отдельный сценарий не требует PySide, тестового устройства и изменения рабочего EXE.
parser = argparse.ArgumentParser(description=__doc__) # Справка описывает назначение нативной проверки.
parser.add_argument('--source', type=Path, required=True) # Указываем уже собранный checkout DSView с build-win64.
parser.add_argument('--runtime', type=Path, required=True) # Полный runtime предоставляет DLL, ресурсы и декодеры.
parser.add_argument('--output', type=Path, required=True) # Все новые файлы и записи сохраняются в отдельном каталоге.
parser.add_argument('--msys-root', type=Path, default=Path('C:/msys64')) # SDK совпадает с использованным при основной сборке UCRT64.
args = parser.parse_args() # Ошибочные параметры отклоняются до запуска эмулятора и компилятора.
source, runtime, output = (path.resolve() for path in (args.source, args.runtime, args.output)) # Исключаем зависимость путей от cwd компилятора.
output.mkdir(parents=True, exist_ok=True) # Сценарий не удаляет прежние артефакты и не затрагивает записи пользователя.
build = source / 'build-win64' # Это штатный каталог сборки канонического рецепта.
sdk = args.msys_root.resolve() / 'ucrt64/bin' # В UCRT64 находятся компилятор и Ninja той же ABI.
env = dict(os.environ, PATH=str(sdk) + os.pathsep + os.environ.get('PATH', '')) # Компилятор должен найти свои DLL без изменения системного PATH.
commands = subprocess.check_output([str(sdk / 'ninja.exe'), '-t', 'commands', 'CMakeFiles/DSView.dir/DSView/main.cpp.obj'], cwd=build, env=env, text=True) # Берём настоящие include и define текущей сборки.
compile_flags = commands.strip().splitlines()[-1].split(' -MD ')[0] # Убираем генерацию зависимостей рабочего main.cpp, оставляя все флаги компилятора.
obj = output / 'check_link_loss.obj' # Проверочный main хранится отдельно от объектов рабочего приложения.
subprocess.run(compile_flags + ' -o ' + subprocess.list2cmdline([str(obj)]) + ' -c ' + subprocess.list2cmdline([str(Path(__file__).with_suffix('.cpp'))]), cwd=build, env=env, check=True) # Компилируем тест тем же C++11 и заголовками Qt5.
ninja = (build / 'build.ninja').read_text(encoding='utf-8') # Метаданные Ninja перечисляют все реальные объекты и библиотеки DSView.
edge = next(line for line in ninja.splitlines() if line.startswith('build ') and 'CXX_EXECUTABLE_LINKER' in line) # В рецепте есть единственный пользовательский EXE.
objects = re.findall(r'CMakeFiles/[^ ]+\.obj', edge.split(' | ')[0]) # Объекты включают ресурсы, moc, аппаратный драйвер и обработчик GUI.
objects.remove('CMakeFiles/DSView.dir/DSView/main.cpp.obj') # Рабочая точка входа заменяется проверочной без изменения остальных объектов.
libraries = re.search(r'^ LINK_LIBRARIES = (.+)$', ninja, re.MULTILINE).group(1) # Сохраняем полный штатный набор библиотек, включая Python и GIO.
executable = runtime / 'check_link_loss.exe' # Штатный поиск ресурсов DSView использует каталог EXE, поэтому тест располагается рядом с ресурсами отдельного проверочного runtime.
response = output / 'link-loss.rsp' # Response-файл обходит ограничение длины командной строки Windows.
response.write_text(' '.join(objects) + ' "' + obj.as_posix() + '" ' + libraries, encoding='utf-8') # Прямые слеши сохраняют Windows-путь при разборе response-файла GCC, где обратный слеш служит экранированием.
subprocess.run([str(sdk / 'c++.exe'), '@' + str(response), '-o', str(executable)], cwd=build, env=env, check=True) # Линкуем те же объекты, что вошли в исправленный DSView.
udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # Отдельный локальный сокет не подключается к реальной плате.
udp.bind(('127.0.0.1', 37575)) # Порт 37575 задан общим заголовком zynq_la_pl.h протокола RJ2.
udp.settimeout(0.1) # Таймаут 100 мс позволяет быстро остановить фоновую фикстуру после завершения EXE.
stopped, sessions, errors = threading.Event(), set(), [] # Уникальные nonce выявляют самопроизвольные повторные захваты.
def serve(): # Один поток отвечает на discovery и затем имитирует исчезновение платы во время захвата.
try: # Ошибки фикстуры передаются главному потоку, чтобы их нельзя было принять за штатный обрыв.
while not stopped.is_set(): # Внешний сценарий управляет временем жизни только собственного сокета.
try: request, peer = udp.recvfrom(2048) # Буфер вмещает обычный START и расширенную конфигурацию триггера.
except socket.timeout: continue # Отсутствие трафика не является ошибкой эмулятора.
if len(request) < 16: continue # Неполный заголовок не принадлежит протоколу тестовой платы.
magic, operation, nonce, value = struct.unpack_from('<4I', request) # Формат совпадает с четырьмя little-endian словами драйвера.
if operation == 0: # Discovery возвращает INFO только до фактического старта данной сессии.
if nonce not in sessions: udp.sendto(struct.pack('<4I', magic, 0, nonce, 200000000), peer) # Частота 200 МГц разрешена для ZLP2, ZLT и ZLR; после START heartbeat исчезает.
elif operation == 1 and nonce not in sessions: # Повторная отправка START с тем же nonce не считается новым захватом.
sessions.add(nonce) # Каждая новая сессия должна появляться только после явного запуска из нативного теста.
if len(sessions) == 2: # Второй захват обрывается после реально принятых данных.
for sequence in range(64): # 64 пакета по 1024 отсчёта дают непрерывный префикс длиной 65 536 отсчётов.
udp.sendto(struct.pack('<4I', magic, 1, nonce, sequence) + bytes([sequence & 255]) * 1024, peer) # Нумерация без пропусков проверяет сохранение хвоста до сетевого таймаута.
time.sleep(0.001) # Пауза 1 мс предотвращает переполнение очереди UDP при медленном тестовом хосте.
except Exception as error: errors.append(error) # Ошибка потока обязана завершить итоговую проверку неуспехом.
thread = threading.Thread(target=serve, daemon=True) # Поток обслуживает только локальную фикстуру текущего запуска.
thread.start() # Discovery рабочего драйвера выполняется синхронно ещё до первого Qt-таймера.
child_env = {key: value for key, value in os.environ.items() if not key.startswith(('PYTHON', 'QT_', 'QML'))} # Python и Qt пакета SETGUI не должны подменять ABI нативного DSView.
child_env['PATH'] = str(runtime) + os.pathsep + str(Path(os.environ['SystemRoot']) / 'System32') # Все DLL берутся из проверяемого runtime.
child_env['QT_PLUGIN_PATH'] = str(runtime) # EXE находится в каталоге артефактов, а плагины Qt остаются в runtime.
child_env['PYTHONHOME'] = str(runtime) # Встроенный Python читает стандартную библиотеку именно проверяемого компонента.
child_env['DSVIEW_CAPTURE_DIR'] = str(output) # Нативный тест сохраняет аппаратные фрагменты и скриншот рядом с отчётом.
try: # Фоновый сокет освобождается при любом исходе компиляции и запуска.
checked = subprocess.run([str(executable)], cwd=runtime, env=child_env, capture_output=True, text=True, errors='replace', timeout=40) # Дедлайн 40 секунд включает нативный предел 30 секунд и остановку декодеров.
(output / 'link-loss.log').write_text(checked.stdout + checked.stderr, encoding='utf-8') # Полный журнал остаётся доступным при ошибке теста.
print(checked.stdout, end='') # Показываем отдельные результаты трёх аппаратных таймаутов.
if checked.returncode: raise RuntimeError(f'Native link-loss check failed ({checked.returncode}): {checked.stderr}') # Падение процесса не маскируется успешной работой эмулятора.
if errors: raise errors[0] # Проверка требует корректного выполнения фоновой фикстуры.
assert len(sessions) == 3, f'Unexpected automatic captures: {len(sessions)}' # Три ручных запуска должны создать ровно три nonce.
recordings = list(output.glob('*.dsl')) # Запись после обрыва должна быть опубликована штатным дисковым писателем.
assert recordings, 'No preserved capture after partial receive' # Потеря связи не должна удалять принятый непрерывный фрагмент.
for path in recordings: # Проверяем целостность всех опубликованных аппаратных архивов текущего запуска.
with zipfile.ZipFile(path) as archive: # Метаданные и отсчёты должны относиться к одному завершённому архиву.
assert archive.testzip() is None # Контроль CRC выявляет незавершённый или повреждённый файл после обрыва.
assert json.loads(archive.read('zynq_recording.json'))['samples'] == 65536 # Ровно 64 пакета по 1024 отсчёта подтверждают сохранение всего непрерывного префикса.
print('PASS: three manual captures, preserved DSL, normal close with warning open') # Итог охватывает исходный пользовательский сценарий и сохранность записи.
finally: # Освобождение фикстуры не зависит от результата нативного процесса.
stopped.set() # Поток завершится после ближайшего короткого таймаута сокета.
thread.join(timeout=2) # Предел 2 секунды исключает бессрочное ожидание фонового recvfrom.
udp.close() # Закрываем только созданный этим сценарием loopback-сокет.
if __name__ == '__main__': main() # Импорт файла не запускает компилятор, сеть или приложение.
+62
View File
@@ -0,0 +1,62 @@
"""Проверка токовых графиков в настоящем DSView без аппаратного захвата.""" # Сценарий открывает готовую синтетическую DSL-запись и сохраняет изображение результата.
import argparse # Пути runtime, захвата и артефактов задаются явно.
import os # Чистое окружение исключает конфликт Qt и Python родительского процесса.
from pathlib import Path # Все артефакты сохраняются в выбранном каталоге проверки.
import re # Подтверждённый HWND извлекается из штатного протокола встраивания.
import subprocess # Проверяется собранный DSView.exe, а не заглушка графического движка.
import time # Ограниченные ожидания позволяют завершить зависший тест без вмешательства в пользовательскую сессию.
def main(): # Проверка управляет только дочерним экземпляром, который сама запустила.
parser = argparse.ArgumentParser(description=__doc__) # Назначение сценария видно при запуске с --help.
parser.add_argument('--runtime', required=True, type=Path) # Каталог должен содержать полный собранный компонент DSView.
parser.add_argument('--capture', required=True, type=Path) # Запись содержит назначения входов и все параметры двигателя.
parser.add_argument('--output', required=True, type=Path) # Изображение и журнал отделены от исходной записи.
parser.add_argument('--timeout', type=float, default=45) # Ожидание полного декодирования ограничено 45 секундами.
args = parser.parse_args() # Все пути читаются до создания окна или процесса.
from PySide6.QtWidgets import QApplication, QWidget # Qt используется только для тестового родительского окна и снимка дочернего компонента.
runtime, capture, output = args.runtime.resolve(), args.capture.resolve(), args.output.resolve() # Относительные параметры не зависят от рабочего каталога дочернего процесса.
output.mkdir(parents=True, exist_ok=True) # Каталог артефактов создаётся отдельно для каждого сценария.
app, window = QApplication([]), QWidget() # Окно воспроизводит штатное встраивание DSView в SETGUI.
window.resize(1500, 1000) # Высоты достаточно для двенадцати цифровых входов и токового графика NPC.
window.setWindowTitle('Induction motor current decoder verification') # Заголовок отличает автоматическую проверку от рабочего окна пользователя.
window.show() # Родитель получает настоящий HWND перед запуском встраиваемого компонента.
env = {key: value for key, value in os.environ.items() if not key.startswith(('PYTHON', 'QT_', 'QML'))} # Нативный компонент загружает собственные Qt и встроенный Python.
env['PATH'] = str(runtime) + os.pathsep + str(Path(os.environ['SystemRoot']) / 'System32') # DLL выбираются из проверяемой поставки и системного каталога Windows.
env['DSVIEW_HOST_SCREENSHOT'] = str(output / 'motor-loading.png') # Встроенный механизм подтверждает фактическое создание и отрисовку окна DSView.
with (output / 'motor-native.log').open('w', encoding='utf-8') as log: # Журнал сохраняет сообщения импорта декодера и завершения обработки записи.
process = subprocess.Popen([str(runtime / 'DSView.exe'), '--loglevel', '3', '--embed-parent', str(int(window.winId())), str(capture)], cwd=runtime, env=env, stdin=subprocess.PIPE, stdout=log, stderr=log, creationflags=subprocess.CREATE_NO_WINDOW) # Запускается только новый тестовый процесс без видимого терминала.
try: # Любая ошибка завершается очисткой именно этого дочернего процесса.
deadline, completed_at, report = time.monotonic() + args.timeout, None, '' # Дополнительная пауза после декодирования позволяет завершить очередную перерисовку.
while time.monotonic() < deadline and process.poll() is None: # Условие ограничивает ожидание по времени и учитывает преждевременное завершение DSView.
app.processEvents() # Родительское Qt-окно продолжает обрабатывать встраивание и отрисовку.
report = (output / 'motor-native.log').read_text(encoding='utf-8', errors='replace') # Чтение журнала не изменяет захват или состояние декодера.
if 'Traceback (most recent call last)' in report: # Ошибка Python-модели должна немедленно провалить нативную проверку.
raise AssertionError('Decoder failed; inspect motor-native.log') # Диагностика остаётся доступной в каталоге артефактов.
ready = re.search(r'DSVIEW_READY (\d+)', report) # Дескриптор принадлежит только созданному тестом компоненту.
if 'Decoded sample count:' in report and completed_at is None: # Сам факт открытия файла недостаточен без полного декодирования.
completed_at = time.monotonic() # Запоминается время фактического окончания расчёта.
window.resize(1501, 1000) # Изменение размера тестового родителя сбрасывает сохранённую Windows поверхность встраиваемого окна перед снимком.
if completed_at is not None and time.monotonic() - completed_at > 1 and ready: # Одна секунда после расчёта даёт Qt возможность показать все рассчитанные кривые.
image = window.screen().grabWindow(int(ready.group(1))) # Снимок берётся непосредственно с HWND проверяемого нативного окна.
assert not image.isNull() and image.save(str(output / 'motor-complete.png')), 'Native screenshot failed' # Пустой или несохранённый результат не считается визуальной проверкой.
break # После сохранения изображения можно штатно закрыть тестовый экземпляр.
time.sleep(0.02) # Двадцать миллисекунд ограничивают нагрузку опроса и не задерживают интерфейс надолго.
assert completed_at is not None and (output / 'motor-complete.png').is_file(), 'Motor decode did not finish; inspect motor-native.log' # Тайм-аут не маскируется успехом запуска EXE.
process.stdin.write(b'CLOSE\n') # Стандартный протокол встраивания закрывает только тестовую сессию.
process.stdin.flush() # Команда немедленно передаётся дочернему процессу.
deadline = time.monotonic() + 5 # Штатное закрытие ограничено пятью секундами.
while time.monotonic() < deadline and process.poll() is None: # Ожидание не блокирует Qt родительского окна.
app.processEvents() # Сообщения уничтожения дочерних окон обрабатываются обычным образом.
time.sleep(0.02) # Частый короткий опрос не создаёт длинной блокирующей паузы.
assert process.poll() == 0, 'DSView did not close cleanly' # Проверяется корректный жизненный цикл нового анализатора.
finally: # Ошибочный тест не должен оставлять свой DSView в фоне.
if process.poll() is None: # Чужие и уже завершённые процессы не затрагиваются.
process.terminate() # Завершается только дочерний процесс текущего сценария.
process.wait(timeout=5) # Освобождение дескриптора процесса ограничено по времени.
window.close() # Тестовое родительское окно больше не требуется.
print(output / 'motor-complete.png') # Готовый снимок можно открыть для визуальной проверки фазных кривых и шкалы ампер.
if __name__ == '__main__': # Импорт сценария не должен сам запускать графический компонент.
main() # Прямой запуск выполняет один нативный тест выбранной DSL-записи.
+62 -11
View File
@@ -3,27 +3,36 @@
Run with a Python containing PySide6. No acquisition hardware is accessed.
"""
import argparse
import ctypes # Win32 WM_NULL проверяет отзывчивость реального потока интерфейса дочернего DSView.
import json
import math
import os
import re # Готовый HWND читается из штатного ответа host protocol 1.
from pathlib import Path
import subprocess
import time
import zipfile
def fixture(path):
count, rate, period = 60032, 1000000, 500
def fixture(path, seconds=0.060032, carrier_hz=2000, layout='split', max_height='1X', show_text=False, text_only=False): # Видимость текстов и графиков воспроизводит пользовательскую компоновку и позволяет сравнить интервалы при разных высотах.
rate = 1000000 # Частота 1 МГц даёт 50 отсчётов на период при нагрузочной несущей 20 кГц.
if seconds <= 0 or not 0 < carrier_hz <= rate / 2: # Каждый период должен занимать хотя бы два отсчёта.
raise ValueError('Positive duration and carrier <= 500000 Hz are required.') # Некорректный сценарий не должен создавать повреждённую запись.
count, period = math.ceil(seconds * rate / 64) * 64, round(rate / carrier_hz) # Формат DSL требует выравнивания числа отсчётов по 64 битам.
decoders = [dict(id='pwm_waveform', version=2, label='PWM sine A / B / C',
view_index=3, channel=[{'a': 0}, {'b': 1}, {'c': 2}],
options=dict(active_a='high', active_b='high', active_c='high',
carrier_hz=0, smoothing_ms=0.0),
carrier_hz=0, smoothing_ms=0.0, waveform_layout=layout), # Используем штатный параметр Decoders, который также сохраняется в записи DSL.
**{'stacked decoders': [], 'show': {'pwm_waveform': True,
**{'pwm_waveform: '+ch+' duty / frequency': False for ch in 'ABC'}}})]
session = dict(Device='virtual-session', DeviceMode=0, Version=3, Title='DSView v1.3.2',
decoder=decoders, channel=[dict(index=i, enabled=True, name='D'+str(i),
colour='default', strigger=0, type=10000, view_index=i) for i in range(3)],
**{'Sample count': str(count), 'Sample rate': str(rate), 'Max Height': '1X'})
**{'Sample count': str(count), 'Sample rate': str(rate), 'Max Height': max_height}) # Большая высота дорожек не должна увеличивать фон числовых аннотаций.
if show_text or text_only: # Текстовые строки нужны для проверки расстояний и переключения видимых полей.
decoders[0]['show'].update({'pwm_waveform: ' + ch + ' duty / frequency': True for ch in 'ABC'}) # Показываем исходные числовые поля всех трёх каналов без изменения расчётных параметров.
if text_only: # Изолированная текстовая компоновка позволяет проверить независимость от масштаба графиков.
decoders[0]['show'].update({'pwm_waveform: ' + ch + ': -1 .. +1': False for ch in 'ABC'}) # Скрываем только графические строки, сохраняя их рассчитанные данные.
header = ('[version]\nversion = 3\n[header]\ndriver = virtual-session\n'
'device mode = 0\ncapturefile = data\n'
f'total samples = {count}\ntotal probes = 3\ntotal blocks = 1\n'
@@ -35,10 +44,17 @@ def fixture(path):
archive.writestr('decoders', json.dumps(decoders))
for ch in range(3):
bits = bytearray(count // 8)
for i in range(count):
width = round(250 + 200 * math.sin(2 * math.pi * (i // period) / 40 + ch * 2 * math.pi / 3))
if i % period < width:
bits[i // 8] |= 1 << (i % 8)
for i in range(0, count, period): # Обходим периоды вместо всех отсчётов, чтобы длинная фикстура создавалась быстро.
width = min(count - i, round(period * (0.5 + 0.4 * math.sin(2 * math.pi * i / rate * 50 + ch * 2 * math.pi / 3)))) # Синус 50 Гц задаёт заполнение от 10 до 90 процентов со сдвигом фаз 120 градусов.
if not width: # Очень короткий завершающий импульс может округлиться до нуля.
continue # Нулевая длительность сохраняет исходные нулевые биты.
first, last = i // 8, (i + width - 1) // 8 # Вычисляем крайние байты активного импульса.
if first == last: # Импульс внутри одного байта заполняется одной битовой маской.
bits[first] |= ((1 << width) - 1) << (i % 8) # Смещение сохраняет позицию фронта с точностью одного отсчёта.
else: # Длинный импульс состоит из двух неполных байтов и полного внутреннего диапазона.
bits[first] |= (255 << (i % 8)) & 255 # В первом байте активны биты начиная с фронта до конца байта.
bits[first + 1:last] = b'\xff' * (last - first - 1) # Внутренние полные байты заполняются без цикла по отдельным отсчётам.
bits[last] |= (1 << ((i + width - 1) % 8 + 1)) - 1 # Последний байт обрезается точно по спаду импульса.
archive.writestr(f'L-{ch}/0', bits)
@@ -46,13 +62,21 @@ def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--runtime', type=Path, required=True)
parser.add_argument('--output', type=Path, required=True)
parser.add_argument('--seconds', type=float, default=0.060032) # Прежний короткий сценарий остаётся значением по умолчанию.
parser.add_argument('--carrier-hz', type=int, default=2000) # Нагрузочная проверка использует 20 кГц и сотни тысяч периодов.
parser.add_argument('--timeout', type=float, default=30) # Ограничиваем время ожидания завершения декодирования.
parser.add_argument('--layout', choices=('split', 'combined'), default='split') # Один нативный сценарий проверяет оба пользовательских вида графиков.
parser.add_argument('--max-height', choices=('1X', '2X', '3X', '4X'), default='1X') # Проверка на увеличенной дорожке воспроизводит прежнее растягивание текстовых полей.
parser.add_argument('--show-text', action='store_true') # Включаем duty/frequency для проверки всей смешанной компоновки.
parser.add_argument('--text-only', action='store_true') # Фиксированные интервалы проверяются также при полностью скрытых графиках.
parser.add_argument('--check-display-cache', action='store_true') # Нативный сценарий принимает реальные диалоги видимости, неизменённых настроек и вида PWM без нового анализа.
args = parser.parse_args()
from PySide6.QtWidgets import QApplication, QWidget
runtime, output = args.runtime.resolve(), args.output.resolve()
output.mkdir(parents=True, exist_ok=True)
capture = output / 'pwm-three-phase.dsl'
screenshot = output / 'pwm-native.png'
fixture(capture)
fixture(capture, args.seconds, args.carrier_hz, args.layout, args.max_height, args.show_text, args.text_only) # Все параметры восстанавливаются из обычного DSL, включая видимость строк и масштаб дорожек.
app = QApplication([])
window = QWidget()
window.resize(1400, 850)
@@ -61,16 +85,40 @@ def main():
env = {k: v for k, v in os.environ.items() if not k.startswith(('PYTHON', 'QT_', 'QML'))}
env['PATH'] = str(runtime) + os.pathsep + str(Path(os.environ['SystemRoot']) / 'System32')
env['DSVIEW_HOST_SCREENSHOT'] = str(screenshot)
cache_report = output / 'display-cache.txt' # Отчёт нативных проверок отделён от журнала единственного декодирования.
if args.check_display_cache: # Обычный smoke-тест не открывает проверочные модальные диалоги.
cache_report.write_text('', encoding='utf-8') # Исключаем ложный успех от артефактов прежнего запуска.
env['DSVIEW_HOST_CHECK'] = str(cache_report) # Используем существующий механизм нативных проверок встроенного DSView.
env['DSVIEW_HOST_CHECK_DISPLAY_CACHE'] = '1' # Проверяем сохранение готовых результатов вместо удаления анализаторов.
began = time.time()
with (output / 'pwm-native.log').open('w', encoding='utf-8') as log:
process = subprocess.Popen([str(runtime / 'DSView.exe'), '--embed-parent',
process = subprocess.Popen([str(runtime / 'DSView.exe'), '--loglevel', '3', '--embed-parent', # Информационный журнал подтверждает фактическое завершение анализа всей записи.
str(int(window.winId())), str(capture)], cwd=runtime, env=env,
stdin=subprocess.PIPE, stdout=log, stderr=log, creationflags=subprocess.CREATE_NO_WINDOW)
try:
deadline = time.monotonic() + 8
deadline = time.monotonic() + args.timeout # Длинная запись должна полностью обработаться до штатного закрытия.
completed, hwnd, response_times = False, None, [] # Фиксируем завершение и задержку обработки сообщений настоящим интерфейсом DSView.
user32 = ctypes.WinDLL('user32', use_last_error=True) # Системный API проверяет только дочерний процесс, запущенный этим тестом.
user32.SendMessageTimeoutW.argtypes = [ctypes.c_void_p, ctypes.c_uint, ctypes.c_size_t, ctypes.c_ssize_t, ctypes.c_uint, ctypes.c_uint, ctypes.POINTER(ctypes.c_size_t)] # Типы указателей учитывают 64-битный HWND.
while time.monotonic() < deadline and process.poll() is None:
app.processEvents()
report = (output / 'pwm-native.log').read_text(encoding='utf-8', errors='replace') # Чтение журнала не изменяет состояние декодера или прибора.
ready = re.search(r'DSVIEW_READY (\d+)', report) # Используем подтверждённый HWND из штатного протокола встраивания.
if ready: # До готовности нативного окна измерять его отзывчивость нельзя.
hwnd = int(ready.group(1)) # Дескриптор относится только к нашему тестовому экземпляру.
result, started = ctypes.c_size_t(), time.monotonic() # Монотонные часы измеряют обработку одного сообщения.
responded = user32.SendMessageTimeoutW(hwnd, 0, 0, 0, 2, 1000, ctypes.byref(result)) # WM_NULL с SMTO_ABORTIFHUNG ожидает не более одной секунды и не меняет приложение.
response_times.append(time.monotonic() - started) # Задержка показывает блокировку цикла событий во время анализа и рисования.
assert responded, 'DSView UI probe failed, Win32 error={}'.format(ctypes.get_last_error()) # Код Win32 отличает реальное зависание от запрета доступа к чужому HWND или смены рабочего стола.
cache = cache_report.read_text(encoding='utf-8') if args.check_display_cache else 'PASS' # Ожидаем завершения всех действий в реальном диалоге настроек.
assert 'FAIL' not in cache, cache # Ошибочное требование повторного анализа немедленно завершает сценарий с диагностикой фазы.
if 'Decoded sample count:' in report and screenshot.exists() and 'PASS' in cache: # Успех требует полного исходного анализа и подтверждённого сохранения кэша.
completed = True # В журнале есть подтверждение обработки всех отсчётов.
window.screen().grabWindow(hwnd).save(str(output / 'pwm-complete.png')) # Сохраняем итоговый экран после завершения длинного анализа.
break # Далее проверяем штатное закрытие завершённого экземпляра.
time.sleep(.02)
assert completed, 'PWM decode did not complete; inspect pwm-native.log' # Тайм-аут не должен маскироваться успешным принудительным закрытием.
print('UI max response ms:', round(max(response_times, default=0) * 1000, 3)) # Отчёт связывает нагрузочный сценарий с реальной задержкой интерфейса.
if process.poll() is None:
process.stdin.write(b'CLOSE\n')
process.stdin.flush()
@@ -80,6 +128,9 @@ def main():
time.sleep(.02)
assert process.poll() == 0, 'DSView did not close cleanly; inspect pwm-native.log'
assert screenshot.exists() and screenshot.stat().st_mtime >= began, 'No fresh render artifact'
if args.check_display_cache: # Проверка по журналу дополняет результат принятия каждого настоящего диалога.
assert report.count('Decoded sample count:') == 1, 'Display changes triggered another decode' # Все переключения обязаны использовать результаты единственного анализа записи.
print(cache.strip()) # Отчёт показывает отдельный успех скрытия строки, неизменённого OK и изменения вида графиков.
finally:
if process.poll() is None:
process.terminate()
@@ -0,0 +1,49 @@
"""Нативная проверка опций NPC, θ, треугольника и фазовых сдвигов в одном DSView.""" # Скрипт запускает только собственный экземпляр с синтетической записью, не обращаясь к оборудованию.
import argparse # Параметры выбирают тестовый runtime и режим отображения.
import json # Метаданные DSL содержат обычные настройки того же анализатора PWM waveform.
import math # Выравнивание длины записи соответствует 64-битным блокам DSView.
from pathlib import Path # Абсолютные пути исключают зависимость от каталога запуска.
import sys # Стандартная нативная проверка вызывается с собственным контролируемым списком аргументов.
import zipfile # DSL является архивом метаданных и упакованных цифровых каналов.
import check_pwm_native as native # Повторно используем проверку окончания декодирования, отзывчивости и штатного закрытия.
from test_pwm_npc import npc_frames, INDICES # Генератор совпадает с численно проверенными входными векторами четырёх затворов на фазу.
def fixture(path, seconds=.06, carrier_hz=2000, layout='combined', max_height='1X', show_text=False, text_only=False): # Сигнатура сохраняет совместимость с существующим нативным сценарием.
count = math.ceil(seconds * 1000000 / 64) * 64 # Частота 1 МГц и длина, кратная 64 битам, согласованы с цифровыми потоками DSL.
options = dict(active_a='high', active_b='high', active_c='high', input_mode='npc-three-level', waveform_mode=MODE, waveform_layout=layout, carrier_hz=2000, smoothing_ms=0.0, show_theta='yes', show_carrier='yes', show_phase_angles='yes') # Все новые опции включаются штатными параметрами одного экземпляра PWM waveform.
channels = [{('abc'[ch] if gate == 0 else 'abc'[ch] + str(gate + 1)): index} for ch in range(3) for gate, index in enumerate(INDICES[ch])] # S1 сохраняет прежние имена A/B/C, дополнительные затворы имеют явные номера S2…S4.
show = {'pwm_waveform': True} # Видимость относится к строкам результата, а не отключает цифровые входы затворов.
show.update({'pwm_waveform: ' + ch + ' duty / frequency': False for ch in 'ABC'}) # Короткие заполнения скрыты, чтобы все расчётные графики помещались на контрольном экране.
show.update({'pwm_waveform: ' + ch + ' PWM carrier / field': False for ch in 'ABC'}) # Значения частот уже проверяются численными тестами и не заслоняют θ, несущую и фазовые углы.
decoders = [dict(id='pwm_waveform', version=2, label='NPC ABC / theta / carrier / phase lag', view_index=12, channel=channels, options=options, **{'stacked decoders': [], 'show': show})] # Запись загружается обычным механизмом сохранённого анализатора DSView.
session = dict(Device='virtual-session', DeviceMode=0, Version=3, Title='DSView v1.3.2', decoder=decoders, channel=[dict(index=index, enabled=True, name='D' + str(index), colour='default', strigger=0, type=10000, view_index=index) for index in range(12)], **{'Sample count': str(count), 'Sample rate': '1000000', 'Max Height': max_height}) # Все двенадцать физических входов остаются доступными декодеру.
header = '[version]\nversion = 3\n[header]\ndriver = virtual-session\ndevice mode = 0\ncapturefile = data\ntotal samples = {}\ntotal probes = 12\ntotal blocks = 1\nsamplerate = 1000000 Hz\ntrigger time = 0\ntrigger pos = 0\n'.format(count) # Заголовок фиксирует ту же временную шкалу, что генератор фронтов.
header += ''.join('probe{} = D{}\n'.format(index, index) for index in range(12)) # Каждый физический затвор имеет собственную цифровую дорожку.
bits = [bytearray(count // 8) for _ in range(12)] # Пакуются реальные логические уровни, а не готовые кривые результата.
frames = list(npc_frames(seconds=seconds)) # Последовательность содержит только фактические изменения допустимых комбинаций NPC.
frames.append((count, frames[-1][1])) # Последний уровень достраивается до конца записи без выдуманного переключения.
for (start, pins), (end, _) in zip(frames, frames[1:]): # Между соседними снимками все цифровые входы постоянны.
for index, level in enumerate(pins): # Двенадцать входов обрабатываются независимо.
if level: # Нулевые биты уже присутствуют в исходных bytearray.
for sample in range(start, min(end, count)): # Синтетический короткий сценарий допускает прямое заполнение каждого отсчёта.
bits[index][sample // 8] |= 1 << (sample % 8) # Младший бит соответствует первому отсчёту байта в формате DSL.
with zipfile.ZipFile(path, 'w', zipfile.ZIP_DEFLATED) as archive: # Полная фикстура хранится одним файлом и открывается без оборудования.
archive.writestr('header', header) # Стандартный заголовок определяет частоту и число проб.
archive.writestr('session', json.dumps(session)) # Видимость и расположение дорожек восстанавливаются штатным путём.
archive.writestr('decoders', json.dumps(decoders)) # Выбранная топология и новые опции сохраняются вместе с записью.
for index, data in enumerate(bits): # Один блок каждого входа содержит все отсчёты сценария.
archive.writestr('L-{}/0'.format(index), data) # Пути соответствуют индексу физического канала DSView.
if __name__ == '__main__': # Проверка запускается явно после сборки нативного компонента.
parser = argparse.ArgumentParser(description=__doc__) # Интерфейс не добавляет зависимостей к обычному unittest.
parser.add_argument('--runtime', type=Path, required=True) # Используется отдельный тестовый runtime либо явно выбранный локальный компонент.
parser.add_argument('--output', type=Path, required=True) # Все журналы и изображения сохраняются в выделенной папке сценария.
parser.add_argument('--mode', choices=('envelope', 'switching'), default='switching') # Один сценарий проверяет оба пользовательских вида основного графика.
parser.add_argument('--layout', choices=('split', 'combined'), default='combined') # Общая компоновка должна сохранять отдельные области θ и треугольника.
args = parser.parse_args() # Параметры проверяются до запуска дочернего DSView.
MODE = args.mode # Выбранный вид встраивается в обычные настройки декодера DSL.
native.fixture = fixture # Стандартный сценарий получает двенадцатиканальную NPC-запись вместо прежнего двоичного ШИМ.
sys.argv = [sys.argv[0], '--runtime', str(args.runtime), '--output', str(args.output), '--seconds', '.06', '--layout', args.layout] # Остальные проверки выполняются тем же существующим нативным инструментом.
native.main() # Дочерний процесс обязан завершить декодирование и закрыться штатно, оставив контрольный скриншот.
+47
View File
@@ -0,0 +1,47 @@
"""Проверка меню осциллографа в настоящем встроенном DSView с цифровой записью.""" # Запускает только собственный дочерний процесс и сохраняет изображение результата.
import argparse # Пути к проверяемому runtime и артефактам задаются явно.
import os # Изолированное окружение исключает смешение Qt5 дочернего процесса и Qt6 проверочного окна.
from pathlib import Path # Все артефакты размещаются в указанном каталоге.
import subprocess # Нативный DSView проходит тот же протокол встраивания, что в SETGUI.
import time # Монотонные часы ограничивают ожидание готовности и штатного завершения.
from check_pwm_native import fixture # Общая цифровая запись также проверяет сохранность готового декодера PWM.
def main(): # Проверка не подключается к USB или сети и не изменяет записи пользователя.
parser = argparse.ArgumentParser(description=__doc__) # Интерфейс сценария повторяет существующие нативные проверки рецепта.
parser.add_argument('--runtime', type=Path, required=True) # Проверяется конкретная собранная папка, а не установленный глобально DSView.
parser.add_argument('--output', type=Path, required=True) # Изображение, журнал и отчёт сохраняются вместе для диагностики.
args = parser.parse_args() # Некорректные аргументы завершают сценарий до создания GUI.
from PySide6.QtWidgets import QApplication, QWidget # Qt6 предоставляет настоящее родительское окно для нативного Qt5 DSView.
runtime, output = args.runtime.resolve(), args.output.resolve() # Дочерний процесс получает однозначные абсолютные пути.
output.mkdir(parents=True, exist_ok=True) # Каталог артефактов создаётся до подготовки проверочной записи.
capture, report, screenshot = output / 'digital.dsl', output / 'scope-check.txt', output / 'scope-native.png' # Каждый результат имеет отдельное назначение.
fixture(capture, seconds=0.008192) # Цифровая запись 8,192 мс содержит несколько периодов синуса и меандра эмулятора.
report.write_text('', encoding='utf-8') # Старый успешный отчёт не может скрыть ошибку нового запуска.
app = QApplication.instance() or QApplication([]) # Один цикл событий обслуживает родительскую область встраивания.
window = QWidget() # Изолированное окно принадлежит только проверке.
window.resize(1400, 900) # Размер в логических пикселях оставляет место для аналоговых, цифровых и декодированных дорожек.
window.show() # Настоящий HWND необходим протоколу --embed-parent DSView.
environment = {key: value for key, value in os.environ.items() if not key.startswith(('PYTHON', 'QT_', 'QML'))} # Дочерний Qt5 не наследует плагины и Python runtime Qt6.
environment.update(PATH=str(runtime) + os.pathsep + str(Path(os.environ['SystemRoot']) / 'System32'), DSVIEW_HOST_CHECK=str(report), DSVIEW_HOST_CHECK_SCOPE='1', DSVIEW_HOST_SCREENSHOT=str(screenshot)) # Проверка меню и снимок включаются только для этого процесса.
with (output / 'scope-native.log').open('w', encoding='utf-8') as log: # Журнал сохраняется даже при нативном падении.
process = subprocess.Popen([str(runtime / 'DSView.exe'), '--embed-parent', str(int(window.winId())), str(capture)], cwd=runtime, env=environment, stdin=subprocess.PIPE, stdout=log, stderr=log, creationflags=subprocess.CREATE_NO_WINDOW) # Открываем синтетическую цифровую запись через штатный нативный путь.
try: # Процесс освобождается при успехе, тайм-ауте и ошибке утверждения.
deadline = time.monotonic() + 30 # Тридцать секунд ограничивают запуск и проверку короткой записи.
while process.poll() is None and not report.read_text(encoding='utf-8') and time.monotonic() < deadline: # Ожидаем результата реальных действий меню, поддерживая родительский цикл событий.
app.processEvents() # Вложенный DSView получает resize и paint без блокировки окна.
time.sleep(0.02) # Короткая пауза ограничивает загрузку процессора при ожидании отчёта.
result = report.read_text(encoding='utf-8') # Отчёт формируется нативной проверкой добавления и удаления каналов.
assert result.startswith('PASS'), result or 'DSView не завершил проверку; см. scope-native.log' # Тайм-аут и аварийное завершение не выдаются за успех.
assert screenshot.is_file(), 'Не создан снимок осциллограммы' # Успех требует фактического рендера новых дорожек.
process.stdin.write(b'CLOSE\n') # Закрываем собственный экземпляр тем же способом, что SETGUI.
process.stdin.flush() # Команда немедленно поступает в канал нативного компонента.
deadline = time.monotonic() + 5 # Штатное завершение короткой синтетической записи не должно зависать.
while process.poll() is None and time.monotonic() < deadline: # Продолжаем обслуживать родителя до завершения дочернего процесса.
app.processEvents() # Встраивание остаётся действительным до закрытия DSView.
time.sleep(0.02) # Не выполняем активное ожидание завершения.
assert process.poll() == 0, 'DSView не завершился штатно' # Нативное падение после проверки также считается ошибкой.
print(result.strip(), screenshot) # Краткий отчёт указывает доступный для визуальной проверки артефакт.
finally: # Не оставляем проверочный DSView после провала проверки.
if process.poll() is None: process.terminate() # Завершаем только собственный дочерний процесс, не затрагивая пользовательские сессии.
process.wait(timeout=5) # Освобождаем дескрипторы процесса перед закрытием родительского окна.
window.close() # Проверочная область встраивания больше не нужна.
if __name__ == '__main__': main() # Прямой запуск сценария выполняет полный нативный smoke-тест.
+108
View File
@@ -0,0 +1,108 @@
#include "pwm_waveform.h" // Проверяем тот же индекс, который использует нативная строка DSView.
#include <chrono> // Монотонные часы измеряют стоимость обзорной перерисовки длинной записи.
#include <iostream> // Результат содержит проверяемые размеры геометрии и измеренное время.
#include <random> // Детерминированный шум проверяет сохранение нерегулярных экстремумов.
#include <stdexcept> // Исключения завершают тест с ненулевым кодом даже в сборке NDEBUG.
static void check(bool condition, const char *message) { // Проверки не отключаются оптимизациями компилятора.
if (!condition) throw std::runtime_error(message); // Ошибка сообщает, какое свойство графика нарушено.
} // Успешная проверка не изменяет состояние индекса.
int main() { // Тест работает без прибора, окна и цикла событий Qt.
set_pwm::Envelope envelope; // Один индекс соответствует одной графической строке PWM.
std::vector<set_pwm::Line> original, actual; // Эталон хранит полные отрезки для независимого сравнения.
envelope.lines(actual, 0, 100, 10); // Запрос до поступления данных должен быть безопасным.
check(actual.empty(), "empty envelope"); // Пустая запись не должна рисовать выдуманный сигнал.
std::mt19937 random(7351); // Постоянное зерно делает случайные экстремумы воспроизводимыми.
double previous = 0; // Начальное значение общей непрерывной кривой равно заполнению 50 процентов.
for (size_t index = 0; index < 4097; ++index) { // Нечётная длина проверяет незавершённые узлы пирамиды.
const double next = double(random() % 20001) / 10000 - 1; // Значения покрывают нормированный диапазон с шагом 0,0001.
envelope.append(index * 10, (index + 1) * 10, previous, next); // Каждый линейный сегмент занимает десять отсчётов.
original.push_back({double(index * 10), double((index + 1) * 10), previous, next}); // Эталон сохраняет координаты без использования индекса.
previous = next; // Соседние сегменты соединяются точно по своим концам.
if (index == 2 || index == 1024 || index == 4096) { // Запросы во время поступления данных проверяют обновление неполного дерева.
actual.clear(); // Каждый запрос получает отдельный выходной вектор, как при перерисовке DSView.
envelope.lines(actual, 0, (index + 1) * 10, 1); // Вся текущая запись сворачивается в единственный пиксель.
double low = 1, high = -1; // Полный перебор эталона независимо находит оба экстремума.
for (const auto &line : original) { low = std::min(low, std::min(line.a, line.b)); high = std::max(high, std::max(line.a, line.b)); } // Эталон не использует дерево или его правила разбиения.
check(actual.size() == 1 && actual[0].a == low && actual[0].b == high, "streaming extrema"); // Даже незавершённый блок должен сохранять все пики.
} // Следующая итерация продолжает пополнять уже опрошенный индекс.
} // Готовая нерегулярная запись используется для проверки разных областей и масштабов.
for (size_t pixels : {size_t(1), size_t(7), size_t(31), size_t(512)}) { // Ширины охватывают одноточечный обзор и обычное экранное окно.
const uint64_t start = 17, end = 40953; // Обе границы проходят внутри сегментов и требуют интерполяции.
actual.clear(); // Результат не должен включать геометрию предыдущего масштаба.
envelope.lines(actual, start, end, pixels); // Запрашиваем плотное представление с обрезкой краёв.
check(actual.size() <= pixels * 2, "bounded geometry"); // Число вызовов рисования не должно расти с количеством периодов.
size_t column = 0; // Каждая вертикаль соответствует очередной непустой колонке.
for (const auto &line : actual) { // Соединительные отрезки не участвуют в сравнении вертикальных экстремумов.
if (line.start != line.end) continue; // Наклонные соединения обеспечивают непрерывность, а не диапазон колонки.
const double left = start + double(end - start) * column / pixels; // Эталон использует физические границы пикселя.
const double right = start + double(end - start) * (column + 1) / pixels; // Правая граница не округляется до номера периода.
double low = 1, high = -1; // Диапазон вычисляется полным перебором всех исходных сегментов.
for (const auto &source : original) { // Независимый алгоритм намеренно медленный, чтобы проверить индекс.
const double begin = std::max(source.start, left), finish = std::min(source.end, right); // Находим реальное пересечение сегмента с колонкой.
if (finish <= begin) continue; // Сегменты вне колонки не могут расширять её экстремумы.
const double a = source.a + (source.b - source.a) * (begin - source.start) / (source.end - source.start); // Левый конец обрезается аналитически.
const double b = source.a + (source.b - source.a) * (finish - source.start) / (source.end - source.start); // Правый конец обрезается независимо от индекса.
low = std::min(low, std::min(a, b)); // Сохраняем самый низкий из всех видимых концов.
high = std::max(high, std::max(a, b)); // Сохраняем самый высокий из всех видимых концов.
} // Полный перебор образует эталон без прореживания.
check(std::abs(line.a - low) < 1e-12 && std::abs(line.b - high) < 1e-12, "clipped pixel extrema"); // Пирамида должна давать тот же диапазон с точностью double.
++column; // Следующая вертикаль относится к следующему пикселю.
} // Проверены все вертикали текущего масштаба.
check(column == pixels, "all visible columns"); // Непрерывная запись должна покрывать каждую колонку.
} // Изменение ширины окна не должно менять измеренные данные.
actual.clear(); // Увеличенный фрагмент проверяется отдельно от обзорного графика.
envelope.lines(actual, 20000, 20100, 1000); // На крупном масштабе десять сегментов занимают тысячу пикселей.
check(actual.size() == 10, "zoom restores original segments"); // Исходные периоды не должны исчезать после обзорной отрисовки.
for (size_t index = 0; index < actual.size(); ++index) { // Сравниваем каждый восстановленный отрезок с полным эталоном.
const auto &expected = original[2000 + index]; // Номер исходного периода следует из координаты 20000 / 10.
check(actual[index].start == expected.start && actual[index].end == expected.end && actual[index].a == expected.a && actual[index].b == expected.b, "exact zoom values"); // Увеличение должно вернуть точные координаты и значения.
} // Проверка исключает разрушительное прореживание исходных аннотаций.
envelope.clear(); // Новый захват должен сбросить старые сегменты и все уровни индекса.
actual.clear(); // Удаляем геометрию предыдущей записи.
envelope.lines(actual, 0, 40970, 100); // Те же координаты после очистки больше не содержат сигнала.
check(actual.empty(), "clear removes stale extrema"); // Старые выбросы не должны переходить в новый анализ.
for (uint64_t index = 0; index < 100; ++index) { // Два участка разделены настоящим отсутствием данных.
envelope.append(index, index + 1, 0, 0); // Первая часть записи имеет нулевую модуляцию.
envelope.append(index, index, 1, 1); // Пустой сегмент не должен нарушать поиск или вызывать деление на ноль.
} // Первый участок занимает отсчёты от нуля до ста.
for (uint64_t index = 300; index < 400; ++index) envelope.append(index, index + 1, 1, 1); // Второй участок начинается после разрыва в двести отсчётов.
actual.clear(); // Проверяем плотную геометрию разрывной записи.
envelope.lines(actual, 0, 400, 4); // Разрыв занимает две полные экранные колонки.
check(actual.size() == 2 && actual[0].a == 0 && actual[1].a == 1, "gaps remain disconnected"); // Между участками не должно появиться искусственной наклонной линии.
for (double direction : {1.0, -1.0}) { // Угол может вращаться в обе стороны, поэтому проверяем сброс 360→0 и обратный переход 0→360.
envelope.clear(); // Каждый вариант вращения проверяется независимо от предыдущей записи.
envelope.append(0, 50, direction * 0.9, direction); // Первый участок заканчивается точно на одном краю нормированной шкалы θ.
envelope.append(50, 100, -direction, -direction * 0.9); // Смежный участок начинается на противоположном краю в тот же отсчёт.
actual.clear(); // Запрашиваем полную геометрию одного циклического перехода.
envelope.lines(actual, 0, 100, 1000); // Крупный масштаб должен сохранить точный момент сброса на отсчёте 50.
check(actual.size() == 3 && actual[1].start == 50 && actual[1].end == 50 && actual[1].a == direction && actual[1].b == -direction, "theta wrap has exact vertical edge"); // Между двумя пилообразными участками требуется вертикаль без ложной диагонали.
actual.clear(); // Повторный запрос начинается непосредственно с момента циклического перехода.
envelope.lines(actual, 50, 100, 1000); // Левая граница окна не должна скрывать вертикаль θ.
check(actual.size() == 2 && actual[0].start == 50 && actual[0].end == 50, "theta edge survives left viewport boundary"); // Соседний невидимый сегмент нужен только для восстановления фронта на границе.
envelope.clear(); // Отдельно отличаем циклический сброс от действительно неизвестного интервала.
envelope.append(0, 50, direction * 0.9, direction); // Первый известный участок остаётся тем же.
envelope.append(51, 100, -direction, -direction * 0.9); // Один пропущенный отсчёт обозначает отсутствие данных, а не мгновенный переход.
actual.clear(); // Старые вертикали не должны переноситься в новый запрос.
envelope.lines(actual, 0, 100, 1000); // Проверяем сохранность разрыва даже при большом увеличении.
check(actual.size() == 2 && actual[0].end == 50 && actual[1].start == 51, "unknown theta interval stays disconnected"); // Новый соединитель не имеет права достраивать неизвестные значения угла.
} // Проверка касается геометрии и не изменяет сами рассчитанные углы или выбор направления вращения.
envelope.clear(); // Длинный нагрузочный сценарий начинается с чистого состояния.
const auto build_start = std::chrono::steady_clock::now(); // Измеряем создание индекса отдельно от перерисовки.
for (uint64_t index = 0; index < 1000000; ++index) { // Миллион периодов соответствует 50 секундам при несущей 20 кГц.
envelope.append(index * 50, (index + 1) * 50, index == 500000 ? -1 : 0, index == 500001 ? 1 : 0); // Одиночные отрицательный и положительный выбросы должны пережить обзор.
} // Длинная запись содержит оба пика среди почти постоянного сигнала.
const auto query_start = std::chrono::steady_clock::now(); // Стоимость создания индекса не включается в задержку интерфейса.
for (int frame = 0; frame < 100; ++frame) { // Сто последовательных кадров выявляют случайный полный обход в перерисовке.
actual.clear(); // Размер геометрии измеряется для каждого кадра отдельно.
envelope.lines(actual, 0, 50000000, 1920); // Ширина 1920 пикселей моделирует полный экран с 50-секундным захватом.
check(actual.size() <= 3840, "million periods bounded"); // Даже миллион периодов выдаёт не более двух отрезков на пиксель.
} // Повторная отрисовка использует уже готовый индекс без разбора строк PWM1.
double low = 1, high = -1; // Проверяем, что нагрузочное уплотнение не скрывает одиночные выбросы.
for (const auto &line : actual) { low = std::min(low, std::min(line.a, line.b)); high = std::max(high, std::max(line.a, line.b)); } // Учитываем все видимые отрезки конечного кадра.
check(low == -1 && high == 1, "single period spikes preserved"); // Редкие пики должны оставаться видимыми среди миллиона периодов.
const auto finish = std::chrono::steady_clock::now(); // Фиксируем итог после всех запросов геометрии.
std::cout << "periods=1000000 lines=" << actual.size() << " build_ms=" << std::chrono::duration<double, std::milli>(query_start - build_start).count() << " frame_ms=" << std::chrono::duration<double, std::milli>(finish - query_start).count() / 100 << std::endl; // Отчёт позволяет сравнить задержку до и после исправления.
return 0; // Нулевой код означает прохождение функциональных и нагрузочных проверок.
} // Все ресурсы индекса освобождаются автоматически после завершения теста.
+31
View File
@@ -0,0 +1,31 @@
#include "scope_demo.h" // Проверяем тот же переносимый источник, который подключён к настоящему DSView.
#include <cassert> // Ошибка физической модели должна завершать нативную проверку ненулевым кодом.
#include <limits> // Нечисловые значения воспроизводят повреждённые входные параметры.
int main() { // Проверка не требует Qt, аппаратного анализатора или платы Zynq.
const double epsilon = 1e-9; // Допуск 1 нВ учитывает погрешность вычисления sin, сохраняя проверку амплитуды в вольтах.
for (unsigned channel = 0; channel < 4; ++channel) { // Все каналы проверяются независимо, включая две разные формы сигнала.
const double period = 1 / set_scope::hz[channel]; // Период в секундах рассчитывается из частоты исходного эмулятора Zynq.
assert(std::abs(set_scope::value(channel, period / 4) - set_scope::peak[channel]) < epsilon); // Четверть периода даёт положительный пик у обеих форм.
assert(std::abs(set_scope::value(channel, 3 * period / 4) + set_scope::peak[channel]) < epsilon); // Три четверти периода дают отрицательный пик.
assert(std::abs(set_scope::value(channel, -period / 4) + set_scope::peak[channel]) < epsilon); // Отрицательное время сохраняет непрерывность фазы при прокрутке.
assert(std::abs(set_scope::value(channel, period / 8) - set_scope::value(channel, period * 5.125)) < epsilon); // Сдвиг на пять целых периодов не изменяет напряжение.
const auto full = set_scope::extrema(channel, 0, 500); // Пятьсот секунд моделируют очень длинную развёртку с сотнями тысяч периодов в пикселе.
assert(full.low == -set_scope::peak[channel] && full.high == set_scope::peak[channel]); // Огибающая обязана сохранять оба пика без алиасинга.
const auto narrow = set_scope::extrema(channel, period * 0.20, period * 0.30); // Внутренний максимум нельзя обнаружить только по концам интервала.
assert(narrow.high == set_scope::peak[channel]); // Аналитический расчёт обязан найти пик между экранными отсчётами.
const auto reverse = set_scope::extrema(channel, period * 0.30, period * 0.20); // Переставленные границы воспроизводят обратное направление выделения.
assert(reverse.low == narrow.low && reverse.high == narrow.high); // Направление просмотра не должно менять диапазон напряжения.
for (int index = 0; index < 300; ++index) { // Непериодическая сетка интервалов выявляет ошибки поиска внутренних экстремумов.
const double first = (index - 150) * period / 37, last = first + period / 13; // Интервалы охватывают отрицательное время и разные положения относительно фронтов.
const auto range = set_scope::extrema(channel, first, last); // Огибающая вычисляется производственным алгоритмом с постоянной сложностью.
for (int sample = 0; sample <= 100; ++sample) { // Плотная независимая выборка проверяет отсутствие потерянных пиков и фронтов.
const double value = set_scope::value(channel, first + (last - first) * sample / 100); // Напряжение берётся внутри проверяемого временного интервала.
assert(value >= range.low - epsilon && value <= range.high + epsilon); // Ни одно значение идеального источника не должно выходить за рассчитанную огибающую.
} // Проверка включает меандр с разрывами и гладкий синус.
} // Всего проверяется более 120 тысяч точек на различных интервалах.
} // Проверены частоты, амплитуды, фаза и длинная развёртка всех четырёх источников.
assert(set_scope::value(4, 0) == 0); // Несуществующий пятый канал безопасно отклоняется.
assert(set_scope::value(0, std::numeric_limits<double>::infinity()) == 0); // Бесконечное время не распространяет NaN в геометрию Qt.
assert(set_scope::extrema(0, 0, std::numeric_limits<double>::quiet_NaN()).high == 0); // Повреждённая граница интервала возвращает определённый пустой диапазон.
return 0; // Нулевой код сообщает об успешной нативной проверке модели Zynq.
} // Исполняемый файл можно запускать на любой платформе с компилятором C++11.
+1 -1
View File
@@ -48,7 +48,7 @@ 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', 'tms_uart', 'plates_pbus', 'plates_sbus', 'pwm_waveform'): # Все анализаторы, включая обе 96-контактные шины, загружаются без установленного SETGUI.
for name in ('gate_driver_timing', 'transistor_pair', 'set_uart', 'set_can', 'pm35_uart', 'tms_uart', 'plates_pbus', 'plates_sbus', 'pwm_waveform', 'sigma_delta'): # Изолированный Python должен импортировать все устанавливаемые анализаторы, включая сигма-дельта и его общее ядро.
module = importlib.import_module(name + '.pd')
assert module.Decoder.api_version == 3
core = importlib.import_module('common.setgui_decoders.gate_timing')
+30
View File
@@ -0,0 +1,30 @@
"""Проверка точности и масштабируемости нативного индекса кривой PWM.""" # Тест компилирует фактическую реализацию DSView без подключения прибора.
import os # Изолированное окружение содержит DLL выбранного MSYS2 SDK.
from pathlib import Path # Пути вычисляются относительно теста и настроенного SDK.
import subprocess # Нативный тест запускается отдельным процессом с проверкой кода возврата.
import tempfile # Исполняемый файл создаётся вне исходников и автоматически удаляется.
import unittest # Проверка входит в существующий набор unittest discover.
class PwmEnvelopeTests(unittest.TestCase): # Функциональные и нагрузочные сценарии используют реальный заголовок C++.
def test_native_extrema_zoom_gaps_and_million_periods(self): # Один запуск проверяет данные и ограниченную геометрию длинного захвата.
candidates = [Path(os.environ.get('SETGUI_MSYS_ROOT', 'C:/msys64')), Path('C:/setcorp/tools/msys64')] # Учитываем явную настройку и оба поддерживаемых расположения SDK.
prefix = next((root / 'ucrt64' for root in candidates if (root / 'ucrt64/bin/g++.exe').is_file()), None) # Компилятор должен принадлежать тому же SDK, что заголовки и DLL Qt.
if os.name != 'nt' or prefix is None: # Переносимые Python-тесты продолжают работать без необязательного нативного SDK.
self.skipTest('Для нативного теста необходим Windows MSYS2 UCRT64 с Qt 5.') # Причина пропуска видна в отчёте unittest.
recipe = Path(__file__).resolve().parents[1] # Заголовок и тест берутся из одного рецепта DSView.
env = dict(os.environ) # Сохраняем стандартные системные настройки процесса компилятора.
env['PATH'] = str(prefix / 'bin') + os.pathsep + env.get('PATH', '') # Компилятор и тест находят DLL UCRT64 без глобального изменения PATH.
with tempfile.TemporaryDirectory(prefix='pwm-envelope-') as temporary: # Все создаваемые бинарные файлы принадлежат только текущему тесту.
executable = Path(temporary) / 'pwm-envelope.exe' # Результат компиляции не меняет установленный DSView.
includes = [recipe / 'native', prefix / 'include', prefix / 'include/QtCore', prefix / 'include/QtGui'] # QtGui предоставляет используемые заголовком типы QPainter и QLineF.
command = [str(prefix / 'bin/g++.exe'), '-std=c++11', '-O2', *('-I' + str(path) for path in includes), str(recipe / 'tests/pwm_envelope.cpp'), '-L' + str(prefix / 'lib'), '-lQt5Gui', '-lQt5Core', '-o', str(executable)] # Стандарт C++11 совпадает с нативной сборкой DSView, оптимизация моделирует рабочий компонент.
compiled = subprocess.run(command, env=env, capture_output=True, text=True, errors='replace', timeout=60) # Ограничение времени выявляет зависший компилятор без бесконечного ожидания.
self.assertEqual(compiled.returncode, 0, compiled.stdout + compiled.stderr) # Ошибки компиляции сообщаются вместе с диагностикой SDK.
checked = subprocess.run([str(executable)], env=env, capture_output=True, text=True, errors='replace', timeout=30) # Миллион периодов должен обрабатываться в ограниченное время.
self.assertEqual(checked.returncode, 0, checked.stdout + checked.stderr) # Сам C++-тест независимо проверяет экстремумы, разрывы, очистку и точный крупный масштаб.
print(checked.stdout.strip()) # Измеренная задержка кадра сохраняется в отчёте для сравнения производительности.
if __name__ == '__main__': # Файл можно запустить отдельно или через общий unittest discover.
unittest.main() # Стандартный запуск возвращает ненулевой код при нарушении проверяемых свойств.
+149
View File
@@ -0,0 +1,149 @@
"""Проверки измерения несущей ШИМ и электрической частоты поля по цифровым фронтам.""" # Синтетические записи проверяют численные результаты без оборудования и установленного DSView.
import importlib.util # Адаптер загружается с подменённым sigrokdecode для проверки фактических аннотаций.
import math # Синус и интеграл линейной частоты формируют стационарные сигналы и разгон.
import sys # Таблица модулей временно предоставляет адаптеру изолированное ядро и заглушку sigrok.
import types # ModuleType создаёт минимальный модуль окружения встроенного декодера.
import unittest # Стандартный набор проверок запускается и в Python 3.8 для Windows 7.
from unittest.mock import patch # Подмена импортов ограничивается загрузкой проверяемого адаптера.
from test_pwm_waveform import ROOT, core # Используем тот же источник ядра, что существующие проверки восстановления кривой.
class FrequencyTests(unittest.TestCase): # Проверяем физический смысл частот отдельно от геометрии нативного графика.
def signal(self, state, frequency=50, phase=0, active=True, duration=0.3, slope=0): # Генератор выдаёт реальные цифровые фронты, а не готовые значения заполнения.
events = [] # Результаты содержат только полностью декодированные периоды или окна.
for index in range(round(duration * 2000) + 1): # Несущая 2000 Гц при дискретизации 1 МГц даёт 500 отсчётов на период.
stamp = index * 500 # Активные фронты расположены равномерно с периодом 500 отсчётов.
seconds = stamp / 1000000 # Электрическая фаза рассчитывается в секундах, независимо от частоты несущей.
angle = math.tau * (frequency * seconds + slope * seconds * seconds / 2) + phase # Интеграл f(t)=frequency+slope*t задаёт непрерывную фазу при разгоне.
width = round(250 + 200 * math.sin(angle)) # Заполнение 10–90% оставляет оба фронта при любой фазе синусоиды.
events.extend(state.update(stamp, active)) # Активный фронт завершает предыдущий измеряемый период ШИМ.
events.extend(state.update(stamp + width, not active)) # Противоположный фронт задаёт длительность активной части текущего периода.
return events # Последний неполный период поля намеренно не достраивается.
def test_three_phases_polarities_and_window_modes(self): # Обе полярности и оба режима должны давать одну электрическую частоту для каждой фазы.
for frequency in (25, 50, 125): # Периоды поля содержат соответственно 80, 40 и 16 периодов несущей 2 кГц.
for phase in (0, math.tau / 3, 2 * math.tau / 3): # Трёхфазная система отличается сдвигом 120 электрических градусов.
for active in (True, False): # Инверсия физического входа не должна менять измеренную частоту.
for carrier in (0, 2000): # Автоматический режим и синхронные окна проверяются на одних цифровых фронтах.
with self.subTest(frequency=frequency, phase=phase, active=active, carrier=carrier): # Ошибка указывает конкретный режим и фазу.
events = self.signal(core.PwmChannel(1000000, active, carrier), frequency, phase, active) # Все вычисления выполняет штатный потоковый декодер.
fields = [event['field'] for event in events if event['field'] is not None] # Отбираем только завершённые электрические периоды.
self.assertGreater(len(fields), 3) # Запись длительностью 300 мс должна содержать несколько полных измерений даже при 25 Гц.
for field in fields: # Проверяется каждый период, а не только среднее, способное скрыть удвоения частоты.
self.assertAlmostEqual(field['frequency'], frequency, delta=frequency * 0.01) # Погрешность менее 1% учитывает дискретизацию ширины импульса и интерполяцию.
self.assertEqual(field['carrier_frequency'], 2000) # Средняя несущая берётся из фронтов и не зависит от фазы поля.
self.assertTrue(all(event['carrier_frequency'] == 2000 for event in events if event['carrier_frequency'] is not None)) # Каждое доступное измерение несущей соответствует реальным периодам.
def test_accelerating_field_tracks_each_complete_period(self): # Измерение должно следовать разгону, видимому на пользовательском примере.
fields = [event['field'] for event in self.signal(core.PwmChannel(1000000), frequency=10, duration=0.5, slope=140) if event['field'] is not None] # Частота растёт с 10 до 80 Гц за полсекунды.
self.assertGreater(len(fields), 10) # Число завершённых периодов исключает единственный усреднённый результат на всю запись.
for field in fields: # У линейного разгона средняя частота периода равна мгновенной частоте в его середине.
seconds = (field['start'] + field['end']) / 2000000 - 0.00025 # Из середины периода вычитаем задержку полпериода несущей: 250 мкс.
expected = 10 + 140 * seconds # Эталон выводится непосредственно из заданного закона разгона, Гц.
self.assertAlmostEqual(field['frequency'], expected, delta=expected * 0.01) # Проверка обнаруживает неверное удвоение, постоянное значение и существенное отставание.
self.assertGreater(fields[-1]['frequency'], fields[0]['frequency'] * 2) # Последовательность измерений действительно отражает увеличение частоты.
def test_window_frequency_does_not_replace_measured_carrier(self): # Ошибочно заданная несущая не должна выдаваться за результат измерения.
events = self.signal(core.PwmChannel(1000000, carrier_hz=1000)) # Окна 1 кГц обрабатывают физический сигнал с несущей 2 кГц.
measured = [event for event in events if event['carrier_frequency'] is not None] # Первые окна без двух активных фронтов исключаются из сравнения.
self.assertGreater(len(measured), 100) # Достаточная длина проверяет устойчивую работу режима окон.
self.assertTrue(all(event['frequency'] == 1000 and event['carrier_frequency'] == 2000 for event in measured)) # Частота интегрирования и фактическая несущая остаются независимыми величинами.
fields = [event['field'] for event in measured if event['field'] is not None] # Даже при двух импульсах в одном окне огибающая содержит электрическую основную частоту.
self.assertTrue(fields) # Заданный размер окна не отключает измерение поля.
self.assertTrue(all(abs(field['frequency'] - 50) < 0.5 and field['carrier_frequency'] == 2000 for field in fields)) # Поле и средняя несущая одновременно получены из одной записи.
def test_constant_duty_and_small_ripple_have_no_field(self): # Постоянная несущая и квантование около нуля не должны превращаться в частоту поля.
for widths in ((250,), (249, 251), (100,), (400,)): # 50%, дрожание ±0,2 процентного пункта и постоянные 20/80% не проходят полосу 49–51%.
state, events = core.PwmChannel(1000000), [] # Каждый вектор начинается с нового независимого состояния.
for index in range(200): # Сто миллисекунд дают множество несущих периодов, но ни одного электрического цикла.
events.extend(state.update(index * 500, True)) # Активный фронт подтверждает наличие реальной несущей.
events.extend(state.update(index * 500 + widths[index % len(widths)], False)) # Заполнение постоянно либо колеблется внутри полосы гистерезиса.
self.assertTrue(events) # Отсутствие поля проверяется при наличии успешно декодированных импульсов.
self.assertTrue(all(event['field'] is None for event in events)) # Ни постоянный уровень, ни малое дрожание не дают ложной электрической частоты.
def test_variable_carrier_is_measured_for_each_real_period(self): # Автоматический режим должен следовать изменению частоты ШИМ, а не запоминать первое значение.
state = core.PwmChannel(1000000) # Частота дискретизации 1 МГц переводит длины периодов непосредственно в микросекунды.
state.update(0, False) # Низкий начальный уровень позволяет первому настоящему фронту открыть измерение.
stamp = 100 # Первый полный импульс начинается через 100 мкс от начала записи.
state.update(stamp, True) # Этот фронт ещё не задаёт частоту, поскольку предыдущий полный период отсутствует.
for period in (500, 400, 250, 1000): # Эталонная несущая последовательно принимает значения 2 кГц, 2,5 кГц, 4 кГц и 1 кГц.
state.update(stamp + period // 2, False) # Заполнение каждого переменного периода составляет 50%.
stamp += period # Следующий фронт завершает именно текущий период, а не среднее нескольких разных периодов.
event = state.update(stamp, True)[0] # Автоматический декодер выдаёт один результат на один завершённый период.
self.assertEqual(event['carrier_frequency'], 1000000 / period) # Численное измерение связано с текущей парой фронтов.
self.assertIsNone(event['field']) # Изменение несущей при постоянном заполнении не создаёт модуляцию поля.
def test_smoothed_waveform_keeps_stationary_field_frequency(self): # Включённый фильтр должен подавлять пульсации без изменения установившегося электрического периода.
events = self.signal(core.PwmChannel(1000000, smoothing_ms=1)) # Постоянная времени 1 мс сравнима с двумя периодами несущей 2 кГц.
fields = [event['field'] for event in events if event['field'] is not None] # Начальный переходный процесс отделяется от завершённых периодов фильтрованной кривой.
self.assertGreater(len(fields), 5) # Фильтр не должен полностью подавлять измерение поля 50 Гц.
self.assertTrue(all(abs(field['frequency'] - 50) < 0.5 for field in fields[2:])) # После затухания начального переходного процесса период сохраняется с погрешностью менее 1%.
def test_incomplete_field_does_not_emit_frequency(self): # Одного положительного перехода недостаточно для полного периода поля.
events = self.signal(core.PwmChannel(1000000), frequency=50, phase=-math.pi / 2, duration=0.012) # Двенадцать миллисекунд короче полного периода 50 Гц, равного 20 мс.
self.assertTrue(all(event['field'] is None for event in events)) # Анализатор ждёт второго подтверждённого восходящего пересечения.
def test_absent_edges_do_not_report_nominal_carrier(self): # Окна при постоянном уровне не являются доказательством наличия несущей.
state = core.PwmChannel(1000, carrier_hz=100) # Окно 10 отсчётов соответствует заданной частоте интегрирования 100 Гц.
state.update(0, False) # Начальный уровень не считается реальным активным фронтом.
events = state.update(100, False) # Десять окон полностью заполнены нулём без единого импульса.
self.assertTrue(all(event['carrier_frequency'] is None for event in events)) # Отсутствующая несущая остаётся неизвестной независимо от настройки окна.
state.update(110, True) # Первый действительный фронт задаёт только начало будущего измерения.
state.update(115, False) # Пять отсчётов высокого уровня формируют половину периода.
state.update(120, True) # Второй фронт завершает период 10 отсчётов, то есть 100 Гц.
events = state.update(170, True) # После исчезновения фронтов прежняя частота должна перестать считаться текущей.
self.assertEqual(events[0]['carrier_frequency'], 100) # Первое следующее окно ещё относится к недавно измеренной несущей.
self.assertIsNone(events[-1]['carrier_frequency']) # Длительное насыщение не сохраняет устаревшее числовое значение.
self.assertTrue(all(event['field'] is None for event in events)) # Один переход между постоянными уровнями не создаёт полный период поля.
def adapter(self, carrier=0): # Загружаем адаптер без внешнего Python-модуля sigrokdecode или нативного процесса.
class FakeDecoder: # Минимальная реализация интерфейса принимает штатные аннотации декодера.
def register(self, kind): # Регистрация возвращает идентификатор выхода для последующих put.
return kind # Нативный дескриптор не нужен для проверки содержимого аннотаций.
def put(self, start, end, output, data): # Аргументы совпадают с контрактом sigrokdecode.
self.emitted.append((start, end, data)) # Сохраняем интервалы и типы строк для проверки отображения.
stub = types.ModuleType('sigrokdecode') # Подменённый модуль существует только во время импорта адаптера.
stub.Decoder, stub.OUTPUT_ANN = FakeDecoder, 0 # Адаптеру нужны базовый класс и тип выхода аннотаций.
with patch.dict(sys.modules, {'sigrokdecode': stub, 'common.setgui_decoders.pwm_waveform': core}): # Изоляция исключает случайный импорт установленной версии ядра.
spec = importlib.util.spec_from_file_location('pwm_frequency_adapter', ROOT / 'tools/dsview/decoders/pwm_waveform/pd.py') # Проверяем именно исходный адаптер поставки.
adapter = importlib.util.module_from_spec(spec) # Отдельный экземпляр модуля не меняет результаты других проверок.
spec.loader.exec_module(adapter) # Определение Decoder связывается с контролируемой заглушкой sigrok.
decoder = adapter.Decoder() # Конструктор сбрасывает состояния каналов так же, как при настоящем декодировании.
decoder.channels_state = {channel: core.PwmChannel(1000000, carrier_hz=carrier) for channel in (0, 2)} # Необязательный канал B отсутствует, а C остаётся доступным.
decoder.emitted = [] # Выходные аннотации начинают новую независимую запись.
decoder.start() # Регистрируем выход штатным методом адаптера.
return decoder # Тесты подают цифровые уровни через тот же _update, который вызывает decode.
def test_adapter_emits_independent_field_rows_and_preserves_curve_contract(self): # Проверяем видимые подписи обеих частот и совместимость нативного графика.
decoder = self.adapter() # Каналы A и C измеряются независимо при отсутствии B.
for index in range(400): # Двести миллисекунд содержат несколько периодов обоих электрических сигналов.
decoder.samplenum = index * 500 # Общие активные фронты задают несущую 2 кГц.
decoder._update([True, 255, True]) # Неподключённый B имеет служебное значение и не должен создавать аннотации.
widths = {channel: round(250 + 200 * math.sin(math.tau * frequency * index / 2000)) for channel, frequency in ((0, 50), (2, 25))} # A работает на 50 Гц, а C на 25 Гц при одинаковой несущей.
pins = [True, 255, True] # Уровни обоих подключённых каналов сохраняются между их индивидуальными спадами.
for channel in sorted(widths, key=widths.get): # Спады подаются в хронологическом порядке даже при разной ширине импульсов.
decoder.samplenum = index * 500 + widths[channel] # Время каждого события задано целым номером отсчёта.
pins[channel] = False # Меняется только выбранный вход, остальные сохраняют прежнее состояние.
decoder._update(pins) # Адаптер сам распределяет события по состояниям подключённых каналов.
fields = [event for event in decoder.emitted if event[2][0] >= 6] # Индексы дополнительных строк не затрагивают графику и заполнение 0–5.
self.assertEqual({event[2][0] for event in fields}, {6, 8}) # Канал B не создаёт пустые результаты или измерения чужого входа.
for start, end, (kind, labels) in fields: # Проверяем интервал полного периода и физические значения в видимых строках.
frequency = 50 if kind == 6 else 25 # Каждая строка должна сохранить частоту именно своего канала.
self.assertAlmostEqual(1000000 / (end - start), frequency, delta=frequency * 0.01) # Аннотация занимает целый электрический период и читается при обзорном масштабе.
self.assertIn('PWM carrier=2000.000 Hz', labels[0]) # Несущая выводится явным текстом с единицами Гц.
self.assertIn('Field={:.3f} Hz'.format(frequency), labels[0]) # Поле присутствует в той же основной подписи, что несущая.
self.assertEqual(labels[-1], '2kHz/{}Hz'.format(frequency)) # Даже самый короткий вариант сохраняет обе частоты, чтобы обзорный масштаб не скрывал несущую.
curves = [event for event in decoder.emitted if event[2][0] < 3] # Нативный renderer продолжает получать прежние графические классы.
self.assertTrue(all(event[2][1][-1].startswith('PWM1 ') for event in curves)) # Версионный контракт сегментов кривой остаётся неизменным.
def test_adapter_distinguishes_window_and_carrier_in_visible_label(self): # Оба числовых значения должны быть различимы непосредственно в интерфейсе.
decoder = self.adapter(carrier=1000) # Окна заданы на 1 кГц при фактической несущей 2 кГц.
for stamp, level in ((0, False), (100, True), (350, False), (600, True), (850, False), (1100, True), (1350, False), (1600, True), (2000, False)): # Последовательность содержит несколько полных периодов несущей до второго окна.
decoder.samplenum = stamp # Время каждого уровня передаётся в штатных номерах отсчётов sigrok.
decoder._update([level, 255, level]) # Оба подключённых канала получают один и тот же тестовый сигнал.
labels = [event[2][1][0] for event in decoder.emitted if event[2][0] in (3, 5)] # Проверяется строка заполнения, доступная и без завершённого периода поля.
self.assertTrue(any('PWM carrier=2000.000 Hz' in label and 'window=1000.000 Hz' in label for label in labels)) # Подпись не подменяет реальную несущую заданной частотой расчётного окна.
if __name__ == '__main__': # Прямой запуск файла равнозначен обнаружению стандартным unittest.
unittest.main() # Ненулевой код завершения сообщает о нарушении измерительного контракта.
+179
View File
@@ -0,0 +1,179 @@
"""Независимые электрические проверки модели двигателя и цифрового адаптера.""" # Проверки не требуют анализатора, GUI или установленного sigrok.
import cmath # Комплексное сопротивление схемы замещения даёт независимый эталон установившегося тока.
import importlib.util # Исходные модули загружаются напрямую из канонической поставки templates.
import math # Синусоидальные напряжения и допуски выражаются в физических единицах СИ.
from pathlib import Path # Пути вычисляются относительно самого набора тестов.
import sys # Заглушка sigrok действует только при импорте адаптера.
import types # Минимальный модуль окружения не зависит от установленного DSView.
import unittest # Проверки доступны в стандартном Python без сторонних зависимостей.
from unittest.mock import patch # Подмена импортов ограничивается контекстом одной проверки.
ROOT = Path(__file__).resolve().parents[3] # Корень templates содержит общую Python-модель и инструменты DSView.
SPEC = importlib.util.spec_from_file_location('motor_core_test', ROOT / 'python/logic_analyzer/decoders/pwm_motor.py') # Проверяется фактический исходник поставляемого физического ядра.
core = importlib.util.module_from_spec(SPEC) # Отдельное пространство имён исключает установленную устаревшую копию модели.
SPEC.loader.exec_module(core) # Классы модели доступны без импорта остальных протоколов проекта.
class MotorTests(unittest.TestCase): # Эталоны проверяют физические свойства, а не воспроизводят матричный алгоритм реализации.
def test_sine_matches_independent_steady_state_equivalent_circuit(self): # Установившийся ток сравнивается с классической Т-схемой замещения при разных скольжениях.
omega, peak, dt = math.tau * 50, 230.0, 0.0001 # Поле 50 Гц, фазная амплитуда 230 В и шаг представления 100 мкс задают независимый режим испытания.
for rpm in (0, 1440, 1500, 1560, -1440): # Неподвижный ротор, двигатель, синхронная скорость, рекуперация и реверс проверяют знак вращательных членов.
with self.subTest(rpm=rpm): # Ошибка указывает механическую скорость, при которой нарушен эталон.
motor = core.InductionMotor(speed_rpm=rpm) # Используются явно документированные примерные параметры двигателя.
for step in range(20000): # Две секунды позволяют затухнуть электрическим переходным процессам.
voltage = peak * cmath.exp(1j * omega * (step + 0.5) * dt) # Значение в середине интервала аппроксимирует непрерывный источник с малой известной погрешностью.
motor.advance(dt, core.phases(voltage)) # Воздействие подаётся как три реальных фазных напряжения.
slip = 1 - rpm * 2 * math.tau / 60 / omega # Две пары полюсов переводят механическую скорость ротора в относительное скольжение.
magnetizing = 1j * omega * 0.15 # Примерная взаимная индуктивность 150 мГн переводится в комплексное сопротивление на 50 Гц.
if abs(slip) < 1e-10: # При нулевом скольжении ветвь приведённого ротора имеет бесконечное активное сопротивление.
parallel = magnetizing # Остаётся только ток намагничивания и ток потерь статора.
else: # В остальных режимах роторная ветвь содержит активную часть Rr/s и индуктивность рассеяния.
rotor = 0.8 / slip + 1j * omega * 0.005 # 0,8 Ом и 5 мГн соответствуют независимой схеме замещения одной обмотки.
parallel = magnetizing * rotor / (magnetizing + rotor) # Параллельное соединение ветвей ротора и намагничивания вычисляется по закону Ома.
expected = peak / (1.0 + 1j * omega * 0.005 + parallel) # Последовательные потери статора и рассеяние дают эталон комплексного фазного тока.
self.assertLess(abs(motor.current - expected), abs(expected) * 0.002) # Амплитуда и фазовый сдвиг должны совпасть с независимым эталоном в пределах 0,2 процента.
def test_constant_voltage_matches_ohms_law_at_locked_rotor(self): # При постоянном токе и неподвижном роторе установившийся ток определяется сопротивлением статора.
motor = core.InductionMotor(speed_rpm=0) # Нулевая скорость исключает генераторную ЭДС вращения.
result = motor.advance(10, (100, -50, -50)) # Десять секунд значительно превосходят постоянные времени примерной машины.
self.assertAlmostEqual(result[0], 100, places=7) # При Rs=1 Ом напряжение 100 В создаёт ток 100 А.
self.assertAlmostEqual(sum(result), 0, places=12) # Трёхпроводная модель не создаёт паразитный ток нейтрали.
def test_transition_is_independent_of_plot_sampling(self): # Число точек графика не должно изменять физический ток при неизменном напряжении.
one, many = core.InductionMotor(), core.InductionMotor() # Начальные параметры и состояния обоих независимых двигателей одинаковы.
one.advance(0.05, (180, -130, -50)) # Один большой интервал проверяет устойчивость точного решения.
for step in range(500): # Второй расчёт разбивает те же 50 мс на небольшие участки.
many.advance(0.0001, (180, -130, -50)) # Физическое воздействие не меняется при добавлении выходных точек.
self.assertLess(abs(one.current - many.current), 1e-8) # Совпадение отделяет модельную точность от частоты отображения.
self.assertLess(abs(one.flux - many.flux), 1e-9) # Поток ротора также не зависит от выходной сетки.
def test_invalid_physical_parameters_are_rejected(self): # Неконечные и нефизические значения не должны доходить до матричной экспоненты.
for settings in ({'rs': 0}, {'rr': -1}, {'lls_mh': 0}, {'llr_mh': -1}, {'lm_mh': float('nan')}, {'pole_pairs': 1.5}, {'speed_rpm': float('inf')}): # Граничные условия проверяют разные физические входы.
with self.subTest(settings=settings), self.assertRaises(ValueError): # Для каждого некорректного параметра ожидается явная диагностика.
core.InductionMotor(**settings) # Ошибка должна обнаруживаться при создании модели.
class InverterTests(unittest.TestCase): # Электрическая топология проверяется отдельно от переходной модели двигателя.
def gates(self, upper, lower=None, inner=None): # Набор затворов следует публичному порядку входов адаптера.
return tuple(upper) + tuple(lower if lower is not None else [None] * 3) + tuple(inner if inner is not None else [None] * 6) # Необязательные входы отличаются от измеренного логического нуля.
def test_two_level_dc_voltage_scales_current(self): # Удвоение напряжения в линейной модели должно удвоить ток каждого проводника.
values = [] # Сохраняем две независимые оценки после одинакового переключения.
for dc in (300, 600): # Различается только полное напряжение между шинами звена.
model = core.PwmMotor(1000000, dc_voltage=dc) # Частота 1 МГц переводит 1000 отсчётов в одну миллисекунду.
model.update(0, self.gates((1, 0, 0))) # Первое состояние задаёт положительное линейное напряжение фазы A.
values.append(model.update(1000)[3]) # Постоянный участок рассчитывается даже без единого дополнительного фронта.
for small, large in zip(*values): # Каждая фаза должна соблюдать ту же линейную зависимость.
self.assertAlmostEqual(large, 2 * small, places=8) # Никакая нормировка графика не участвует в физических амперах.
def test_common_mode_voltage_does_not_drive_floating_star(self): # Одинаковое переключение всех плеч не создаёт линейных напряжений.
model = core.PwmMotor(1000) # Симметричная машина подключена звездой без нейтрального провода.
model.update(0, self.gates((1, 1, 1))) # Все выходы подключены к одной и той же положительной шине.
self.assertEqual(model.update(100)[3], (0, 0, 0)) # Синфазный ШИМ не должен вызывать ложный двигательному току сигнал.
def test_three_level_encoding_and_midpoint_imbalance(self): # P/N-кодировка должна различать плюс, среднюю точку и минус.
model = core.PwmMotor(1000, topology='3-level P/N', dc_voltage=600, midpoint_percent=60) # Дисбаланс 60/40 процентов создаёт шины +360 и −240 В.
model.update(0, self.gates((1, 0, 0), (0, 0, 1))) # Команды фаз равны 10, 00 и 01 соответственно.
self.assertEqual(model.poles, (360, 0, -240)) # Ни один из трёх уровней не выводится из заполнения других фаз.
self.assertEqual(model.warnings, ()) # Все три команды допустимы для P/N.
def test_npc_twelve_gates_match_signed_three_level_commands(self): # Реальные Q1…Q4 должны создавать те же напряжения, что явная кодировка P/N.
npc = core.PwmMotor(1000000, topology='3-level NPC') # Четыре ключа на фазу требуют двенадцати назначенных входов.
pn = core.PwmMotor(1000000, topology='3-level P/N') # Сравниваем электрическое воздействие, а не внутренние булевы поля.
npc.update(0, self.gates((1, 0, 0), (0, 0, 1), (1, 0, 1, 1, 0, 1))) # Q1…Q4 фаз A/B/C равны 1100, 0110 и 0011.
pn.update(0, self.gates((1, 0, 0), (0, 0, 1))) # P/N фаз A/B/C равны 10, 00 и 01.
self.assertEqual(npc.poles, pn.poles) # Разные входные кодировки должны давать одинаковые полюсные напряжения.
self.assertEqual(npc.update(1000)[3], pn.update(1000)[3]) # Совпадение физических токов проверяет весь путь до модели двигателя.
def test_delta_reports_line_currents(self): # Для тех же сопротивлений обмотки линейный постоянный ток треугольника втрое больше звезды.
values = [] # Сохраняем установившиеся токи двух схем подключения.
for connection in ('star', 'delta'): # Меняется соединение обмоток при одинаковых параметрах каждой обмотки.
model = core.PwmMotor(1000, connection=connection, speed_rpm=0) # Неподвижный ротор и постоянное напряжение дают простой независимый эталон.
model.update(0, self.gates((1, 0, 0))) # Полюсное напряжение инвертора одинаково в обоих опытах.
values.append(model.update(10000)[3]) # Десять секунд обеспечивают завершение электрического переходного процесса.
self.assertAlmostEqual(values[1][0], 3 * values[0][0], places=6) # График должен показывать именно ток провода, а не ток одной ветви треугольника.
def test_invalid_or_missing_gates_are_explicit(self): # Невозможные комбинации не должны выглядеть как достоверно рассчитанное напряжение.
model = core.PwmMotor(1000, topology='3-level P/N') # В этом режиме нижние команды всех фаз обязательны.
with self.assertRaises(ValueError): # Служебное отсутствие канала не равнозначно команде средней точки.
model.update(0, self.gates((1, 0, 0))) # Назначены только три верхних входа вместо шести.
model.update(0, self.gates((1, 0, 0), (1, 0, 0))) # Команда 11 в фазе A недопустима.
self.assertIn('invalid gates 11', model.warnings[0]) # Предупреждение должно содержать реальную ошибочную комбинацию.
with self.assertRaises(ValueError): # Время не может двигаться назад при потоковом декодировании.
model.update(-1) # Проверяется явная ошибка входной временной отметки.
def test_active_low_preserves_electrical_waveform(self): # Глобальная инверсия затворных сигналов не должна менять физическое воздействие.
high, low = core.PwmMotor(1000), core.PwmMotor(1000, active_high=False) # Различается только настройка активной полярности входов.
high.update(0, self.gates((1, 0, 0))) # Высокоактивный верхний ключ A подключает фазу к положительной шине.
low.update(0, self.gates((0, 1, 1))) # Инвертированные физические уровни задают те же включённые ключи.
self.assertEqual(high.update(10)[3], low.update(10)[3]) # Токи совпадают после нескольких периодических точек без фронтов.
def test_interval_warnings_belong_to_previous_gate_state(self): # Восстановление допустимой команды не должно скрывать ошибку предшествующего участка тока.
model = core.PwmMotor(1000, topology='3-level P/N') # Команды P/N позволяют явно подать невозможное одновременное включение.
model.update(0, self.gates((1, 0, 0), (1, 0, 0))) # На первом интервале фаза A имеет недопустимую комбинацию 11.
model.update(10, self.gates((1, 0, 0), (0, 0, 0))) # В конце интервала входы переключаются в допустимое состояние 10.
self.assertEqual(model.warnings, ()) # Новый интервал уже имеет определённое выходное напряжение.
self.assertIn('invalid gates 11', model.interval_warnings[0]) # Завершённый пакет сохраняет реальную недостоверность предыдущих десяти отсчётов.
class AdapterTests(unittest.TestCase): # Минимальный движок ожидания проверяет настоящий цикл decode на постоянном участке и на фронтах.
def decoder(self, settings=None): # Каждая проверка получает новый адаптер и собственный журнал выходов.
class FakeDecoder: # Совпадают только необходимые адаптеру публичные методы sigrok.
def register(self, kind): # Дескриптор позволяет различать аннотации и структурированный поток.
return kind # Нативная библиотека для этого теста не нужна.
def has_channel(self, index): # В базовом опыте назначены три двухуровневых верхних команды.
return index < 3 # Отсутствующие нижние ключи моделируются идеальными комплементарными парами.
def put(self, start, end, output, data): # Выходы собираются без изменения типов и единиц данных адаптера.
self.emitted.append((start, end, output, data)) # Время и содержимое доступны независимым утверждениям теста.
def wait(self, conditions): # Виртуальный захват содержит фронт на отсчёте 23 и заканчивается на отсчёте 103.
if conditions == {}: # Начальный запрос должен вернуть уровни без ожидания первого фронта.
self.samplenum = 0 # Область декодирования начинается с первого отсчёта.
else: # Следующее событие выбирается между фактическим фронтом и точкой периодической сетки.
boundary = self.samplenum + conditions[-1]['skip'] # Последнее условие адаптера задаёт максимальный интервал до новой точки.
self.samplenum = min(boundary, 23) if self.samplenum < 23 else boundary # Фронт не должен пропасть между узлами выходной сетки.
if self.samplenum > 103: # Окончание захвата не создаёт вымышленного полного выходного окна.
self.samplenum = 103 # Последний известный отсчёт используется штатным end.
raise EOFError # Тестовая остановка имитирует завершение wait в движке декодирования.
return ([1, 0, 0] if self.samplenum < 23 else [0, 1, 0]) + [255] * 9 # Уровни меняются одновременно; служебные 255 отсутствующих входов фильтруются адаптером.
stub = types.ModuleType('sigrokdecode') # Окружение импорта ограничено заглушкой публичных констант.
stub.Decoder, stub.OUTPUT_ANN, stub.OUTPUT_PYTHON, stub.SRD_CONF_SAMPLERATE = FakeDecoder, 0, 1, 10000 # Значения выходов различимы в журнале теста.
with patch.dict(sys.modules, {'sigrokdecode': stub, 'common.setgui_decoders.pwm_motor': core}): # Реальный адаптер связывается с фактической проверяемой моделью.
spec = importlib.util.spec_from_file_location('motor_adapter_test', ROOT / 'tools/dsview/decoders/pwm_motor/pd.py') # Загружается исходный модуль, который попадёт в runtime.
module = importlib.util.module_from_spec(spec) # Независимый экземпляр исключает влияние предыдущих настроек.
spec.loader.exec_module(module) # Определение класса выполняется в контролируемом окружении sigrok.
decoder = module.Decoder() # Состояние двигателя сбрасывается штатным конструктором.
decoder.options = {option['id']: option['default'] for option in decoder.options} # Настройки по умолчанию воспроизводят поведение диалога DSView.
decoder.options.update(settings or {}) # Проверка может изменить шкалу или частоту отображения.
decoder.emitted, decoder.samplenum = [], 0 # Выходной журнал и временная отметка начинаются с пустого захвата.
decoder.metadata(stub.SRD_CONF_SAMPLERATE, 1000000) # Частота 1 МГц задаёт 10 отсчётов на точку при выходе 100 кГц.
decoder.start() # Оба типа выхода регистрируются перед decode.
return decoder # Дальнейшая проверка запускает настоящий цикл адаптера.
def test_real_decode_keeps_edges_constant_spans_units_and_final_tail(self): # Один сценарий проверяет временную сетку, фронты, амперы и конец записи.
decoder = self.decoder() # Используются реальные настройки по умолчанию, включая частоту 100 кГц.
with self.assertRaises(EOFError): # Конец виртуальной записи штатно прерывает ожидание событий.
decoder.decode() # Выполняется фактический код адаптера без ручного вызова его внутренних методов.
decoder.samplenum, decoder.last_samplenum = 100, 103 # DSView сохраняет samplenum последнего wait и передаёт окончание записи отдельным атрибутом.
decoder.end() # Последний частичный интервал до отсчёта 103 должен быть сохранён.
packets = [event for event in decoder.emitted if event[2] == 1] # Структурированный поток содержит ненормированные линейные токи.
self.assertEqual(packets[0][0], 0) # Начальный постоянный участок до первого фронта не теряется.
self.assertEqual(packets[-1][1], 103) # Конец не округляется до следующего полного окна в 110 отсчётов.
self.assertIn(23, [event[1] for event in packets]) # Фронт между точками 20 и 30 должен завершить собственный сегмент.
self.assertTrue(all(event[3][1]['unit'] == 'A' and event[3][1]['estimated'] for event in packets)) # Амперы и расчётный характер доступны следующему анализатору.
self.assertTrue(all(abs(sum(event[3][1][key] for key in ('ia', 'ib', 'ic'))) < 1e-9 for event in packets)) # Все выходные точки соблюдают первый закон Кирхгофа.
warnings = [event for event in decoder.emitted if event[2] == 0 and event[3][0] == 3] # Диагностическая строка должна охватить всю оценённую запись.
self.assertEqual((warnings[0][0], warnings[-1][1]), (0, 103)) # Даже неизменная диагностика завершается при end.
def test_plot_clipping_keeps_unclipped_amperes(self): # Узкая шкала не должна ограничивать физический расчёт двигателя.
decoder = self.decoder({'plot_range_a': 0.001}) # Один миллиампер намного меньше токов выбранного испытательного напряжения.
with self.assertRaises(EOFError): # Виртуальная запись заканчивается тем же механизмом, что и обычный сценарий.
decoder.decode() # Адаптер рассчитывает ток, превышающий заданную графическую шкалу.
decoder.end() # Превышение шкалы должно попасть и в последний интервал диагностики.
packets = [event[3][1] for event in decoder.emitted if event[2] == 1] # Численные результаты извлекаются из структурированного выхода.
self.assertTrue(any(abs(packet['ia']) > 0.001 and packet['outside_plot_range'] for packet in packets)) # Истинные амперы сохраняются при насыщении только изображения.
curves = [event for event in decoder.emitted if event[2] == 0 and event[3][0] < 3] # Только графические классы используют служебный формат PWM1.
self.assertTrue(all(abs(float(value)) <= 1 for event in curves for value in event[3][1][-1].split()[1:])) # Координаты остаются совместимыми с ограниченным нативным индексом экстремумов.
if __name__ == '__main__': # Набор можно запускать отдельно от GUI и других тестов проекта.
unittest.main() # Код возврата отражает численные и интеграционные проверки.
+181
View File
@@ -0,0 +1,181 @@
"""Проверки NPC, коммутационного вида, θ, расчётной несущей и межфазных углов.""" # Синтетические цифровые входы проверяют опции одного анализатора без силового оборудования.
import importlib.util # Адаптер загружается из канонического исходника вместе с изолированной заглушкой sigrok.
import math # Эталонные трёхфазные огибающие и направления вектора задаются аналитически.
import sys # Таблица модулей ограничивает подмену импортов временем загрузки адаптера.
import types # ModuleType создаёт минимальное окружение встроенного sigrokdecode.
import unittest # Проверки используют стандартную библиотеку и совместимы с Python 3.8.
from unittest.mock import patch # Внешний интерпретатор DSView не нужен для численных проверок адаптера.
from test_pwm_waveform import ROOT, core # Оба режима проверяются на том же ядре, что восстановление обычной огибающей.
GATES = {1: (1, 1, 0, 0), 0: (0, 1, 1, 0), -1: (0, 0, 1, 1)} # Классическая стойка NPC нумерует S1…S4 сверху вниз.
INDICES = {ch: (ch, 3 + ch * 3, 4 + ch * 3, 5 + ch * 3) for ch in range(3)} # Старые входы A/B/C сохраняют положение S1 каждой фазы.
def npc_frames(seconds=.12, frequency=50, offsets=(0, -120, -240), reverse=False): # Генератор формирует дискретные состояния всех двенадцати затворов при несущей 2 кГц.
changes = {} # Одинаковые моменты разных фаз объединяются в один атомарный снимок цифровых входов.
for period in range(round(seconds * 2000)): # При 1 МГц период несущей 2 кГц занимает ровно 500 отсчётов.
base = period * 500 # Начало периода задаёт синфазную треугольную несущую PD для трёх фаз.
for ch, offset in enumerate(offsets): # Независимые смещения позволяют проверить как правильную, так и обратную последовательность.
angle = math.tau * frequency * (base + 250) / 1000000 + math.radians(-offset if reverse else offset) # Модуляция берётся в середине окна, совпадающей с временной координатой восстановленной огибающей.
mean = .8 * math.cos(angle) # Амплитуда 0,8 оставляет ненулевые интервалы обоих уровней каждой полуволны.
if mean >= 0: # Положительная полуволна сравнивается с верхним треугольником 0…+1.
states = ((base, 1), (base + round(mean * 250), 0), (base + round((1 - mean / 2) * 500), 1)) # Состояние +1 обрамляет нулевой промежуток около вершины несущей.
else: # Отрицательная полуволна сравнивается с нижним треугольником −1…0.
states = ((base, 0), (base + round((1 + mean) * 250), -1), (base + round((1 - mean) * 250), 0)) # Отрицательный импульс расположен вокруг вершины нижнего треугольника.
for stamp, level in states: # События каждого затвора определяются полным допустимым состоянием стойки.
changes.setdefault(stamp, {})[ch] = GATES[level] # Несколько состояний после округления к одному отсчёту объединяются последним реальным уровнем.
pins = [0] * 12 # Снимок заполняется допустимыми комбинациями всех фаз в первом событии.
for stamp, updates in sorted(changes.items()): # Адаптер получает строго неубывающие номера отсчётов.
for ch, gates in updates.items(): # Одновременно изменённые фазы сохраняются в одной записи.
for index, level in zip(INDICES[ch], gates): # Порядок соответствует входам S1, S2, S3, S4 каждой фазы.
pins[index] = level # Физический цифровой вход имеет только значения 0 или 1.
yield stamp, tuple(pins) # Неизменяемый снимок исключает случайное изменение уже сохранённых тестовых событий.
class NpcTests(unittest.TestCase): # Физическая таблица NPC и алгоритмы углов проверяются отдельно от нативной компоновки графиков.
def test_truth_table_polarity_and_unknown_states(self): # Все шестнадцать комбинаций должны сохранять различие между допустимым уровнем и неизвестным напряжением.
for active in (True, False): # Полярность сигналов затворов настраивается независимо от схемы стойки.
state = core.NpcChannel(1000000, active) # Параметры времени не влияют на декодирование логического состояния.
for bits in range(16): # Четыре затвора дают шестнадцать возможных входных комбинаций.
gates = tuple((bits >> shift) & 1 for shift in (3, 2, 1, 0)) # Старший бит соответствует верхнему ключу S1.
expected = core.NpcChannel.STATES.get(gates) # Только три штатные комбинации имеют однозначный уровень напряжения.
physical = gates if active else tuple(1 - bit for bit in gates) # Инвертированные драйверы представляют ту же физическую комбинацию противоположными входными уровнями.
self.assertEqual(state.state(physical), expected) # Ни dead-time 0000, ни запрещённые комбинации не должны стать фиктивной нейтралью.
def test_signed_integration_and_fixed_windows(self): # Огибающая должна учитывать знаковую площадь всех трёх уровней.
state = core.NpcChannel(1000, carrier_hz=100) # Окно 10 отсчётов соответствует 100 Гц при дискретизации 1 кГц.
state.update(0, GATES[1]) # Первые два отсчёта имеют положительное напряжение.
state.update(2, GATES[0]) # Три следующих отсчёта соответствуют нейтрали.
state.update(5, GATES[-1]) # Последние пять отсчётов имеют отрицательное напряжение.
event = state.update(10, GATES[0])[0] # Полное окно содержит площадь +2−5, делённую на длительность 10.
self.assertAlmostEqual(event['value'], -.3) # Средний уровень равен −0,3, а не заполнению отдельного затвора.
self.assertEqual(event['valid_fraction'], 1) # Все отсчёты восстановлены по допустимым состояниям.
self.assertIsNone(event['carrier_frequency']) # Один переход между положительным и отрицательным уровнем не является измерением полного периода несущей.
def test_unknown_time_is_excluded_and_long_gaps_reset_field(self): # Короткие dead-time допускают оценку по известным участкам, длительные ошибки разрывают измерение.
state = core.NpcChannel(10000, carrier_hz=100) # Период 100 отсчётов позволяет точно задать долю неизвестного времени.
state.update(0, GATES[1]) # Начальная допустимая часть окна имеет уровень +1.
state.update(49, (0, 0, 0, 0)) # Один отсчёт без включённых ключей считается неизвестным, а не нулевым.
state.update(50, GATES[0]) # Остальная половина окна соответствует достоверной нейтрали.
event = state.update(100, (1, 1, 1, 1))[0] # Первое окно содержит 99 известных отсчётов и единичную коммутационную паузу.
self.assertAlmostEqual(event['value'], 49 / 99) # Среднее нормируется по известному времени, явно оставаясь оценкой.
self.assertEqual(event['valid_fraction'], .99) # Покрытие отражает исключённую неизвестную длительность.
state.update(190, GATES[0]) # Следующее окно почти целиком содержит запрещённое состояние всех включённых ключей.
self.assertEqual(state.update(200, GATES[1]), []) # Недостаточно определённое окно не выдаёт числа или нарисованного нуля.
self.assertIsNone(state.previous) # График не соединяет достоверные данные через длительную неизвестную область.
self.assertIsNone(state.field_crossing) # Частота поля не измеряется через потерянную часть записи.
def test_npc_sine_and_frequency_in_both_modes(self): # Восстановление NPC должно работать как по фронтам, так и с заданной несущей.
for carrier in (0, 2000): # Нулевая настройка измеряет периоды импульсов; 2 кГц задаёт равномерные окна.
state, events = core.NpcChannel(1000000, carrier_hz=carrier), [] # Состояние не переносится между режимами.
for stamp, pins in npc_frames(): # Синтетическая запись содержит шесть полных электрических периодов.
events.extend(state.update(stamp, [pins[index] for index in INDICES[0]])) # Проверяется реальная последовательность четырёх затворов фазы A.
self.assertGreater(len(events), 100) # Результат должен содержать множество полных периодов несущей.
for event in events: # Контролируется вся огибающая, включая смену знака и начало новой полуволны.
expected = .8 * math.cos(math.tau * 50 * event['midpoint'] / 1000000) # Эталон задан синусоидой в том же моменте времени, что восстановленная точка.
self.assertAlmostEqual(event['value'], expected, delta=.065) # Допуск учитывает дискретизацию и автоматическое окно между движущимися фронтами.
fields = [event['field'] for event in events if event['field'] is not None] # Электрическая частота измеряется по полным периодам знаковой огибающей.
self.assertGreaterEqual(len(fields), 3) # Начальный фрагмент не должен скрыть установившееся поле.
self.assertTrue(all(abs(field['frequency'] - 50) < 1 for field in fields)) # Смена знака ненулевых импульсов не удваивает частоту поля.
def test_vector_angle_common_mode_reverse_and_zero(self): # θ должен удалять синфазную составляющую и учитывать фактическое направление последовательности.
for direction in (1, -1): # Прямое и обратное вращения различаются знаком электрического угла.
analysis, results = core.PhaseAnalysis(1000000), [] # Каждый закон вращения начинается с пустой истории.
for sample in range(0, 40001, 500): # Один оборот поля занимает 20 мс при частоте 50 Гц.
angle = direction * math.tau * 50 * sample / 1000000 # Эталонный угол известен независимо от наблюдавшихся фаз.
for ch in range(3): # Полное преобразование Кларка должно работать при общей добавке к трём фазам.
value = .5 * math.cos(angle - ch * math.tau / 3) + .1 # Синфазное смещение 0,1 не должно поворачивать вектор поля.
vector = analysis.add(ch, dict(midpoint=sample, value=value, field=None)) # Каждая огибающая обновляется своим событием.
if vector is not None: # Первые точки используются только для создания интервала интерполяции.
expected = math.degrees(angle) % 360 # Нулевой угол соответствует положительному максимуму A.
error = (vector['theta'] - expected + 180) % 360 - 180 # Сравнение учитывает эквивалентность 0 и 360 градусов.
self.assertAlmostEqual(error, 0, places=8) # Симметричные аналитические фазы должны восстанавливать точный угол.
results.append(vector) # Число результатов проверяет наличие работающей графической последовательности.
self.assertGreater(len(results), 50) # θ не должен выдаваться только при пересечениях нуля отдельной фазы.
zero = core.PhaseAnalysis(1000) # Одинаковые значения A/B/C содержат только синфазную составляющую.
for sample in (0, 10): # Две точки каждой фазы образуют общий интервал.
for ch in range(3): # Направление вектора при одинаковых фазах неопределённо.
vector = zero.add(ch, dict(midpoint=sample, value=.5, field=None)) # Ненулевой общий уровень не означает ненулевой пространственный вектор.
self.assertIsNone(vector['theta']) # Околонулевая амплитуда не получает выдуманное направление.
def test_vector_gap_discards_old_phase_and_lag(self): # После потери одного входа никакая интерполяция или оценка угла не должна пересекать неизвестный участок.
analysis = core.PhaseAnalysis(1000000) # Все времена заданы в отсчётах одной общей шкалы.
for sample in (0, 500): # Две точки формируют первоначальные согласованные огибающие.
for ch in range(3): # До разрыва доступны все три фазы.
analysis.add(ch, dict(midpoint=sample, value=.5 * math.cos(ch * math.tau / 3), field=None)) # Ненулевой стационарный вектор создаёт предыдущую историю.
analysis.fields[0] = (500, 20000) # Имитируем измеренный период первой фазы до неизвестного участка.
vector = analysis.add(0, dict(midpoint=10000, value=.5, field=None, previous=None)) # Ядро помечает первый достоверный результат после пропуска отсутствием предыдущей точки.
self.assertIsNone(vector) # Одной новой точки недостаточно для восстановления общего вектора после разрыва.
self.assertEqual(analysis.points[0], [(10000, .5)]) # Старые точки A не участвуют в интерполяции через потерянный интервал.
self.assertNotIn(0, analysis.fields) # Старый межфазный период сбрасывается вместе с огибающей, независимо от тайм-аута.
def test_signed_phase_lags_and_stale_inputs(self): # Численные сдвиги должны отличать реальную асимметрию от идеальных 120 градусов.
analysis = core.PhaseAnalysis(1000000) # Период 20 тысяч отсчётов соответствует полю 50 Гц.
analysis.fields = {0: (20000, 20000), 1: (20000 + 20000 / 3, 20000), 2: (20000 + 40000 / 3, 20000)} # Последовательные одноимённые пересечения сдвинуты на 120 градусов.
angles = analysis.differences(40000) # Все три измерения свежие и относятся к одному моменту.
self.assertTrue(all(abs(value - 120) < 1e-9 for value in angles.values())) # Сдвиги A→B, B→C и C→A рассчитываются независимо, включая переход через оборот.
analysis.fields[1] = (20000 + 20000 / 4, 20000) # Искусственно изменяем только фазу B на запаздывание 90 градусов относительно A.
self.assertAlmostEqual(analysis.differences(40000)['A→B'], 90) # Измерение не подставляет заранее известное значение 120 градусов.
self.assertEqual(analysis.differences(100000), {}) # Устаревшие более чем на два периода входы не сохраняют прежние углы.
def adapter(self, frames, connected=tuple(range(12)), **options): # Заглушка воспроизводит полный жизненный цикл wait/start/decode/end.
class StopCapture(Exception): # Исчерпание подготовленной записи моделирует завершение потока sigrok.
pass # Исключение не маскируется как ошибка проверяемого декодера.
class FakeDecoder: # Минимальный интерфейс сохраняет все аннотации реального адаптера.
def register(self, kind): # Регистрация аннотационного выхода не требует нативного дескриптора.
return kind # Для проверок достаточно постоянного идентификатора.
def has_channel(self, channel): # Подключение отдельных затворов проверяется до запуска обработки.
return channel in connected # Неполная стойка NPC должна быть отвергнута самим адаптером.
def put(self, start, end, output, data): # Формат соответствует API sigrokdecode.
self.emitted.append((start, end, data)) # Сохраняются как видимые подписи, так и нативный контракт кривых.
def wait(self, conditions): # Подготовленные снимки выдаются в хронологическом порядке.
try: # Конец итератора отделяется от вычислительных ошибок анализатора.
self.samplenum, pins = next(self.frames) # Одно событие содержит атомарный снимок всех подключённых входов.
except StopIteration: # Запись завершена после последнего фактического изменения состояния.
raise StopCapture() # Штатный end затем проверит завершение только полных окон.
return pins # Служебное ожидание пропуска не меняет доступные цифровые значения.
stub = types.ModuleType('sigrokdecode') # Изолированный модуль существует только во время импорта адаптера.
stub.Decoder, stub.OUTPUT_ANN = FakeDecoder, 0 # Внешний интерпретатор нужен только в нативной проверке, а не в численных тестах.
with patch.dict(sys.modules, {'sigrokdecode': stub, 'common.setgui_decoders.pwm_waveform': core}): # Подмена ядра исключает импорт устаревшей установленной копии.
spec = importlib.util.spec_from_file_location('pwm_npc_adapter', ROOT / 'tools/dsview/decoders/pwm_waveform/pd.py') # Загружается файл, включаемый в поставку DSView.
module = importlib.util.module_from_spec(spec) # Отдельный объект не затрагивает экземпляры других тестов.
spec.loader.exec_module(module) # Базовый класс связывается с минимальным FakeDecoder.
decoder = module.Decoder() # Конструктор создаёт пустое состояние всех новых опций.
decoder.options = {entry['id']: entry['default'] for entry in decoder.options} # Значения по умолчанию берутся из реального интерфейса анализатора.
decoder.options.update(options) # Тест изменяет только проверяемые пользовательские опции.
decoder.frames, decoder.emitted, decoder.samplerate = iter(frames), [], 1000000 # Частота дискретизации совпадает с синтетическими номерами отсчётов.
decoder.start() # Выход аннотаций регистрируется штатным методом.
try: # Ошибки настройки должны распространяться наружу, а нормальный конец захвата обрабатывается отдельно.
decoder.decode() # Вся диспетчеризация затворов и опций выполняется настоящим адаптером.
except StopCapture: # После исчерпания записи сохраняется текущий сампл, как в штатном декодировании.
decoder.end() # Завершаются только полные интервалы и постоянные участки.
return decoder # Проверки анализируют конечный набор кривых и численных измерений.
def test_adapter_npc_all_options_and_compact_angles(self): # Все дополнительные результаты должны работать в одном экземпляре анализатора.
decoder = self.adapter(npc_frames(), input_mode='npc-three-level', carrier_hz=2000, waveform_mode='switching', show_theta='yes', show_carrier='yes', show_phase_angles='yes') # Фиксированные окна согласуют три фазы и дают эталон 2 кГц/50 Гц.
kinds = {entry[2][0] for entry in decoder.emitted} # Типы аннотаций отделяют фазные осциллограммы от θ, несущей и углов.
self.assertTrue({0, 1, 2, 6, 7, 8, 9, 10, 11}.issubset(kinds)) # Требуются три фазы, три частоты и все три запрошенные дополнительные функции.
raw = [entry for entry in decoder.emitted if entry[2][0] < 3] # Коммутационный режим должен содержать три действительных уровня NPC.
levels = {float(entry[2][1][-1].split()[1]) for entry in raw} # Читается тот же нормированный контракт, который получает нативный renderer.
self.assertTrue({-1, 0, 1}.issubset(levels)) # Отрицательные состояния не теряются при переходе от двоичного режима к NPC.
angles = [entry for entry in decoder.emitted if entry[2][0] == 11] # Межфазные измерения появляются после получения полных периодов всех необходимых фаз.
self.assertGreater(len(angles), 1) # Опция должна выдавать последовательность обновлений на записи.
self.assertTrue(all('A→B=' in entry[2][1][0] and 'B→C=' in entry[2][1][0] and 'C→A=' in entry[2][1][0] for entry in angles)) # Каждая доступная пара имеет явное обозначение направления.
for entry in angles: # Наличие подписей недостаточно: реальная запись должна давать близкие к 120 градусам значения.
values = [float(value) for value in entry[2][1][1].split(' / ')] # Короткая подпись сохраняет порядок трёх пар A→B, B→C, C→A.
self.assertTrue(all(abs(value - 120) < 1 for value in values)) # Допуск один градус учитывает целочисленное измерение импульсов при дискретизации 1 МГц.
triangles = [entry for entry in decoder.emitted if entry[2][0] == 10] # Два сегмента одного периода задают расчётный треугольник.
self.assertEqual(triangles[0][2][1][-1], 'PWM1 -1.000000000 1.000000000') # Верхняя и нижняя несущие NPC выводятся нативно из одного нормированного треугольника.
def test_missing_gates_and_missing_phases_are_explicit_errors(self): # Неполные входы не должны незаметно превращаться в неверную реконструкцию.
with self.assertRaisesRegex(ValueError, 'all four gates'): # Один вход A не определяет состояние стойки NPC.
self.adapter([], connected=(0,), input_mode='npc-three-level') # Ошибка должна возникнуть до ожидания первого события.
with self.assertRaisesRegex(ValueError, 'all three phases'): # Пространственный угол требует реальных A/B/C.
self.adapter([], connected=(0,), show_theta='yes') # Обычный однофазный ШИМ остаётся допустимым лишь при выключенном θ.
with self.assertRaisesRegex(ValueError, 'at least two phases'): # Межфазный угол нельзя вычислять по одному каналу.
self.adapter([], connected=(0,), show_phase_angles='yes') # Отсутствующая пара не заменяется идеальным сдвигом 120 градусов.
if __name__ == '__main__': # Файл можно запускать отдельно при отладке или через стандартное обнаружение тестов.
unittest.main() # Ошибка любого нового режима возвращает ненулевой код завершения.
+4
View File
@@ -47,6 +47,10 @@ class RuntimeTests(unittest.TestCase):
(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 += [recipe / 'pwm-waveform.patch', recipe / 'native/pwm_waveform.h'] # Изменение отрисовки или индекса PWM тоже должно делать установленный runtime устаревшим.
files += [recipe / 'zynq-ethernet/ethernet.patch'] # Проверяем, что исправление перетаскивания дорожек не признаёт прежний нативный компонент актуальным.
files += [recipe / 'scope-channel.patch', recipe / 'native/scope_demo.h', recipe / 'native/scope_trace.h', recipe / 'motor-currents.patch'] # Изменения шкалы фазных токов должны делать прежний нативный компонент устаревшим вместе с остальными графическими патчами.
files += [recipe / 'decoder-scope.patch', recipe / 'native/decoder_scope.h'] # Проверяется обязательная пересборка при изменении независимых окон осциллограмм или их интеграции с исходными графиками.
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) # Для каждого переносимого пакета создаются вложенные каталоги.
+17
View File
@@ -0,0 +1,17 @@
"""Нативная проверка напряжений, фазы и сохранения экстремумов эмулятора Zynq.""" # Тест использует производственный заголовок без отдельной реализации генератора.
import os # Путь к DLL компилятора задаётся только дочернему проверочному процессу.
from pathlib import Path # Пути вычисляются относительно переносимого рецепта DSView.
import shutil # Системный компилятор обнаруживается без установки новых зависимостей.
import subprocess # Настоящая C++-модель компилируется и исполняется в отдельном процессе.
import tempfile # Исполняемые артефакты не попадают в исходники рецепта.
import unittest # Проверка включается в существующий набор тестов templates.
class ScopeDemoTests(unittest.TestCase): # Один нативный сценарий проверяет все четыре канала и крайние случаи времени.
def test_native_signal_and_envelope(self): # Числовые утверждения выполняются компилятором того же семейства, что сборка DSView.
compiler = shutil.which('g++') or ('C:/msys64/ucrt64/bin/g++.exe' if Path('C:/msys64/ucrt64/bin/g++.exe').is_file() else None) # Используем уже установленный C++ SDK, не меняя настройки компьютера.
if not compiler: self.skipTest('Для нативной проверки нужен компилятор g++') # Отсутствие необязательного SDK явно видно в результате тестирования.
here = Path(__file__).resolve().parent # Исходник проверки и производственный заголовок принадлежат одному checkout.
environment = dict(os.environ, PATH=str(Path(compiler).parent) + os.pathsep + os.environ.get('PATH', '')) # Windows находит DLL UCRT64 без копирования в системные каталоги.
with tempfile.TemporaryDirectory(prefix='scope-demo-') as temporary: # Каждый запуск получает собственный исполняемый файл.
executable = Path(temporary) / ('scope-test.exe' if os.name == 'nt' else 'scope-test') # Расширение соответствует платформе проверочного процесса.
subprocess.run([compiler, '-std=c++11', '-O2', '-I', str(here.parent / 'native'), str(here / 'scope_demo_test.cpp'), '-o', str(executable)], env=environment, check=True, capture_output=True) # Проверяем компиляцию модели без Qt и аппаратных библиотек.
subprocess.run([str(executable)], env=environment, check=True, capture_output=True) # Ненулевой код любого числового утверждения становится провалом теста.
+217
View File
@@ -0,0 +1,217 @@
"""Контрольные потоки, независимая FIR-модель и проверка поставки сигма-дельта декодера.""" # Проверки не требуют настоящего прибора и установленного DSView.
import ast # Совместимость синтаксиса проверяется для Python 3.6 старых установок DSView.
import importlib.util # Ядро и адаптер загружаются непосредственно из проверяемых исходников.
import random # Закреплённое зерно формирует воспроизводимый поток для независимой свёртки.
from pathlib import Path # Пути вычисляются относительно templates, независимо от текущего каталога.
import subprocess # Изолированный Python проверяет переносимость упакованного декодера.
import sys # Исполняемый файл тестового Python используется для проверки чистого импорта.
import tempfile # Упаковка выполняется в отдельный каталог без изменения установленного DSView.
import types # Минимальный модуль sigrokdecode подменяет только границу API приложения.
import unittest # Тесты доступны через стандартный unittest discovery.
import weakref # Модель движка проверяет освобождение внутреннего буфера уровней перед следующим wait.
from unittest.mock import patch # Подмена импортов действует только во время загрузки адаптера.
ROOT = Path(__file__).resolve().parents[3] # Общий корень содержит python и tools/dsview одного checkout templates.
def load(name, path): # Общая загрузка не добавляет исходники в глобальный путь поиска Python.
spec = importlib.util.spec_from_file_location(name, ROOT / path) # Явный путь исключает случайный импорт установленной старой версии.
module = importlib.util.module_from_spec(spec) # Каждый вызов создаёт самостоятельное пространство имён.
spec.loader.exec_module(module) # Выполняем настоящий исходник, а не его копию в тесте.
return module # Тесты получают и фильтр, и рецепт упаковки без зависимостей от GUI.
CORE = load('sigma_delta_core', 'python/logic_analyzer/decoders/sigma_delta.py') # Одна каноническая реализация используется всеми сценариями.
class CaptureEnd(Exception): # Исключение воспроизводит остановку wait на конце конечного цифрового захвата.
pass # Дополнительные данные не нужны: неполный блок остаётся только во внутреннем состоянии фильтра.
class PinBuffer: # Возвращаемый движком буфер нельзя удерживать между вызовами wait в libsigrokdecode4DSL.
def __init__(self, pins): # Обёртка позволяет обнаружить оставшуюся ссылку без зависимости от счётчика ссылок Python.
self.pins = pins # Храним уровни только одного выбранного фронта захвата.
def __iter__(self): # Копирование в список должно сразу освободить временный объект результата wait.
return iter(self.pins) # Новый список получает значения уровней без ссылки на внутренний буфер движка.
def __getitem__(self, index): # Прямое чтение допустимо, но сохранение этого объекта до следующего wait недопустимо.
return self.pins[index] # Так модель воспроизводит обычный доступ к tuple возвращённых уровней.
class FakeDecoder: # Модель границы sigrok принимает настоящие переходы CLK и уровни DATA.
def has_channel(self, channel): # Отсутствующий обязательный канал должен обнаруживаться до ожидания фронтов.
return channel in self.connected # Сценарии отдельно исключают DATA и CLK.
def register(self, kind): # Различаем аннотации и структурированные Python-пакеты.
return kind # Нативные дескрипторы для проверки содержимого выходов не требуются.
def put(self, start, end, kind, data): # Записываем фактические границы и полезную нагрузку каждого результата.
self.emitted.append((start, end, kind, data)) # Поздние проверки могут обнаружить лишний бит или неполный выходной блок.
def wait(self, condition): # Сканируем только переходы CLK требуемой полярности.
if getattr(self, 'last_buffer', lambda: None)() is not None: # Настоящий DSView заполняет прежний tuple через PyTuple_SetItem, требующий отсутствия внешних ссылок.
raise RuntimeError('DSView pin buffer retained across wait calls.') # Регрессия обнаруживается до следующего выхода, как ошибка SystemError нативного движка.
self.conditions.append(condition) # Проверяем, что адаптер запрашивает фронт нужной линии.
for sample, pins in self.trace: # Изменения DATA между фронтами остаются видны, но не запускают приём бита.
previous, self.last_pins = self.last_pins, pins # Храним предыдущий уровень CLK, включая начальный уровень записи.
if previous[1] != pins[1] and pins[1] == (condition == {1: 'r'}): # Нарастающий фронт завершается единицей, спадающий нулём.
self.samplenum = sample # Номер реально выбранного фронта задаёт время результата.
buffer = PinBuffer(pins) # Временная обёртка моделирует принадлежащий движку буфер pinvalues.
self.last_buffer = weakref.ref(buffer) # Слабая ссылка обнаруживает удержание результата адаптером и сама не продлевает его жизнь.
return buffer # DATA берётся в момент CLK, а уровни нужно скопировать до следующего вызова wait.
raise CaptureEnd() # Конец записи не добавляет отсутствующие фронты и не вызывает искусственный flush.
def capture(bits, falling_bits=None, initial_clock=0): # Генерируем физическую трассу с десятью отсчётами на такт.
trace = [] # Начальное состояние задаётся отдельно и не считается событием фронта.
for index, bit in enumerate(bits): # Каждый бит имеет подготовку DATA, нарастающий и спадающий фронты CLK.
trace.append((index * 10 + 1, (bit, 0))) # Установка DATA до такта проверяет отсутствие приёма по его собственному фронту.
trace.append((index * 10 + 3, (bit, 1))) # Через два отсчёта после подготовки приходит нарастающий фронт CLK.
trace.append((index * 10 + 8, (falling_bits[index] if falling_bits is not None else bit, 0))) # Спадающий фронт может захватывать независимое тестовое значение DATA.
return ((0, initial_clock), trace) # Начальное состояние CLK позволяет проверять захват, начавшийся с высокого уровня.
def adapter(options=None, bits=(), falling_bits=None, samplerate=1000000, connected=(0, 1), initial_clock=0): # Все настройки сценария передаются до вызова decode, как в sigrok.
stub = types.ModuleType('sigrokdecode') # Тест не использует установленный на компьютере libsigrokdecode.
stub.Decoder, stub.OUTPUT_ANN, stub.OUTPUT_PYTHON, stub.SRD_CONF_SAMPLERATE = FakeDecoder, 0, 1, 2 # Числа лишь различают типы выходов и сообщение о частоте.
with patch.dict(sys.modules, {'sigrokdecode': stub, 'common.setgui_decoders.sigma_delta': CORE}): # Явная подмена ядра не затрагивает модули других тестов DSView.
module = load('sigma_delta_adapter', 'tools/dsview/decoders/sigma_delta/pd.py') # Загружаем настоящий адаптер API версии 3.
decoder = module.Decoder() # Конструктор сбрасывает метаданные перед новым захватом.
decoder.options = {item['id']: item['default'] for item in decoder.options} # Начальные настройки берутся из декларации адаптера.
decoder.options.update(options or {}) # Сценарий переопределяет только проверяемые параметры.
decoder.connected = connected # Подключённые каналы учитываются штатным методом has_channel.
initial, trace = capture(bits, falling_bits, initial_clock) # Преобразуем биты в последовательность физических состояний входов.
decoder.last_pins, decoder.trace = initial, iter(trace) # Начальный уровень не возвращается как выбранный тактовый фронт.
decoder.emitted, decoder.conditions = [], [] # Каждый захват получает отдельные журналы результатов и ожиданий.
if samplerate is not None: # В отдельном сценарии частота захвата намеренно неизвестна.
decoder.metadata(2, samplerate) # При десяти отсчётах на такт CLK равен samplerate / 10.
decoder.start() # Регистрируем оба выхода до передачи первых фронтов.
return decoder # Сценарий сам выбирает ожидаемое завершение или ошибку конфигурации.
def samples(decoder): # Выделяем только структурированные выходные отсчёты среди текстовых аннотаций.
return [event for event in decoder.emitted if event[2] == 1] # Дескриптор один соответствует OUTPUT_PYTHON тестового движка.
class SigmaDeltaTests(unittest.TestCase): # Независимые ожидаемые результаты выявляют ошибки порядка каскадов и децимации.
def test_cic_matches_independent_fir_convolution(self): # Каскад скользящих сумм задаёт эталон без интеграторов и гребенчатых разностей.
rng = random.Random(271828) # Постоянное зерно делает ошибку воспроизводимой на любой платформе.
bits = [rng.randrange(2) for _ in range(5000)] # Длинный поток многократно переполняет ограниченные регистры CIC.
for order in (1, 2, 3): # Проверяются все поддерживаемые sinc-фильтры.
for ratio in (1, 2, 3, 7, 16, 256): # Нечётные OSR выявляют скрытую зависимость от степени двойки.
with self.subTest(order=order, ratio=ratio): # Диагностика указывает режим несовпавшего фильтра.
taps = [1] # Импульсная характеристика до первого каскада является единичным импульсом.
for _ in range(order): # Сворачиваем N прямоугольных окон длины OSR.
taps = [sum(taps[max(0, index - ratio + 1):min(len(taps), index + 1)]) for index in range(len(taps) + ratio - 1)] # Коэффициенты строятся прямой FIR-свёрткой без алгоритма проверяемого ядра.
state = CORE.SigmaDeltaFilter(ratio, order) # Каждый режим начинает с чистых регистров.
for index, bit in enumerate(bits): # Фильтру передаются те же биты, что использует независимый эталон.
event = state.feed(bit) # До границы выходного блока результат отсутствует.
ready = (index + 1) % ratio == 0 and index + 1 >= order * ratio # Ожидаемые границы учитывают децимацию и начальное установление.
self.assertEqual(event is not None, ready) # Проверяем также точное число пропущенных и выданных результатов.
if ready: # Прямую свёртку вычисляем только на установившихся выходных отсчётах.
weighted = sum(tap * bits[index - lag] for lag, tap in enumerate(taps)) # FIR использует входную историю и не зависит от внутренних регистров CIC.
self.assertEqual(event['code'], 2 * weighted - sum(taps)) # Целочисленный код обязан совпадать точно, без допуска округления.
self.assertEqual(event['density'], weighted / ratio ** order) # Проверяется нормировка фильтрованной плотности единиц.
self.assertEqual(event['value'], event['code'] / ratio ** order) # Нормированная амплитуда должна сохранять тот же масштаб.
def test_dc_extremes_zero_and_inversion(self): # Контрольные плотности проверяют знак и физически понятные крайние значения.
for order in (1, 2, 3): # Нулевая предыстория не должна смещать постоянный сигнал после установления.
for pattern, expected in (([0], -1), ([1], 1), ([0, 1], 0), ([0, 1, 1, 1], 0.5)): # Плотности 0, 100, 50 и 75 процентов имеют известную нормированную амплитуду.
for invert in (False, True): # Инверсия должна менять знак при любом порядке фильтра.
state = CORE.SigmaDeltaFilter(8, order, invert) # OSR восемь содержит целое число периодов всех контрольных шаблонов.
results = [event['value'] for bit in pattern * 64 for event in [state.feed(bit)] if event is not None] # Собираем только завершённые и установившиеся отсчёты.
self.assertTrue(results) # Пустой выход не может считаться успешной проверкой постоянного сигнала.
self.assertEqual(set(results), {expected * (-1 if invert else 1)}) # Каждый выходной отсчёт обязан иметь правильный знак и масштаб.
def test_invalid_filter_settings_and_logic_levels(self): # Ошибочные настройки должны отклоняться до появления числового результата.
for ratio in (0, -1, 1.5, True, 65537): # Проверяются обе границы диапазона и недопустимые типы OSR.
with self.assertRaises(ValueError): # Тихое округление OSR меняло бы частоту и усиление фильтра.
CORE.SigmaDeltaFilter(ratio) # Используется реальный конструктор ядра.
for order in (0, 4, 1.5, True): # Разрешены только целые порядки один, два и три.
with self.assertRaises(ValueError): # Неизвестный порядок не должен заменяться начальным значением.
CORE.SigmaDeltaFilter(order=order) # Проверка независима от адаптера DSView.
for bit in (-1, 2, 255, None): # Значение 255 моделирует неподключённый цифровой вход sigrok.
with self.assertRaises(ValueError): # Невалидный вход нельзя включать в статистику единиц.
CORE.SigmaDeltaFilter().feed(bit) # Ошибка обнаруживается на первом неправильном уровне.
def test_adapter_edges_rates_voltage_and_partial_tail(self): # Проверяется полный путь от переходов CLK до аннотаций и Python-пакетов.
for edge in ('rising', 'falling'): # Разные значения на двух фронтах выявляют выбор неверной полярности CLK.
decoder = adapter({'filter': 'sinc1', 'decimation': 4, 'clock_edge': edge, 'full_scale': 2.5}, [1] * 11, [0] * 11) # Одиннадцать битов содержат два полных блока и неполный хвост из трёх битов.
with self.assertRaises(CaptureEnd): # Реальный decode завершается только по концу трассы.
decoder.decode() # Все числовые результаты формирует адаптер, а не тестовый фильтр.
output = samples(decoder) # Текстовые строки анализируются отдельно от структурированного канала.
self.assertEqual(len(output), 2) # Последние три бита не должны создавать третий отсчёт.
for start, end, _, packet in output: # Проверяем каждый выданный блок, включая первый после начала записи.
self.assertEqual(end - start, 30) # Четыре фронта CLK охватывают три периода по десять отсчётов.
self.assertEqual(packet[0], 'SAMPLE') # Тип пакета стабилен для последующего стекового декодера.
self.assertEqual(packet[1]['value'], 1 if edge == 'rising' else -1) # DATA на спаде намеренно противоположна уровню на нарастающем фронте.
self.assertEqual(packet[1]['voltage'], 2.5 if edge == 'rising' else -2.5) # Физический масштаб должен умножать уже восстановленную амплитуду.
self.assertEqual(packet[1]['clock_hz'], 100000) # Мегагерц захвата и десять отсчётов на период означают CLK 100 кГц.
self.assertEqual(packet[1]['output_hz'], 25000) # OSR четыре уменьшает частоту результата до 25 кГц.
self.assertEqual({tuple(condition.items()) for condition in decoder.conditions}, {((1, 'r' if edge == 'rising' else 'f'),)}) # Адаптер должен ждать только выбранный фронт второго входа.
self.assertEqual(len(decoder.emitted), 10) # Два результата содержат по четыре аннотации и одному Python-пакету.
def test_adapter_warmup_missing_samplerate_and_initial_high_clock(self): # Начальный высокий CLK не считается фронтом, а отсутствие герц не мешает фильтрации.
decoder = adapter({'decimation': 4}, [1] * 15, samplerate=None, initial_clock=1) # sinc3 пропускает два первых блока и имеет один полный установленный результат.
with self.assertRaises(CaptureEnd): # Пятнадцатый бит оставляет незавершённый четвёртый блок.
decoder.decode() # Конец захвата не должен дополнять его шестнадцатым битом.
output = samples(decoder) # Результаты должны существовать без метаданных частоты.
self.assertEqual(len(output), 1) # Выдаётся только третий полный блок после двух блоков установления.
self.assertEqual(output[0][:2], (83, 113)) # Третий блок содержит реальные нарастающие фронты девятого–двенадцатого битов.
self.assertEqual(output[0][3][1]['value'], 1) # Начальное установление не должно создавать отрицательное смещение постоянного DATA.
self.assertIsNone(output[0][3][1]['clock_hz']) # Без частоты захвата нельзя присваивать CLK вымышленное значение.
self.assertEqual({event[3][0] for event in decoder.emitted if event[2] == 0}, {0, 1, 2}) # Три амплитудные строки остаются, строка частоты отсутствует.
def test_single_bit_decimation_and_reset(self): # OSR один проверяет отсутствие деления на ноль и границы точечных аннотаций.
decoder = adapter({'filter': 'sinc1', 'decimation': 1, 'invert': 'yes'}, [0, 1]) # Инверсия должна действовать до формирования нормированного кода.
with self.assertRaises(CaptureEnd): # Два фронта дают два результата и затем штатный конец захвата.
decoder.decode() # Первая частота неизвестна, вторая измеряется по предыдущему фронту.
output = samples(decoder) # В режиме OSR один каждое принятое значение создаёт пакет.
self.assertEqual([event[3][1]['value'] for event in output], [1, -1]) # Получаем инвертированные уровни в биполярном диапазоне.
self.assertIsNone(output[0][3][1]['clock_hz']) # Один фронт не позволяет измерить период.
self.assertEqual(output[1][3][1]['output_hz'], 100000) # При OSR один выходная частота совпадает с CLK.
self.assertTrue(all(start == end for start, end, _, _ in output)) # Точечный блок не получает искусственно удлинённый временной интервал.
decoder.reset() # Повторное использование объекта начинает новый захват без старых метаданных.
self.assertIsNone(decoder.samplerate) # Частота предыдущего прибора не должна переноситься в новый захват.
def test_adapter_rejects_missing_channels_and_invalid_options(self): # Некорректная конфигурация не должна дожидаться первого такта.
for connected in ((0,), (1,), ()): # Поочерёдно отсутствуют CLK, DATA и оба входа.
with self.assertRaises(ValueError): # Требование обязательных каналов проверяет сам адаптер.
adapter(connected=connected).decode() # Пустая трасса отличает раннюю проверку от случайного успешного чтения.
for options in ({'full_scale': 0}, {'full_scale': -1}, {'full_scale': float('nan')}, {'full_scale': float('inf')}, {'filter': 'sinc4'}, {'clock_edge': 'both'}, {'invert': 'maybe'}, {'decimation': 2.5}): # Ошибки охватывают масштаб, перечисления и тип OSR.
with self.assertRaises(ValueError): # Ни одна ошибка не должна превращаться в CaptureEnd или числовой отсчёт.
adapter(options).decode() # Проверяются фактические параметры нового декодера.
for rate in (0, -1, float('nan'), float('inf')): # Частота захвата задаётся только положительным конечным числом.
with self.assertRaises(ValueError): # Метаданные проверяются до расчёта частоты CLK.
adapter(samplerate=rate) # Неверная частота не должна попадать в выходной пакет.
def test_packaged_adapter_imports_in_isolated_python(self): # Ведомость должна включать адаптер и каноническое ядро без установленного SETGUI.
build = load('sigma_delta_packager', 'tools/dsview/build.py') # Используем штатную упаковку встроенного DSView.
with tempfile.TemporaryDirectory() as temporary: # Каталог содержит только подготовленную поставку, без внешних зависимостей.
root = Path(temporary) # Все файлы проверки ограничены временной директорией.
build.package_decoders(root) # Общий рецепт копирует адаптеры и ядра из protocol-files.json.
script = '\n'.join(( # Изолированный процесс не наследует sys.path и подмены модулей текущих тестов.
'import importlib, pathlib, sys, types # Для импорта нужны только стандартные модули Python.', # Каждая строка дочернего сценария также документирована.
'root = pathlib.Path(sys.argv[1]) # Корень упакованных декодеров передаётся отдельным аргументом.', # Аргумент исключает зависимость от рабочего каталога.
'sys.path.insert(0, str(root)) # Разрешаем импорт только из подготовленной поставки.', # Исходники templates не добавляются в поиск.
"stub = types.ModuleType('sigrokdecode') # Моделируем только доступную при импорте базу API.", # Настоящий DSView не запускается.
'stub.Decoder = object # Методы базы при проверке импорта не вызываются.', # Выходные константы нужны только после start.
"sys.modules['sigrokdecode'] = stub # Подмена ограничена дочерним процессом.", # Глобальное окружение пользователя не изменяется.
"adapter = importlib.import_module('sigma_delta') # Проверяем стандартную точку входа пакета.", # Импорт обязан транзитивно загрузить ядро из common.
"core = importlib.import_module('common.setgui_decoders.sigma_delta') # Ядро должно входить в ту же поставку.", # Проверяем отсутствие скрытой зависимости от рабочего checkout.
'pathlib.Path(core.__file__).resolve().relative_to(root.resolve()) # Местоположение ядра обязано принадлежать пакету.', # Неправильное происхождение вызывает ошибку.
"assert adapter.Decoder.id == 'sigma_delta' # Идентификатор совпадает с меню приложения.", # Сохранённые сессии используют тот же идентификатор.
"assert core.SigmaDeltaFilter(1, 1).feed(1)['value'] == 1 # Упакованное ядро выполняет действительное восстановление.", # Проверяется и работоспособность, и полнота импорта.
)) # В сценарии используются настоящие переводы строк, а не экранированные команды оболочки.
result = subprocess.run([sys.executable, '-I', '-c', script, str(root / 'decoders')], cwd=temporary, capture_output=True, text=True) # Отдельные аргументы сохраняют пути с пробелами и не запускают оболочку.
self.assertEqual(result.returncode, 0, result.stderr) # Отсутствующий модуль или неверное расположение ядра делают проверку неуспешной.
def test_portable_python_syntax(self): # Старые версии DSView используют Python 3.6, хотя сами тесты могут выполняться новым Python.
paths = [ROOT / 'python/logic_analyzer/decoders/sigma_delta.py'] + list((ROOT / 'tools/dsview/decoders/sigma_delta').glob('*.py')) # Проверяются оба устанавливаемых слоя и точка входа пакета.
for path in paths: # Ошибка указывает точное имя файла поставки.
ast.parse(path.read_text(encoding='utf-8'), filename=str(path), feature_version=(3, 6)) # Одновременно проверяем UTF-8 и совместимость синтаксиса.
if __name__ == '__main__': # Разрешаем запуск отдельного тестового файла без pytest и GUI.
unittest.main() # Стандартный runner выдаёт количество проверок и описание несоответствий.