Udało mi się ukończyć powyższe zadanie przy użyciu timerów, jednak od tego czasu używam wszystkich rejestrów timera (i dopasowuję dostępne rezystory) do ważniejszych zadań w ramach tego samego projektu.

W takim przypadku wszystko idzie źle. O ile absolutnie nie potrzebujesz wysokiej rozdzielczości, niskiego jittera lub innych funkcji sprzętowych timerów sprzętowych, powinieneś wykonywać synchronizację w oprogramowaniu, używając jednego z timerów sprzętowych do generowania ciągłych okresowych przerwań, które możesz policzyć w ISR.

„Przerwanie pulsu” z okresem od 100 µs do 100 ms (lub więcej) jest powszechną cechą systemów wbudowanych. Pozwala to na utworzenie dowolnej liczby programowych timerów.

Nawet jeśli już używasz wszystkich liczników sprzętowych, o ile przynajmniej jeden z nich wykonuje coś okresowego, na przykład generuje sygnał PWM lub tworzy zegar dla interfejsu szeregowego, możesz włączyć na nim przerwania i używaj ich jako podstawy czasu oprogramowania. Okres może nie być „wygodną” wartością, ale jest to prosty problem skalowania, z którym oprogramowanie może sobie poradzić.

Twój kod wydaje się być nieco błędny i jest trudny do zrozumienia, ponieważ nie jest jasne, gdzie znajduje się pętla while w odniesieniu do przerwania lub cokolwiek ustawia funkcję DownCount.

Wydaje się również, że zwiększasz licznik odbić w dwóch miejscach w pętli while, co po prostu wydaje się błędne.

Twoje rozwiązanie in-line jest problematyczne z wielu powodów, z których nie mniej ważny jest Twój czas, który będzie się różnił w zależności od tego, co jeszcze dzieje się w mikro, chyba że zatrzymasz się i wykonasz ścisłą pętlę podczas liczenia. Ale zatrzymanie się na pięć sekund to również zły pomysł.

Ten rodzaj funkcji jest normalnie obsługiwany w mikro za pomocą licznika tików, czyli bicia serca. Zasadniczo powszechną praktyką jest rezerwowanie jednego timera, który będzie działał jako zegar dla twojego kodu. Zegar generowałby regularne przerwanie, być może 10 razy na sekundę.

Ten program obsługi przerwań może zająć się wieloma funkcjami porządkowymi, takimi jak wyłączanie przełączników, miganie diod LED, sprawdzanie limitów czasu komunikacji itp. Może również obejmować liczenie czasu naciskania przycisku. Gdy zostanie naciśnięty przez odpowiedni czas, wspomniana funkcja obsługi wywołuje następnie odpowiednią procedurę obsługi dla tego zdarzenia.

Ta metoda umożliwia użycie jednego licznika czasu dla wielu funkcji.

Ponieważ przyciski są obsługiwane przez bardzo powolnych ludzi, w stosunku do szybkości procesora, można uniknąć powolnego odpytywania. Na przykład co 10 milisekund.
Możesz łatwo utworzyć jedną funkcję do obsługi wielu przycisków, z wieloma wzorcami naciśnięć i akcjami przytrzymania.

very simple wersja tego, czego często używam, wygląda tak. Ma tylko flagę wstrzymania 5 sekund, żadne z naciśnięć nie liczy i nie potwierdza flagi (flagi zostaną ustawione natychmiast po ponownym wyczyszczeniu).
Ale przy odrobinie kreatywności możesz w ten sposób dodać wiele rzeczy. Ale będzie trochę wydłużony.
Możesz nawet dodać kanały wejściowe komputera i sprawić, by były w ten sposób usuwane.

  #define BUTTON_INTERVAL 10
# zdefiniować BUTTON_COUNT 1

/ * Definicja typu dla przycisku * /
typedef struct button_s {
    void * port; / * Używaj typu portu GPIO, niezależnie od tego, z czego korzysta Twoja platforma, może nawet za pośrednictwem bitbandingu * /
    uint32_t hi_time; / * Czas wysoki * /
    uint8_t pin; /* Kod PIN */
    flagi uint8_t; / * Flagi wyjściowe * /
} button_t;

/ * Tablica wszystkich przycisków * /
button_t przyciski [BUTTON_COUNT];

/ * Obsługa odpytywania przycisku * /
void buttonHandler (void) {
    uint8_t i;
    for (i = 0; i<NR_OF_BUTTONS; i ++) {
        button_t * b = przyciski [i];
        uint8_t state = * b->port & (1<<b->pin);
        if (state) {
            // Nasycenie 32-bitowego dodawania bez znaku
            // Twój procesor może mieć odpowiednią instrukcję, np .: arm __uqadd (a, b))
            if (b->hi_time < 0xFFFFFFFF) b->hi_time + = BUTTON_INTERVAL;
        }jeszcze{
            b->hi_time = 0;
        }
        // Jedno z wielu możliwych porównań flag:
        if (b->hi_time > = 5000) {
            b->flags | = BUTTON_HI_5S;
        }
    }
}

/ * Przykład użycia flagi * /
void waitForButton () {
    if (button [0] ->flags & BUTTON_HI_5S) {
        przycisk [0] ->flags & = ~ BUTTON_HI_5S;
// ..stuff ..
    }
}
 

Najważniejsze punkty, jeśli wybierasz się sam:
- Struktura dla wszystkich danych, jeśli chcesz, możesz nawet zmieniać mapowanie kluczy w locie.
- Nieskończone przyciski za pomocą struktur.Nigdy więcej nie pisz tego kodu!
- Zegary nasycające, nie przepełniają.
- Flagi, łatwe do wymiany na wywołania systemu operacyjnego.

Jeśli dobrze rozumiem Twoje potrzeby, potrzebujesz czegoś takiego:

  void SwitchCheck (void)
{
    DebounceTimer = false; // Jeśli używasz flagi timera
    if (currentButton)
        {
        debounce ++;
        }
    jeszcze
        {
        if (odbij > NORMAL_OPERATION)
              {
              // Rób tutaj normalne rzeczy
              }
        debounce = 0;
        }
    if (debounce == MAX_TIMEOUT)
         {
         // Zrób swoją trzymaną tutaj rzecz
         }
}
 

Nazwij to z głównej pętli. Najlepiej wywołać to dopiero po poprawnym ustawieniu przerwania timera, aby uzyskać dokładny czas.

Przez lata robiłem wiele, wiele razy wyłączanie przełączników bez timerów (chociaż nie tak naprawdę), po prostu dzwoniąc z głównej pętli i działa. Jeśli jednak szukasz dokładności w swoim pięciosekundowym pomiarze czasu, to nie wystarczy.

Dalsza edycja:

W ISR Twojego timera:

  TimerISR ()
{
DebounceTimer = true;
// Inne rzeczy
}
 

Głównie:

  if (DebounceTimer)
    SwitchCheck ();
 

Lub po prostu wywołaj to z main bez sprawdzania flagi, czy nie używasz timera, i eksperymentuj empirycznie z MAX_TIMEOUT.