Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

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,

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:

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.

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

  1. Dominando a Instrução Switch em C#: Sintaxe, Exemplos e Boas Práticas
  2. Dominando Declarações Using em C#: Imports, Aliases e Diretivas Estáticas
  3. Construindo Estação Meteorológica Externa com Raspberry Pi 2 e ADS‑WS1
  4. Sistema de Controle de Temperatura Baseado em LM35 com Microcontrolador AT89S52
  5. Monitoramento Remoto do Tempo com Raspberry Pi 3 e PubNub
  6. Integre TI SensorTag ao Blynk via Node‑RED no Raspberry Pi Zero
  7. Controle um LED com Sensor de Movimento PIR no Raspberry Pi
  8. Construa um Robô Inteligente com a Bridge Shield – Integração Raspberry Pi e Arduino
  9. Construa Robô Raspberry Pi Controlado por Wi-Fi com Python – Guia Passo a Passo
  10. Hacking de Hardware Embarcado para Dispositivos IoT: Ferramentas, Técnicas e Implicações de Negócio