Rust sur RP2040

Dans la continuité de la LED clignotante sur Longan Nano, pourquoi ne pas tester sur RP2040 puisque j’en ai une dans mon étagère ? En plus, il existe un projet tout prêt pour ça.

Alors allons y. On clone d’abord le projet :

$ git clone https://github.com/eterevsky/rp2040-blink.git
$ cd rp2040-blink/

On installe la chaîne de développement rust pour le RP2040 (Arm cortex-m0 et tous les trucs elf2uf2-rs):

$ rustup target install thumbv6m-none-eabi
info: downloading component 'rust-std' for 'thumbv6m-none-eabi'
info: installing component 'rust-std' for 'thumbv6m-none-eabi'
$ cargo install --locked elf2uf2-rs
    Updating crates.io index
  Downloaded elf2uf2-rs v1.3.7
  Downloaded 1 crate (51.1 KB) in 0.52s
  Installing elf2uf2-rs v1.3.7
warning: package `crossbeam-utils v0.8.5` in Cargo.lock is yanked in registry `crates-io`, consider running without --locked
...
   Compiling elf2uf2-rs v1.3.7
    Finished release [optimized] target(s) in 2m 06s
  Installing /home/fabien/.cargo/bin/elf2uf2-rs
   Installed package `elf2uf2-rs v1.3.7` (executable `elf2uf2-rs`)

Enfin on connecte la carte sur l’USB en laissant le bouton «BOOTSEL» appuyé pour lancer la compilation de l’exemple avec cargo:

$ cargo run --release
    Updating crates.io index
  Downloaded debug-helper v0.3.13
...
  Compiling rp2040-hal v0.3.0
    Finished release [optimized] target(s) in 41.66s
     Running `elf2uf2-rs -d -s target/thumbv6m-none-eabi/release/blink`
Found pico uf2 disk /media/fabien/RPI-RP2
Transfering program to pico
61.50 KB / 61.50 KB [=======================================================================================================================================================================] 100.00 % 122.27 KB/s 
Found pico serial on /dev/ttyACM0

Chez moi ça se bloque dans cet état. Pour lancer le programme il faut débrancher puis rebrancher la carte et … la LED clignote !

Alors, tout comme pour la Longan Nano, je dois dire que l’installation et l’utilisation des outils de crosscompilation et de téléchargement est géniale ! C’est très rapide, ça s’installe en très peu de commande. Et visiblement c’est complètement cross-platforme puisque la doc du projet de led clignotant indique que ça n’avait pas été testé sous Linux mais seulement W$ et pomme.

Par contre pour le moment nous n’avons pas vu une once de code rust. Il est temps de fourrer notre groin dans le code d’exemple pour pacifier un peu le clignotement de cette led.

Codons mon bon

Allumé, éteint, allumé, éteint, … c’est un peu violent. Voyons si nous pouvons faire quelque chose de plus progressif pour avoir un clignotement doux. Le code d’exemple est nettement plus long que celui que nous avions sur la Longan Nano. La raison principale étant que le programme intègre la gestion de l’USB en plus de la simple LED clignotante.

Pas besoin d’avoir des milliers d’heures de pratique pour trouver la boucle de clignotement cependant :

    loop {
        led_pin.set_high().unwrap();
        write!(usb, "On\n").unwrap();
        delay.delay_ms(500);

        led_pin.set_low().unwrap();
        write!(usb, "Off\n").unwrap();
        delay.delay_ms(500);
    }

Les macro «write!()» permettent d’écrire du texte sur le port uart émulé par l’usb.

À partir de là il est assez simple de modifier cette partie pour faire du soft-blink. Comme pour la Longan Nano, la documentation de la cagette cortex_m nous indique qu’il existe une manière d’attendre les µs : delay_us(). Le code va donc ressembler à s’y méprendre à celui de la Longan Nano :

    let count_max:u32 = 1000;
    let mut count:u32 = 0;
    let mut decount: bool = true;

    loop {
        // on
        led_pin.set_high().unwrap();
        delay.delay_us(count);
        // off
        led_pin.set_low().unwrap();
        delay.delay_us(count_max - count);
        if decount {
            if count == 0 {
                decount = false;
            } else {
                count = count - 1;
            }
        } else {
            if count < count_max {
                count = count + 1;
            }else{
                decount = true;
            }
        }
    }

On prendra bien soin de virer les messages on/off qui ralentissent prodigieusement le comptage du clignotement doux.

Et la LED clignote

Voila \o/

Pour conclure

Encore une fois, la mise en œuvre des outils pour programmer en Rust sur un microcontrôleur est d’une incroyable facilité et rapidité. Deux trois lignes de commandes (et un projet github qui va bien quand même 😉 et c’est plié !

Je suis encore très loin de maîtriser le langage, mais il m’a été extrêmement facile de trouver la bonne documentation pour avoir la fonction qui va bien de manière à améliorer l’exemple et faire un minimum «joujou» avec la machine.

Ce contenu a été publié dans Non classé, avec comme mot(s)-clé(s) , , , , . Vous pouvez le mettre en favoris avec ce permalien.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.