STM32 Mbed CodeIDE (3/8): buttons, pull-ups, and debounce

Inputs turn a fixed light pattern into a controller that responds to a person, switch, or sensor. You will first prove what the button reads when it is released and pressed, then add a simple debounce check so the program reacts to one real press instead of a noisy contact.

The CodeIDE guide lists PC_5, PC_6, and PC_10 among the button/sensor pins available in the STM32 WB55RG lab. This lesson uses PC_5 first and teaches you to verify the pressed value before building logic around it.

Many pull-up button circuits are active-low, meaning the pressed electrical level is lower than the released level. The lab wiring must still be measured before you put either value into control logic.

DigitalIn button(PC_5, PullUp);
int raw = button.read();

DigitalIn is the Mbed input object for reading a pin. PullUp asks Mbed to use the microcontroller's internal pull-up resistor, so the pin has a defined value when the button is released. button.read() returns the current 0/1 value at the moment your code calls it.

The remote lab UI has round button controls. In this lesson, use B1 for PC_5.

Plan for three builds and about 25 minutes of active lab time: probe, sequence, then one changed sequence delay. If queued, prepare the two observation fields and read TODOs 1-2 before the session starts.

#include "mbed.h"

DigitalIn button(PC_5, PullUp);
int main() {
    printf("Button probe start\n");

    while (true) {
        int raw = button.read();

        printf("button_raw=%d\n", raw);
        ThisThread::sleep_for(500ms);
    }
}

Record the released and pressed readings separately. Copy the exact button_raw number from the console.

Your copied serial lines should use observed values, not values supplied by the lesson:

button_raw=<released value observed>
button_raw=<pressed value observed>

Now use B1 to start a three-LED sequence. You will insert the pressed value measured in your own probe rather than copy an assumed value.

Mechanical buttons can bounce: during one press, the electrical signal may rapidly switch between 0 and 1 for a few milliseconds. Debouncing means waiting briefly and checking again so one physical press is not treated as several presses.

Three protections have different jobs:

- Debounce confirmation: wait 50 ms, sample again, and accept only if the second sample still equals the observed pressed value.
- Sequence lockout: run_sequence() is blocking, so input is not sampled while the LED sequence runs. This prevents a second start during the sequence; it is not debounce.
- Release re-arm: after the sequence, wait until the input differs from the pressed value before accepting another press. This prevents one held press from immediately starting again; it is also not debounce.

The starter has exactly two compile-blocking placeholders. TODO 1 uses your observed pressed value. TODO 2 must be a genuine second-sample rejection condition. Replace both and search for TODO before compiling.

#include "mbed.h"

DigitalIn button(PC_5, PullUp);
DigitalOut led1(PB_13, 1);
DigitalOut led2(PB_14, 1);
DigitalOut led3(PB_15, 1);

void led_on(DigitalOut &led) {
    led = 0;
}

void led_off(DigitalOut &led) {
    led = 1;
}

void all_off() {
    led_off(led1);
    led_off(led2);
    led_off(led3);
}

void run_sequence() {
    led_on(led1);
    ThisThread::sleep_for(500ms);
    led_on(led2);
    ThisThread::sleep_for(500ms);
    led_on(led3);
    ThisThread::sleep_for(2000ms);
    all_off();
}

int main() {
    // 1: replace with the exact pressed value observed in the probe.
    const int pressed_value = TODO_PRESSED_VALUE;
    all_off();
    printf("Button sequence start\n");

    while (true) {
        bool pressed = (button.read() == pressed_value);

        if (pressed) {
            ThisThread::sleep_for(50ms);
            // 2: reject the press if the second sample is not pressed.
            if (TODO_CONFIRM_CONDITION) {
                continue;
            }

            printf("press detected: running sequence\n");
            run_sequence();
            printf("sequence complete; release button\n");
            while (button.read() == pressed_value) {
                ThisThread::sleep_for(20ms);
            }
            printf("ready for next press\n");
        }

        ThisThread::sleep_for(20ms);
    }
}

Record three short sequence checks. Keep prediction and evidence separate.