Yocto Project

O que é o Yocto Project?

O Yocto Project é um sistema de build com o objetivo de criar distribuições Linux embarcado customizadas, ademais, ele apresenta questões importantes no desenvolvimento do produto como: redução do time-to-market, redução de custos de desenvolvimento e manutenção.

Funções de um sistema build

É esperado que um Sistema de Build:
• Forneça Toolchain para cross-compiling e debug;
• Construção dos artefatos de software;
• Gerenciar cadeias de dependências entre os pacotes;
• Construção da imagem (bootloader + kernel + rootfs);
• Geração de SDK (+);
• Integração com IDEs (+);
• Gerenciador de Pacotes a ser utilizado no target (+);
• Automação de Testes (+);
• Emulador do HW (+).
https://www.embarcados.com.br/yocto-project-introducao/

Sistema Linux Embarcado

Sistema Linux embarcado é um sistema customizado que sofre adaptações para ser utilizado da melhor forma em determinado hardware, podendo ele possuir todas (ou grande parte) das características do sistema operacional comum utilizado no desktop, com o objetivo de suprir todas as necessidades de armazenamento, desempenho e energia, visando sempre a economia de recursos, que são, de fato, limitados. Além disso, o Linux é implantado em diversos dispositivos eletrônicos, dentre eles estão: receptores de TV via satélite, TVs, Smartphones, geladeiras, automação de carros, roteadores, etc.
É necessário uma série de artefatos softwares adequados para o funcionamento e execução de um sistema Linux Embarcado em um determinado hardware, sendo eles: Aplicações, Serviços, Bibliotecas, Linux Kernel e Bootloader. Esse conjunto é chamado de Distribuição.

Assim como todos projetos, o sistema customizado tem seus prós e contras. Alta flexibilidade, total controle, feito de acordo com o projeto e hardware, são exemplos de prós. Entretanto, os principais contras são: suporte técnico e mão de obra especializada, necessidade de infraestrutura para geração de imagens, ramp up pode ser demorado, e nem todos os pacotes necessários podem estar disponíveis para compilação.

Para desenvolvermos esses artefatos de softwares, precisaremos de algumas ferramentas:

Características

As principais características do Yocto Project são:

Como observamos, há Releases a cada 6 meses, uma geralmente em abril e outra geralmente em outubro, abaixo mostraremos uma tabela com as versões mais recentes:

Como citado anteriormente, o Yocto Project é baseado no Openembedded, que é um conjunto de metadados para executar o build através do Bitbake.

Metadados: Ajudam a relação e a utilidade das informações dos dados. Contém dados de outros dados e informam o Bitbake o que e como construir os artefatos de software.

Bitbake: É inspirado no Portage, usado para distribuição e pacotes com linux embarcado, execução de tarefas e gerenciamento de metadados escrita em python.

Em questões de arquitetura, o sistema tem algumas partes principais, que são: código fonte upstream, metadados e entrada, sistema de build, pacotes resultantes, tarefas e imagem resultante.

Depois das preparações necessárias, o Bitbake vai processar e criar uma ordem de execução das tarefas, visando sempre suas dependências. Geralmente o fluxo que é encontrado nas tarefas é o mesmo da imagem acima.

1. Código fonte é baixado
2. Aplicação de patches (nem sempre é necessário)
3. Configuração e compilação
4. Análise do resultado para a divisão do pacote e suas relações de dependência
5. Geração de pacotes
6. Testes de garantia de qualidade dos pacotes
7. Geração do feed de pacotes
8. Geração da imagem ou do SDK

Quick Build

Nesse tópico, iremos construir uma distribuição Linux embarcado usando o Yocto Project, sendo executada pelo emulador QEMU.

Usamos a versão 20.04 do Ubuntu, mas citaremos as versões compatíveis atualmente:

• Ubuntu 16.04 (LTS)
• Ubuntu 18.04 (LTS)
• Ubuntu 19.04
• Ubuntu 20.04
• Fedora 28
• Fedora 29
• Fedora 30
• Fedora 31
• Fedora 32
• CentOS 7.x
• Debian GNU / Linux 8.x (Jessie)
• Debian GNU / Linux 9.x (Stretch)
• Debian GNU / Linux 10.x (Buster)
• OpenSUSE Leap 15.1

Após a insalação do host, devemos instalar alguns pacotes essenciais para a execução do projeto, sendo eles:

Ubuntu e Debian:

$ sudo apt-get install gawk wget git-core diffstat descompacte texinfo gcc-multilib \
     build-essential chrpath socat cpio python3 python3-pip python3-pexpect \
     xz-utils debianutils iputils-ping python3-git python3-jinja2 libegl1-mesa libsdl1.2-dev \
     pylint3 xterm    

Fedora:

$ sudo dnf install gawk make wget tar bzip2 gzip python3 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 \
     python3-pexpect findutils cujo arquivo cpio python python3-pip xz python3-GitPython \
     python3-jinja2 SDL-devel xterm rpcgen

OpenSUSE

$ sudo zypper install python gcc gcc-c ++ git chrpath make wget python-xml \
     diffstat makeinfo python-curses patch socat python3 python3-curses tar python3-pip \
     python3-pexpect xz que python3-Jinja2 Mesa-libEGL1 libSDL-devel xterm rpcgen
     $ sudo pip3 install GitPython

CentOS-7

 $ sudo yum install -y epel-release
     $ sudo yum makecache
     $ sudo yum install gawk make wget tar bzip2 gzip python3 descompacte perl patch \
     diffutils diffstat git cpp gcc gcc-c ++ glibc-devel texinfo chrpath socat \
     perl-Data-Dumper perl-Text-ParseWords perl-Thread-Queue python36-pip xz \
     qual SDL-devel xterm
     $ sudo pip3 install GitPython jinja2

CentOS-8

 $ sudo dnf install -y epel-release
     $ sudo dnf config-manager --set-enabled PowerTools
     $ sudo dnf makecache
     $ sudo dnf install gawk make wget tar bzip2 gzip python3 unzip perl patch \
     diffutils diffstat git cpp gcc gcc-c ++ glibc-devel texinfo chrpath ccache \
     socat perl-Data-Dumper perl-Text-ParseWords perl-Thread-Queue python3-pip \
     python3-GitPython python3-jinja2 python3-pexpect xz que SDL-devel xterm \
     rpcgen

Ambiente de Construção

Agora iremos preparar o ambiente de construção, usaremos a versão Dunfell do yocto, que é a mais recente disponível.

Primeiro iremos criar os diretórios e clonar o yocto:

mkdir yocto
cd yocto
git clone -b dunfell git://git.yoctoproject.org/poky poky-dunfell

Como dito anteriormente, precisamos gerar alguns artefatos de software, sendo assim, devemos usar os seguintes comandos:

cd yocto
source poky-dunfell/oe-init-build-env build-dunfell

Após esse comando, será criado um subdiretório com o nome de build-dunfell, dentro dele terá a pasta conf, onde estão o local.conf e o bblayers.conf, essas pastas não serão alteradas nessa distribuição, mas em projetos mais elaborados ambas são muito importantes para a execução correta.

Gerando a imagem

Para iniciar a compilação, devemos usar o seguinte comando:

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

A configuração será a seguinte:

Build Configuration:
BB_VERSION           = "1.46.0"
BUILD_SYS            = "x86_64-linux"
NATIVELSBSTRING      = "ubuntu-20.04"
TARGET_SYS           = "X86_64-poky-linux"
MACHINE              = "qmeux86-64"
DISTRO               = "poky"
DISTRO_VERSION       = "3.1.2"
TUNE_FEATURES        = "m64 core2"
TERGET_FPU           = ""
meta
meta-poky
meta-yocto-bsp       = "dunfell:09c99632ac74f4ebd9e8fa4696f8d0ddaea37d36"

Esse processo pode demorar muito, pois são em média 6835 tarefas. Após o carregamento total, devemos executar a imagem.

Execução da imagem

Iremos rodar a imagem usando o QEMU, o comando abaixo deve ser utilizado:

runqemu qemux86-64

Em questão de segundos deverá abrir uma página de carregamento do Yocto Project, e depois, a seguinte imagem irá aparecer: