Yocto Project: Quick Start

yocto project introdução
Este post faz parte da série Yocto Project. Leia também os outros posts da série:

Na primeira parte dessa série apresentamos os prós e contras ao se utilizar distribuições Linux prontas e customizadas, uma breve introdução sobre o Yocto Project, bem como suas características principais e seus diferenciais. Na segunda parte vimos em mais detalhes a arquitetura e conceitos e definições do Yocto Project. Nessa terceira parte faremos um Quick Start e demonstraremos na prática o uso dos conceitos apresentados.

 

Nesse Quick Start iremos gerar uma distribuição Linux embarcado com interface gráfica que será executada pelo emulador de hardware QEMU para arquiteturas ARM.

 

Preparando o Host

 

O Yocto Project suporta oficialmente as seguintes distribuições GNU/Linux como ambiente de construção:

  • Ubuntu 14.04, 14.10, 15.04, 15.10;
  • Fedora 21 e 22;
  • CentOS 6.x e 7.x;
  • Debian 7.x e 8.x;
  • openSUSE 13.2.

 

Para que ele execute no Host, alguns pacotes necessitam ser instalados.

 

Ubuntu e Debian:

sudo apt-get install gawk wget git-core diffstat unzip texinfo gcc-multilib build-essential \
     chrpath socat libsdl1.2-dev xterm make xsltproc docbook-utils fop dblatex xmlto autoconf \
     automake libtool libglib2.0-dev libarchive-dev python-git

 

Fedora:

sudo dnf 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 perl-bignum socat \
     findutils which SDL-devel xterm make docbook-style-dsssl docbook-style-xsl \
     docbook-dtds docbook-utils fop libxslt dblatex xmlto xsltproc automake libtool \
     glib2-devel libarchive-devel GitPython

 

openSUSE:

sudo zypper install python gcc gcc-c++ git chrpath make wget python-xml \
     diffstat makeinfo python-curses patch socat libSDL-devel xterm make \
     fop xsltproc dblatex xmlto autoconf automake libtool glib2-devel \
     libarchive-devel python-GitPython

 

CentOS:

sudo yum install gawk make wget tar bzip2 gzip python unzip perl patch \
     diffutils diffstat git cpp gcc gcc-c++ glibc-devel texinfo chrpath socat \
     perl-Data-Dumper perl-Text-ParseWords perl-Thread-Queue SDL-devel xterm \
     make docbook-style-dsssl docbook-style-xsl docbook-dtds docbook-utils \
     fop libxslt dblatex xmlto xsltproc autoconf automake libtool glib2-devel \
     libarchive-devel GitPython

 

 

Montando o ambiente de construção

 

Neste tutorial iremos utilizar a versão mais recente do Yocto (krogoth) disponível. Após instalar os pacotes para o Host, vamos criar os diretórios e baixar os fontes necessários:

 

mkdir -p ~/yocto/dl
cd ~/yocto
git clone -b krogoth git://git.yoctoproject.org/poky poky-krogoth

 

Agora vamos configurar o ambiente para gerarmos os artefatos de software:

 

cd ~/yocto
source poky-krogoth/oe-init-build-env build-krogoth

 

Toda vez que desejarmos usar o Yocto em uma nova instância do shell devemos usar o comando "source" para que as variáveis de ambiente sejam devidamente configuradas.

Adicione as seguintes variáveis no arquivo ~/yocto/build-krogoth/conf/local.conf:

 

DISTRO = "poky"
MACHINE = "qemuarm"
DL_DIR = "${TOPDIR}/../dl"
PACKAGE_CLASSES = "package_ipk"

 

Note que configuramos nossa Distro como poky (DISTRO = "poky"), Machine como sendo a qemuarm (MACHINE = "qemuarm"), mudamos o diretório de download (DL_DIR = "${TOPDIR}/../dl") para podermos reutilizar os fontes baixados em outros projetos e iremos gerar pacotes para usarmos o opkg (PACKAGE_CLASSES = "package_ipk").

 

Na primeira vez que executamos o comando "source" acima o Yocto irá gerar o arquivo "~/yocto/build-krogoth/conf/bblayers.conf" com as camadas básicas, como podemos ver abaixo:

 

# POKY_BBLAYERS_CONF_VERSION is increased each time build/conf/bblayers.conf
# changes incompatibly
POKY_BBLAYERS_CONF_VERSION = "2"

BBPATH = "${TOPDIR}"
BBFILES ?= ""

BBLAYERS ?= " \
  /home/dsueiro/yocto/poky-krogoth/meta \
  /home/dsueiro/yocto/poky-krogoth/meta-poky \
  /home/dsueiro/yocto/poky-krogoth/meta-yocto-bsp \
  "

 

O arquivo bblayers.conf configura quais serão as camadas a serem consideradas pelo sistema de build.

 

 

Construindo a imagem

 

Vamos gerar uma imagem com interface gráfica mínima (core-image-sato) que utiliza o X11 como backend e GTK com o comando:

 

source poky-krogoth/oe-init-build-env build-krogoth
bitbake core-image-sato

 

Esta é a configuração de build utilizada:

 

Build Configuration:
BB_VERSION        = "1.30.0"
BUILD_SYS         = "x86_64-linux"
NATIVELSBSTRING   = "universal"
TARGET_SYS        = "arm-poky-linux-gnueabi"
MACHINE           = "qemuarm"
DISTRO            = "poky"
DISTRO_VERSION    = "2.1.1"
TUNE_FEATURES     = "arm armv5 thumb dsp"
TARGET_FPU        = "soft"
meta              
meta-poky         
meta-yocto-bsp    = "krogoth:98c57bb512ea6790db8604fcf0b88c81651d2ab4"

 

Ao final do processo receberemos uma mensagem semelhante a essa:

 

NOTE: Tasks Summary: Attempted 5408 tasks of which 270 didn't need to be rerun and all succeeded.

 

 

Executando a imagem com QEMU

 

Agora estamos prontos para rodar a imagem que geramos com QEMU para processadores ARM com o seguinte comando no mesmo shell que usamos para rodar o bitbake:

 

runqemu qemuarm

 

Se você desejar rodar o QEMU em outra instância do shell será necessário rodar o comando "source" utilizado anteriormente.

 

Ao executar o "runqemu" o script irá solicitar que entre com a senha de "root" e teremos a seguinte mensagem no terminal:

 

Continuing with the following parameters:
KERNEL: [/home/dsueiro/yocto/build-krogoth/tmp/deploy/images/qemuarm/zImage-qemuarm.bin]
ROOTFS: [/home/dsueiro/yocto/build-krogoth/tmp/deploy/images/qemuarm/core-image-sato-qemuarm-20160719090358.rootfs.ext4]
FSTYPE: [ext4]
Setting up tap interface under sudo
[sudo] password for dsueiro: 
Acquiring lockfile for tap0...
Running qemu-system-arm...
/home/dsueiro/yocto/build-krogoth/tmp/sysroots/x86_64-linux/usr/bin/qemu-system-arm -kernel /home/dsueiro/yocto/build-krogoth/tmp/deploy/images/qemuarm/zImage-qemuarm.bin -net nic,model=virtio -net tap,vlan=0,ifname=tap0,script=no,downscript=no -M versatilepb -drive file=/home/dsueiro/yocto/build-krogoth/tmp/deploy/images/qemuarm/core-image-sato-qemuarm-20160719090358.rootfs.ext4,if=virtio,format=raw -no-reboot -show-cursor -usb -usbdevice tablet -no-reboot -m 128 -serial mon:vc -serial null -append "root=/dev/vda rw console=ttyAMA0,115200 console=tty ip=192.168.7.2::192.168.7.1:255.255.255.0 mem=128M highres=off rootfstype=ext4 "

 

Após alguns instantes abrirá a tela do emulador e poderemos acompanhar o carregamento da imagem do sistema como ilustrado na figura 1.

 

Yocto quick start - Carregamento do QEMU
Figura 1 - Carregamento do QEMU.

 

Ao término teremos o sistema como apresentado na figura 2 e as aplicações disponíveis presentes na imagem como na figura 3.

 

Tela inicial da imagem Sato
Figura 2 - Tela inicial da imagem Sato.
Aplicativos presentes na imagem Sato
Figura 3 - Aplicativos presentes na imagem Sato.

 

 

Conclusão

 

Nessa última parte da série de Introdução ao Yocto Project vimos de maneira prática como gerar uma distribuição Linux embarcado com suporte à interface gráfica (X11 e GTK) para ser emulada no QEMU para processadores ARM.

 

Confira os diversos artigos publicados no site sobre o uso do Yocto Project para gerar diferentes tipos de distribuições para diversos tipos de placas. 

Outros artigos da série

<< Yocto Project: Definições e Conceitos
Este post faz da série Yocto Project. Leia também os outros posts da série:
NEWSLETTER

Receba os melhores conteúdos sobre sistemas eletrônicos embarcados, dicas, tutoriais e promoções.

Obrigado! Sua inscrição foi um sucesso.

Ops, algo deu errado. Por favor tente novamente.

Licença Creative Commons Esta obra está licenciada com uma Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.

Diego Sueiro
Formado em Engenharia de Controle e Automação pela UNIFEI e CEO do Embarcados, atualmente trabalho na Inglaterra com Desenvolvimento de Sistemas Linux Embarcado Real Time. Sou consultor e desenvolvedor de software para Sistemas Embarcados com vasta experiência em projetos com processadores de 8bits a 32bits, sistemas bare metal, RTOS, Linux Embarcado e Android Embarcado. Um apaixonado por Pink Floyd e Empreendedorismo.

1
Deixe um comentário

avatar
 
1 Comment threads
0 Thread replies
0 Followers
 
Most reacted comment
Hottest comment thread
1 Comment authors
phfbertoleti Recent comment authors
  Notificações  
recentes antigos mais votados
Notificar
phfbertoleti
Visitante
phfbertoleti

Muito bom!