STM32 Mbed CodeIDE (2/8): sequências de LED e temporização

Uma única piscada prova que a placa é programável; um padrão temporizado de LEDs pode transmitir informações, como uma varredura de inicialização, uma sequência de aviso ou um código de status. A ideia importante não é apenas “acender LEDs”: a ordem do código e os intervalos de espera se transformam em comportamento visível no hardware.

Um microcontrolador segue exatamente a ordem do seu código. O programa abaixo usará chamadas auxiliares como led_on(led1) para que o código seja parecido com a ação física que você deseja ver.

Se você escrever:

led_on(led1);
ThisThread::sleep_for(500ms);
led_on(led2);

então LED 1 deve ligar antes de LED 2.
LED 1 permanecerá ligado enquanto LED 2 estiver ligado, porque o código ainda não chamou led_off(led1).

Esta lição usa três pinos de saída Mbed disponíveis no laboratório STM32 WB55RG:

- PB_13
- PB_14
- PB_15

Essas são saídas para LEDs verdes na placa de treinamento. Nos exemplos locais do CodeIDE com Mbed, elas são ativas em nível baixo: escrever 0 acende o LED e escrever 1 o apaga. Por isso, o código inicial usa funções auxiliares em vez de exigir que você memorize a polaridade bruta de 0/1.

Em Mbed, cada linha DigitalOut cria um objeto de saída conectado a um pino STM32. O objeto mantém seu último valor enquanto o programa espera, então ThisThread::sleep_for(500ms) pausa o código sem apagar o estado LED que você acabou de definir.

Use este mapeamento ao comparar seu código com a câmera:

- led1 = PB_13 = LED verde mais à esquerda no grupo de três LEDs.
- led2 = PB_14 = LED verde central nesse grupo.
- led3 = PB_15 = LED verde mais à direita nesse grupo.

No cabeçalho do auxiliar DigitalOut &led, o & significa que o auxiliar funciona no objeto LED real que você passa, não em uma cópia. Em 500ms, ms significa milissegundos.

Planeje duas compilações e cerca de 20 minutos de laboratório ativo. A compilação 1 usa a ordem da esquerda para a direita e 500ms; a compilação 2 altera apenas step_delay para 250ms ou 1000ms. Enquanto estiver na fila, responda à pergunta sobre o padrão cumulativo, escolha o segundo intervalo e escreva a ordem esperada.

O código inicial contém exatamente quatro marcadores que impedem a compilação. Substitua os TODOs 1–4 antes de salvar ou compilar. Procure por TODO; um arquivo pronto não deve apresentar correspondências.

#include "mbed.h"

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);
}

int main() {
    // 1: substitua o espaço reservado de tempo por 500 ms para compilação 1.
    const auto step_delay = TODO_STEP_DELAY;
    const auto reset_delay = 1000ms;
    all_off();

    while (true) {
        // 2-4: escolha cada LED uma vez para fazer uma ordem da esquerda para a direita.
        led_on(TODO_FIRST_LED);
        ThisThread::sleep_for(step_delay);

        led_on(TODO_SECOND_LED);
        ThisThread::sleep_for(step_delay);

        led_on(TODO_THIRD_LED);
        ThisThread::sleep_for(reset_delay);

        all_off();
        ThisThread::sleep_for(reset_delay);
    }
}

Registre separadamente as duas versões testadas. Como o código inicial mantém os LEDs anteriores acesos até executar all_off(), a sequência visível esperada é cumulativa: LED 1 aceso → LEDs 1+2 acesos → LEDs 1+2+3 acesos → todos apagados.

Mantenha a ordem TODO da esquerda para a direita no arquivo final. Sua única alteração na segunda compilação é a escolha do tempo: 250ms fornece uma comparação mais rápida; 1000ms oferece uma comparação mais lenta e fácil de usar. Ambos são válidos se as evidências corresponderem.