Chống rung nút bấm

/* Chương trình chứng minh hiện tượng: đếm mọi cạnh xuống. */
#include "gpio.h"

static volatile uint32_t so_canh = 0;
static uint8_t truoc = 1;

int main(void)
{
    gpio_cau_hinh(GPIOC, 13, GPIO_VAO, GPIO_KEO_LEN);
    uart_khoi_tao();

    for (;;) {
        uint8_t hien = gpio_doc(GPIOC, 13);

        if (truoc == 1 && hien == 0) {      /* cạnh xuống */
            ++so_canh;
            uart_in_uint(so_canh);
            uart_gui_chuoi("\r\n");
        }

        truoc = hien;
    }
}

#ifndef DEBOUNCE_H
#define DEBOUNCE_H

#include <stdint.h>

#include "stm32f4.h"

typedef struct {
    GPIO_TypeDef *cong;
    uint8_t       chan;
    uint8_t       muc_nhan;     /* mức điện áp tương ứng với nhấn */
    uint8_t       on_dinh;      /* trạng thái đã lọc */
    uint8_t       tho_truoc;    /* lần đọc thô gần nhất */
    uint32_t      moc;          /* thời điểm lần đổi thô cuối */
    uint16_t      nguong_ms;
} Nut;

void    nut_khoi_tao(Nut *n, GPIO_TypeDef *cong, uint8_t chan,
                     uint8_t muc_nhan, uint16_t nguong_ms);
uint8_t nut_cap_nhat(Nut *n, uint32_t tick_ms);

#endif

#include "debounce.h"
#include "gpio.h"

void nut_khoi_tao(Nut *n, GPIO_TypeDef *cong, uint8_t chan,
                  uint8_t muc_nhan, uint16_t nguong_ms)
{
    n->cong      = cong;
    n->chan      = chan;
    n->muc_nhan  = muc_nhan;
    n->nguong_ms = nguong_ms;

    gpio_cau_hinh(cong, chan, GPIO_VAO,
                  muc_nhan ? GPIO_KEO_XUONG : GPIO_KEO_LEN);

    n->tho_truoc = gpio_doc(cong, chan);
    n->on_dinh   = n->tho_truoc;
    n->moc       = 0u;
}

/* Gọi thường xuyên từ vòng lặp chính. Trả về 1 nếu trạng thái
   ổn định vừa THAY ĐỔI, tức có một sự kiện nhấn hoặc nhả. */
uint8_t nut_cap_nhat(Nut *n, uint32_t tick_ms)
{
    uint8_t tho = gpio_doc(n->cong, n->chan);

    if (tho != n->tho_truoc) {
        /* Tín hiệu thô vừa đổi: bấm lại đồng hồ, chưa tin gì cả */
        n->tho_truoc = tho;
        n->moc       = tick_ms;

        return 0u;
    }

    /* Tín hiệu thô giữ nguyên. Đã đủ lâu chưa? */
    if (tho != n->on_dinh && (tick_ms - n->moc) >= n->nguong_ms) {
        n->on_dinh = tho;

        return 1u;      /* có sự kiện */
    }

    return 0u;
}

/* Trạng thái đã lọc, dùng khi cần biết nút đang giữ hay không */
static inline uint8_t nut_dang_nhan(const Nut *n)
{
    return n->on_dinh == n->muc_nhan;
}

#include "debounce.h"
#include "gpio.h"
#include "systick.h"

int main(void)
{
    Nut     nut;
    uint8_t che_do = 0u;

    systick_khoi_tao();                   /* tick 1 ms, xem Bài 50.1 */
    gpio_cau_hinh(GPIOA, 5, GPIO_RA, GPIO_KHONG_KEO);
    nut_khoi_tao(&nut, GPIOC, 13, 0u, 20u);   /* nhấn là mức 0, ngưỡng 20 ms */

    for (;;) {
        uint32_t nay = systick_lay_tick();

        if (nut_cap_nhat(&nut, nay) && nut_dang_nhan(&nut)) {
            che_do = (uint8_t)((che_do + 1u) % 3u);
            uart_in_uint(che_do);
        }

        /* Vòng lặp chính vẫn làm việc khác, không bị chặn */
        cap_nhat_den(che_do, nay);
    }
}

typedef enum {
    NUT_KHONG_GI = 0,
    NUT_NHAN,
    NUT_NHA,
    NUT_NHAN_NGAN,
    NUT_NHAN_GIU,
} SuKienNut;

typedef struct {
    Nut      loc;
    uint32_t moc_nhan;
    uint8_t  da_bao_giu;
    uint16_t nguong_giu_ms;
} NutDayDu;

SuKienNut nut_su_kien(NutDayDu *n, uint32_t nay)
{
    uint8_t doi = nut_cap_nhat(&n->loc, nay);

    if (doi) {
        if (nut_dang_nhan(&n->loc)) {
            n->moc_nhan   = nay;
            n->da_bao_giu = 0u;

            return NUT_NHAN;
        }

        /* Vừa nhả. Nếu chưa báo giữ thì đây là một lần nhấn ngắn. */
        if (!n->da_bao_giu) return NUT_NHAN_NGAN;

        return NUT_NHA;
    }

    /* Không đổi trạng thái, nhưng có thể đã giữ đủ lâu */
    if (nut_dang_nhan(&n->loc) && !n->da_bao_giu &&
        (nay - n->moc_nhan) >= n->nguong_giu_ms) {
        n->da_bao_giu = 1u;

        return NUT_NHAN_GIU;
    }

    return NUT_KHONG_GI;
}

/* Mạch: nút nối chân xuống đất, điện trở kéo lên R, tụ C nối chân xuống đất.

   Hằng số thời gian:  tau = R * C

   Muốn lọc rung 20 ms thì cần tau khoảng 10 ms.

   Chọn R = 10 kilo ohm, C = 1 micro farad:
     tau = 10000 * 0.000001 = 0.01 s = 10 ms

   Thời gian nạp tới ngưỡng logic cao, khoảng 0.7 * Vcc:
     t = tau * ln(1 / (1 - 0.7)) = 10 * 1.2 = 12 ms

   Đủ để bỏ qua rung 5 tới 20 ms, và người dùng không cảm nhận được. */

/* Gọi từ ngắt định thời 1 ms. Giữ lịch sử 8 lần đọc gần nhất
   trong một byte, và chỉ đổi trạng thái khi cả 8 lần giống nhau. */
static uint8_t lich_su = 0xFFu;
static uint8_t on_dinh = 1u;

void SysTick_Handler(void)
{
    lich_su = (uint8_t)((lich_su << 1) | gpio_doc(GPIOC, 13));

    if      (lich_su == 0x00u) on_dinh = 0u;      /* 8 lần liên tiếp là 0 */
    else if (lich_su == 0xFFu) on_dinh = 1u;      /* 8 lần liên tiếp là 1 */
    /* Ngoài hai trường hợp đó thì giữ nguyên, tức đang rung */
}