Chave de Boot Alimentada por Pico: Escolha Seu SO Antes de Ligar
Pré-escolha o SO para boot, mesmo antes de ligar o computador, alternando uma chave. Agora você não precisa esperar para selecionar o SO.
História
Navegando pelo Hackaday.io em busca de projetos, tropecei neste projeto (clique) de Stephen Holdaway. Neste projeto, ele resolveu uma tarefa frustrante enfrentada por todo usuário de dual boot: sentar e esperar para escolher o SO (Windows) no menu GRUB toda vez que queremos mudar para Windows. Ele conseguiu adicionar uma chave de hardware para determinar o SO a ser iniciado cada vez que o computador é ligado.
Ele conseguiu isso configurando um microcontrolador STM32 como dispositivo de armazenamento em massa USB. Ele documentou toda sua jornada através da pesquisa e implementação do projeto no post do hackaday (clique). Por favor, leia seu post para melhor entendimento das implementações.
Neste projeto, mostrarei como consegui portar as mudanças para Raspberry Pi Pico. Você pode encontrar minha versão neste GitHub Repo (Clique).
Conceito
GNU GRUB é um programa que roda antes de qualquer Sistema Operacional ser carregado. Através deste menu, podemos selecionar qual SO carregar. GRUB oferece módulos muito limitados para trabalhar. Isso significa que ele não pode ler dados de um microcontrolador conectado via USB. Mas ele pode ler dados de discos de armazenamento.
Então podemos enganar o GRUB para ler dados do microcontrolador, enumerando nosso micro como dispositivo de armazenamento em massa.
Portanto, enumeramos nosso Raspberry Pi Pico como dispositivo de armazenamento em massa, via biblioteca tinyUSB, que terá um arquivo switch.cfg, no qual o pico escreverá a posição da chave, ou seja, 1 para ON, 0 para OFF.
Temos que adicionar um script no GRUB, que funciona para ler o arquivo switch.cfg e definir o default para 0(Ubuntu) / 2(Windows).
GRUB, ao carregar, executa nossos scripts personalizados, que por sua vez buscam nosso dispositivo por seus identificadores UUID, e se existe, lê o arquivo switch.cfg. Após obter a posição da chave, define a seleção default do SO respectivamente.
Em resumo,
- pico se configurará como dispositivo de armazenamento em massa.
- menu grub chama nosso script e pede o arquivo específico.
- Pico responde à requisição de leitura adicionando a posição da chave no arquivo switch.cfg.
- o script no grub extrai a info do arquivo e define a opção default a partir dos dados extraídos.
Configurando Pico como Dispositivo de Armazenamento em Massa
Usei o exemplo cdc_msc da tinyUSB para alcançar isso. O exemplo configura o pico como dispositivo de armazenamento em massa e cria um sistema de arquivos FAT12 e enumera um arquivo README.txt.
Mudei README.txt para switch.cfg e adicionei a linha "set os_hw_switch=0\n" ao arquivo.
#define SWITCH_CFG_CONTENTS \
"set os_hw_switch=0\n"
...
//------------- Block3: Readme Content -------------//
SWITCH_CFG_CONTENTS
Agora configuramos o pico como dispositivo de armazenamento em massa. Após copiar o arquivo uf2 para o pico, ele enumera como dispositivo de armazenamento. Precisaremos do UUID do dispositivo para o script GRUB, que é 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"
Circuito
Lendo Posição da Chave e Escrevendo no Arquivo
Agora precisamos ler a posição da chave e alterar o conteúdo do arquivo switch.cfg accordingly, ou seja:
- se a chave está ON: set os_hw_switch=1\n
- se a chave está OFF: set os_hw_switch=0\n
Usei GPIO_PIN 28 como pino da chave, configurado como pull down.
read_switch_value retorna a posição da chave, ou seja, '1' é on (puxado high) e '0' é off (puxado low).
//-------------------------main.c---------------------
#define SWITCH_PIN 28
// read switch value
uint8_t read_switch_value()
{
return gpio_get(SWITCH_PIN) ? '1' : '0';
}
int main(void)
{
gpio_init(SWITCH_PIN);
//configure pin as INPUT
gpio_set_dir(SWITCH_PIN, false);
//configure pin as PULL_DOWN
gpio_set_pulls (SWITCH_PIN,false,true);
Para escrever a posição da chave no switch.cfg, usei readGRUBConfig() que chama a função read_switch_value, e define o buffer de saída com a posição da chave.
Descobri que ao ler o terceiro bloco3 lba é definido como 3, então interceptando a chamada e chamando readGrubConfig e passando o buffer onde o conteúdo do arquivo será copiado.
//-------------------------msc_disk.c---------------------
static char grubConfigStr[] = "set os_hw_switch=0\n";
static void readGrubConfig(uint8_t* output)
{
// Modify config string with current switch value
grubConfigStr[sizeof(grubConfigStr)-3] = read_switch_value();
memcpy(output, &grubConfigStr, sizeof(grubConfigStr));
}
// Callback invoked when received READ10 command.
// Copy disk's data to buffer (up to bufsize) and return number of copied bytes.
int32_t tud_msc_read10_cb(uint8_t lun, uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize)
{
(void) lun;
// when reading the file
if(lba == 3){
readGrubConfig(buffer);
return bufsize;
}
...
...
}
Compilar Código do Pico
Precisamos adicionar stdlib do pico ao nosso código para obter acesso ao pino gpio.
//-------------------------main.c-----------------------------------
#include
#include
#include
#include "bsp/board.h"
#include "tusb.h"
...
#include "pico/stdlib.h"
Para fazer o projeto:
$ mkdir build
$ cd build
$ cmake ..
$ make
Configurando GRUB para Ler Conteúdo do Arquivo
Adicionei estas mudanças no meu Ubuntu 20.10.
$ sudo vim /etc/grub.d/40_custom
....
# Look for hardware switch device by its hard-coded filesystem ID
search --no-floppy --fs-uuid --set hdswitch 0000-1234
# If found, read dynamic config file and select appropriate entry for each 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
Primeiro, buscamos nosso filesystem. GRUB tem um subcomando search just for this.
- -no-floppy option prevents searching floppy devices
- -fs–uuid 0000-1234 searches a file system with UUID of 0000-1234.
Se qualquer dispositivo for encontrado, o primeiro dispositivo encontrado é definido como valor da variável de ambiente.
–set hdswitchhdswitch é nossa variável de ambiente e é definida com nome do disco se encontrado.
Em seguida, fazemos source do arquivo switch.cfg se a variável hdswitch estiver definida, o que cria outra variável de ambiente os_hw_switch com a posição da chave, ou seja, 0/1.
Lemos o valor do os_hw_switch e definimos default para 0 ou 2 respectivamente. 0 porque Ubuntu está na posição 0 e Windows na posição 2 no menu GRUB.
Por fim, se hdswitch não foi definido, definimos default para GRUB_DEFAULT.
Agora precisamos atualizar nosso grub:
$ sudo update-grub
Fonte: Hardware Boot Select Switch Using Pico
Processo de manufatura
- Dominando a Instrução Switch em C#: Sintaxe, Exemplos e Boas Práticas
- Dominando Declarações Using em C#: Imports, Aliases e Diretivas Estáticas
- Construindo Estação Meteorológica Externa com Raspberry Pi 2 e ADS‑WS1
- Sistema de Controle de Temperatura Baseado em LM35 com Microcontrolador AT89S52
- Monitoramento Remoto do Tempo com Raspberry Pi 3 e PubNub
- Integre TI SensorTag ao Blynk via Node‑RED no Raspberry Pi Zero
- Controle um LED com Sensor de Movimento PIR no Raspberry Pi
- Construa um Robô Inteligente com a Bridge Shield – Integração Raspberry Pi e Arduino
- Construa Robô Raspberry Pi Controlado por Wi-Fi com Python – Guia Passo a Passo
- Hacking de Hardware Embarcado para Dispositivos IoT: Ferramentas, Técnicas e Implicações de Negócio