Intel Galileo Board – Usando o Yocto System para gerar uma imagem Linux
Intel Galileo Olá você leitor do Blog do Imobilis, interessado em aprender como usar Linux em Boards como a Intel Galileo mas de que forma é feito, ou quais ferramentas utilizar. Este post foi criado para dar-lhe uma introdução breve e mostrar os procedimentos básico para que você comece a experimentar e construir seus próprios projetos.
Mostraremos como construir uma imagem Linux para ser utilizada na Intel Galileo Board.
A Intel Galileo e o Yocto Project Build System
Intel Galileo é uma placa com o microcontrolador Intel Quark SoC X1000 Aplication Processor, um processador de classe Intel Pentium 32-bits sistema em um chip. É o primeira placa baseada na arquitetura Intel projetada para compatibilidade de pinos em hardware e software com shields Arduino projetados para a Uno R3, assim como compatibilidade com o Arduino Software Development Enviroment (IDE), que a torna fácil de familiarizar para que já tem experiencia com a plataforma.
Além da compatibilidade com o hardware e software, a Galileo também possui várias outras portas de I/O padrão na industria e recursos que incrementam as possibilidades além do ecossistema de shields Arduino. Na placa, há uma entrada mini-PCI Express, porta de Ethernet de 100Mb, entrada para cartões Micro-SD, porta serial RS-232, porta USB Host, porta USB Client, e 8MByte de memória NOR flash.
O Projeto Yocto é um projeto colaborativo open-source que proporciona templates, utilitários e métodos direcionados a ajudar a contruir sistemas Linux customizados para produtos embarcados independente da sua arquitetura de hardware. O projeto foi criado em 2010 com a colaboração de fabricantes de hardware, fornecedores de sistemas operacionais open-source, e copanias de eletrônicos em uma tentativa de organizar o desenvolvimento de sistemas Linux Embarcados.
Entre outras coisas, o Yocto Project utiliza um Build System baseado no Projeto OpenEmbedded (OE), que usa o utilitário BitBake para construir imagens Linux completas.
Mais informações podem ser encontradas aqui.
Requerimentos Básicos Intel Galileo
Esse guia foi criado da forma mais simples possível, possibilitando que o leitor obtenha ao final destes passos uma imagem funcional para ser utilizada na placa. Entretanto a execução dos passos podem mudar em diferentes distribuições, assim como alguns erros por diferenças entre sistemas de arquivos e caminho absoluto do build system. Portanto, familiaridade com as ferramentas de sistema do Linux ajudam bastante a solucionar os problemas.
Assim também falaremos de alguns problemas enfrentados pro nós enquanto criávamos este tutorial.
Neste tutorial, o build system foi instalado em uma computador com openSUSE 13.2, em uma partição separada com o sistema de arquivos btrfs de 100GB. Não há requerimento ou recomendação para o sistema de arquivos para ser utilizado, mas tivemos muitos problemas anteriormente utilizando uma partição NTFS. Portanto, um sistema nativo Linux é preferível.
Os Pacotes
Os pacotes necessários para a construção através do Yocto Project variam de acordo com o sistema de desenvolvimento, e o objetivo do sistema a ser construído. Como estamos interessados na construção para a Galileo, os pacotes necessários são:
Ubuntu e Debian:
sudo apt-get install gawk wget git-core diffstat unzip texinfo gcc-multilib \ build-essential chrpath socat libsdl1.2-dev xterm
Fedora:
sudo yum install gawk make wget tar bzip2 gzip python unzip perl patch \ diffutils diffstat git cpp gcc gcc-c++ glibc-devel texinfo chrpath \ ccache perl-Data-Dumper perl-Text-ParseWords perl-Thread-Queue SDL-devel xterm
OpenSuse:
sudo zypper install python gcc gcc-c++ git chrpath make wget python-xml \ diffstat makeinfo python-curses patch socat libSDL-devel xterm
Montando Ambiente de Construção para a Intel Galileo
O sistema de construção pode ser obtido através dos repositórios já com as as camadas compatibilidade e configurações para a Galileo. Clonando o repositório:
cd ~ git clone -b devkit-daisy-1.6.1 git://git.yoctoproject.org/meta-intel-iot-devkit
Neste turorial, estamos utilizando uma branch baseada na versão 1.6.1(Codinome Daisy) do Yocto Project.
Em nossas algumas de nossas tentativas, tivemos problemas na hora da contrução devido ao tamanho dos argumentos gerados pelo processo. Tente instalar o repositório em um caminho com menos de 256 caracteres de comprimento.
Agora, podemos configurar o ambiente para gerar os arquivos de configuração iniciais:
cd meta-intel-iot-devkit
source iot-devkit-init-build-env
Ao executar source no neste script, varias variaveis de ambientes são criadas de acordo com a configuração das camadas. Quando execetucado a primeira vez, o script também cria os arquivos de configuração iniciais na pasta build. Nela, há os arquivo build/conf/local.conf, onde configurações personalizadas podem ser colocadas.
Como dica interessante, podemos adicionar a linha:
DL_DIR ?= "${TOPDIR}/../../downloads"
Assim, todos os arquivos adquiridos no processo podem ser compartilhados por possíveis outras configurações do Yocto.
Construindo a Imagem.
Após termos estabelecermos o ambiente de construção com o source, podemos construir a imagem com:
bitbake iot-devkit-image
OBS: quando este guia foi escrito, havia um problema com a receita meta-intel-iot-devkit/meta-quark-bsp/recipes-bsp/grub/grub_0.97.bb Bitbake é o script de construção principal. Ele lê todas as receitas, e executa todas as tarefas necessárias como obter os arquivos fonte, configuração, compilação e escrita no sistema de arquivos da imagem. O processo pode ser basteante demorado. Podemos usar a opção:
bitbake -k iot-devkit-image
para garantir que a construção continuará mesmo com uma falha, continuando tarefas não dependentes daquela que falhou. Lembre-se que sempre que o desejar executar o bitbake, o script de ambiente deverá ser antes inicializado.
Testando a imagem na Intel Galileo.
Após o fim da construção há duas maneiras de gerar uma imagem funcional para a board. novos diretórios são povoados dentro do diretório build. Uma delas é a pasta tmp/deploy, onde ficam os produtos finais da construção. Nela, há:
images: Arquivo para a imagem a ser utilizada na board ipk, rpm ou deb: Pacotes gerados pelas recipes das camadas. licences: Licenças de cada pacote. Primeiramente, iremos formatar o cartão de memória para o sistema e arquivos FAT32.
sudo fdisk -l Disk /dev/sda: 238.5 GiB, 256060514304 bytes, 500118192 sectors Units: sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes Disklabel type: gpt Disk identifier: F9A868E7-F3FC-4C2E-819E-5852952D29BA Disk /dev/sdb: 931.5 GiB, 1000204886016 bytes, 1953525168 sectors Units: sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 4096 bytes I/O size (minimum/optimal): 4096 bytes / 4096 bytes Disklabel type: gpt Disk identifier: 59CB678F-8AD4-415F-B317-824A6D9D88DA Disk /dev/sdc: 7.4 GiB, 7948206080 bytes, 15523840 sectors Units: sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes Disklabel type: dos Disk identifier: 0x2ef12e9c
No nosso caso, nosso cartão de memória está em /dev/sdc. Formatando o sistema de arquivos:
sudo mkfs.vfat -n GALILEO /dev/sdc1
Depois, podemos copiar os arquivos para o cartão de memória.
mkdir $HOME/galileo sudo mount /dev/sdc1 $HOME/galileo cd meta-intel-iot-devkit/tmp/deploy/images cp boot/grub/grub.conf $HOME/galileo/boot/grub/ cp bzImage $HOME/galileo/ cp core-image-minimal-initramfs-quark.cpio.gz $HOME/galileo/ cp grub.efi $HOME/galileo/ cp iot-devkit-image-quark.ext3 $HOME/galileo/
O nosso boot/grub/grub.conf deverá conter as seguintes linhas:
default 1 timeout 5 color white/blue white/cyan title Quark X1000 kernel-SPI initrd-SPI IMR-On IO-APIC/HPET NoEMU kernel --spi root=/dev/ram0 console=ttyS1,115200n8 earlycon=uart8250,mmio32,0x8010f000,115200n8 reboot=efi,warm apic=debug rw initrd --spi title Quark X1000 kernel-MassStorage iot-devkit on SD IMR-On IO-APIC/HPET NoEMU debug root (hd0,0) kernel /bzImage root=/dev/ram0 rootwait console=ttyS1,115200n8 earlycon=uart8250,mmio32,0x8010f000,115200n8 vmalloc=384M reboot=efi,warm apic=debug rw LABEL=boot debugshell=5 rootimage=iot-devkit-image-quark.ext3 initrd /core-image-minimal-initramfs-quark.cpio.gz
Como alternativa:
Há um script chamado wic que automatiza a maior parte deste processo. Depois de ter criado o ambiente de construção (source iot-devkit-init-build-env) e o fim da execução bem sucedida do bitbake, pode se executar:
../srcripts/wic create iot-devkit -e iot-devkit-image
Após concluído, a imagem para disco estará em:
/var/tmp/wic/build/iot-devkit-(hora de contrução).direct
Com elas podemos simplesmente executar:
dd if=/var/tmp/wic/build/iot-devkit-(hora de contrução).direct of=/dev/sdc
E o cartão estará pronto para ser utilizado.
Após qualquer um destes métodos, a imagem estará pronta para ser colocada na Galieo Board. Lembre-se de que o firmware da board precisa estar atualizado para que o boot do Linux tenha sucesso.
Depois de inicializada, a board pode ser acessada com o comando:
ssh root@IP
Para obter o IP da Intel Galileo board, antes de colocá-la na rede, execute:
nmap -sn (endereço da rede local).0/24
E depois execute o comando novamente. O IP não presente na execução anterior será o da Board.
Artigos Futuros.
Em postagens futuras, mostraremos como adicionar novos pacotes a imagem.
Referências.
Yocto Project Quick Start – http://www.yoctoproject.org/docs/current/yocto-project-qs/yocto-project-qs.html
Yocto Project Reference Manual – http://www.yoctoproject.org/docs/current/ref-manual/ref-manual.html
Galileo + Yocto – Como construir sua própria distribuição Linux Embarcado – http://www.embarcados.com.br/galileo-yocto/
Galileo Getting Started Guide – https://learn.sparkfun.com/tutorials/galileo-getting-started-guide

