Está piscando

Delaying

Agora vamos dar uma breve olhada nas abstrações de delay fornecidas pelo embedded-hal antes de combiná-las com as abstrações de GPIO do capítulo anterior para finalmente fazer um LED piscar.

O embedded-hal nos fornece duas abstrações para atrasar a execução do nosso programa: DelayUs e DelayMs. Ambas funcionam exatamente da mesma forma, exceto pelo fato de aceitarem unidades diferentes para sua função de delay.

Dentro de nossa MCU, existem vários dos chamados "timers". Eles podem fazer várias coisas relacionadas ao tempo para nós, inclusive simplesmente pausar a execução do nosso programa por um período fixo de tempo. Um programa muito simples baseado em delay que imprime algo a cada segundo pode, por exemplo, ser semelhante a isso:

#![deny(unsafe_code)]
#![no_main]
#![no_std]

use cortex_m_rt::entry;
use rtt_target::{rtt_init_print, rprintln};
use panic_rtt_target as _;
use microbit::board::Board;
use microbit::hal::timer::Timer;
use microbit::hal::prelude::*;

#[entry]
fn main() -> ! {
    rtt_init_print!();
    let mut board = Board::take().unwrap();

    let mut timer = Timer::new(board.TIMER0);

    loop {
        timer.delay_ms(1000u16);
        rprintln!("1000 ms passed");
    }
}

Observe que alteramos nossa implementação de pânico de panic_halt para panic_rtt_target aqui. Isso exigirá que você descomente as duas linhas RTT do arquivo Cargo.toml e comentar a linha panic-halt, já que o Rust permite apenas uma implementação de pânico por vez.

Para realmente ver o que foi imprimido, temos que alterar o Embed.toml da seguinte forma:

[default.general]
# chip = "nrf52833_xxAA" # uncomment this line for micro:bit V2
# chip = "nrf51822_xxAA" # uncomment this line for micro:bit V1

[default.reset]
halt_afterwards = false

[default.rtt]
enabled = true

[default.gdb]
enabled = false

E agora, após colocar o código em src/main.rs e executar outro rápido cargo embed (novamente com os mesmos sinalizadores que você usou antes) você deverá ver "1000 ms passed" sendo enviado ao seu console a cada segundo a partir da MCU.

Piscando

Agora chegamos ao ponto em que podemos combinar nosso novo conhecimento sobre GPIO e abstrações de delay para realmente fazer um LED na parte traseira do micro:bit piscar. O programa resultante é, na verdade, apenas uma mistura do programa acima com o programa que acendeu o LED na última seção e se parece com isso:

#![deny(unsafe_code)]
#![no_main]
#![no_std]

use cortex_m_rt::entry;
use rtt_target::{rtt_init_print, rprintln};
use panic_rtt_target as _;
use microbit::board::Board;
use microbit::hal::timer::Timer;
use microbit::hal::prelude::*;

#[entry]
fn main() -> ! {
    rtt_init_print!();
    let mut board = Board::take().unwrap();

    let mut timer = Timer::new(board.TIMER0);

    board.display_pins.col1.set_low().unwrap();
    let mut row1 = board.display_pins.row1;

    loop {
        row1.set_low().unwrap();
        rprintln!("Dark!");
        timer.delay_ms(1_000_u16);
        row1.set_high().unwrap();
        rprintln!("Light!");
        timer.delay_ms(1_000_u16);
    }
}

Depois de colocar o código em src/main.rs e executar um cargo embed final (com os sinalizadores adequados), você deverá ver o LED acender antes de piscar, bem como um print, toda vez que o LED mudar de desligado para ligado e vice-versa.