Компиляция приложения для работы в условиях сильной радиации: защита от сбоев

Основные стратегии защиты от радиационных сбоев (Single Event Upsets)

Ваша проблема типична для космических и ядерных приложений. Радиация вызывает SEU (Single Event Upset) — "переворот" бита в памяти или логике. Стандартные механизмы C++ (исключения, RAII) здесь бессильны, так как сбой происходит на аппаратном уровне. Решение — сочетание аппаратных мер (если доступно) и программной избыточности.

1. Критические флаги и переменные: тройное резервирование (TMR)

Самый надежный программный метод — хранить каждую критическую переменную в трех экземплярах и "голосовать" большинством. Это защищает от одиночных сбоев.

// Шаблон для TMR (Triple Modular Redundancy)
template<typename T>
class TMRVariable {
    T copies[3];
public:
    T read() const {
        // Голосование большинством: если два из трех совпадают — берем это значение
        if (copies[0] == copies[1]) return copies[0];
        if (copies[1] == copies[2]) return copies[1];
        return copies[0]; // Все разные — худший случай, берем первое
    }
    void write(const T& value) {
        copies[0] = value;
        copies[1] = value;
        copies[2] = value;
    }
    // Метод для восстановления после сбоя (scrubbing)
    void scrub() {
        T majority = read();
        copies[0] = majority;
        copies[1] = majority;
        copies[2] = majority;
    }
};

// Использование для вашего флага valid
struct TelemetryPacket {
    uint8_t buffer[256];
    uint32_t checksum;
    TMRVariable<bool> valid; // Теперь защищен от одиночных сбоев
};

2. Защита кода в Flash: контрольные суммы и ECC

GCC не умеет автоматически добавлять ECC в код, но вы можете:

• Разместить код в ECC-защищенной Flash (если есть поддержка в микроконтроллере, например, у STM32H7 есть ECC для Flash).
• Использовать CRC для секций кода и периодически проверять его целостность. Если CRC не совпадает — перезагружаться или переключаться на резервную копию.
• Флаг компилятора -fstack-protector-strong — добавит защиту стека от повреждений, но не спасет от всех сбоев.

3. Защита вычислений: двойные вычисления с проверкой

Для критических функций (как ваша checksum) выполняйте вычисления дважды и сравнивайте результаты. Разместите копии данных в разных банках памяти.

uint32_t safe_calculate_checksum(const uint8_t* data, size_t len) {
    // Первый проход
    uint32_t sum1 = 0;
    for (size_t i = 0; i < len; ++i) {
        sum1 += data[i];
    }
    // Второй проход (можно с инвертированным порядком для разнообразия)
    uint32_t sum2 = 0;
    for (size_t i = len; i > 0; --i) {
        sum2 += data[i-1];
    }
    // Если результаты не совпали — сигнал тревоги
    if (sum1 != sum2) {
        // Возможно, произошел сбой. Можно пересчитать третий раз или вернуть ошибку
        trigger_error_handler();
    }
    return sum1; // Или среднее арифметическое при расхождении
}

4. Флаги компиляции GCC, полезные для отказоустойчивости

Добавьте в Makefile:

-fno-strict-aliasing -fno-delete-null-pointer-checks -fno-strict-overflow -mno-sched-prolog -fomit-frame-pointer (осторожно)

Но главное — используйте -O1 или -Os вместо -O2/-O3. Высокая оптимизация может удалить "лишние" проверки или изменить порядок операций, что критично для TMR.

5. Watchdog и Hardware scrubbing

Обязательно настройте аппаратный watchdog с максимально коротким таймаутом. В основном цикле вызывайте:

void main_loop() {
    while(1) {
        // Периодическое "освежение" TMR-переменных
        telemetryPacket.valid.scrub();
        // Сброс watchdog
        HAL_Watchdog_Refresh();
        // Основная логика...
    }
}

Итог

Компилятор сам по себе не сделает код устойчивым к радиации. Вам нужно:

• Использовать TMR для всех критических данных (флаги, указатели, счетчики).
• Дублировать вычисления для важных функций.
• Включить ECC для памяти (если доступно).
• Периодически проверять целостность кода через CRC.
• Настроить watchdog и "scrubbing" (восстановление) TMR-данных.

Это значительно повысит шансы вашей системы пережить радиационные сбои без потери функциональности.

// Храним две копии критических данных: основную и теневую
struct RedundantData {
    uint32_t primary;
    uint32_t shadow;
    
    bool is_consistent() const {
        return primary == shadow;
    }
    
    void write(uint32_t val) {
        primary = val;
        shadow = val;
    }
    
    uint32_t read() const {
        if (is_consistent()) return primary;
        // При расхождении — берем теневую и восстанавливаем основную
        const_cast<RedundantData*>(this)->primary = shadow;
        return shadow;
    }
};