TMS_STM_Peripher/Balsam_167
16
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Обновить логгер УМП и исправить запуск UART и EEPROM

Browse Source 
Перейти на компактные 12-словные записи v4 и сохранять 10 процентов банка после отключения. Добавить трёхсекундное ожидание роста ЗПТ и настраиваемый лимит пусков. Явно инициализировать состояние UART и гарантировать публикацию параметров EEPROM перед запуском Timer2. Сохранить воспроизводимые сборки, регрессионные проверки, документацию и обновлённые результаты сборки; исключить временные артефакты.
This commit is contained in:
Andrey
2026-10-12 12:25:41 +03:00
parent f741741cf8
commit 1e911e5250
38 changed files with 2089 additions and 1485 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/load_control/load_control_test.c
+183 -27
View File
@@ -15,8 +15,6 @@ unsigned int test_start, test_stop, test_permission, test_tick;
unsigned int test_starts, test_last_stop_tick, test_last_start_tick, test_init_dac;
/* Объявляет test_bad_order — данные test_bad_order. */
int test_bad_order;
/* Объявляет ump_dac_ramp — ump ЦАП ramp; ump_dac_duration — ump ЦАП duration; ump_dac_go10 — ump ЦАП go 10; ump_dac_stop10 — ump ЦАП stop 10; ump_dac_position — ump ЦАП position. */
unsigned int ump_dac_ramp, ump_dac_duration, ump_dac_go10, ump_dac_stop10, ump_dac_position;
/* Задаёт CHECK = do { if (!(x)) { printf("FAIL line %d: %s\n", __LINE__, #x); return 1; } } while (0); данные CHECK. */
#define CHECK(x) do { if (!(x)) { printf("FAIL line %d: %s\n", __LINE__, #x); return 1; } } while (0)
/* Начинает функцию setup; назначение модуля — проверка load_control на модели ПК. */
@@ -45,10 +43,167 @@ static void tick(unsigned int n, int exchange, unsigned int volts) {
}
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
}
/* Точка входа: настраивает периферию, загружает параметры и обслуживает команды в главном цикле. */
/* Проверяет штатные 6 мА, трёхсекундную реакцию ЗПТ и сохранение защитных остановов на настоящем DAC.c. */
static int startup_test(void) {
/* mode перебирает УМП 5/6, attempt контролирует пять пусков, code хранит отправленный код, count — оставшиеся токовые такты ожидания. */
unsigned int mode, attempt, code, count;
/* Проверяет оба штатных CAN-индекса: ЗПТ1 у УМП 5 и ЗПТ2 у УМП 6. */
for (mode = 5; mode <= 6; mode++) {
/* Подаёт START при заводских 6 мА и свежем нулевом ЗПТ; первые 10 мс включают базовый и стартовый кадры ЦАП. */
setup(mode); DAC_go = 6; Commands = 0x80; tick(10, 1, 0);
/* Первая попытка должна удерживать разрешение и получить 6 мА вместо мгновенного STOP. */
CHECK(test_starts == 1 && test_start && test_permission && !test_stop && modbus[0x1C] == 60 && modbus[123] != DAC_min());
/* Запоминает код 6 мА для исключения скрытого повышения тока до подтверждённых 30 В. */
code = modbus[123];
/* Проверяет последний миллисекундный такт перед тремя секундами от первой отправки 6 мА. */
tick(2999, 1, 29);
/* До конца выдержки сохраняет одну попытку, рабочее состояние и прежнее задание в масштабе 0,1 мА. */
CHECK(load_state == LOAD_RUN && load_attempts == 1 && modbus[0x1C] == 60 && (unsigned int)modbus[123] == code);
/* Ровно через 3000 мс свежее ЗПТ ниже 30 В должно завершить попытку защитным сбросом. */
tick(1, 1, 29);
/* Проверяет STOP, снятое разрешение и передачу базового тока 4 мА через калибровочный минимум. */
CHECK(load_state == LOAD_RELOAD && test_stop && !test_permission && modbus[0x1C] == 40 && modbus[123] == DAC_min());
/* После секунды STOP вторая попытка должна снова получить 6 мА и собственные три секунды ожидания. */
tick(1000, 1, 0);
/* Исключает повторный START и немедленный STOP в одном вызове обработчика. */
CHECK(test_starts == 2 && test_start && !test_stop && modbus[0x1C] == 60);
/* Проходит оставшиеся четыре попытки по реальному миллисекундному времени без ускорения рампы. */
for (attempt = 2; attempt <= 5; attempt++) {
/* Даёт каждой попытке 3000 мс свежего нулевого ЗПТ после начальной отправки 6 мА. */
tick(3000, 1, 0);
/* Проверяет возврат к 4 мА и полную выдержку каждой попытки до STOP. */
CHECK(test_stop && !test_permission && load_attempts == attempt && modbus[0x1C] == 40 && test_last_stop_tick - test_last_start_tick >= 3000);
/* До пятой попытки соблюдает дополнительную секунду STOP, после пятой повтор запрещён. */
if (attempt < 5) tick(1000, 1, 0);
/* Закрывает перебор разрешённых пусков. */
}
/* Достаточное ЗПТ после ошибки само по себе не должно давать шестой пуск. */
tick(3000, 1, 30);
/* Проверяет удержание ошибки, STOP и соблюдение порядка START/STOP/разрешения. */
CHECK(test_starts == 5 && (LOAD_STATUS & 1) && test_stop && !test_bad_order);
/* Закрывает независимые проверки обоих адресов УМП. */
}
/* Подаёт достаточное ЗПТ в последний такт выдержки: порог 30 В должен иметь приоритет перед истечением ожидания. */
setup(5); DAC_go = 6; Commands = 0x80; tick(3009, 1, 29); tick(1, 1, 30);
/* Проверяет, что на границе 3000 мс от первого токового кадра не произошло ложного STOP или второго START. */
CHECK(load_state == LOAD_RUN && test_starts == 1 && !test_stop && test_permission);
/* Даёт УМП 5 две секунды низкого ЗПТ при начальном токе 6 мА: первый токовый кадр отправляется на 10 мс. */
setup(5); DAC_go = 6; Commands = 0x80; tick(2010, 1, 29);
/* Устройство должно продолжать ожидание на первой попытке без роста выше 6 мА. */
CHECK(load_attempts == 1 && modbus[0x1C] == 60 && !test_stop);
/* Запоминает начальный код для проверки роста после прихода достаточного ЗПТ. */
code = modbus[123];
/* Ровно 30 В разрешают разгон; за 300 мс изменение видно даже при разрешении регистра 0,1 мА. */
tick(300, 1, 30);
/* Проверяет продолжение первой попытки и рост отправленного токового задания. */
CHECK(test_starts == 1 && load_state == LOAD_RUN && modbus[0x1C] > 60 && (unsigned int)modbus[123] > code);
/* После успешного роста падение до 29 В не получает дополнительную трёхсекундную выдержку. */
tick(5, 1, 29); CHECK(load_state == LOAD_RELOAD && test_stop && modbus[0x1C] == 40);
/* Даже повышенная начальная уставка 9 мА должна ограничиваться 6 мА до подтверждения роста ЗПТ. */
setup(5); DAC_go = 9; Commands = 0x80; tick(10, 1, 0);
/* Исключает преждевременную передачу повышенного начального задания при низком ЗПТ. */
CHECK(modbus[0x1C] == 60 && load_state == LOAD_RUN && test_starts == 1);
/* После исчезновения CAN отправленное задание должно остаться 6 мА, даже если начальная уставка равна 9 мА. */
tick(1000, 0, 0); CHECK((LOAD_STATUS & 2) && modbus[0x1C] == 60);
/* Короткий тайм-аут 20 мс позволяет проверить приостановку стартовой выдержки при потере выбранного CAN-напряжения. */
setup(5); DAC_go = 6; LOAD_CAN_TIMEOUT = 20; Commands = 0x80; tick(10, 1, 0);
/* Дожидается устаревания последнего ЗПТ без новых кадров. */
tick(30, 0, 0);
/* Сохраняет остаток стартовых отправок и последний код после перехода в паузу CAN. */
count = load_start_remaining; code = modbus[123];
/* Отсутствие CAN дольше всей выдержки не должно расходовать её остаток или следующую попытку. */
tick(4000, 0, 0);
/* Проверяет удержание кода, счётчика ожидания, разрешения и первой попытки во время тайм-аута. */
CHECK((LOAD_STATUS & 2) && load_start_remaining == count && (unsigned int)modbus[123] == code && load_attempts == 1 && !test_stop);
/* Свежее низкое ЗПТ возобновляет отсчёт от сохранённого значения. */
tick(5, 1, 29); CHECK(!(LOAD_STATUS & 2) && load_start_remaining == count - 1 && test_starts == 1);
/* RESET должен прекратить ожидание сразу и отправить 4 мА на ближайшем токовом такте. */
Commands = 0xC0; tick(5, 1, 29); CHECK(test_stop && !test_permission && modbus[0x1C] == 40);
/* Ручная калибровка вместе со START не должна подменять стартовое задание. */
setup(5); DAC_go = 6; Commands = 0x280; DAC_cal() = 4095; tick(6, 1, 0);
/* Команда инициализации на первом токовом такте не подтверждает отправку 6 мА и не расходует выдержку. */
cInitDac = 1; tick(4, 1, 0); CHECK(load_start_remaining == 600 && modbus[0x1C] == 40);
/* Следующий такт должен выдать настоящий начальный ток вместо ручного кода 4095. */
tick(5, 1, 0); CHECK(modbus[0x1C] == 60 && modbus[123] != 4095 && load_start_remaining == 599);
/* Последний такт перед тремя секундами от токового кадра ещё сохраняет ожидание. */
tick(2999, 1, 0); CHECK(load_state == LOAD_RUN);
/* Следующий такт завершает выдержку и возвращает 4 мА без подмены ручной калибровкой. */
tick(1, 1, 0); CHECK(load_state == LOAD_RELOAD && modbus[0x1C] == 40 && modbus[123] == DAC_min());
/* Возвращает успех после проверки реакции ЗПТ, пяти попыток, CAN, RESET и калибровки. */
return 0;
/* Закрывает проверку стартового этапа нагрузки. */
}
/* Проверяет настраиваемый лимит, независимость счётчика, уменьшение лимита в паузе STOP и верхнюю 16-битную границу. */
static int attempt_limit_test(void) {
/* Адреса 5/6 выбирают оба УМП; limit задаёт общий предел START, attempt считает проверяемые неудачи. */
unsigned int mode, limit, attempt, out[8], error;
/* Ноль из старой EEPROM должен превратиться в прежние заводские пять пусков. */
setup(5); CHECK(LOAD_MAX_ATTEMPTS == 5);
/* Подготовка тактов ЦАП после загрузки параметров обязана сохранять ненулевую пользовательскую настройку. */
LOAD_MAX_ATTEMPTS = 7; Setup_DAC_time(); CHECK(LOAD_MAX_ATTEMPTS == 7);
/* Проверяет одинаковый смысл лимита для ЗПТ1 и ЗПТ2, выбранных штатными CAN-адресами. */
for (mode = 5; mode <= 6; mode++) {
/* Значения 1, 2 и 7 проверяют отсутствие дополнительных пусков и снятие прежнего жёсткого предела пяти. */
for (limit = 1; limit <= 7; limit = limit == 1 ? 2 : 7) {
/* Новый сеанс начинает работу с указанным пределом; START включается только штатной командой. */
setup(mode); LOAD_MAX_ATTEMPTS = limit; Commands = 0x80;
/* Каждая успешная реакция ЗПТ позволяет затем проверить немедленную защиту при его падении. */
for (attempt = 1; attempt <= limit; attempt++) {
/* Даёт 1010 мс на первый пуск либо окончание секундного STOP перед очередным START. */
tick(1010, 1, 30);
/* Переводит рампу выше границы 6 мА при достаточном ЗПТ, затем имитирует его падение до нуля. */
load_count_ramp = time_dac / 6; tick(5, 1, 30); tick(5, 1, 0);
/* Проверяет число реальных START и неизменность записанного лимита после работы Timer1. */
CHECK(test_starts == attempt && load_attempts == attempt && LOAD_MAX_ATTEMPTS == (int)limit);
/* До последней попытки допускается повтор; последняя неудача обязана зафиксировать LOAD_FAULT. */
CHECK(load_state == (attempt == limit ? LOAD_FAULT : LOAD_RELOAD));
/* Завершает проверку всех разрешённых попыток текущего сеанса. */
}
/* Достаточное напряжение и повышение лимита сами по себе не снимают уже зафиксированную ошибку. */
LOAD_MAX_ATTEMPTS = limit + 1; tick(3000, 1, 30);
/* Счётчик остаётся прежним, аппаратный STOP и запрет разрешения сохраняются после изменения настройки. */
CHECK(test_starts == limit && load_attempts == limit && test_stop && !test_permission);
/* Диагностический блок версии 1 продолжает возвращать текущий счётчик в слове 5, независимо от лимита 0x7D. */
CHECK(Load_protection_prepare(3, 0x1300, 8, out, &error) == 8 && !error && out[5] == limit);
/* Снятие START обнуляет счётчик, но сохраняет лимит для следующего сеанса пуска. */
Commands = 0; tick(1000, 1, 30); CHECK(!load_attempts && LOAD_MAX_ATTEMPTS == (int)(limit + 1));
/* Значение 7 — последний сценарий; выход исключает повторение итерации с неизменным limit. */
if (limit == 7) break;
/* Завершает перебор проверяемых пользовательских лимитов. */
}
/* Завершает проверку обоих адресов УМП. */
}
/* Подготавливает первый неудачный пуск с разрешёнными пятью попытками. */
setup(5); Commands = 0x80; tick(1010, 1, 30);
/* Падение уже подтверждённого ЗПТ переводит автомат в секундный STOP перед повтором. */
load_count_ramp = time_dac / 6; tick(5, 1, 0); CHECK(load_state == LOAD_RELOAD);
/* Уменьшает предел до уже использованной одной попытки во время STOP, проверяя защиту перед следующим START. */
LOAD_MAX_ATTEMPTS = 1; tick(3000, 1, 30); CHECK(load_state == LOAD_FAULT && test_starts == 1);
/* Верхняя граница регистра сохраняется после подготовки автомата и не трактуется как отрицательный лимит. */
setup(6); LOAD_MAX_ATTEMPTS = 65535U; Setup_DAC_time(); WAKEpowse = 0;
/* Проверяет чтение максимального 16-битного значения без обнуления пользовательской настройки. */
CHECK((unsigned int)LOAD_MAX_ATTEMPTS == 65535U);
/* Доводит первый пуск до защитной паузы, затем моделирует последнюю попытку без 65534 циклов ожидания. */
Commands = 0x80; tick(1010, 1, 30); load_count_ramp = time_dac / 6; tick(5, 1, 0);
/* Значение 65534 соответствует числу ранее выданных START перед последней разрешённой попыткой. */
load_attempts = 65534U; tick(1000, 1, 30); CHECK(load_attempts == 65535U && test_starts == 2);
/* Последняя неудача фиксирует ошибку до возможного переполнения 16-битного счётчика. */
load_count_ramp = time_dac / 6; tick(5, 1, 0); tick(3000, 1, 30);
/* Проверяет удержание максимального счётчика, отсутствие дополнительного START и неизменность лимита. */
CHECK(load_state == LOAD_FAULT && load_attempts == 65535U && test_starts == 2 && (unsigned int)LOAD_MAX_ATTEMPTS == 65535U);
/* Возвращает успех после проверки сохранения лимита и пограничных сценариев его применения. */
return 0;
/* Завершает проверки настраиваемого количества попыток запуска. */
}
/* Запускает новые стартовые сценарии и прежние регрессии автомата на программных подменах периферии. */
int main(void) {
/* Объявляет out — данные out; error — ошибка; count — число; ramp — данные ramp; code — данные code. */
unsigned int out[8], error, count, ramp, code, stopped_at;
/* Сначала проверяет исправляемый штатный пуск с 6 мА, затем выполняет остальные регрессии защиты. */
CHECK(startup_test() == 0);
/* Дополнительно проверяет записываемый лимит 0x7D до прежних регрессий автомата нагрузки. */
CHECK(attempt_limit_test() == 0);
/* Вызывает setup с аргументами (5) в текущей последовательности операций. */
setup(5);
/* Boot ISR before parameters: no divide-by-zero and no GPIO start. */
@@ -76,18 +231,18 @@ int main(void) {
/* Freeze current and code at timeout; unrelated exchange cannot unfreeze. */
/* Вызывает tick с аргументами (1000, 1, 30); tick(600, 0, 0) в текущей последовательности операций. */
tick(1000, 1, 30); tick(600, 0, 0);
/* Записывает ramp значением ump_dac_ramp; code = modbus[123]; данные ramp. */
ramp = ump_dac_ramp; code = modbus[123];
/* Вызывает tick с аргументами (2000, 0, 0); CHECK(ump_dac_ramp == ramp && (unsigned int)modbus[123] == code) в текущей последовательности операций. */
tick(2000, 0, 0); CHECK(ump_dac_ramp == ramp && (unsigned int)modbus[123] == code);
/* Записывает ramp значением load_count_ramp; code = modbus[123]; данные ramp. */
ramp = load_count_ramp; code = modbus[123];
/* Вызывает tick с аргументами (2000, 0, 0); CHECK(load_count_ramp == ramp && (unsigned int)modbus[123] == code) в текущей последовательности операций. */
tick(2000, 0, 0); CHECK(load_count_ramp == ramp && (unsigned int)modbus[123] == code);
/* Вызывает CHECK с аргументами (test_permission && !test_stop && (LOAD_STATUS & 2)) в текущей последовательности операций. */
CHECK(test_permission && !test_stop && (LOAD_STATUS & 2));
/* Вызывает Load_voltage_can. Принимает напряжение выбранной нагрузки из достоверных слов CAN и сбрасывает возраст только нужного измерения. */
Load_voltage_can(0x8000U | 8U, 200, 0, 0); tick(10, 0, 0);
/* Вызывает CHECK с аргументами (ump_dac_ramp == ramp) в текущей последовательности операций. */
CHECK(ump_dac_ramp == ramp);
/* Вызывает tick с аргументами (10, 1, 30); CHECK(ump_dac_ramp > ramp) в текущей последовательности операций. */
tick(10, 1, 30); CHECK(ump_dac_ramp > ramp);
/* Вызывает CHECK с аргументами (load_count_ramp == ramp) в текущей последовательности операций. */
CHECK(load_count_ramp == ramp);
/* Вызывает tick с аргументами (10, 1, 30); CHECK(load_count_ramp > ramp) в текущей последовательности операций. */
tick(10, 1, 30); CHECK(load_count_ramp > ramp);
/* Exactly 30 V permits growth; 29 V fails strictly above 6 mA. */
/* Записывает Commands значением 0x80; tick(10, 1, 30); слово команд, технологический регистр 127. */
setup(6); Commands = 0x80; tick(10, 1, 30);
@@ -97,8 +252,8 @@ int main(void) {
CHECK(load_state == LOAD_RUN && modbus[0x1C] >= 60);
/* Вызывает tick с аргументами (5, 1, 29); CHECK(load_state == LOAD_RELOAD && test_stop && !test_permission) в текущей последовательности операций. */
tick(5, 1, 29); CHECK(load_state == LOAD_RELOAD && test_stop && !test_permission);
/* Вызывает CHECK с аргументами (!test_start && ump_dac_ramp == 0 && modbus[0x1C] == 40) в текущей последовательности операций. */
CHECK(!test_start && ump_dac_ramp == 0 && modbus[0x1C] == 40);
/* Вызывает CHECK с аргументами (!test_start && load_count_ramp == 0 && modbus[0x1C] == 40) в текущей последовательности операций. */
CHECK(!test_start && load_count_ramp == 0 && modbus[0x1C] == 40);
/* Записывает stopped_at значением test_last_stop_tick; данные stopped_at. */
CHECK(modbus[123] == DAC_min()); stopped_at = test_last_stop_tick;
/* Вызывает tick с аргументами (999, 1, 0); CHECK(test_starts == 1 && test_stop) в текущей последовательности операций. */
@@ -116,16 +271,16 @@ int main(void) {
if (load_state == LOAD_RELOAD) tick(1000, 1, 0);
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
}
/* Вызывает CHECK с аргументами (test_starts == 5 && LOAD_ATTEMPTS == 5 && (LOAD_STATUS & 1)) в текущей последовательности операций. */
CHECK(test_starts == 5 && LOAD_ATTEMPTS == 5 && (LOAD_STATUS & 1));
/* Вызывает CHECK с аргументами (test_starts == 5 && load_attempts == 5 && (LOAD_STATUS & 1)) в текущей последовательности операций. */
CHECK(test_starts == 5 && load_attempts == 5 && (LOAD_STATUS & 1));
/* Вызывает tick с аргументами (3000, 1, 200); CHECK(test_starts == 5 && test_stop && !test_permission) в текущей последовательности операций. */
tick(3000, 1, 200); CHECK(test_starts == 5 && test_stop && !test_permission);
/* Записывает Commands значением 0xC0; tick(10, 1, 200); CHECK(load_state == LOAD_FAULT); слово команд, технологический регистр 127. */
Commands = 0xC0; tick(10, 1, 200); CHECK(load_state == LOAD_FAULT);
/* Записывает Commands значением 0; tick(1000, 1, 200); CHECK(!(LOAD_STATUS & 1)); слово команд, технологический регистр 127. */
Commands = 0; tick(1000, 1, 200); CHECK(!(LOAD_STATUS & 1));
/* Записывает Commands значением 0x80; test_starts = 0; tick(10, 1, 200); CHECK(LOAD_ATTEMPTS == 1); слово команд, технологический регистр 127. */
Commands = 0x80; test_starts = 0; tick(10, 1, 200); CHECK(LOAD_ATTEMPTS == 1);
/* Записывает Commands значением 0x80; test_starts = 0; tick(10, 1, 200); CHECK(load_attempts == 1); слово команд, технологический регистр 127. */
Commands = 0x80; test_starts = 0; tick(10, 1, 200); CHECK(load_attempts == 1);
/* Manual reset dominates START; releasing it alone cannot start again. */
/* Записывает Commands значением 0xC0; tick(1, 1, 200); CHECK(test_stop && !test_permission); слово команд, технологический регистр 127. */
Commands = 0xC0; tick(1, 1, 200); CHECK(test_stop && !test_permission);
@@ -150,12 +305,12 @@ int main(void) {
Load_protection_prepare(6, 0x1302, 1, out, &error); CHECK(!error);
/* Вызывает tick с аргументами (30, 1, 200); CHECK(LOAD_STATUS & 2) в текущей последовательности операций. */
tick(30, 1, 200); CHECK(LOAD_STATUS & 2);
/* Записывает ramp значением ump_dac_ramp; tick(100, 1, 200); CHECK(ump_dac_ramp == ramp); данные ramp. */
ramp = ump_dac_ramp; tick(100, 1, 200); CHECK(ump_dac_ramp == ramp);
/* Записывает ramp значением load_count_ramp; tick(100, 1, 200); CHECK(load_count_ramp == ramp); данные ramp. */
ramp = load_count_ramp; tick(100, 1, 200); CHECK(load_count_ramp == ramp);
/* Вызывает Load_protection_prepare. Фиксирует управляющие входы перед выполнением автомата защиты нагрузки. */
Load_protection_prepare(6, 0x1302, 0, out, &error);
/* Вызывает tick с аргументами (10, 1, 200); CHECK(!(LOAD_STATUS & 2) && ump_dac_ramp > ramp) в текущей последовательности операций. */
tick(10, 1, 200); CHECK(!(LOAD_STATUS & 2) && ump_dac_ramp > ramp);
/* Вызывает tick с аргументами (10, 1, 200); CHECK(!(LOAD_STATUS & 2) && load_count_ramp > ramp) в текущей последовательности операций. */
tick(10, 1, 200); CHECK(!(LOAD_STATUS & 2) && load_count_ramp > ramp);
/* Вызывает Load_protection_prepare. Фиксирует управляющие входы перед выполнением автомата защиты нагрузки. */
Load_protection_prepare(6, 0x1302, 2, out, &error);
/* Записывает load_count_ramp значением time_dac / 6; tick(5, 1, 200); CHECK(load_state == LOAD_RELOAD); load число ramp. */
@@ -177,10 +332,10 @@ int main(void) {
/* Вызывает tick с аргументами (1, 1, 200); CHECK(test_starts == 1) в текущей последовательности операций. */
tick(1, 1, 200); CHECK(test_starts == 1);
/* Timeout while STOP is held cannot initiate the pending retry. */
/* Записывает Commands значением 0x80; tick(10, 1, 0); слово команд, технологический регистр 127. */
setup(5); Commands = 0x80; tick(10, 1, 0);
/* Записывает load_count_ramp значением time_dac / 6; tick(5, 1, 0); load число ramp. */
load_count_ramp = time_dac / 6; tick(5, 1, 0);
/* Начинает пуск с заводскими 6 мА и свежим нулевым ЗПТ, чтобы затем проверить исчезновение CAN во время STOP. */
setup(5); DAC_go = 6; Commands = 0x80; tick(10, 1, 0);
/* Даёт три секунды на реакцию ЗПТ после первой отправки 6 мА, затем проверяет потерю CAN во время защитного сброса. */
tick(3000, 1, 0);
/* Вызывает CHECK с аргументами (load_state == LOAD_RELOAD) в текущей последовательности операций. */
CHECK(load_state == LOAD_RELOAD);
/* Вызывает tick с аргументами (1500, 0, 0); CHECK(test_starts == 1 && test_stop) в текущей последовательности операций. */
@@ -189,8 +344,9 @@ int main(void) {
tick(1, 1, 0); CHECK(test_starts == 2 && !test_stop);
/* Вызывает Load_control_init. Сбрасывает все переменные автомата нагрузки до разрешения прерываний; COFF не обнуляет всю .ebss. */
Load_control_init(); CHECK(!load_simulation);
/* Вызывает puts с аргументами ("PASS: production DAC control, timeout, CAN slots, STOP ordering, five attempts, simulation") в текущей последовательности операций. */
puts("PASS: production DAC control, timeout, CAN slots, STOP ordering, five attempts, simulation");
/* Сообщает об успехе проверки реального автомата, включая новый старт 6 мА с выдержкой 3 секунды и прежние защитные сценарии. */
/* Сообщает о проверке рабочих исходников, настраиваемого лимита и прежних режимов защиты нагрузки. */
puts("PASS: production DAC control, startup, timeout, CAN, STOP ordering, writable attempt limit, simulation");
/* Завершает main и возвращает 0. */
return 0;
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
tests/load_control/stubs/package.h
+4 -2
View File
@@ -25,8 +25,10 @@ extern unsigned int test_init_dac;
#define LOAD_CAN_TIMEOUT modbus[0x52]
/* Задаёт LOAD_STATUS = modbus[0x7C]; слово состояния защиты нагрузки для чтения, регистр 0x7C. */
#define LOAD_STATUS modbus[0x7C]
/* Задаёт LOAD_ATTEMPTS = modbus[0x7D]; число попыток пуска для чтения, регистр 0x7D. */
#define LOAD_ATTEMPTS modbus[0x7D]
/* Задаёт записываемый лимит общего числа пусков в регистре 0x7D; допустимы 1..65535 попыток, включая первый START. */
#define LOAD_MAX_ATTEMPTS modbus[0x7D]
/* Сохраняет прежний заводской предел пяти пусков для сброса настроек и замены нуля из старой EEPROM. */
#define LOAD_DEFAULT_MAX_ATTEMPTS 5U
/* Задаёт DAC_min = modbus[0x79]; ЦАП min. */
#define DAC_min() modbus[0x79]
/* Задаёт DAC_max = modbus[0x78]; ЦАП max. */