WOL ESP Watchdog

Aby zrealizować watchdoga na urządzeniu z układem ESP, który po 5 minutach działania wysyła sygnał Wake-on-LAN (WoL), można wykorzystać ESP8266 lub ESP32. Oto kroki, które należy podjąć:

### Wymagania sprzętowe i programowe:
1. **Moduł ESP8266 lub ESP32**
2. **Arduino IDE** (lub inny kompatybilny środowisko programistyczne)
3. **Biblioteka ESPAsyncTCP** (dla ESP32) lub **ESP8266WiFi** (dla ESP8266)
4. **Biblioteka WiFiUDP** (dla wysyłania pakietu WoL)

### Krok po kroku:

#### 1. Konfiguracja Arduino IDE:
- Zainstaluj Arduino IDE.
- Dodaj wsparcie dla ESP8266 lub ESP32 w Arduino IDE (w ustawieniach menedżera płytki).

#### 2. Instalacja bibliotek:
- Zainstaluj biblioteki **ESPAsyncTCP** (dla ESP32) lub **ESP8266WiFi** (dla ESP8266) oraz **WiFiUDP**.

#### 3. Skrypt:
Poniżej znajduje się przykładowy skrypt, który uruchamia timer na 5 minut i po tym czasie wysyła pakiet Wake-on-LAN.

```cpp
#include <ESP8266WiFi.h>  // dla ESP8266
//#include <WiFi.h>       // dla ESP32
#include <WiFiUdp.h>

const char* ssid = "Twoja_SSID";
const char* password = "Twoje_Haslo";

WiFiUDP UDP;

unsigned long previousMillis = 0;  // Zmienna do przechowywania poprzedniego czasu
const long interval = 300000;      // Interwał 5 minut w milisekundach

// MAC address urządzenia docelowego
byte mac[6] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Łączenie...");
  }
  Serial.println("Połączono z WiFi");
}

void loop() {
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    sendWakeOnLan();
  }
}

void sendWakeOnLan() {
  const int port = 9;  // standardowy port WoL
  byte payload[102];   // Magic packet ma 102 bajty

  // Pierwsze 6 bajtów ustawione na 0xFF
  for (int i = 0; i < 6; i++) {
    payload[i] = 0xFF;
  }

  // Kolejne 16 razy MAC address
  for (int i = 1; i <= 16; i++) {
    for (int j = 0; j < 6; j++) {
      payload[i * 6 + j] = mac[j];
    }
  }

  // Wysyłanie pakietu UDP
  UDP.beginPacket("255.255.255.255", port); // Adres broadcast
  UDP.write(payload, sizeof(payload));
  UDP.endPacket();
  Serial.println("Wysłano sygnał Wake-on-LAN");
}
```

### Wyjaśnienie skryptu:
1. **Konfiguracja WiFi**:
   - Podłącz ESP do sieci WiFi, używając SSID i hasła.
2. **Timer**:
   - Używając funkcji `millis()`, ustawiamy timer na 5 minut (300000 milisekund).
3. **Wysłanie WoL**:
   - Przygotowujemy magic packet (102 bajty), który składa się z 6 bajtów 0xFF i 16 powtórzeń adresu MAC.
   - Używamy `WiFiUDP` do wysłania pakietu UDP na adres broadcast (`255.255.255.255`) na standardowy port WoL (9).

Po uruchomieniu skryptu ESP będzie czekać 5 minut, a następnie wyśle pakiet WoL do urządzenia z określonym adresem MAC.

--------
Lub
Korzystanie z ESPHome lub ESPEasy do konfiguracji watchdog, który po 5 minutach działania wysyła sygnał Wake-on-LAN, jest możliwe, ale wymaga nieco innego podejścia. Oba te narzędzia pozwalają na konfigurację urządzeń ESP bez potrzeby programowania niskopoziomowego, wykorzystując konfigurację w plikach YAML.

### ESPHome

#### 1. Instalacja ESPHome:
- Zainstaluj ESPHome zgodnie z oficjalnymi instrukcjami na [stronie ESPHome](https://esphome.io/guides/getting_started_command_line.html).

#### 2. Konfiguracja YAML:

Plik YAML konfiguracji dla ESPHome może wyglądać następująco:

```yaml
esphome:
  name: my_esp_device
  platform: ESP8266
  board: nodemcuv2  # lub odpowiednia płytka dla twojego ESP

wifi:
  ssid: "Twoja_SSID"
  password: "Twoje_Haslo"

logger:
api:
ota:

time:
  - platform: sntp
    id: my_time

switch:
  - platform: restart
    name: "Restart ESP"

interval:
  - interval: 5min
    then:
      - wake_on_lan.send_magic_packet:
          mac_address: DE:AD:BE:EF:FE:ED
          broadcast_address: 255.255.255.255

wake_on_lan:
```

#### Wyjaśnienie:
- **esphome**: Definiuje nazwę i platformę dla urządzenia.
- **wifi**: Konfiguracja połączenia WiFi.
- **logger**, **api**, **ota**: Standardowe komponenty ESPHome do logowania, interfejsu API i aktualizacji OTA.
- **time**: Używamy SNTP do synchronizacji czasu.
- **switch**: Dodano opcjonalny przełącznik do restartowania ESP.
- **interval**: Definiuje, że co 5 minut wysyłany jest sygnał Wake-on-LAN do podanego adresu MAC.
- **wake_on_lan**: Deklaracja komponentu Wake-on-LAN.

#### 3. Wgranie konfiguracji:
Wgraj konfigurację na ESP za pomocą komendy:

```sh
esphome run my_esp_device.yaml
```

### ESPEasy

#### 1. Instalacja ESPEasy:
- Pobierz i zainstaluj ESPEasy zgodnie z instrukcjami na [stronie ESPEasy](https://www.letscontrolit.com/wiki/index.php/ESPEasy).

#### 2. Konfiguracja:

Po zainstalowaniu ESPEasy, dostęp do konfiguracji odbywa się przez przeglądarkę. ESPEasy używa interfejsu webowego, który pozwala na konfigurację urządzenia.

1. **Dodanie modułu Wake-on-LAN**:
   - Przejdź do zakładki `Devices` i dodaj nowe urządzenie, wybierając typ `Generic - MQTT Import` (dla komunikacji MQTT) lub inny odpowiedni typ.

2. **Skrypt Rules**:
   - W ESPEasy można użyć zakładki `Tools -> Advanced -> Rules` do dodania skryptu.

Przykładowy skrypt Rules dla wysyłania Wake-on-LAN co 5 minut:

```ini
on System#Boot do
  timerSet,1,300  // Ustawia timer na 300 sekund (5 minut)
endon

on Rules#Timer=1 do
  SendToHTTP 192.168.1.255,80,/wol?mac=DEADBEFEED  // Wysyła pakiet WoL
  timerSet,1,300  // Resetuje timer
endon
```

#### Wyjaśnienie:
- **System#Boot**: Ustawia timer na 5 minut po starcie urządzenia.
- **Rules#Timer=1**: Po upływie 5 minut wysyła pakiet WoL na adres broadcastowy (musisz upewnić się, że Twój router pozwala na takie żądania HTTP).
- **SendToHTTP**: Wysyła żądanie HTTP, które powoduje wysłanie pakietu WoL (możesz dostosować adres IP i port do swojego środowiska).

Te metody pozwalają na prostsze zarządzanie i konfigurację urządzeń ESP z wykorzystaniem ESPHome lub ESPEasy, bez konieczności pisania kodu w Arduino IDE.