Debouncing as a state machine in Embedded C

Introduction

Debouncing helps to ignore quick, unwanted changes in a button press. Using a state machine makes it easy to track button states clearly and avoid mistakes.

When reading a button press on a microcontroller to avoid false triggers.

When you want to detect a clean press and release of a switch.

When you need reliable input from mechanical buttons in an embedded system.

Syntax

Embedded C

typedef enum {
    BUTTON_RELEASED,
    BUTTON_DEBOUNCE_PRESS,
    BUTTON_PRESSED,
    BUTTON_DEBOUNCE_RELEASE
} ButtonState;

ButtonState state = BUTTON_RELEASED;

void updateButtonState(int buttonInput) {
    switch(state) {
        case BUTTON_RELEASED:
            if(buttonInput == 1) {
                state = BUTTON_DEBOUNCE_PRESS;
                // start debounce timer
            }
            break;
        case BUTTON_DEBOUNCE_PRESS:
            if(debounce_time_passed()) {
                if(buttonInput == 1) {
                    state = BUTTON_PRESSED;
                    // button confirmed pressed
                } else {
                    state = BUTTON_RELEASED;
                }
            }
            break;
        case BUTTON_PRESSED:
            if(buttonInput == 0) {
                state = BUTTON_DEBOUNCE_RELEASE;
                // start debounce timer
            }
            break;
        case BUTTON_DEBOUNCE_RELEASE:
            if(debounce_time_passed()) {
                if(buttonInput == 0) {
                    state = BUTTON_RELEASED;
                    // button confirmed released
                } else {
                    state = BUTTON_PRESSED;
                }
            }
            break;
    }
}

The state machine uses four states to track button press and release.

Debounce timers help confirm the button state after a short delay.

Examples

A simple state machine without debounce timers, just toggling states.

Embedded C

typedef enum { BUTTON_RELEASED, BUTTON_PRESSED } ButtonState;

ButtonState state = BUTTON_RELEASED;

void updateButtonState(int buttonInput) {
    if(state == BUTTON_RELEASED && buttonInput == 1) {
        state = BUTTON_PRESSED;
    } else if(state == BUTTON_PRESSED && buttonInput == 0) {
        state = BUTTON_RELEASED;
    }
}

State machine with debounce only on press, release is immediate.

Embedded C

typedef enum {
    BUTTON_RELEASED,
    BUTTON_DEBOUNCE_PRESS,
    BUTTON_PRESSED
} ButtonState;

ButtonState state = BUTTON_RELEASED;

void updateButtonState(int buttonInput) {
    switch(state) {
        case BUTTON_RELEASED:
            if(buttonInput == 1) {
                state = BUTTON_DEBOUNCE_PRESS;
                // start debounce timer
            }
            break;
        case BUTTON_DEBOUNCE_PRESS:
            if(debounce_time_passed()) {
                if(buttonInput == 1) {
                    state = BUTTON_PRESSED;
                } else {
                    state = BUTTON_RELEASED;
                }
            }
            break;
        case BUTTON_PRESSED:
            if(buttonInput == 0) {
                state = BUTTON_RELEASED;
            }
            break;
    }
}

Sample Program

This program simulates a button being pressed and released with debounce using a state machine. It prints messages when debounce starts and when button states are confirmed.

Embedded C

#include <stdio.h>
#include <stdbool.h>

typedef enum {
    BUTTON_RELEASED,
    BUTTON_DEBOUNCE_PRESS,
    BUTTON_PRESSED,
    BUTTON_DEBOUNCE_RELEASE
} ButtonState;

ButtonState state = BUTTON_RELEASED;

// Simulated debounce timer counter
int debounce_counter = 0;
const int debounce_threshold = 3; // number of cycles to confirm

// Simulated function to check if debounce time passed
bool debounce_time_passed() {
    return debounce_counter >= debounce_threshold;
}

void updateButtonState(int buttonInput) {
    switch(state) {
        case BUTTON_RELEASED:
            if(buttonInput == 1) {
                state = BUTTON_DEBOUNCE_PRESS;
                debounce_counter = 0;
                printf("Start debounce press\n");
            }
            break;
        case BUTTON_DEBOUNCE_PRESS:
            debounce_counter++;
            if(debounce_time_passed()) {
                if(buttonInput == 1) {
                    state = BUTTON_PRESSED;
                    printf("Button pressed confirmed\n");
                } else {
                    state = BUTTON_RELEASED;
                    printf("False press, back to released\n");
                }
            }
            break;
        case BUTTON_PRESSED:
            if(buttonInput == 0) {
                state = BUTTON_DEBOUNCE_RELEASE;
                debounce_counter = 0;
                printf("Start debounce release\n");
            }
            break;
        case BUTTON_DEBOUNCE_RELEASE:
            debounce_counter++;
            if(debounce_time_passed()) {
                if(buttonInput == 0) {
                    state = BUTTON_RELEASED;
                    printf("Button released confirmed\n");
                } else {
                    state = BUTTON_PRESSED;
                    printf("False release, back to pressed\n");
                }
            }
            break;
    }
}

int main() {
    // Simulated button input sequence: 0 means not pressed, 1 means pressed
    int inputs[] = {0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0};
    int len = sizeof(inputs) / sizeof(inputs[0]);

    for(int i = 0; i < len; i++) {
        printf("Input: %d, State: %d\n", inputs[i], state);
        updateButtonState(inputs[i]);
    }

    return 0;
}

Important Notes

Debounce timers prevent quick, noisy changes from triggering false button presses.

State machines make the logic clear and easy to follow.

Adjust debounce time based on your hardware's noise level.

Summary

Debouncing avoids false button triggers caused by mechanical noise.

Using a state machine helps track button states step-by-step.

Timers confirm the button state before changing it.

Practice

1.

What is the main purpose of using debouncing in embedded C button handling?

easy

A. To avoid false triggers caused by mechanical noise

B. To speed up button press detection

C. To reduce power consumption

D. To increase button press sensitivity

Solution

1. Step 1: Understand mechanical noise in buttons

   Mechanical buttons can create multiple rapid on/off signals when pressed or released, called noise.

2. Step 2: Purpose of debouncing

   Debouncing filters out these rapid changes to detect a single clean press or release.

3. Final Answer:

   To avoid false triggers caused by mechanical noise -> Option A

4. Quick Check:

   Debouncing = Avoid false triggers [OK]

Hint: Debouncing stops noisy signals from causing multiple presses [OK]

Common Mistakes:

• Thinking debouncing speeds up detection
• Confusing debouncing with power saving
• Assuming it increases sensitivity

2.

Which of the following is the correct way to declare a state variable for a debounce state machine in embedded C?

?

easy

A. char state = 0;

B. int state = "IDLE";

C. enum ButtonState {IDLE, DEBOUNCE, PRESSED}; ButtonState state = IDLE;

D. bool state = false;

Solution

1. Step 1: Identify proper state variable type

   Using an enum clearly names states and improves code readability.

2. Step 2: Check syntax correctness

   enum ButtonState {IDLE, DEBOUNCE, PRESSED}; ButtonState state = IDLE; correctly declares an enum and initializes the state variable.

3. Final Answer:

   enum ButtonState {IDLE, DEBOUNCE, PRESSED}; ButtonState state = IDLE; -> Option C

4. Quick Check:

   Enum for states = enum ButtonState {IDLE, DEBOUNCE, PRESSED}; ButtonState state = IDLE; [OK]

Hint: Use enum for clear, readable state variables [OK]

Common Mistakes:

• Assigning string to int variable
• Using bool for multiple states
• Using char without clear meaning

3.

Given this snippet of a debounce state machine, what will be the value of state after 3 calls if the button is pressed and held?

enum State {IDLE, DEBOUNCE, PRESSED};
State state = IDLE;
int timer = 0;

void update(bool buttonPressed) {
  switch(state) {
    case IDLE:
      if(buttonPressed) {
        state = DEBOUNCE;
        timer = 2;
      }
      break;
    case DEBOUNCE:
      if(timer > 0) timer--;
      else state = PRESSED;
      break;
    case PRESSED:
      if(!buttonPressed) state = IDLE;
      break;
  }
}

// Calls:
update(true);
update(true);
update(true);

medium

A. PRESSED

B. Undefined

C. IDLE

D. DEBOUNCE

Solution

1. Step 1: Trace state changes through calls

   First call: state IDLE -> DEBOUNCE, timer=2. Second call: DEBOUNCE, timer=2>0, timer-- to 1, still DEBOUNCE. Third call: DEBOUNCE, timer=1>0, timer-- to 0, still DEBOUNCE (else not executed).

2. Step 2: Confirm final state after 3 calls

   Button is still pressed, state=DEBOUNCE (timer=0 now, changes to PRESSED on next call).

3. Final Answer:

   DEBOUNCE -> Option D

4. Quick Check:

   Timer counts down, state changes only if timer==0 at start of DEBOUNCE [OK]

Hint: Count timer ticks before state changes to PRESSED [OK]

Common Mistakes:

• Thinking PRESSED after exactly 3 calls
• Not decrementing timer
• Resetting state incorrectly

4.

Identify the bug in this debounce state machine code snippet:

enum State {IDLE, DEBOUNCE, PRESSED};
State state = IDLE;
int timer = 0;

void update(bool buttonPressed) {
  switch(state) {
    case IDLE:
      if(buttonPressed) {
        state = DEBOUNCE;
        timer = 3;
      }
      break;
    case DEBOUNCE:
      if(timer == 0) state = PRESSED;
      else timer--;
      break;
    case PRESSED:
      if(!buttonPressed) state = IDLE;
      break;
  }
}

What is the problem?

medium

A. State never changes from DEBOUNCE

B. Timer decrements after checking zero, causing one extra cycle

C. Timer is never initialized

D. Button press is ignored in PRESSED state

Solution

1. Step 1: Analyze timer decrement logic

   The code checks if timer == 0 before decrementing, so timer reaches 0 but state changes only next call.

2. Step 2: Identify effect on debounce timing

   This causes the debounce to last one extra cycle longer than intended.

3. Final Answer:

   Timer decrements after checking zero, causing one extra cycle -> Option B

4. Quick Check:

   Check timer before decrement causes delay [OK]

Hint: Decrement timer before zero check to fix timing [OK]

Common Mistakes:

• Thinking state never changes
• Ignoring timer initialization
• Assuming button ignored in PRESSED

5.

You want to implement a debounce state machine that only confirms a button press if the button is held for at least 5 cycles. Which approach below correctly implements this behavior?

enum State {IDLE, DEBOUNCE, PRESSED};
State state = IDLE;
int timer = 0;

void update(bool buttonPressed) {
  switch(state) {
    case IDLE:
      if(buttonPressed) {
        state = DEBOUNCE;
        timer = 5;
      }
      break;
    case DEBOUNCE:
      if(buttonPressed) {
        if(timer > 0) timer--;
        else state = PRESSED;
      } else {
        state = IDLE;
      }
      break;
    case PRESSED:
      if(!buttonPressed) state = IDLE;
      break;
  }
}

What happens if the button is pressed for 3 cycles then released?

hard

A. State returns to IDLE without reaching PRESSED

B. State changes to PRESSED after 3 cycles

C. State stays in DEBOUNCE indefinitely

D. State immediately changes to PRESSED on press

Solution

1. Step 1: Trace timer decrement with button held 3 cycles

   Timer starts at 5, decrements each cycle while buttonPressed is true, so after 3 cycles timer = 2.

2. Step 2: Button released before timer reaches zero

   On release, state immediately returns to IDLE without reaching PRESSED.

3. Final Answer:

   State returns to IDLE without reaching PRESSED -> Option A

4. Quick Check:

   Hold less than 5 cycles resets state [OK]

Hint: Hold button full timer cycles to reach PRESSED [OK]

Common Mistakes:

• Assuming PRESSED reached early
• Thinking DEBOUNCE lasts indefinitely
• Believing immediate PRESSED on press