Debouncing as a state machine in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple debounce state machine

What is the output of this debounce state machine code when the input signal toggles rapidly?

Embedded C

#include <stdio.h>

#define DEBOUNCE_TIME 3

typedef enum {IDLE, DEBOUNCE} State;

int main() {
    int input[] = {0,1,0,1,1,1,1,0,0,0};
    int stable_output = 0;
    State state = IDLE;
    int counter = 0;

    for (int i = 0; i < 10; i++) {
        switch(state) {
            case IDLE:
                if (input[i] != stable_output) {
                    state = DEBOUNCE;
                    counter = 1;
                }
                break;
            case DEBOUNCE:
                if (input[i] == stable_output) {
                    state = IDLE;
                } else {
                    counter++;
                    if (counter >= DEBOUNCE_TIME) {
                        stable_output = input[i];
                        state = IDLE;
                    }
                }
                break;
        }
        printf("%d", stable_output);
    }
    return 0;
}

A 0001111000

B 0000000000

C 0111111111

D 0001111111

💡 Hint

Think about how the state machine waits for the input to be stable for 3 cycles before changing output.

The state machine changes the output only after the input stays different from the output for 3 consecutive cycles. The output starts at 0 and changes to 1 after the input is stable at 1 for 3 cycles, then back to 0 after stable 0 input.

🧠 Conceptual

intermediate

Understanding debounce state transitions

In a debounce state machine, what triggers the transition from the DEBOUNCE state back to the IDLE state without changing the output?

A Input signal changes to a new value different from stable output

B Output is forced to toggle regardless of input

C Debounce timer reaches zero

D Input signal matches the current stable output before debounce time is reached

💡 Hint

Think about what happens if the input bounces back to the stable value during debounce.

If the input returns to the stable output value before the debounce time completes, the state machine cancels the debounce and returns to IDLE without changing the output.

🔧 Debug

advanced

Identify the bug in debounce state machine code

What is the bug in this debounce state machine code snippet?

Embedded C

typedef enum {IDLE, DEBOUNCE} State;

int stable_output = 0;
State state = IDLE;
int counter = 0;

void update(int input) {
    switch(state) {
        case IDLE:
            if (input != stable_output) {
                state = DEBOUNCE;
                counter = 0;
            }
            break;
        case DEBOUNCE:
            if (input == stable_output) {
                state = IDLE;
            } else {
                counter++;
                if (counter >= 3) {
                    stable_output = input;
                    state = IDLE;
                }
            }
            break;
    }
}

A The condition 'counter > 3' should be 'counter >= 3' to debounce correctly

B The stable_output should be updated before changing state to IDLE

C Counter should start at 1, not 0, to count the first differing input

D The state should never return to IDLE once in DEBOUNCE

💡 Hint

Check the debounce time condition carefully.

The condition 'counter > 3' means the output changes after 4 counts, but debounce time is 3. It should be 'counter >= 3' to change output exactly after 3 counts.

📝 Syntax

advanced

Syntax error in debounce state machine code

Which option contains the syntax error in this debounce state machine snippet?

Embedded C

typedef enum {IDLE, DEBOUNCE} State;

int stable_output = 0;
State state = IDLE;
int counter = 0;

void update(int input) {
    switch(state) {
        case IDLE:
            if (input != stable_output) {
                state = DEBOUNCE;
                counter = 1;
            }
            break;
        case DEBOUNCE:
            if (input == stable_output) {
                state = IDLE;
            } else {
                counter++;
                if (counter >= 3) {
                    stable_output = input;
                    state = IDLE;
                }
            }
            break;
    }
}

A Incorrect enum declaration syntax

B Missing braces around if statement in case DEBOUNCE

C Missing semicolon after 'state = DEBOUNCE' in case IDLE

D Missing return type for update function

💡 Hint

Look carefully at the lines inside the switch cases.

The line 'state = DEBOUNCE' is missing a semicolon, causing a syntax error.

🚀 Application

expert

Number of stable output changes in debounce state machine

Given this input sequence and debounce time of 2, how many times does the stable output change?

int input[] = {0,1,1,0,0,1,1,1,0,0};
int debounce_time = 2;

A 5

B 3

C 4

D 2

💡 Hint

Count how many times the input stays stable for 2 cycles before output changes.

The output changes 3 times: from 0 to 1 after input stable at 1 for 2 cycles, back to 0 after stable 0, then again to 1 after stable 1.