1285903-intel-galileo-quark-photo-couverture-boite-octobre-2013

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

Summary
Intel Galileo Board - Usando o Yocto System para gerar uma imagem Linux
Article Name
Intel Galileo Board - Usando o Yocto System para gerar uma imagem Linux
Description
Intel Galileo Board - Usando o Yocto System para gerar uma imagem Linux
Author
Publisher Name
iMobilis
Publisher Logo

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

*
*
Website