ESP8266 Arduino – zliczanie impulsów zewnętrznych TIMER0 i przerwaniami GPIO

Pytanie

ESP8266 jak zliczać impulsy zewnętrzne timerem program w arduino

Odpowiedź Sztucznej Inteligencji

Bezpośrednia odpowiedź na pytanie

• W ESP8266 w środowisku Arduino impulsy zewnętrzne możesz zliczać na dwa sposoby:
  1) najprościej – przerwaniami GPIO (attachInterrupt()),
  2) sprzętowo – wykorzystując licznik TIMER0 taktowany zewnętrznym sygnałem ​T0CKI na GPIO0.
• Do ~5 kHz wystarczy metoda 1, dla setek kHz ÷ MHz niezbędna jest metoda 2 lub zewnętrzny licznik.

Kluczowe punkty
• attachInterrupt() = łatwe, dowolny pin, ale ograniczona prędkość.
• TIMER0 = brak obciążenia CPU, wysoka częstotliwość, tylko GPIO0 i konfiguracja rejestrów.
• Piny specjalne (GPIO0/2/15) muszą mieć poprawny stan podczas resetu.
• Debouncing i separacja galwaniczna – zależnie od źródła impulsów.

Szczegółowa analiza problemu

1. Zliczanie przerwaniami GPIO (software)

const uint8_t PULSE_PIN = D2;            // dowolny pin wspierający IRQ
volatile uint32_t pulseCnt = 0;

IRAM_ATTR void onPulse() { pulseCnt++; }

void setup() {
  Serial.begin(115200);
  pinMode(PULSE_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(PULSE_PIN), onPulse, RISING); // lub FALLING/CHANGE
}

void loop() {
  static uint32_t last = 0;
  noInterrupts(); uint32_t v = pulseCnt; interrupts();
  if (millis() - last >= 1000) {
    Serial.printf("Impulsy/s: %u\n", v);
    noInterrupts(); pulseCnt = 0; interrupts();
    last = millis();
  }
}

• Czas ISR < 3 µs → do ok. 30 kHz.
• W ISR unikaj Serial, delay(), dynamicznej alokacji.
• Gdy źródłem jest przycisk – wstaw filtr RC lub programowy debouncing (np. minimalny odstęp > x ms).

2. Sprzętowy licznik TIMER0 (T0CKI @ GPIO0)

TIMER0 potrafi liczyć impulsy bez udziału CPU. Arduino-core go nie używa, dlatego można go skonfigurować bez konfliktów. Wejście licznika przydzielone jest na GPIO0, który podczas bootu musi być w stanie HIGH.

Minimalny, praktyczny kod:

#include <Arduino.h>
#define REG_T0_LOAD   (*(volatile uint32_t*)0x60000600)
#define REG_T0_COUNT  (*(volatile uint32_t*)0x60000604)
#define REG_T0_CTRL   (*(volatile uint32_t*)0x60000608)
#define T0_CTRL_EN        (1U << 31)
#define T0_CTRL_AUTOREL   (1U << 30)
#define T0_CTRL_DIV1      (0U << 16)   // dzielnik 1 => każdy impuls

void setup() {
  Serial.begin(115200);
  // 1. GPIO0 jako T0CKI
  PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO0_U, 1); // funkcja 1 = CLK_OUT1/T0CKI
  pinMode(0, INPUT_PULLUP);                   // pull-up dla poprawnego bootu
  // 2. konfiguracja timera
  REG_T0_LOAD = 0;            // licz od zera w górę
  REG_T0_CTRL = T0_CTRL_EN | T0_CTRL_AUTOREL | T0_CTRL_DIV1;
}

void loop() {
  static uint32_t prev = 0, tPrev = 0;
  uint32_t now = REG_T0_COUNT;
  if (millis() - tPrev >= 1000) {          // co sekundę
    Serial.printf("Impulsy/s: %u\n", now - prev);
    prev  = now;
    tPrev = millis();
  }
}

• Zdolność zliczania: > 2 MHz (ograniczenie elektryczne wejścia).
• Brak ISR ⇒ rdzeń Wi-Fi / TCP nie jest zakłócany.
• W razie potrzeby restart licznika: wyłącz timer, zapisz REG_T0_LOAD = 0, ponownie włącz.

3. Timer1/Ticker jako okno pomiaru

Jeśli używasz przerwań GPIO, możesz dodać soft-timer (Ticker, ESP8266TimerInterrupt) który raz na N ms odczyta i wyzeruje pulseCnt – otrzymasz próbkowanie częstotliwości bez blokowania pętli.

4. Debouncing i filtracja

Sygnały z czujników mechanicznych:
• RC 1 kΩ + 100 nF,
• Schmitt-trigger (74HC14),
• opto-izolacja w środowisku wysokoszumowym.

Aktualne informacje i trendy

• Firmware core 3.1.2 (2024) nadal nie wykorzystuje HW TIMER0, więc metoda 2 jest kompatybilna.
• Coraz częściej w miejsce ESP8266 stosuje się ESP32 z dedykowanym peryferium PCNT (Pulse Counter) – eliminuje konieczność manipulacji rejestrami.
• Biblioteki open-source „ESP8266PulseCounter” pojawiły się na GitHubie (2023 – 2024); wewnętrznie używają przedstawionej konfiguracji TIMER0.

Wspierające wyjaśnienia i detale

• volatile – kompilator nie buforuje zmiennej modyfikowanej w ISR.
• IRAM_ATTR (nowe core) = ICACHE_RAM_ATTR (stare core) – przenosi kod ISR do RAM (czas dostępu).
• Na NodeMCU piny opisane „D0…D8” są mapowane na faktyczne GPIO (D2 → GPIO4, D4 → GPIO2).

Aspekty etyczne i prawne

• Jeśli impulsy pochodzą z układów sieci energetycznej lub liczników energii, obowiązuje norma PN-EN 62053-31 (izolacja, bezpieczeństwo).
• W aplikacjach pomiaru zużycia mediów zachowaj zgodność z RODO – dane użytkowników są danymi osobowymi (profilowanie zużycia).

Praktyczne wskazówki

• Przy częstotliwościach > 50 kHz absolutnie unikaj Serial.print() w ISR.
• GPIO0 zabezpiecz rezystorem 10 kΩ do 3,3 V.
• Testuj licznik sztucznym sygnałem z generatora (np. 1 kHz → oscyloskop + porównanie).
• Dla bardzo wysokich częstotliwości (≥ 10 MHz) rozważ układ 74HC393/LS7366R i okresowe odczyty przez SPI/I²C.

Ewentualne zastrzeżenia lub uwagi dodatkowe

• Dokumentacja ESP8266 ma niejednoznaczny opis kierunku zliczania TIMER0; praktycznie przy LOAD=0 licznik inkrementuje się. Sprawdź eksperymentalnie.
• GPIO0 bywa używany przez niektóre płytki do sterowania LED – upewnij się, że nie ma konfliktu sprzętowego.
• Gdy moduł działa w trybie Light-Sleep, przerwania GPIO mogą się gubić – TIMER0 nadal działa, ale odczyt musi być zsynchronizowany z pobudką.

Sugestie dalszych badań

• Migracja projektu na ESP32 i wykorzystanie peryferium PCNT lub RMT.
• Analiza zużycia energii przy liczeniu impulsów w Light- / Deep-Sleep.
• Implementacja licznika sprzętowego w FPGA + SPI jako interfejs do ESP8266.
• Biblioteki RTOS-owe (ESP8266-RTOS SDK) pozwalają obsłużyć TIMER0 w zadaniu FreeRTOS – warto porównać z Arduino-core.

Krótkie podsumowanie

Zliczanie impulsów w ESP8266:

1. Przerwania GPIO – najszybszy start, dobre do kilku kHz.
2. TIMER0 + pin T0CKI (GPIO0) – prawdziwy sprzętowy licznik do > MHz; wymaga ustawienia rejestrów i zachowania poprawnego stanu GPIO0 przy bootowaniu.
3. Soft-timery (Ticker/Timer1) służą jedynie do porządkowego odczytu wyników.

Wybierz metodę adekwatną do częstotliwości, liczby dostępnych pinów oraz wymagań niezawodności programu.