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

Перейти на компактные 12-словные записи v4 и сохранять 10 процентов банка после отключения. Добавить трёхсекундное ожидание роста ЗПТ и настраиваемый лимит пусков. Явно инициализировать состояние UART и гарантировать публикацию параметров EEPROM перед запуском Timer2. Сохранить воспроизводимые сборки, регрессионные проверки, документацию и обновлённые результаты сборки; исключить временные артефакты.

tests/load_control/load_control_test.c

@@ -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;
 /* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */