Перенести улучшения 166 и добавить сборку для M95M02 и Flash

Восстановить телеметрию CAN, обработку TESTLAMP и сохранение команд при загрузке параметров.

Выбрать M95M02 основным профилем, добавить самостоятельную Flash-сборку и проверять образы до публикации.

Проверки: хостовые тесты, реальные сборки TI C2000, контроль COFF/SCI8 и защита записи при активной нагрузке.
This commit is contained in:
2026-10-19 16:33:28 +03:00
parent 985804607d
commit bbd82b3a4e
42 changed files with 1820 additions and 321 deletions
+107
View File
@@ -0,0 +1,107 @@
#include <stdint.h> /* Фиксирует ширину таймера и аппаратных полей eCAN независимо от разрядности host-компилятора. */
#include <stdio.h> /* Выводит точную строку нарушенного сценария вместо молчаливого неверного результата. */
#include <string.h> /* Изолирует независимые случаи очисткой модели аппаратуры и данных. */
typedef uint16_t Uint16; typedef uint32_t Uint32; /* Повторяет 16- и 32-битные аппаратные типы TI C28x. */
#define READY_FREQ 1000U /* Один такт Timer1 равен одной миллисекунде, как в действующей прошивке 166. */
#define CANPOWSE 20U /* Прежний базовый интервал обнаружения обновлений данных составляет 20 мс. */
#define ANSWER_LEN 128 /* Как в package.h, технологическая карта содержит ровно R0–R127 без дополнительного запаса для ошибочного чтения. */
#define interrupt /* Host-модель вызывает настоящий ISR как обычную функцию без атрибутов процессора TI. */
#define EALLOW ((void)0) /* Защищённый доступ аппаратных регистров отдельно проверяется настоящим компилятором TI. */
#define EDIS ((void)0) /* Модель не подменяет логику изменения битов тайм-аута mailbox. */
#define EINT ((void)0) /* Тесты явно выбирают момент аппаратного прерывания, исключая недетерминированные потоки. */
#define DINT ((void)0) /* Сценарий проверяет восстановление маски, не симулируя планировщик ОС. */
#define M_INT9 0x0100U /* Девятая группа PIE обслуживает eCAN в production-обработчике. */
#define MINT9 0x0100U /* Сохраняет аппаратную маску CPU INT9 при обработке ошибки передачи. */
#define MG96 0x00DFU /* Маска соответствует подавлению вложенного INTx6 в старом ISR проекта. */
struct REG { Uint32 all; }; /* Даёт production-коду настоящие 32-битные поля регистров eCAN. */
struct ECAN_REGS { struct REG CANTA, CANAA, CANTRR, CANTRS, CANTOC, CANTOS; Uint32 CANTSC; }; /* Моделирует только используемый жизненный цикл штатного mailbox. */
static volatile struct ECAN_REGS ECanaRegs; /* Volatile сохраняет все наблюдаемые записи production-функций при оптимизации O3. */
static struct { struct { struct REG MDH, MDL; } MBOX0; } ECanaMboxes; /* Восемь октетов передаваемого кадра наблюдаются независимо от кэша алгоритма. */
static struct { Uint32 InterruptCount; } CpuTimer1; /* Счётчик переполняется в точности через 2^32 тактов. */
static struct { struct { Uint16 all; } PIEIER9; union { unsigned all; struct { unsigned reserved:8, ACK9:1; } bit; } PIEACK; } PieCtrlRegs; /* Сохраняет реальное положение PIEACK9 в маске подтверждения IRQ. */
static Uint16 IER; static unsigned int irq_mask; /* Позволяет проверить возврат исходного состояния прерываний после короткого снимка данных. */
static int wait, CanTimeOutErrorTR, Mode, Desk, modbus[ANSWER_LEN]; /* Использует настоящий размер массива технологических слов и наблюдаемые параметры узла. */
static unsigned int Maska[2][8]; /* Каждому потоку соответствует восемь 16-битных масок разрешённых регистров. */
#define Cancount (modbus + 0x60) /* Как в package.h, R96 и R97 определяют включение двух потоков данных. */
static unsigned int __disable_interrupts(void) { unsigned int previous = irq_mask; irq_mask = 1U; return previous; } /* Имитирует сохранение исходной маски IRQ даже при вложенном чтении Timer1. */
static void __restore_interrupts(unsigned int previous) { irq_mask = previous; } /* Выявляет ошибочное безусловное разрешение прерываний отправителем. */
static void led1_toggle(void) {} /* Индикация не влияет на подтверждение доставки или период таймера. */
#include "can_telemetry_impl.h" /* Компилирует точный production-алгоритм, а не отдельную копию реализации в тесте. */
/* TIMEOUT_ISR */
#define CHECK(condition) do { if (!(condition)) { printf("FAIL line %d: %s\n", __LINE__, #condition); return 1; } } while (0) /* Проверка остаётся активной при оптимизации и показывает нарушенное ожидание. */
static Uint32 frames_hi[2048], frames_lo[2048], frames_at[2048]; static unsigned int count; /* Журнал хранит только действительно запущенные аппаратные кадры и момент их передачи. */
static void hardware_ack(void) { ECanaRegs.CANTRS.all &= ~1UL; ECanaRegs.CANTRR.all &= ~1UL; ECanaRegs.CANTA.all = 1UL; ECanaRegs.CANAA.all = 0UL; } /* Завершает именно mailbox 0 успешным аппаратным ACK. */
static void prepare(unsigned int mode, unsigned int desk) { /* Начинает независимый сценарий, включая имитацию повторного запуска программы. */
memset((void *)&ECanaRegs, 0, sizeof(ECanaRegs)); memset(&ECanaMboxes, 0, sizeof(ECanaMboxes)); memset(&PieCtrlRegs, 0, sizeof(PieCtrlRegs)); /* Сбрасывает только модель периферии между испытаниями. */
memset(modbus, 0, sizeof(modbus)); memset(Maska, 0, sizeof(Maska)); CpuTimer1.InterruptCount = 0U; count = 0U; irq_mask = 0U; /* Устанавливает известное начальное содержимое карты и таймера. */
Mode = mode; Desk = desk; Cancount[0] = 10; Cancount[1] = 101; IER = M_INT9; PieCtrlRegs.PIEIER9.all = 0x0030U; CanTimeOutErrorTR = 0; /* Периоды 10 и 101 проверяют независимость нового повтора от старых делителей. */
CAN_telemetry_init(); /* Первый снимок после каждого запуска должен отправляться независимо от содержимого старых кэш-массивов. */
} /* Аппаратный ACK в каждом сценарии задаётся явно. */
static int pump(void) { /* Выдаёт всю уже готовую очередь с ACK между кадрами, не продвигая тестовое время. */
unsigned int limit; /* Ограничивает итерации для обнаружения зависания на пустой маске или неизменном пакете. */
for (limit = 0U; limit < 512U; ++limit) { /* Полная карта из двух потоков требует значительно меньше 512 аппаратных кадров. */
CAN_telemetry_service(); /* Обслуживает реальную очередь, heartbeat и индивидуальные периоды подтверждённых данных. */
CHECK(irq_mask == 0U); /* После любого пути отправки прерывания должны иметь первоначальное состояние. */
if (!(ECanaRegs.CANTRS.all & 1UL)) return 0; /* Отсутствие нового TX означает завершённую выдачу готовых кадров. */
CHECK(count < 2048U); /* Исключает скрытое переполнение тестового журнала. */
frames_hi[count] = ECanaMboxes.MBOX0.MDH.all; frames_lo[count] = ECanaMboxes.MBOX0.MDL.all; frames_at[count++] = CpuTimer1.InterruptCount; /* Запоминает точные данные mailbox, не используя внутренний кэш production-кода как эталон. */
hardware_ack(); /* Только успешное подтверждение разрешает алгоритму подавить следующий неизменный пакет. */
} /* Бесконечное повторение выявляется как ошибка конечной модели. */
CHECK(0); /* Даже при пустой маске или неподтверждённом адресе сервис обязан возвращаться без блокировки. */
return 1; /* Сохраняет однозначный код ошибки для компилятора C. */
} /* Все вызовы pump выполняются с фиксированным временем, поэтому сравнения периодов точны. */
static unsigned int address_at(unsigned int index) { return (unsigned int)((frames_hi[index] >> 16) & 0x1FFFU); } /* Декодирует существующий маркер BALZAM независимо от внутренней реализации отправителя. */
static unsigned int count_address(unsigned int address) { unsigned int index, found = 0U; for (index = 0U; index < count; ++index) if (address_at(index) == address) ++found; return found; } /* Считает реальные кадры выбранного технологического или heartbeat-адреса. */
int main(void) { /* Проверяет требования пользователя, границы карты и ошибки аппаратного TX на настоящем коде прошивки. */
unsigned int mode, before, index; Uint32 started; /* Сценарии используют независимые ожидаемые периоды в миллисекундах. */
for (mode = 1U; mode <= 9U; ++mode) { /* Сравнение данных и повтор 1,3 с применяются ко всем аппаратным Mode, включая задатчик. */
prepare(mode, mode == 8U ? 4U : 0U); Maska[0][0] = 1U; modbus[0] = 9; modbus[1] = 12; modbus[2] = -1; CHECK(pump() == 0); /* Начальный пакет должен передаться сразу в прежнем порядке трёх слов. */
CHECK(count == 1U && frames_hi[0] == 0xE0000009UL && frames_lo[0] == 0x000CFFFFUL); /* Отрицательное 16-битное значение не портит упаковку и старший регистр. */
CpuTimer1.InterruptCount = 999U; CHECK(pump() == 0 && count == 1U); /* Неизменившиеся данные не создают лишних кадров до секундного heartbeat. */
CpuTimer1.InterruptCount = 1000U; CHECK(pump() == 0 && count == 2U && address_at(1U) == 0x100U); /* Heartbeat появляется ровно через одну секунду, независимо от обоих Cancount. */
CHECK((frames_hi[1] & 0xFFFFUL) == 1U && frames_lo[1] == ((Uint32)Mode << 16 | (unsigned int)Desk)); /* Отдельный heartbeat содержит счётчик секунд, Mode и Desk. */
CpuTimer1.InterruptCount = 1299U; CHECK(pump() == 0 && count_address(0U) == 1U); /* Технологический пакет не повторяется раньше индивидуального срока. */
CpuTimer1.InterruptCount = 1300U; CHECK(pump() == 0 && count_address(0U) == 2U); /* Неизменные данные повторяются на границе 1,3 с без искусственного изменения состояния планировщика тестом. */
CHECK(frames_at[count - 1U] == 1300U && frames_hi[count - 1U] == frames_hi[0]); /* Повторяет сами данные, а не только отдельный heartbeat. */
} /* Завершает проверку одинакового поведения всех Mode. */
prepare(5U, 0U); Maska[0][0] = 1U; Maska[1][0] = 8U; modbus[0] = 1; modbus[3] = 2; CHECK(pump() == 0 && count == 2U); /* Два потока получают отдельные пакеты и подтверждения без ожидания старых делителей. */
CpuTimer1.InterruptCount = 40U; modbus[1] = 77; CHECK(pump() == 0 && count == 3U && address_at(2U) == 0U); /* Изменение второго слова пакета отправляется до истечения 1,3 с. */
CpuTimer1.InterruptCount = 60U; modbus[2] = 88; CHECK(pump() == 0 && count == 4U && (frames_lo[3] & 0xFFFFUL) == 88U); /* Изменение третьего слова тоже обнаруживается и не подавляется кэшем первого регистра. */
CpuTimer1.InterruptCount = 1300U; CHECK(pump() == 0 && count_address(3U) == 2U && count_address(0U) == 3U); /* Независимый пакет повторяется через 1,3 с, а обновлённый пакет R0 ещё не достиг своего нового срока. */
CpuTimer1.InterruptCount = 1360U; CHECK(pump() == 0 && count_address(0U) == 4U); /* Период R0 отсчитывается заново от ACK последнего изменённого снимка. */
prepare(8U, 4U); Maska[0][1] = 1U; Maska[1][0] = 15U; ECanaRegs.CANTRS.all = 1U; ECanaMboxes.MBOX0.MDH.all = 0x12345678UL; CAN_telemetry_service(); /* Занятый внешним запросом mailbox нельзя менять или считать доставленным. */
CHECK(ECanaMboxes.MBOX0.MDH.all == 0x12345678UL && can_scan_due == 1U); /* Оба потока сохраняют готовность до физического освобождения передатчика. */
ECanaRegs.CANTRS.all = 0U; CHECK(pump() == 0 && count_address(16U) == 1U && count_address(0U) == 1U && count_address(3U) == 1U); /* После занятости не теряются R0–R2 и R3–R5 медленного потока. */
prepare(5U, 0U); Maska[0][0] = 1U; CAN_telemetry_service(); CHECK(wait && !(can_valid[0] & 1U)); /* Постановка первого пакета в TX ещё не означает успешную доставку. */
ECanaRegs.CANTA.all = 0U; ECanaRegs.CANTOS.all = 1U; ECanaRegs.CANTOC.all = 5U; CANa_reset_err(); /* Воспроизводит аппаратный timeout, пока отдельный контроль служебного mailbox тоже включён. */
CHECK(can_tx_failed && CanTimeOutErrorTR == 1 && ECanaRegs.CANTRR.all == 1U && ECanaRegs.CANTOC.all == 4U); /* ISR помечает отказ и отменяет только штатный TX без выключения служебного контроля. */
ECanaRegs.CANTOS.all &= ECanaRegs.CANTOC.all; ECanaRegs.CANTRS.all = ECanaRegs.CANTRR.all = 0U; ECanaRegs.CANAA.all = 0U; CpuTimer1.InterruptCount = 10U; CAN_telemetry_service(); /* Отмена завершена без CANAA: отсутствие этого флага не должно навсегда заблокировать очередь. */
CHECK(!wait && can_backoff && !(can_valid[0] & 1U)); /* Неудачный снимок не становится подтверждённым и остаётся кандидатом следующей попытки. */
CpuTimer1.InterruptCount = 1009U; modbus[0] = 42; CAN_telemetry_service(); CHECK(!(ECanaRegs.CANTRS.all & 1U)); /* До окончания секундной паузы после ошибки повтор не засоряет CAN. */
CpuTimer1.InterruptCount = 1010U; CHECK(pump() == 0 && count_address(0U) == 1U && (frames_hi[count - 1U] & 0xFFFFUL) == 42U); /* После паузы повторяет актуальное изменение и отдельно ожидающий heartbeat. */
prepare(5U, 0U); Maska[0][0] = 1U; CAN_telemetry_service(); ECanaRegs.CANTA.all = 0U; CpuTimer1.InterruptCount = 100U; CAN_telemetry_service(); /* Потерянный timeout IRQ страхуется реальным временем Timer1 через 100 мс. */
CHECK(can_tx_failed && ECanaRegs.CANTRR.all == 1U && CanTimeOutErrorTR == 1); /* Программная отмена не ждёт аппаратного CANAA в блокирующем цикле. */
CAN_telemetry_service(); CHECK(CanTimeOutErrorTR == 1); /* Длительная аппаратная отмена не увеличивает счётчик ошибки на каждой итерации main. */
prepare(5U, 0U); Maska[0][0] = 1U; CHECK(pump() == 0); CpuTimer1.InterruptCount = 20U; modbus[0] = 2; CAN_telemetry_service(); ECanaRegs.CANTA.all = 0U; ECanaRegs.CANTRS.all = 0U; ECanaRegs.CANAA.all = 1U; CAN_telemetry_service(); /* Изменение, отменённое после старого успешного снимка, не должно затереть подтверждённый кэш. */
CHECK(can_last_hi[0] == 0xE0000000UL && can_backoff); /* Только реально доставленный прежний пакет остаётся подтверждённым. */
prepare(5U, 0U); CHECK(pump() == 0 && count == 0U); CpuTimer1.InterruptCount = 3500U; CHECK(pump() == 0 && count == 1U && address_at(0U) == 0x100U && (frames_hi[0] & 0xFFFFU) == 3U); /* Пустые маски не зависают; после задержки main отправляется последний heartbeat без пачки пропущенных секунд. */
CHECK(pump() == 0 && count == 1U); /* Повторная итерация main не дублирует уже поставленный heartbeat. */
prepare(5U, 0U); Maska[0][0] = 1U; Cancount[0] = 0; Cancount[1] = 0; CHECK(pump() == 0 && count == 0U); CpuTimer1.InterruptCount = 1000U; CHECK(pump() == 0 && count == 1U && address_at(0U) == 0x100U); /* Отключённые потоки не отключают независимый heartbeat узла. */
prepare(5U, 0U); Maska[0][7] = 0x8000U; modbus[127] = 0x55AA; CHECK(pump() == 0 && count == 1U && frames_hi[0] == 0xE07F55AAUL && frames_lo[0] == 0U); /* Конец карты R127 дополняется нулями без чтения data[128] и data[129]. */
prepare(5U, 0U); for (index = 0U; index < 8U; ++index) Maska[0][index] = 0xFFFFU; CHECK(pump() == 0 && count == 43U); /* Плотная маска сохраняет прежние 43 трёхсловных пакета вместо лишних 128 перекрывающихся кадров. */
for (index = 0U; index < count; ++index) CHECK(address_at(index) == index * 3U); /* Первый полный снимок покрывает ровно R0, R3, ... R126 в установленном формате. */
CpuTimer1.InterruptCount = 1300U; CHECK(pump() == 0 && count_address(0U) == 2U && count_address(126U) == 2U && count == 87U); /* Готовая очередь выдаёт всю карту за период, а не один кадр маски каждые 1,3 с. */
prepare(5U, 0U); CpuTimer1.InterruptCount = 0xFFFFFF00UL; started = CpuTimer1.InterruptCount; Maska[0][0] = 1U; CHECK(pump() == 0); CpuTimer1.InterruptCount = started + 1000U; CHECK(pump() == 0 && count_address(0x100U) == 1U); /* Секундный heartbeat переживает переполнение Timer1. */
CpuTimer1.InterruptCount = started + 1300U; CHECK(pump() == 0 && count_address(0U) == 2U); /* Период повторения данных тоже корректен через 32-битное переполнение. */
prepare(5U, 0U); Maska[0][0] = 1U; CHECK(pump() == 0); before = count; can_valid[7] = 0xFFFFU; can_backoff = can_heartbeat_due = 1U; wait = 1; CAN_telemetry_init(); CHECK(pump() == 0 && count == before + 1U); /* Повторная инициализация отбрасывает грязное состояние и заново отправляет первый снимок. */
prepare(5U, 0U); Maska[0][1] = 1U; Maska[1][0] = 1U; for (index = 0U; index <= 250U; ++index) { CpuTimer1.InterruptCount = index * 20U; modbus[16] = index; CHECK(pump() == 0); } /* Непрерывное изменение быстрого потока не должно вытеснить heartbeat и неизменный пакет другого потока. */
CHECK(count_address(16U) == 251U && count_address(0U) == 4U && count_address(0x100U) == 5U); /* За пять секунд доставляются все изменения, четыре состояния R0 и пять секундных heartbeat. */
prepare(5U, 0U); Maska[0][0] = 1U; CAN_telemetry_service(); CpuTimer1.InterruptCount = 50U; hardware_ack(); CAN_telemetry_service(); /* Подтверждает первый пакет через 50 мс после запуска, а не в нулевой момент передачи. */
CpuTimer1.InterruptCount = 1349U; CHECK(CAN_send(0, modbus, 0) == 2); CpuTimer1.InterruptCount = 1350U; CHECK(CAN_send(0, modbus, 0) == 1); /* Индивидуальные 1300 мс отсчитываются от ACK, поэтому ранний повтор через 1300 мс от запуска запрещён. */
prepare(5U, 0U); ECanaRegs.CANTOC.all = 1U; ECanaRegs.CANTRS.all = 1U; CANa_reset_err(); /* Вызывает фантомный ISR без аппаратного CANTOS0 во время исправной передачи. */
CHECK(!can_tx_failed && !CanTimeOutErrorTR && ECanaRegs.CANTRR.all == 0U && ECanaRegs.CANTOC.all == 1U && PieCtrlRegs.PIEIER9.all == 0x0030U); /* Не отменяет исправный кадр и восстанавливает прежние разрешения обоих CAN IRQ. */
prepare(5U, 0U); Maska[0][0] = 1U; ECanaRegs.CANTRR.all = 1U; ECanaMboxes.MBOX0.MDH.all = 0x11223344UL; CAN_telemetry_service(); CHECK(ECanaMboxes.MBOX0.MDH.all == 0x11223344UL && !wait); /* Даже без CANTRS незавершённая аппаратная отмена запрещает перезапись mailbox. */
prepare(5U, 0U); irq_mask = 1U; CHECK(CAN_send(0, modbus, 0) == 1 && irq_mask == 1U); /* Передатчик сохраняет уже запрещённые IRQ вызывающего кода вместо безусловного разрешения. */
puts("PASS: heartbeat 1 Hz; changed data; per-packet refresh 1300 ms; all modes; masks; ACK, timeout and backoff; wraparound; dirty RAM; bounds"); /* Подтверждает проверку реального production-кода без утверждения о запуске на физической плате. */
return 0; /* Все независимые поведенческие проверки завершились успешно. */
} /* Модель не требует подключения CAN-адаптера и не отправляет команды реальному оборудованию. */
+22
View File
@@ -0,0 +1,22 @@
from pathlib import Path # Находим production-исходники относительно установленного теста либо явно выбранного проверяемого снимка.
import os # Подключаем runtime GCC только дочернему процессу теста.
import re # Извлекаем настоящий ISR с сохранением вложенных условий и без отдельной копии алгоритма ошибки.
import subprocess # Компилируем и выполняем поведенческую модель передатчика.
import sys # Разрешаем проверить изолированный снимок коммита вместо текущего рабочего дерева.
import tempfile # Создаём исполняемый файл проверки только во временном каталоге теста.
test = Path(__file__).resolve().parent # Производственная установка хранит этот файл в tests/can_telemetry.
root = Path(sys.argv[1]).resolve() if len(sys.argv) > 1 else test.parents[1] # При обычном запуске проверяет текущий проект прошивки.
source = (root / 'Source/Internal/ecan.c').read_text(encoding='utf-8') # Изменённый production-файл и русские комментарии обязаны быть корректным UTF-8.
clean = re.sub(r'/\*.*?\*/|//[^\n]*', '', source, flags=re.S) # Скобки комментариев не влияют на выделение ISR.
match = re.search(r'interrupt\s+void\s+CANa_reset_err\(void\)\s*\{', clean) # Отличаем определение обработчика от прототипа и регистрации IRQ.
assert match # Отсутствующий обработчик не считается успешной проверкой передачи.
end, depth = match.end(), 1 # Начинаем поиск после внешней открывающей скобки функции.
while depth: depth += (clean[end] == '{') - (clean[end] == '}'); end += 1 # Сохраняем все вложенные аппаратные проверки оригинала.
model = (test / 'model.c').read_text(encoding='utf-8').replace('/* TIMEOUT_ISR */', clean[match.start():end]) # Сама реализация телеметрии подключается напрямую через production-header.
compiler = os.environ.get('CC', 'C:/msys64/mingw64/bin/gcc.exe') # Поддерживаем установленный GCC и явный выбор другого совместимого компилятора.
environment = dict(os.environ); environment['PATH'] = str(Path(compiler).parent) + os.pathsep + environment.get('PATH', '') # Не меняем системный PATH пользователя или настройки CCS.
with tempfile.TemporaryDirectory(prefix='can-telemetry-166-') as directory: # Временные файлы не попадают в источник прошивки или Git-коммит.
cfile, exe = Path(directory) / 'test.c', Path(directory) / 'test.exe' # Отделяем исходник модели и её исполняемый результат.
cfile.write_text(model, encoding='utf-8') # Тестовые комментарии сохраняются в той же кодировке UTF-8.
subprocess.run([compiler, '-std=c99', '-O3', '-Wall', '-Wextra', '-Werror', '-I' + str(root / 'Source/Internal/Include'), str(cfile), '-o', str(exe)], env=environment, check=True) # Все предупреждения нового алгоритма считаются ошибками до создания коммита.
subprocess.run([str(exe)], env=environment, check=True, timeout=10) # Зависание очереди или нарушенный тайминг завершают проверку ошибкой.
+4 -31
View File
@@ -1,31 +1,4 @@
"""Проверяет тайм-аут штатного CAN на настоящих функциях проекта 167.""" # Модель не заменяет испытание аппаратного eCAN.
import os # Передаёт пути библиотек GCC только дочерним процессам.
from pathlib import Path # Находит исходники независимо от рабочего каталога запуска.
import re # Удаляет комментарии и выделяет тела проверяемых функций.
import subprocess # Запускает компилятор и проверяет поведенческий результат модели.
import tempfile # Изолирует сгенерированные файлы от образов прошивки пользователя.
import sys # Позволяет проверить отдельно сохранённую старую версию ecan.c.
root = Path(__file__).resolve().parents[2] # Корень проекта содержит рабочую реализацию eCAN.
source_path = Path(sys.argv[1]) if len(sys.argv) > 1 else root / "Source/Internal/ecan.c" # Дополнительный путь нужен для проверки чувствительности к старой ошибке.
source = re.sub(r"/\*.*?\*/|//[^\n]*", "", source_path.read_text(encoding="utf-8"), flags=re.S) # Комментарии со скобками не участвуют в выделении функций.
def function(name): # Извлекает текущий алгоритм вместо поддержания отдельной копии в тесте.
match = re.search(r"(?:interrupt\s+)?void\s+" + name + r"\([^;{}]*\)\s*\{", source) # Отличает определение от вызова и объявления.
assert match is not None, name # Исчезновение функции должно останавливать проверку.
end, depth = match.end(), 1 # Начинает поиск после открывающей скобки тела.
while depth: # Учитывает вложенные условия до закрытия внешнего блока.
depth += (source[end] == "{") - (source[end] == "}") # Считает только скобки кода без комментариев.
end += 1 # Включает найденную закрывающую скобку в результат.
return source[match.start():end] # Сохраняет все реальные обращения к регистрам и условия.
model = Path(__file__).with_name("model.inc").read_text(encoding="utf-8") # Загружает минимальное аппаратное окружение и сценарии потери ACK.
model = model.replace("/* PRODUCTION */", function("CAN_send") + "\n" + function("CANa_reset_err")) # Проверяет передачу и прерывание в одном жизненном цикле.
compiler = os.environ.get("CC", "C:/msys64/mingw64/bin/gcc.exe") # Использует установленный GCC, сохраняя возможность явно выбрать другой.
environment = dict(os.environ) # Не меняет окружение приложения и проекта CCS.
environment["PATH"] = str(Path(compiler).parent) + os.pathsep + environment.get("PATH", "") # Делает библиотеки MinGW доступными тестовой программе.
with tempfile.TemporaryDirectory(prefix="can-timeout-") as directory: # Удаляет только собственные временные файлы после завершения проверки.
c_path, exe_path = Path(directory) / "test.c", Path(directory) / "test.exe" # Разделяет исходник модели и исполняемый результат.
c_path.write_text(model, encoding="utf-8") # Сохраняет русские пояснения модели в требуемой кодировке.
subprocess.run([compiler, "-std=c99", "-O3", "-Wall", "-Wextra", "-Wno-unused-parameter", "-Werror", str(c_path), "-o", str(exe_path)], env=environment, check=True) # Проверяет реальные функции под оптимизацией и без скрытых предупреждений.
subprocess.run([str(exe_path)], env=environment, check=True, timeout=10) # Зависание и нарушенное условие делают сценарий неуспешным.
"""Проверяет аппаратный timeout и его программную страховку общими сценариями передатчика.""" # После переноса ACK-кэша отказ и секундная пауза проверяются вместе с повтором данных.
from pathlib import Path # Находит соседний тест без зависимости от текущего рабочего каталога.
import runpy # Выполняет тот же набор проверок реального production-header вместо устаревшей копии void CAN_send.
runpy.run_path(str(Path(__file__).resolve().parents[1] / "can_telemetry" / "run_test.py"), run_name="__main__") # Сохраняет прежнюю команду проверки timeout и проверяет также CANAA, фантомный IRQ и backoff.
+68
View File
@@ -0,0 +1,68 @@
"""Проверяет частоту подтверждения R3 на настоящих масках и планировщике 167 после переноса рассылки.""" # Проверка выполняется на ПК без отправки команд плате.
from pathlib import Path # Находит исходники проекта и отдельно подготовленный вариант маски.
import os # Передаёт библиотеки GCC только дочерним процессам проверки.
import re # Извлекает определения и блоки C без комментариев.
import subprocess # Компилирует и исполняет реальные алгоритмы прошивки в модели времени.
import sys # Позволяет проверить старый и исправленный файлы одинаковым сценарием.
import tempfile # Ограничивает результаты компиляции временным каталогом.
root = Path(sys.argv[1]) if len(sys.argv) > 1 else Path(__file__).resolve().parents[2] # Установленная проверка по умолчанию использует свой проект прошивки.
measure = Path(sys.argv[2]) if len(sys.argv) > 2 else root / 'Source/Internal/measure.c' # Подмена только этого файла позволяет воспроизвести ошибку до применения исправления.
def clean(path): # Удаляет комментарии перед поиском парных скобок C.
raw = path.read_bytes() # Сохраняет возможность чтения старых исходников Windows-1251.
source = raw.decode('utf-8') if _utf8(raw) else raw.decode('cp1251') # Не теряет русские комментарии исходника при выборе кодировки.
return re.sub(r'/\*.*?\*/|//[^\n]*', '', source, flags=re.S) # Скобки в пояснениях не меняют границы блока алгоритма.
def _utf8(raw): # Отличает старую Windows-кодировку от требуемого UTF-8 без замены символов.
try: # Корректный UTF-8 имеет приоритет перед совместимой однобайтовой кодировкой.
raw.decode('utf-8'); return True # Успешное декодирование разрешает чтение современного исходника.
except UnicodeDecodeError: # Старый файл будет прочитан в его исходной кодировке.
return False # Не выдаёт повреждённые комментарии за исходный текст.
def block(source, start): # Выделяет настоящий блок с вложенными условиями.
cursor, depth = source.index('{', start) + 1, 1 # Начинает после открывающей скобки внешнего блока.
while depth: # Ищет соответствующую закрывающую скобку.
depth += (source[cursor] == '{') - (source[cursor] == '}') # Учитывает только скобки очищенного C-кода.
cursor += 1 # Включает завершающую скобку в извлечённый текст.
return source[start:cursor] # Проверка не поддерживает отдельную копию алгоритма прошивки.
package = clean(root / 'Source/Internal/Include/package.h') # Значения режимов и индексов потоков берутся из текущего проекта 167.
names = ('dsk_COMM', 'dsk_BKSD', 'dsk_BKST', 'dsk_EPLT', 'dsk_SHKF', 'dsk_LOAD', 'm_FAST', 'm_SLOW') # Модели нужны только константы, используемые масками.
defines = '\n'.join(re.search(r'^#define\s+' + name + r'\s+\d+', package, re.M).group() for name in names) # Не дублирует номера плат в тестовой карте.
measure_source = clean(measure) # Выбирает проверяемую версию Init_packMask.
mask_function = block(measure_source, measure_source.index('void Init_packMask(')) # Состав быстрой и медленной рассылки полностью берётся из прошивки.
ecan = clean(root / 'Source/Internal/ecan.c') # Реальный ISR завершает ту же передачу, что и новый сервис телеметрии.
match = re.search(r'interrupt\s+void\s+CANa_reset_err\(void\)\s*\{', ecan) # Находит определение обработчика ошибок вместо его прототипа.
assert match is not None # Исчезновение обработчика должно проваливать проверку.
model = (root / 'tests/can_telemetry/model.c').read_text(encoding='utf-8').split('int main(void)')[0] # Повторно использует аппаратуру, ACK и журнал кадров общей модели нового передатчика.
model = model.replace('/* TIMEOUT_ISR */', block(ecan, match.start())) # Вставляет реальное тело обработчика без отдельной копии его алгоритма.
model += '\n' + defines + '\nstatic int Kurrent, pow_addr, Owen; /* Повторяет настройки каналов и OWEN, используемые настоящими масками версии 167. */\n' + mask_function # Берёт реальные номера плат, потоков и состав масок из текущей прошивки.
model += r'''
int main(void) { /* Измеряет свежесть R3 при реальной карте пульта и разных настройках потоков EEPROM. */
const unsigned periods[][2] = {{2,101},{10,101},{12,50},{2,0},{1,101},{1,1}}; /* Проверяет прежние настройки, включая отключённый медленный поток. */
unsigned scenario, tick, cursor, received, last, gap, worst; /* Наблюдает переданные кадры и разрыв между обновлениями R3. */
for (scenario = 0; scenario < sizeof(periods)/sizeof(periods[0]); ++scenario) { /* Проверяет независимые запуски платы. */
prepare(8U, dsk_EPLT); Init_packMask(); /* Строит настоящую карту задатчика поверх сброшенной модели CAN. */
CHECK((Maska[m_FAST][0] & 15U) == 15U && !(Maska[m_SLOW][0] & 15U)); /* R0–R3 остаются в быстром потоке при отключённом медленном. */
CHECK(Maska[m_FAST][1] == 1U && Maska[m_SLOW][6] == 0x1FFU && Maska[m_SLOW][7] == 0xE000U); /* Кнопки и параметры сохраняют состав исходной карты. */
Cancount[0] = periods[scenario][0]; Cancount[1] = periods[scenario][1]; /* Ненулевое значение теперь включает обновления по изменению и таймеру. */
cursor = received = last = worst = 0U; /* Учитывает также начальное ожидание первого подтверждения. */
for (tick = 1U; tick <= 5000U; ++tick) { /* Пять секунд включают heartbeat и обязательные повторы неизменных данных. */
CpuTimer1.InterruptCount = tick; modbus[3] = tick; CHECK(pump() == 0); /* Меняет R3 каждую миллисекунду и выдаёт готовую очередь через настоящие CAN_send и ACK. */
for (; cursor < count; ++cursor) { /* Анализирует только новые кадры mailbox. */
if (address_at(cursor) != 3U) continue; /* R3 начинает второй трёхсловный фрагмент действительной маски. */
CHECK((frames_hi[cursor] & 0xFFFFU) == tick); /* Требует свежее значение вместо старого снимка. */
gap = tick - last; if (gap > worst) worst = gap; last = tick; ++received; /* Измеряет худший интервал получения актуального R3. */
} /* Завершает анализ кадров текущего момента. */
} /* Приоритет heartbeat обрабатывается общей моделью передатчика. */
CHECK(received > 0U && worst <= CANPOWSE && tick - 1U - last <= CANPOWSE); /* При немедленном ACK интервал ограничен шагом сканирования 20 мс независимо от slow. */
CHECK(count_address(CAN_HEARTBEAT_ADDR) >= 4U); /* Обновление R3 не должно вытеснять секундный heartbeat. */
printf("PASS VPU fast=%u slow=%u: R3 max=%u ms, updates=%u\n", periods[scenario][0], periods[scenario][1], worst, received); /* Выводит измеренный интервал и число свежих кадров. */
} /* Завершает матрицу настроек EEPROM. */
return 0; /* Подтверждает программную модель без заявления об аппаратном испытании. */
} /* Завершает проверку обратной связи R3. */
''' # Использует production-маски и production-сервис вместо удалённого блока if(CanGO).
compiler = Path(os.environ.get('CC', 'C:/msys64/mingw64/bin/gcc.exe')) # Использует установленный GCC без изменения системных настроек.
environment = dict(os.environ, PATH=str(compiler.parent) + os.pathsep + os.environ.get('PATH', '')) # Добавляет runtime только дочерним процессам.
with tempfile.TemporaryDirectory(prefix='vpu-r3-rx-') as directory: # Отделяет временные результаты от образов пользователя.
source, executable = Path(directory) / 'test.c', Path(directory) / 'test.exe' # Разделяет исходник и исполняемый результат.
source.write_text(model, encoding='utf-8') # Сохраняет русские пояснения в UTF-8.
subprocess.run([str(compiler), '-std=c99', '-O3', '-Wall', '-Wextra', '-Werror', '-I' + str(root / 'Source/Internal/Include'), str(source), '-o', str(executable)], env=environment, check=True) # Компилирует настоящий заголовок при строгих предупреждениях.
subprocess.run([str(executable)], env=environment, check=True, timeout=10) # Нарушение задержки или зависание проваливает проверку.
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
+12
View File
@@ -3,8 +3,10 @@
#include <stdio.h>
/* Подключает <string.h>: настройки и интерфейс string. */
#include <string.h>
#define FLASH_BOOT 1 /* Проверяет дополнительный read-only запрос безопасности, который отсутствует в обычном RAM-образе. */
/* Подключает "../../Source/Internal/DAC.c": выход ЦАП и автомат защиты нагрузки с проверкой напряжения и свежести CAN. */
#include "../../Source/Internal/DAC.c"
#include "production_flash_guard.inc" /* Вызывает настоящий запрет FlashRs_Command перед CRC/erase на том же production-автомате нагрузки. */
/* Объявляет READY — данные READY; Desk — аппаратно определённый тип платы; Mode — рабочий адрес или режим платы, выбранный перемычками. Начальное значение задаётся справа от знака равенства. */
int READY = 1, Desk = 6, Mode = 5;
/* Объявляет modbus — массив технологических регистров; слово int на C28x занимает 16 бит. */
@@ -198,6 +200,16 @@ static int attempt_limit_test(void) {
/* Запускает новые стартовые сценарии и прежние регрессии автомата на программных подменах периферии. */
int main(void) {
setup(5); CHECK(flash_load_guard(0) == 0 && flash_load_guard(24) == 0x1005U); /* Probe разрешён при холодном старте, запись запрещена до штатного STOP и подтверждённого ЦАП. */
Commands = 0x80; tick(10, 1, 200); /* Поднимает реальную нагрузку через Timer1-модель с START, разрешением и ненулевым заданием. */
CHECK(load_state == LOAD_RUN && flash_load_guard(24) == 0x1005U && flash_load_guard(0) == 0); /* Активный LOAD_RUN отклоняется до Flash API; проверка возможностей не меняет рабочие выходы. */
CHECK(test_start && test_permission && !test_stop); /* Отказ загрузчика не выполняет кустарную аварийную остановку GPIO вместо штатного автомата. */
Commands = 0; tick(1, 1, 200); CHECK(flash_load_guard(24) == 0x1005U); /* Только начало STOP ещё не разрешает erase: нужно дождаться базового тока и полной выдержки. */
tick(1000, 1, 200); CHECK(Load_flash_safe() && flash_load_guard(24) == 0); /* После штатного idle, STOP длительностью не менее секунды и SPI-отправки 4 мА запись разрешается. */
CHECK(!test_start && !test_permission && test_stop && modbus[123] == DAC_min()); /* Проверяет программно подтверждённые безопасные выходы до будущего отключения Timer1. */
Commands = 0x200; CHECK(flash_load_guard(24) == 0x1005U); /* Отложенная калибровка не должна изменить аналоговое задание во время автономного программирования. */
Commands = 0; DAC_min()++; CHECK(flash_load_guard(24) == 0x1005U); /* Новая калибровка минимума требует фактической повторной SPI-отправки, а не доверия старому флагу нулевого задания. */
modbus[123] = DAC_min(); CHECK(flash_load_guard(24) == 0x1005U); /* Подмена открытого диагностического регистра не заменяет приватное подтверждение последнего отправленного кода. */
/* Объявляет out — данные out; error — ошибка; count — число; ramp — данные ramp; code — данные code. */
unsigned int out[8], error, count, ramp, code, stopped_at;
/* Сначала проверяет исправляемый штатный пуск с 6 мА, затем выполняет остальные регрессии защиты. */
@@ -0,0 +1,62 @@
/* Проверяет реальные Default_params/Load_params и защиту живого слова команд от сохранённого START в EEPROM. */
#include <assert.h> /* Делает нарушение сохранности команд, атомарности или состояния IRQ ошибкой теста. */
#include <stdio.h> /* Печатает результат самостоятельной регрессии загрузки параметров. */
#include <string.h> /* Копирует модель EEPROM и обнуляет регистры между независимыми сценариями. */
#define interrupt /* Убирает аппаратный атрибут ISR при подключении настоящих типов и констант датчиков на ПК. */
#include "../../Source/Internal/Include/filter_bat2.h" /* Предоставляет настоящий тип FILTERBAT, необходимый объявлениям measure.h. */
#include "../../Source/Internal/Include/measure.h" /* Подключает настоящие ERROR, частоты и объявления глобальных измерительных данных. */
typedef union { int all; struct { unsigned int reserved:4, bit4:1; } bit; } WORDE; /* Сохраняет адресацию слова R127 и бита калибровки4 в модели GCC. */
#include "../../Source/Internal/Include/package.h" /* Использует настоящие адреса R127, калибровок, тайм-аута и лимита пусков профиля167. */
#include "../../Source/Internal/Include/caliber.h" /* Даёт Default_params реальные заводские таблицы167 для всех режимов платы. */
#define ANSWER_LEN 128U /* Повторяет длину технологической карты без аппаратных зависимостей message.h. */
#define BALSAM167_EEPROM_PARAMS_START_WORD 0x3F7EU /* Адрес не влияет на управление: модель проверяет чтение полного блока параметров без запрета IRQ. */
int modbus[129], READY, Desk, Mode, Kalibro, Owen, Kurrent, TermoSW; /* Предоставляет рабочим функциям регистры и признаки режима платы. */
unsigned int param[129], Caliber_time; /* Предоставляет считанный EEPROM-блок и таймер калибровки из рабочего интерфейса. */
int sens_type[24]; /* Позволяет заводской инициализации обращаться к таблице типов SHKF без изменения рабочего алгоритма. */
static unsigned int irq_mask, saved_count, concurrent_command; /* Хранит исходную маску IRQ, число записей EEPROM и команду, принятую во время чтения. */
static unsigned int image[129]; /* Моделирует отдельную сохранённую EEPROM, чтобы загрузка не читала текущие команды обратно из RAM. */
static unsigned int __disable_interrupts(void) { unsigned int old = irq_mask; irq_mask = 1; return old; } /* Проверяет вложенное сохранение маски при применении RAM-настроек. */
static void __restore_interrupts(unsigned int old) { irq_mask = old; } /* Возвращает переданную вызывающим кодом маску, включая заранее запрещённые IRQ. */
static void Seeprom_read(unsigned long address, unsigned int *data, unsigned int bytes) /* Моделирует только длительное чтение EEPROM, не подменяя Default/Load. */
{ /* Начинает передачу проверенного набора параметров в рабочий буфер param. */
assert(!irq_mask && address == BALSAM167_EEPROM_PARAMS_START_WORD && bytes == 258U); /* EEPROM-драйвер нуждается в прерываниях; 129 слов занимают258 байт C28x. */
memcpy(data, image, sizeof(image)); /* Считывает в том числе сохранённый START, чтобы проверить его исключение из применения параметров. */
if (concurrent_command) Commands = concurrent_command; /* Имитирует принятие нового START/RESET по CAN во время длительного чтения EEPROM. */
} /* Заканчивает чтение при исходно разрешённых прерываниях. */
static unsigned int get_crc16(const unsigned int *data, unsigned int words) { assert(data == param && words == ANSWER_LEN); return 0x1234U; } /* Выбирает валидную ветку по контрольному слову image без повторения алгоритма загрузки. */
void Save_params(void) { assert(!irq_mask); saved_count++; } /* Проверяет, что восстановление заводских настроек не удерживает IRQ во время записи EEPROM. */
void Init_sensors_more(void) { assert(!irq_mask); } /* Проверяет освобождение короткой RAM-секции перед расчётом измерительных коэффициентов. */
#include "production_parameters.inc" /* Подключает неизменённые reset_parameter_commands, Default_params и Load_params из текущего рабочего message.c. */
static void setup(unsigned int live, unsigned int stored, unsigned int crc) /* Готовит независимую плату нагрузки и EEPROM с намеренно отличающимся словом команд. */
{ /* Сбрасывает модель, сохраняя реальное расположение регистров профиля167. */
memset(modbus, 0, sizeof(modbus)); memset(image, 0, sizeof(image)); /* Удаляет состояние предыдущего сценария только в тестовой модели. */
READY = 1; Desk = dsk_LOAD; Mode = adr_LOA1; Kalibro = Kurrent = 1; Owen = TermoSW = 0; /* Выбирает готовую плату нагрузки с заводской калибровкой167. */
Commands = live; image[127] = stored; image[126] = Mode; image[ANSWER_LEN] = crc; /* Разделяет текущую команду интерфейса и потенциально опасный сохранённый START. */
image[0x52] = 2000; image[0x7D] = 7; irq_mask = saved_count = concurrent_command = 0; /* Задаёт допустимые новые защиты и независимые счётчики модели. */
} /* Завершает подготовку до вызова настоящего рабочего кода. */
int main(void) /* Проверяет режимы RUN/STOP/RESET/FAULT через сохранение уровней, на которых работает неизменённый автомат DAC167. */
{ /* Начинает все комбинации текущих и сохранённых команд. */
unsigned int live, stored; /* Перебирает четыре сочетания START/RESET независимо от содержимого EEPROM. */
for (live = 0; live <= 0xC0U; live += 0x40U) { /* Проверяет ожидание, RESET, START и совместное удержание двух управляющих битов. */
for (stored = 0; stored <= 0xC0U; stored += 0x40U) { /* Не допускает ни отмены текущего START, ни появления START из EEPROM. */
setup(live | 0x0305U, stored, 0x1234U); Load_params(); /* Загружает корректный блок с дополнительными одноразовыми служебными командами. */
assert((unsigned int)Commands == live && LOAD_MAX_ATTEMPTS == 7 && LOAD_CAN_TIMEOUT == 2000 && !irq_mask && !saved_count); /* Сохраняет только живые START/RESET и действительно применяет новые настройки защиты. */
setup(live | 0x0305U, stored, 0); Load_params(); /* Проверяет ту же гарантию при неверной CRC и автоматическом восстановлении заводских параметров. */
assert((unsigned int)Commands == live && saved_count == 1 && LOAD_MAX_ATTEMPTS == 5 && LOAD_CAN_TIMEOUT == 2000 && !irq_mask); /* Сохранение исправленного блока EEPROM не очищает управляющие уровни нагрузки. */
} /* Завершает все варианты сохранённых команд для текущего живого уровня. */
setup(live | 0x0305U, 0, 0x1234U); Default_params(); /* Проверяет прямую команду Default без предварительного чтения EEPROM. */
assert((unsigned int)Commands == live && !irq_mask && LOAD_MAX_ATTEMPTS == 5); /* Заводской сброс сохраняет RUN/STOP-семантику, удаляя одноразовые служебные флаги. */
} /* Завершает проверку всех четырёх живых сочетаний START/RESET. */
setup(0, 0x80U, 0x1234U); concurrent_command = 0xC0U; Load_params(); /* Передаёт новый RESET/START во время чтения вместо снимка, снятого до EEPROM. */
assert(Commands == 0xC0U && !irq_mask); /* Не теряет последнюю принятую по интерфейсу команду при завершении Load. */
setup(0xC0U, 0x80U, 0x1234U); READY = 0; Load_params(); /* На холодном старте имитирует и мусор RAM, и сохранённый START EEPROM. */
assert(!Commands && !irq_mask); /* До READY ни один источник сохранённого состояния не разрешает автоматический пуск. */
setup(0xC0U, 0, 0x1234U); READY = 0; Default_params(); /* Проверяет ту же стартовую очистку в заводской ветке без EEPROM. */
assert(!Commands && !irq_mask); /* Начальные START/RESET обязательно очищены до разрешения рабочего такта платы. */
setup(0xC0U, 0x80U, 0x1234U); Desk = dsk_COMM; Kalibro = Kurrent = 0; Load_params(); /* У остальных плат сохраняет прежнее поведение очистки всех команд после загрузки. */
assert(!Commands && !irq_mask); /* Не переносит специальную семантику УМП на несвязанные типы плат. */
setup(0x2C0U, 0, 0x1234U); irq_mask = 1; reset_parameter_commands(); /* Проверяет вызов helper из уже защищённого блока применения параметров. */
assert(Commands == 0xC0U && irq_mask == 1); /* Вложенный helper сохраняет внешнюю маску IRQ и не выдаёт EINT без разрешения вызывающего кода. */
puts("PASS: production parameter loading/defaults preserve live START/RESET and reject EEPROM commands"); /* Сообщает о прохождении рабочего кода, а не копии алгоритма в модели. */
return 0; /* Возвращает успех только после всех сценариев сохранности команд и состояния IRQ. */
} /* Завершает регрессию без обращения к аппаратной плате. */
+43 -1
View File
@@ -3,6 +3,8 @@
"""Compile the production DAC.c against GPIO/IRQ mocks; no hardware writes."""
# Подключает модуль os для этой проверки или подготовки сборки.
import os
# Разбирает только границы настоящих функций message.c, сохраняя их неизменённое тело в регрессии параметров.
import re
# Импортирует необходимые имена: from pathlib import Path.
from pathlib import Path
# Подключает модуль shutil для этой проверки или подготовки сборки.
@@ -22,11 +24,51 @@ os.environ['PATH'] = str(Path(compiler).resolve().parent) + os.pathsep + os.envi
with tempfile.TemporaryDirectory(prefix='load-control-') as tmp:
# Задаёт exe по выражению справа; значение используется последующими операциями.
exe = Path(tmp) / 'test.exe'
flash = (root / 'Source/Internal/flash_rs.c').read_text(encoding='utf-8') # Проверяет настоящий запрет активной нагрузки перед переходом к Flash API.
guard = re.search(r'^static unsigned int flash_load_guard\([^\n]*\n\{[^\n]*\n[^\n]*\n\}', flash, re.M) # Извлекает короткий production-helper без переписывания его условия в тестовой модели.
assert guard, 'Production Flash load guard missing' # Переименование или удаление защиты не должно незаметно отключить тест перед erase.
(Path(tmp) / 'production_flash_guard.inc').write_text(guard.group() + '\n', encoding='utf-8') # Включает реальный helper в тот же C-модуль, который исполняет production DAC.c.
# Запускает внешний компилятор, генератор или тест; ненулевой результат проверяется параметрами вызова.
subprocess.run([compiler, '-Wall', '-Wextra', '-std=c99',
# Продолжает текущий вызов, список или выражение: '-Itests/load_control/stubs', '-ISource/Internal/Include',; порядок аргументов сохраняется.
'-Itests/load_control/stubs', '-ISource/Internal/Include',
'-Itests/load_control/stubs', '-ISource/Internal/Include', '-I' + tmp, # Добавляет только каталог извлечённого рабочего Flash-helper этой проверки.
# Задаёт 'tests/load_control/load_control_test.c', '-o', str(exe)], cwd по выражению справа; значение используется последующими операциями.
'tests/load_control/load_control_test.c', '-o', str(exe)], cwd=root, check=True)
# Запускает внешний компилятор, генератор или тест; ненулевой результат проверяется параметрами вызова.
subprocess.run([str(exe)], check=True, timeout=10)
# Читает рабочие загрузку и заводской сброс параметров для отдельной проверки живых START/RESET.
message = (root / 'Source/Internal/message.c').read_text(encoding='utf-8')
# Маскирует комментарии пробелами той же длины, чтобы фигурные скобки пояснений не влияли на поиск границ функций.
masked = re.sub(r'/\*.*?\*/|//[^\n]*', lambda match: ' ' * len(match.group()), message, flags=re.S)
# Собирает только проверяемые рабочие функции: EEPROM и GPIO заменяются моделью, сам алгоритм загрузки остаётся исходным.
functions = []
# Извлекает helper и обе ветки применения параметров независимо от форматирования вложенных блоков в исходнике.
for name in ('reset_parameter_commands', 'Default_params', 'Load_params'):
# Находит объявление функции с настоящим именем и необязательным static.
match = re.search(r'^(?:static )?void ' + name + r'\(', masked, re.M)
# Не допускает молчаливого запуска модели после удаления или переименования рабочего обработчика.
assert match, name
# Начинает подсчёт вложенных блоков с первой открывающей скобки тела найденной функции.
end, depth = masked.index('{', match.start()), 0
# Идёт до парной закрывающей скобки, сохраняя все вложенные условия и циклы рабочего кода.
while end < len(masked):
# Учитывает открывающую скобку только после удаления комментариев.
depth += masked[end] == '{'
# Учитывает соответствующую закрывающую скобку в том же уровне вложенности.
depth -= masked[end] == '}'
# Переходит к следующему символу, включая последнюю закрывающую скобку в извлекаемый текст.
end += 1
# Нулевой уровень означает завершение всей функции, а не первого вложенного if.
if depth == 0:
# Завершает поиск, чтобы не включить соседний обработчик Modbus.
break
# Копирует исходный текст функции вместе с русскими комментариями без изменения условий и присваиваний.
functions.append(message[match.start():end])
# Передаёт извлечённый production-код компилятору из временного каталога, не записывая generated-файлы в репозиторий.
(Path(tmp) / 'production_parameters.inc').write_text('\n'.join(functions), encoding='utf-8')
# Выбирает отдельный исполняемый файл, чтобы проверка параметров не подменяла прежние регрессии автомата DAC.
parameters_exe = Path(tmp) / 'parameters.exe'
# Компилирует реальную загрузку параметров с контролем IRQ, модели EEPROM и содержимого R127.
subprocess.run([compiler, '-Wall', '-Wextra', '-std=c99', '-I' + tmp, 'tests/load_control/parameter_commands_test.c', '-o', str(parameters_exe)], cwd=root, check=True)
# Выполняет комбинации живых START/RESET, сохранённых команд, неверной CRC, холодного старта и CAN во время чтения.
subprocess.run([str(parameters_exe)], check=True, timeout=10)
+36 -50
View File
@@ -23,7 +23,8 @@ static struct { struct gpio_reg GPADAT, GPBDAT; } GpioDataRegs; /* Хранит
static struct { unsigned long all; } DigErr; /* Принимает диагностическую маску посторонней ветви SHKF. */
static struct { unsigned long InterruptCount; } CpuTimer1; /* Учитывает вызовы настоящего обработчика пульта. */
int modbus[129], Desk; /* Предоставляет технологические регистры и выбирает ветвь пульта. */
unsigned int INcount0, CanPowse, CanGO; /* Хранит production-накопитель кнопки и таймер выдачи CAN. */
unsigned int INcount0; /* Сохраняет 16-битный тип накопителя кнопок из 167, соответствующий указателю er_anal. */
unsigned int CanPowse, CanGO; /* Хранит счётчик тактов выдачи CAN и признак готовности очередной передачи. */
unsigned long isMask, Lonely; /* Хранит тестовую маску и возраст последней связи. */
int isNumb, quaLamp = 6; /* Сохраняет тестовые цифры и число ламп из pulto.c. */
static unsigned int IER, mask_at_eint, entry_mask, failures, sends, nested_entries, timer_pending; /* Отслеживает разрешения прерываний, пакетные вызовы и возможность вложенного Timer1. */
@@ -71,52 +72,37 @@ static void tick(void) /* Моделирует сохранение и восс
check(mask_at_eint == (entry_mask & MINT13 & ~M_INT13), "interrupt mask"); /* Проверяет отсутствие собственного Timer1 и запрет включения ранее выключенных источников. */
check(sends >= 1 && sends <= 2, "packet count"); /* Требует штатный объём одного такта: пакет ламп и не более одного пакета очередного индикатора. */
} /* Завершает один такт индикации. */
int main(void) /* Запускает на настоящих функциях сценарий рабочих ламп, теста с помехами и возврата в работу. */
{ /* Начинает общий поведенческий сценарий. */
int i, pwm_on = 0; /* Перебирает опросы и такты; считает включённые такты рабочего PWM за один полный период. */
memset(modbus, 0, sizeof(modbus)); /* Убирает старые команды и состояния перед сценарием. */
check(sizeof(WORDE) == sizeof(modbus[0]), "register layout"); /* Подтверждает корректность production-псевдонимов в хостовой модели. */
Desk = dsk_EPLT; /* Выбирает реальную ветвь чтения TESTLAMP пульта. */
modbus[2] = 1; /* Включает рабочую лампу до нажатия TESTLAMP, как в сообщении пользователя. */
Bright[0] = maximum_bright; /* Задаёт уже включённой лампе постоянную яркость для обнаружения случайных провалов. */
entry_mask = M_INT13 | (1U << 0) | (1U << 13); /* Разрешает Timer1, группу ADC и Timer2, проверяя также маскирование равного приоритета. */
tick(); /* Получает первый рабочий пакет ламп. */
check(lamp_word == 1, "normal lamp before test"); /* Подтверждает исходное постоянное свечение до нажатия. */
GpioDataRegs.GPADAT.bit.GPIO26 = 1; /* Нажимает физическую кнопку активным высоким уровнем. */
for (i = 0; i < 1001; i++) get_Buttons(); /* Проходит реальные 1000 накопительных опросов и следующий опрос фиксации порога. */
check(bTestLamp == 1, "test activation"); /* Требует включения теста после полной выдержки. */
for (i = 0; i < 600; i++) { /* Проверяет удержание более BLINK_TIME=500 тактов без подавления штатного медленного мигания. */
unsigned long expected_mask; /* Сохраняет фазу теста перед очередным возмущением кнопки. */
GpioDataRegs.GPADAT.bit.GPIO26 = 0; /* Вводит короткий провал входа на один опрос главного цикла. */
get_Buttons(); /* Выполняет настоящий накопительный фильтр и публикацию кнопки. */
check(bTestLamp == 1, "held test"); /* Проверяет сохранение TESTLAMP вместо мгновенного возврата рабочих масок. */
timer_pending = 1; /* Допускает новый аппаратный такт во время передачи для проверки запрета повторного входа. */
tick(); /* Формирует тестовый пакет при кратком провале физического входа. */
expected_mask = isMask; /* Получает ожидаемую медленную фазу из настоящей what_is. */
check(lamp_word == expected_mask, "test packet during input glitch"); /* Исключает рабочую маску уже горящих ламп из тестового потока. */
check(!digit_sends || (digit_word == isNumb && digit_dot == 4), "test digit packet during input glitch"); /* Требует сохранения тестового значения и формата цифр во время помехи кнопки. */
check(nested_entries == 0, "nested transmission"); /* Требует единственного владельца DATA/CLK на протяжении передачи. */
timer_pending = 0; /* Убирает смоделированное событие после завершения текущего такта. */
GpioDataRegs.GPADAT.bit.GPIO26 = 1; /* Возвращает уровень удерживаемой кнопки. */
get_Buttons(); /* Восстанавливает насыщенный накопитель без смены тестового режима. */
} /* Завершает серию коротких помех при удержании. */
check(isNumb == 1111 && isMask == 0xFFFFFFFFUL, "slow test sequence"); /* После 600 миллисекунд требует единственного штатного шага what_is с периодом 500 тактов, а не ускоренного строба. */
GpioDataRegs.GPADAT.bit.GPIO26 = 0; /* Отпускает физическую кнопку на длительное время. */
for (i = 0; i < 1001; i++) get_Buttons(); /* Даёт накопителю полностью разрядиться и зафиксировать отпускание. */
check(bTestLamp == 0, "test release"); /* Проверяет, что сохранение состояния не залипает в TESTLAMP. */
tick(); /* Возвращает передачу рабочей маски после отпускания. */
check(lamp_word == 1, "normal lamp after test"); /* Восстанавливает уже включённую до теста лампу. */
cTestLamp = 1; /* Включает независимую удалённую команду теста через production-регистр. */
tick(); /* Проверяет приоритет удалённого TESTLAMP при отпущенной физической кнопке. */
check(lamp_word == isMask, "remote test"); /* Требует тестовую маску для обоих источников команды. */
cTestLamp = 0; /* Завершает удалённый тест перед проверкой рабочего PWM. */
Bright[0] = 6; /* Устанавливает шесть включённых тактов из десяти в production-периоде яркости. */
for (i = 0; i < 10; i++) { /* Проверяет один полный период PWM после выхода из теста. */
tick(); /* Даёт настоящей функции вычислить текущую фазу яркости. */
check(lamp_word == 0 || lamp_word == 1, "normal PWM packet"); /* Исключает оставшиеся тестовые биты из рабочей маски. */
pwm_on += lamp_word == 1; /* Измеряет реальное число включённых тактов production-PWM. */
} /* Завершает период обычной яркости. */
check(pwm_on == 6, "normal PWM duty"); /* Подтверждает сохранение заданной яркости 6/10 после выхода из теста. */
printf("%s TESTLAMP: held input glitches, single ISR, normal lamps, release, remote command\n", failures ? "FAIL" : "PASS"); /* Выводит проверенные свойства без заявления о физическом испытании платы. */
return failures ? 1 : 0; /* Возвращает результат всех поведенческих требований. */
} /* Завершает хостовую проверку. */
int main(void) /* Проверяет двухсекундное удержание по Timer1 и защиту стробов DATA/CLOCK от повторного входа. */
{ /* Начинает независимые сценарии физической кнопки, удалённой команды и яркости. */
int i, pwm_on = 0; /* Считает такты удержания и включённые фазы десятишагового PWM. */
memset(modbus, 0, sizeof(modbus)); /* Очищает команды и входы перед запуском production-функций. */
check(sizeof(WORDE) == sizeof(modbus[0]), "register layout"); /* Подтверждает совместимость битовых псевдонимов с массивом хостовой модели. */
Desk = dsk_EPLT; modbus[2] = 1; Bright[0] = maximum_bright; /* Выбирает пульт и заранее включает рабочую лампу с полной яркостью. */
entry_mask = M_INT13 | (1U << 0) | (1U << 13); /* Проверяет Timer1 вместе с ранее разрешёнными источниками разных приоритетов. */
tick(); check(lamp_word == 1, "normal lamp before test"); /* Проверяет рабочую индикацию до начала удержания. */
GpioDataRegs.GPADAT.bit.GPIO26 = 1; /* Нажатие TESTLAMP представлено высоким уровнем входа платы. */
for (i = 0; i < 4000; i++) get_Buttons(); /* Частый main не должен ускорять выдержку, которую теперь считает только Timer1. */
check(!bTestLamp, "polling independent"); /* Доказывает независимость порога от числа опросов главного цикла. */
for (i = 0; i < 2 * READY_FREQ - 1; i++) { tick(); check(!bTestLamp, "short test"); } /* Даже 1999 тактов при 1000 Гц ещё не разрешают местный тест. */
tick(); check(bTestLamp, "test activation"); /* Двухтысячный такт включает тест точно после двух секунд удержания. */
for (i = 0; i < 600; i++) { /* Проверяет непрерывный тест дольше периода BLINK_TIME=500 без потери защиты стробов. */
timer_pending = 1; tick(); /* Имитирует новый такт во время передачи, когда прежний ISR ещё не завершился. */
check(bTestLamp && lamp_word == isMask, "held test"); /* Требует передачу тестовой фазы вместо исходной рабочей маски. */
check(!digit_sends || (digit_word == isNumb && digit_dot == 4), "test digit packet"); /* Проверяет тестовый формат числового индикатора. */
check(nested_entries == 0, "nested transmission"); timer_pending = 0; /* Единственный владелец DATA/CLOCK исключает перемешивание пакетов. */
} /* Завершает длительное удержание физической кнопки. */
GpioDataRegs.GPADAT.bit.GPIO26 = 0; tick(); /* Отпускание сбрасывает местный тест в следующем такте Timer1. */
check(!bTestLamp && lamp_word == 1, "release"); /* Возвращает заранее включённую рабочую лампу без дополнительной задержки. */
for (i = 0; i < 3; i++) { /* Отдельные короткие нажатия суммарно превышают две секунды, но не должны включать тест. */
int held; GpioDataRegs.GPADAT.bit.GPIO26 = 1; /* Начинает очередное независимое нажатие. */
for (held = 0; held < READY_FREQ; held++) tick(); /* Удерживает вход одну секунду, то есть меньше порога. */
check(!bTestLamp, "separate presses"); /* Не позволяет сложить длительности разных нажатий. */
GpioDataRegs.GPADAT.bit.GPIO26 = 0; tick(); /* Сбрасывает накопленную выдержку отпусканием. */
} /* Завершает сценарий повторных коротких нажатий. */
cTestLamp = 1; tick(); check(lamp_word == isMask, "remote test"); /* Команда Modbus сохраняет немедленный независимый запуск теста. */
cTestLamp = 0; Bright[0] = 6; /* Возвращает рабочий режим с яркостью шесть тактов из десяти. */
for (i = 0; i < 10; i++) { tick(); check(lamp_word <= 1, "normal PWM packet"); pwm_on += lamp_word == 1; } /* Измеряет полный период реального алгоритма яркости после теста. */
check(pwm_on == 6, "normal PWM duty"); /* Подтверждает сохранение настроенной скважности рабочего сигнала. */
printf("%s TESTLAMP: 2-second hold, main independent, single ISR, release, remote command, PWM\n", failures ? "FAIL" : "PASS"); /* Указывает проверенные программные свойства без заявления об аппаратном испытании. */
return failures ? 1 : 0; /* Любое нарушенное условие завершает процесс проверки с ошибкой. */
} /* Завершает проверку кнопки и защищённой передачи индикации. */
+2 -2
View File
@@ -27,13 +27,13 @@ button = function(source("peripher.c"), "get_Buttons") # Проверяет и
pult = source("pulto.c") # Берёт текущую обработку индикации, включая реальные ветви теста и яркости.
body = "\n".join((function(source("measure.c"), "er_anal"), button, function(pult, "what_is"), function(pult, "cpu_timer1_isr_PULT"))) # Собирает функции, участвующие в переключении режима и передаче масок.
before, after = Path(__file__).with_name("model.inc").read_text(encoding="utf-8").split("/* HANDLERS */") # Помещает production-функции между аппаратными заглушками и поведенческими сценариями.
old_button, count_button = re.subn(r"(er_anal\(GpioDataRegs\.GPADAT\.bit\.GPIO26,\s*&INcount0,\s*1000,\s*)bTestLamp(\))", r"\g<1>0\2", body) # Возвращает сброс фильтра при одном провале только во временную мутацию.
old_button, count_button = re.subn(r"test_lamp_hold_ticks >= 2U \* \(unsigned int\)READY_FREQ", "test_lamp_hold_ticks >= 1U", body) # Убирает задержку только во временной модели, чтобы доказать обнаружение преждевременного включения теста.
old_mask, count_mask = re.subn(r"IER\s*&=\s*\(MINT13\s*&\s*~M_INT13\);", "IER |= MINT13;", body) # Восстанавливает ошибочное разрешение прерываний в отдельном временном варианте.
assert count_button == count_mask == 1, "Не найдены единственные места исправлений TESTLAMP" # Не позволяет мутации незаметно проверять неизменённый код.
environment = dict(os.environ) # Сохраняет окружение основного процесса.
environment["PATH"] = str(Path(args.cc).resolve().parent) + os.pathsep + environment.get("PATH", "") # Делает DLL и вспомогательные программы GCC доступными дочерним процессам.
with tempfile.TemporaryDirectory(prefix="testlamp-") as directory: # Изолирует артефакты каждой проверки от дерева прошивки.
for name, functions, failure in (("production", body, None), ("old_button", old_button, "FAIL held test"), ("old_mask", old_mask, "FAIL interrupt mask")): # Проверяет исправление и чувствительность сценариев к каждой из двух старых ошибок.
for name, functions, failure in (("production", body, None), ("old_button", old_button, "FAIL short test"), ("old_mask", old_mask, "FAIL interrupt mask")): # Проверяет задержку удержания и запрет вложенного Timer1 вместе с чувствительностью сценариев к каждой ошибке.
c_path, exe_path = Path(directory) / (name + ".c"), Path(directory) / (name + ".exe") # Разделяет временные исходники и программы трёх вариантов.
c_path.write_text(before + functions + after, encoding="utf-8") # Сохраняет модель и русские пояснения в UTF-8.
subprocess.run([args.cc, "-std=c99", "-O3", "-fno-strict-aliasing", "-Werror=implicit-function-declaration", "-I", str(ROOT / "Source/Internal/Include"), "-I", str(ROOT / "Source/External/v120/DSP2833x_common/include"), str(c_path), "-o", str(exe_path)], env=environment, check=True) # Сохраняет адреса production-псевдонимов регистров и использует реальную таблицу приоритетов TI.