Commutateur de sélection de démarrage matériel à l'aide de Pico

Pré-choisissez le système d'exploitation à démarrer, avant même d'allumer l'ordinateur en basculant un interrupteur. Vous n'avez plus besoin d'attendre pour sélectionner le système d'exploitation.

Histoire

En errant sur Hackaday.io pour des projets, je suis tombé sur ce projet(clic) de Stephen Holdaway. Dans ce projet, il a résolu une tâche frustrante à laquelle est confronté chaque utilisateur à double démarrage, qui attend de choisir le système d'exploitation (Windows) dans le menu GRUB à tout moment lorsque nous voulons passer à Windows. Il a pu ajouter un commutateur matériel pour déterminer le système d'exploitation à démarrer chaque fois que l'ordinateur est allumé.

Il y est parvenu en configurant le microcontrôleur STM32 en tant que périphérique de stockage de masse USB. Il a documenté tout son parcours à travers la recherche et la mise en œuvre du projet dans hackaday post(click). Veuillez consulter son message pour mieux comprendre les implémentations.

Dans ce projet, je vais montrer comment j'ai réussi à porter les modifications sur Raspberry Pi Pico. Vous pouvez trouver ma version dans ce GitHub Repo (Cliquez).

Concept

GNU GRUB est un programme qui s'exécute avant le chargement de tout système d'exploitation. Grâce à ce menu, nous pouvons sélectionner le système d'exploitation à charger. GRUB propose des modules très limités avec lesquels travailler. Cela signifie qu'il ne peut pas lire les données d'un microcontrôleur connecté via USB. Mais il peut lire les données des disques de stockage.

Nous pouvons donc tromper GRUB pour qu'il lise les données du microcontrôleur, en énumérant notre micro comme un périphérique de stockage de masse.

Par conséquent, nous énumérons notre raspberry pi pico comme un périphérique de stockage de masse, via la bibliothèque TinyUSB, qui aura un fichier switch.cfg fichier, dans lequel pico écrira la position du commutateur, c'est-à-dire 1 pour ON 0 pour OFF .

Nous devons ajouter un script dans GRUB, c'est-à-dire des fonctions pour lire le fichier switch.cfg et définir le par défaut à 0(Ubuntu )/2(Windows).

GRUB lors du chargement, exécute nos scripts personnalisés, qui à leur tour recherchent notre appareil par ses identifiants UUID, et en cas de sortie, lisent le fichier switch.cfg. Après avoir obtenu la position du commutateur, il définit respectivement la sélection par défaut du système d'exploitation.

En résumé,

• pico se configurera comme un périphérique de stockage de masse.
• le menu grub appelle notre script et demande le fichier particulier.
• Pico répond à la demande de lecture en ajoutant la position du commutateur dans le fichier switch.cfg.
• le script dans grub extrait les informations du fichier et définit l'option par défaut à partir des données extraites.

Configuration de Pico en tant que périphérique de stockage de masse

J'ai utilisé le cdc_msc exemple par tinyUSB pour y parvenir. L'exemple configure le pico en tant que périphérique de stockage de masse, crée un système de fichiers FAT12 et énumère un fichier README.txt.

J'ai changé le README.txt en switch.cfg et j'ai ajouté la ligne "set os_hw_switch=0\n" au fichier.

#define SWITCH_CFG_CONTENTS \
"set os_hw_switch=0\n"

...
//----- -------- Block3 :Contenu Lisezmoi -------------//
SWITCH_CFG_CONTENTS

Nous avons maintenant configuré pico comme périphérique de stockage de masse. Après avoir copié le fichier uf2 sur pico, il est énuméré en tant que périphérique de stockage. Nous aurons besoin de l'identifiant UUID de l'appareil pour le script GRUB, qui est UUID="0000-1234".

$ sudo blkid
...
/dev/sda :SEC_TYPE="msdos" LABEL_FATBOOT="TinyUSB MSC" LABEL="TinyUSB MSC" UUID="0000-1234" BLOCK_SIZE="512" TYPE="vfat"

Circuit

Lecture de la position du commutateur et écriture dans le fichier

Nous devons maintenant lire la position du commutateur et modifier le contenu du fichier switch.cfg en conséquence c'est-à-dire

• si le commutateur est activé : set os_hw_switch=1\n
• si le commutateur est désactivé : set os_hw_switch=0\n

J'ai utilisé GPIO_PIN 28 comme broche de commutation, qui est configurée pour s'abaisser.

read_switch_value retourner la position du commutateur, c'est-à-dire que « 1 » est activé (tiré vers le haut) et « 0 » est éteint (tiré vers le bas).

//-------------------------main.c-------- -------------
#define SWITCH_PIN 28

// lire la valeur du commutateur 
uint8_t read_switch_value()
{
 retourner gpio_get(SWITCH_PIN) ? '1' :'0';
}

int main(void)
{
 gpio_init(SWITCH_PIN);

 // configurer la broche comme INPUT
 gpio_set_dir(SWITCH_PIN, false); 

 //configurer la broche en tant que PULL_DOWN
 gpio_set_pulls (SWITCH_PIN,false,true);

Pour écrire la position du commutateur dans switch.cfg, j'ai utilisé readGRUBConfig() qui appelle la read_switch_value fonction et définissez le tampon de sortie avec la position du commutateur.

J'ai trouvé cela en lisant le troisième bloc3 lba est défini sur 3, ce qui permet d'intercepter l'appel et d'appeler readGrubConfig et en passant le buffer où sera copié le contenu du fichier.

//--------------------------msc_disk.c-------- -------------

static char grubConfigStr[] ="set os_hw_switch=0\n" ;
static void readGrubConfig(uint8_t* output)
{
 // Modifier la chaîne de configuration avec la valeur actuelle du commutateur
 grubConfigStr[sizeof(grubConfigStr)-3] =read_switch_value();
 memcpy(output, &grubConfigStr, sizeof(grubConfigStr)); 
}

// Rappel invoqué lors de la réception de la commande READ10.
// Copier les données du disque dans la mémoire tampon (jusqu'à bufsize) et renvoyer le nombre d'octets copiés.
int32_t tud_msc_read10_cb(uint8_t lun, uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize)
{
 (void) lun;
 // lors de la lecture du fichier
 if(lba ==3){
 readGrubConfig(buffer);
 return bufsize;
 }
 ...
 ...
}

Compiler le code Pico

Nous devons ajouter pico stdlib à notre code pour obtenir le gpio accès par broche.

//-------------------------main.c-------- ---------------------------
#include 
#include 
#include 
#include "bsp/board.h"
#include "tusb.h"
...
#include "pico/ stdlib.h"

Pour réaliser le projet :

$ mkdir build
$ cd build
$ cmake ..
$ make

Configuration de GRUB pour lire le contenu du fichier

J'ai ajouté ces changements dans mon Ubuntu 20.10.

$ sudo vim /etc/grub.d/40_custom

....
# Recherchez le périphérique de commutateur matériel par son code en dur ID du système de fichiers
search --no-floppy --fs-uuid --set hdswitch 0000-1234

# Si trouvé, lisez le fichier de configuration dynamique et sélectionnez l'entrée appropriée pour chaque position
if [ "${hdswitch}" ]; then
 source ($hdswitch)/switch.cfg

 if [ "${os_hw_switch}" ==0 ]; then
 # Boot Linux
 set default="0"
 elif [ "${os_hw_switch}" ==1 ]; then
 # Boot Windows
 set default="2"
 else
 # Fallback to default
 set default="${GRUB_DEFAULT}"
 fi

else
 set default="${GRUB_DEFAULT}"
fi

Tout d'abord, nous recherchons notre système de fichiers. GRUB a une sous-commande search juste pour ça.

• -pas de disquette l'option empêche la recherche de lecteurs de disquettes
• -fs–uuid  0000-1234 recherche un système de fichiers avec l'UUID de 0000-1234.

Si un périphérique est trouvé, le premier périphérique trouvé est défini comme valeur de la variable d'environnement.

–définir hdswitch hdswitch est notre variable d'environnement et est défini avec le nom du disque s'il est trouvé.

Ensuite, nous obtenons le fichier switch.cfg si le hdswitch variable est définie, ce qui crée une autre variable d'environnement os_hw_switch avec la position du commutateur c'est-à-dire soit 0/1.

Nous lisons la valeur de os_hw_switch et définissez la valeur par défaut sur 0 ou 2 respectivement. 0 car Ubuntu est à la 0ème position et Windows à la 2ème position dans le menu GRUB.

Enfin, si hdswitch n'a pas été défini, nous avons défini la valeur par défaut sur GRUB_DEFAULT.

Nous devons maintenant mettre à jour notre grub :

$ sudo update-grub

Source : Commutateur de sélection de démarrage matériel à l'aide de Pico