Je test pour vous : la prime de 1000€ pour un vélo cargo

Alors voila, je viens de me rendre compte que je suis potentiellement éligible pour la prime de 1k€ à l’achat d’un vélo cargo. Si l’état propose autant d’argent pour ces pouilleux de cyclistes, c’est qu’il doit y avoir un loup non ?

Voyons voir.

Déjà cette prime n’est que pour les pauvres, car il faut gagner moins de 13 489 € par part imposable. Bref le SMIC quoi !

Noter que pour siphonner plus de 5k€ à l’achat d’une bagnole électrique l’état ne donne pas de condition de ressources. Pas de problème pour prendre sur mes impôts et payer une seconde bagnole à madame à coté du SUV de monsieur.

Formulaire en ligne

Comme c’est pour les pauvres évidemment il ne faut pas s’attendre à de la simplicité administrative hé ça va !

Super, il y a un formulaire pour faire sa demande en ligne directement ! Mais seulement si vous êtes sous W$:

Pas de microsoft, bin t’es bon pour te farcir des frais postaux

Je suis donc bon pour imprimer la demi-douzaine de papiers demandés pour être bien sûr que je suis pauvre et que je n’ai pas volé la marchandise.

Publié dans Non classé | Marqué avec , , | Laisser un commentaire

Rhaaa python :

In [6]: hex(1<<31)                                                                                                                                                                                                 
Out[6]: '0x80000000'

In [7]: hex(1<<31 + 1)                                                                                                                                                                                             
Out[7]: '0x100000000'

Le décalage binaire est moins prioritaire que l’addition. Noubliez pas les parenthèses :

In [8]: hex((1<<31) + 1)                                                                                                                                                                                           
Out[8]: '0x80000001'

Publié le par admin | Laisser un commentaire

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.

Publié dans Non classé | Marqué avec , , , , | Laisser un commentaire

Rust sur Longan Nano

La Longan Nano est une petite carte de la taille d’un pouce munie d’un microcontrôleur à cœur RISC-V le GD32VF103CBT6. Processeur qui est un clone du fameux stm32 de chez ST, MAIS avec un cœur RISC-V (alors que le stm32 est à base de ARM).

Ce qui est bien avec la Longan Nano c’est que pour $4.90 il y a absolument tout pour faire du développement embarqué: en plus de l’écran oled couleurs et la LED RGB il y a une interface USB (connecteur usb-c) qui permet d’alimenter la carte, la programmer et communiquer par UART. Pour le JTAG par contre il faut un adaptateur externe qui peut cependant être très pratique pour utiliser un debugger.

Ce qui est moins bien par contre c’est qu’elle semble en rupture de stock depuis longtemps.

Bref, c’est une «vieille» carte mais qui est parfaite pour faire du développement embarqué sans rien d’autre qu’un PC et un câble USB.

Pourquoi ne pas tenter de faire du Rust avec alors ? En plus il semble exister des projets de support du langage pour cette carte. Voila qui pourrait démystifier rust pour l’embarqué !

Codons mon bon

La documentation officielle de la cagette nous demande de vérifier la version de rust :

$ rustup default stable
info: using existing install for 'stable-x86_64-unknown-linux-gnu'
info: default toolchain set to 'stable-x86_64-unknown-linux-gnu'

  stable-x86_64-unknown-linux-gnu unchanged - rustc 1.58.0 (02072b482 2022-01-11)

Version 1.58, c’est bon on est supérieur à la 1.36 requise. Comme je veux travailler avec juste le câble usb j’utiliserais (ou tenterais d’utiliser) dfu-util pour programmer le micro.

Il faut juste se compiler une version des binutils comme indiqué dans la doc pour avoir l’utilitaire objcopy :

$ git clone https://github.com/sifive/riscv-binutils-gdb.git
$ cd riscv-binutils-gdb
$ ./configure --target=riscv64-unknown-elf --disable-werror --with-python=no --disable-gdb --disable-sim --disable-libdecnumber --disable-libreadline --with-expat=yes --with-mpc=no --with-mpfr=no --with-gmp=no
$ make

Ça prend un peut de temps avec ma vieille machine (T430) mais ça marche.

On aura également besoin d’une toolchain riscv:

$ wget https://static.dev.sifive.com/dev-tools/riscv64-unknown-elf-gcc-8.1.0-2019.01.0-x86_64-linux-ubuntu14.tar.gz
$ tar zxvf riscv64-unknown-elf-gcc-8.1.0-2019.01.0-x86_64-linux-ubuntu14.tar.gz

Et bien entendu, il faudra «descendre» le projet git hub d’exeexamplesmple:

$ git clone https://github.com/riscv-rust/longan-nano.git

Puisque visiblement j’ai une version B du microcontrôleur il faut modifier le fichier de configuration .cargo/config.

Et c’est parti mamie :

$ cargo build --examples --release --all-features

On extrait maintenant l’huile essentiel de notre binaire avec objcopy que l’on appelera firmware.bin :

../riscv64-unknown-elf-gcc-8.1.0-2019.01.0-x86_64-linux-ubuntu14/bin/riscv64-unknown-elf-objcopy -O binary target/riscv32imac-unknown-none-elf/release/examples/blinky firmware.bin

Puis on le télécharge dans la carte au moyen de dfu-util en ayant bien pris soin de mettre le microcontrôleur en mode «bootstrap» ( appui sur reset tout en gardant boot0 pressé).

$  dfu-util -a 0 -s 0x08000000:leave -D firmware.bin
dfu-util 0.10-dev

Copyright 2005-2009 Weston Schmidt, Harald Welte and OpenMoko Inc.
Copyright 2010-2021 Tormod Volden and Stefan Schmidt
This program is Free Software and has ABSOLUTELY NO WARRANTY
Please report bugs to http://sourceforge.net/p/dfu-util/tickets/

dfu-util: Warning: Invalid DFU suffix signature
dfu-util: A valid DFU suffix will be required in a future dfu-util release
dfu-util: Cannot open DFU device 0a5c:21e6 found on devnum 3 (LIBUSB_ERROR_ACCESS)
Opening DFU capable USB device...
Device ID 28e9:0189
Device DFU version 011a
Claiming USB DFU Interface...
Setting Alternate Interface #0 ...
Determining device status...
DFU state(2) = dfuIDLE, status(0) = No error condition is present
DFU mode device DFU version 011a
Device returned transfer size 2048
DfuSe interface name: "Internal Flash  "
Found GD32VF103, which reports a bad page size and count for its internal memory.
Fixed layout based on part number: page size 1024, count 128.
Downloading element to address = 0x08000000, size = 9388
Erase   	[=========================] 100%         9388 bytes
Erase    done.
Download	[=========================] 100%         9388 bytes
Download done.
File downloaded successfully

Et la led clignote \o/ !

Le code

Le code à proprement parler du clignotement de led est donné dans le fichier examples/blinky.rs

Et le cœur de la boucle de clignotement est donnée ci-dessous :

    let mut i = 0;
    loop {
        let inext = (i + 1) % leds.len();
        leds[i].off();
        leds[inext].on();
        delay.delay_ms(500);

        i = inext;
    }

Il y a trois leds (RGB), on se sert de l’index i pour parcourir le tableau de leds. On éteint la led courante puis on allume la suivante et on attend 500ms.

De cette manière, la led va changer de couleur toutes les demi-seconde et nous offrir un clignotement tricolore.

Si l’on trouve le clignotement on/off un peu trop violent, on peut, comme exercice faire en sorte que la couleurs s’allume et s’éteigne progressivement avec un code de ce genre :

    leds[0].off();
    leds[1].off();
    leds[2].off();

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

    loop {
        leds[i].on();
        delay.delay_us(count);
        leds[i].off();
        delay.delay_us(count_max - count);
        if decount {
            if count == 0 {
                decount = false;
                i = (i + 1) % leds.len();
            } else {
                count = count - 1;
            }
        } else {
            if count < count_max {
                count = count + 1;
            }else{
                decount = true;
            }
        }
    }

On aura bien pris soin de descendre la granularité du délais à la microseconde puisque c’est disponible dans le HAL du microcontrôleur (GD32VF103).

Voila un clignotement plus doux des LEDs. Et on se rend compte par la même occasion que la LED verte est nettement plus puissante que les deux autres.

Il y a d’autres exemples dans le git du projet, notamment pour utiliser le lecteur microSD ainsi que l’écran, mais je laisse le soin au lecteur de les découvrir par lui même 😉

Pour conclure, grâce à ce projet, la prise en main de la Longan Nano avec du Rust est vraiment simple et très peu verbeuse. J’avais eu beaucoup plus de mal à la prendre en main en C avec tout le bazar de platformio et vscode à l’époque. Mais c’est peut-être tout simplement parce que la carte est plus mature aujourd’hui aussi 😉

Ressources

Publié dans Non classé | Marqué avec , , | Laisser un commentaire

«Si vous avez besoin d’une aide, indiquez-le en respectant les consignes suivantes : Pour garder vos enfants, répondez GARD. Pour faire les courses, répondez COU. Si vous ne pouvez pas vous isoler dans votre logement, répondez LOG. Pour un autre problème non médical, répondez AUT»

Publié le par admin | Laisser un commentaire

Le web 2022 pue vraiment la merde. Sur le site d’information électronique cnx-software.com je regarde une vidéo de LED clignotantes sur un lecteur youtube embarqué.

Une fois la vidéo terminée youtube me fait des suggestions de trucs à visionner … jugez par vous même :

Publié le par admin | Laisser un commentaire

Un peu de «stop-motion» à la pâte à modeler

Les films en «stop-motion» en pâte à modeler sont des trucs rigolos à faire pour occuper des enfants quand il pleut. L’avantage de cette activité c’est qu’elle est (presque) sans écran. En effet, hormis l’appareil photo, pas besoin d’ordinateur pour toute la partie pâte à modeler. Et il est possible de visualiser le «film» en appuyant rapidement sur le bouton «suivant» de lecture des photos (tous les appareils photos numériques font ça).

Le matériel est finalement minimaliste, il suffit d’avoir:

  • Un appareil photo numérique, mais un téléphone avec une caméra fait également l’affaire.
  • avec de préférence un pied. On trouve des tri-pieds d’appareil photo sur le net à des prix tout à fait raisonnable.
  • de la pâte à modeler.
  • Un PC pour faire la «post-prod» (mais ça c’est sans les enfants après).

Dans un premier temps, je n’avais que de la vieille pâte à modeler grisâtre et à moitié sèche pour faire une limace. Il suffit donc de rouler un simple boudin de pâte à modeler, fixer l’appareil photo et ne plus le bouger, prendre une photo, bouger légèrement la limace, puis reprendre une photo, etc.

Quelques conseils, vous faite un film, pas besoin d’avoir une résolution de malade, préférez le réglage minimum pour la résolution. Parce que sinon ça donne des «vidéos» gigantesque.

De même, il est préférable d’enlever le flash. De toute manière, l’appareil photo est fixe donc vous pouvez faire des poses longue.

Pendant la prise de vue, on peut visualiser le «film» simplement en faisant défiler les photos. Suivant la puissance de l’appareil, on comprend l’intérêt d’avoir réglé la résolution au minimum : on évite les temps de chargement à la visualisation images par images.

Faire un GIF animé avec ImageMagick.

Les photos que vous aurez prises seront rangées avec un numéro d’incrément dans le répertoire de votre carte mémoire, ce qui va faciliter les manipulations avec ImageMagick.

Dans le cas de mon appareil photo, la résolution minimal est déjà énorme : 1600×1200. J’ai donc commencé par réduire en masse leurs tailles avec la commande (attention, la commande va modifier directement les photos, ne pas oublier de faire des copies de sauvegarde avant):

$ ls
DSCN1132.JPG  DSCN1138.JPG  DSCN1144.JPG  DSCN1150.JPG  DSCN1156.JPG  DSCN1162.JPG  DSCN1168.JPG  DSCN1174.JPG  DSCN1180.JPG  DSCN1186.JPG  DSCN1192.JPG  DSCN1198.JPG  DSCN1204.JPG  DSCN1210.JPG
DSCN1133.JPG  DSCN1139.JPG  DSCN1145.JPG  DSCN1151.JPG  DSCN1157.JPG  DSCN1163.JPG  DSCN1169.JPG  DSCN1175.JPG  DSCN1181.JPG  DSCN1187.JPG  DSCN1193.JPG  DSCN1199.JPG  DSCN1205.JPG  DSCN1211.JPG
DSCN1134.JPG  DSCN1140.JPG  DSCN1146.JPG  DSCN1152.JPG  DSCN1158.JPG  DSCN1164.JPG  DSCN1170.JPG  DSCN1176.JPG  DSCN1182.JPG  DSCN1188.JPG  DSCN1194.JPG  DSCN1200.JPG  DSCN1206.JPG
DSCN1135.JPG  DSCN1141.JPG  DSCN1147.JPG  DSCN1153.JPG  DSCN1159.JPG  DSCN1165.JPG  DSCN1171.JPG  DSCN1177.JPG  DSCN1183.JPG  DSCN1189.JPG  DSCN1195.JPG  DSCN1201.JPG  DSCN1207.JPG
DSCN1136.JPG  DSCN1142.JPG  DSCN1148.JPG  DSCN1154.JPG  DSCN1160.JPG  DSCN1166.JPG  DSCN1172.JPG  DSCN1178.JPG  DSCN1184.JPG  DSCN1190.JPG  DSCN1196.JPG  DSCN1202.JPG  DSCN1208.JPG
DSCN1137.JPG  DSCN1143.JPG  DSCN1149.JPG  DSCN1155.JPG  DSCN1161.JPG  DSCN1167.JPG  DSCN1173.JPG  DSCN1179.JPG  DSCN1185.JPG  DSCN1191.JPG  DSCN1197.JPG  DSCN1203.JPG  DSCN1209.JPG
$ mogrify -resize 320x240 *.JPG
$

Évidemment, il faudra avoir préalablement trié les photos pour qu’il ne reste que celle de la séquence voulue.

On peut ensuite faire un gif avec convert :

$ convert -loop 0 *.JPG pam_chenille.gif
Bientôt en sélection au festival du court métrage

Le résultat ci-dessus est tout de même obèse puisqu’on se retrouve avec un gif de 4Mo, mais il passe bien en pièce jointe de mail ou sur la messagerie signal 😉

Et pourquoi pas une vidéo avec ffmpeg et peertube ?

Le gif c’est sympa mais ça devient vite énorme, on ne peut pas faire pause et ça passe mal avec certain visualiseurs d’images. Pour la séquence suivante j’ai voulu tester la vidéo avec ffmpeg. C’est un petit peu plus compliqué de trouver la bonne combinaison d’options pour que ça marche avec les lecteurs de vidéo de messagerie mobile comme Signal (D’où cette note de blog pour me souvenir !).

Le premier épisode ayant été un succès international, j’ai eu le budget pour acheter de la pâte à modelée neuve avec plusieurs couleurs en plus !

Le scénario s’est en plus enrichi d’autres personnages en pâte à modeler pour plus d’aventures palpitantes. La limace a acquit une carapace d’escargot la bourgeoise !

Donc de la même manière que pour le Gif on se retrouve avec une liste de fichiers d’images JPG qu’il faut réduire :

$ convert -resize 50% *.JPG

Listes d’images que l’on peut convertir directement en vidéo mp4 grâce à la formule magique suivante :

$ ffmpeg -framerate 10 -i images/%2d.JPG -vcodec libx264 -crf 18 -pix_fmt yuv420p pam_escargot_serpent.mp4

Le fichier de sortie au format vidéo à l’avantage de pouvoir être stoppé, relancé, avancé, accéléré, etc. Grâce à son lecteur vidéo préféré.

L’intérêt d’une vidéo c’était l’occasion de tester le service de vidéo peertube, histoire de ne pas toujours tout publier sur youtube. Mais la publication avec wordpress directement fonctionne également

Aventure palpitante de l’escargot bicolore

Si le lecteur embarqué de peertube ne fonctionne pas, le fichier mp4 peut être visualisé sur le lecteur embarqué de wordpress tout simplement :

Les vidéos s’affichent très bien dans wordpress.

Et bien sûr, le fichier mp4 généré, qui ne fait que 4.5Mo, est parfaitement diffusable sur Signal ou par mail.

Voila, si vous souhaitez faire des vidéos en pâte à modeler, vous avez les commandes à utiliser.

Je parlerais peut être une autre fois de la version dessin :

[Edit] On en discute sur LinuxFR.

Publié dans dessin | Marqué avec , , , , | Laisser un commentaire

Starteupeuuur

Magnifique

Publié dans Non classé | Marqué avec , , , | Laisser un commentaire

La biodynamie: ensemble de pratiques agricoles conformes aux rites de l’église Anthroposophique.

Trouvé sur ce silo social :

Et aussi ici

Publié dans Non classé | Marqué avec , , , , , , | Laisser un commentaire

Livre sur le Scala

Pour apprendre un nouveau langage de programmation, j’utilise toujours la même méthode : Lire un livre (papier) de référence et commencer un projet en parallèle.

Cette méthode à fait ses preuves et fonctionne, à condition de choisir le bon livre.

Pour Scala, j’avais acquis le livre «Programming Scala» aux édition O’Reilly qui s’est avéré assez décevant. Le Scala est un langage qui mélange le paradigme fonctionnel avec le paradigme objet, il est nécessaire de «recommencer au début» pour se l’approprier. Ce livre suppose que l’on maîtrise déjà assez bien les deux paradigmes, ce qui est somme toute assez rare.

Plutôt que de s’adresser à ses adeptes il vaut mieux s’adresser au créateur directement : le suisse Martin Odersky avec le livre «Programming in Scala, Fourth edition» des éditions Artima. En partant de la base, ce livre donne de bien meilleurs base pour bien saisir le Scala et comprendre les différents codes que l’on peu avoir à lire.

Le livre de référence pour se mettre au Scala

Le livre est plus cher que celui de chez O’REILLY, mais il s’avérera un bien meilleurs investissement pour comprendre toutes les bases du langage.

Par contre je me rend compte que cette édition va bientôt être obsolète puisque la cinquième parait dans 6 jours. Édition qui portera sur la version 3.0 de Scala.

La version quatre reste cependant un bon investissement à mon avis.

Publié dans Non classé | Laisser un commentaire