Watchdog и Избыточность. Как не зависнуть и не сломаться

Нормальная работа:
[Программа] → каждые 0.5 сек → [WDT: сброс] → [Программа]
                          (всё хорошо)

Зависание:
[Программа ЗАВИСЛА] → ... → [WDT: таймер 0] → ПЕРЕЗАГРУЗКА!

#include <avr/wdt.h>  // Библиотека для Watchdog

void setup() {
  Serial.begin(9600);
  Serial.println("Робот запускается...");
  
  // Включаем Watchdog на 2 секунды
  // WDTO_2S значит: перезагрузить через 2 секунды тишины
  wdt_enable(WDTO_2S);
}

void loop() {
  // Делаем свою работу
  readSensors();
  makeDecision();
  controlMotors();
  
  // ВАЖНО: "Кормим собаку" - сбрасываем таймер
  // Если эта строка не выполнится за 2 секунды -> перезагрузка
  wdt_reset();
}

// Пример зависания - ЗАКОММЕНТИРУЙТЕ для теста!
void badFunction() {
  while(true) {
    // Бесконечный цикл!
    // Watchdog перезагрузит Arduino через 2 секунды
  }
}

#include "esp_task_wdt.h"

void setup() {
  // Подключаем Watchdog к главной задаче (Task)
  esp_task_wdt_init(2, true); // Таймаут 2 секунды
  esp_task_wdt_add(NULL); // Добавляем текущую задачу
  
  // Теперь если задача зависнет >2 сек -> перезагрузка
}

void loop() {
  // Делаем что-то...
  
  // Сбрасываем Watchdog для этой задачи
  esp_task_wdt_reset();
  
  // Если добавили другие задачи, их тоже нужно сбрасывать
}

float getDistance() {
  float dist1 = ultrasonic1.read();
  float dist2 = ultrasonic2.read();
  
  // Если датчики показывают примерно одинаково
  if (abs(dist1 - dist2) < 10) {
    return (dist1 + dist2) / 2; // Среднее значение
  }
  // Если один сломался (показывает 0 или 1000)
  else if (dist1 < 1 || dist1 > 500) {
    return dist2; // Используем только рабочий
  }
  else if (dist2 < 1 || dist2 > 500) {
    return dist1;
  }
  // Если оба показывают разное, но в пределах
  else {
    return min(dist1, dist2); // Берем ближайший (безопаснее)
  }
}

Для робота-исследователя:
1. Ультразвуковой датчик: точен на 20-200 см
2. Инфракрасный датчик: точен на 10-80 см  
3. Лазерный дальномер (LiDAR): точен везде, но дорогой

Если один запылился или сломался — используем другие!

Гусеничный робот с 2 моторами на борт:
[Левый борт] Мотор1 → Мотор2 (резервный)
[Правый борт] Мотор3 → Мотор4 (резервный)

Если Мотор1 сломался → включаем Мотор2
Робот продолжает движение, только медленнее

Проблема: ИК-датчик может загрязниться или сломаться
Решение: 5 датчиков вместо 3

Логика:
1. Если все 5 работают → используем все
2. Если 1 сломался → используем 4
3. Если 2 сломался → используем 3 (минимум)
4. Если 3 сломалось → останавливаемся, сигнал ошибки

Код:
int sensors[5] = {0, 0, 0, 0, 0};
int workingCount = 0;
float average = 0;

for(int i = 0; i < 5; i++) {
  int val = readSensor(i);
  if(val >= 100 && val <= 900) { // Рабочий диапазон
    sensors[i] = val;
    workingCount++;
    average += val;
  }
}

if(workingCount >= 3) {
  average /= workingCount;
  followLine(average); // Работаем
} else {
  emergencyStop(); // Слишком много сломалось
}

Избыточность данных:
1. Температура: 2 датчика (DHT22 + DS18B20)
2. Давление: 2 датчика (BMP280 + BME280)
3. Влажность: 2 датчика (DHT22 + отдельный)

Если датчики показывают разное:
• Берём среднее
• Отмечаем в логе "расхождение"
• Если расхождение большое → используем более надежный

Защита от сбоев:
1. Watchdog на 500 мс (быстрая реакция)
2. 2 концевых выключателя на каждом суставе
3. Датчик тока на каждом моторе
4. Резервный источник питания для контроллера

При любой ошибке:
1. Watchdog перезагружает если завис
2. Концевик останавливает мотор физически
3. Датчик тока отключает при перегрузке
4. Резервное питание держит 5 сек для безопасной остановки

Короткое время (100-500 мс):
• Для быстрых роботов (дроны, гоночные)
• Быстрое обнаружение зависаний
• Но нужно часто сбрасывать

Длинное время (1-8 секунд):
• Для медленных роботов (манипуляторы, метеостанции)
• Можно делать долгие операции (измерения, отправка данных)
• Медленнее реагирует на зависания

#include <avr/wdt.h>

void setup() {
  // Проверяем причину перезагрузки
  if (MCUSR & (1 << WDRF)) { // Перезагрузились из-за Watchdog
    Serial.println("ПЕРЕЗАГРУЗКА Watchdog! Программа зависла.");
    logError("Watchdog reset");
    
    // Можно восстановить состояние
    recoverFromCrash();
  }
  
  MCUSR = 0; // Сбрасываем флаг
  wdt_enable(WDTO_2S); // Включаем снова
}

Компоненты:
• Основной контроллер: Raspberry Pi (планирование)
• Резервный контроллер: Arduino (аварийное управление)
• Датчики расстояния: 8 штук (4 основных + 4 резервных)
• Моторы: 4 (каждый может работать в одиночку)

При отказе:
1. Если Raspberry Pi завис → Arduino берет управление
2. Если 1-2 датчика сломались → используем остальные
3. Если 1 мотор сломался → едем на 3-х, медленнее
4. Если 2 мотора сломались → останавливаемся, зовем помощь

Код управления моторами:
void controlMotors() {
  // Проверяем работоспособность каждого мотора
  bool motorsOK[4] = {true, true, true, true};
  
  for(int i = 0; i < 4; i++) {
    if (getMotorCurrent(i) > MAX_CURRENT) motorsOK[i] = false;
    if (getMotorTemperature(i) > 80) motorsOK[i] = false;
  }
  
  // Сколько моторов работает?
  int working = 0;
  for(int i = 0; i < 4; i++) if(motorsOK[i]) working++;
  
  if (working == 4) {
    // Все хорошо - нормальная работа
    setAllMotors(normalSpeed);
  }
  else if (working >= 2) {
    // Работаем в ограниченном режиме
    setWorkingMotors(reducedSpeed);
    sendAlert("Некоторые моторы не работают");
  }
  else {
    // Слишком много сломалось
    emergencyStop();
  }
}

Проблема: delay(5000) на 5 секунд
Watchdog сработает через 2 секунды → перезагрузка

Решение:
unsigned long start = millis();
while(millis() - start < 5000) {
  wdt_reset(); // Сбрасываем в цикле
  // Можно делать что-то полезное
}

Проблема: 2 одинаковых дешёвых датчика
Оба выходят из строя в одинаковых условиях

Решение: Разные типы датчиков
Ультразвуковой + инфракрасный + лазерный

Проблема: Включили резервный мотор, но не проверили
Через 5 минут и он сломался

Решение: Проверять резервные системы тоже
testBackupSystems();

Проблема: Программа делает сложные вычисления 3 секунды
Watchdog настроен на 2 секунды → постоянные перезагрузки

Решение: 
1. Увеличить время Watchdog
2. Разбить сложную задачу на части
3. Сбрасывать Watchdog внутри длинной операции

#include <avr/wdt.h>

void dangerousFunction() {
  // ОПАСНО: может зависнуть
  while(random(100) != 42) {
    // Иногда зависает здесь надолго
  }
}

void setup() {
  wdt_enable(WDTO_1S); // Строгий Watchdog: 1 секунда
  pinMode(LED_BUILTIN, OUTPUT);
  randomSeed(analogRead(0));
}

void loop() {
  // Нормальная работа: мигаем
  digitalWrite(LED_BUILTIN, HIGH);
  delay(100);
  digitalWrite(LED_BUILTIN, LOW);
  
  // Иногда вызываем опасную функцию
  if (random(10) == 0) {
    dangerousFunction();
  }
  
  // Сбрасываем Watchdog
  // Если dangerousFunction() зависнет >1 сек -> перезагрузка
  // Но светодиод СНОВА начнет мигать после перезагрузки!
  wdt_reset();
}