yocto: treinamento em português

Yocto: Sua próxima Plataforma de Desenvolvimento para Linux Embarcado

Otavio SalvadorDiretor Técnico

Mario GoulartDesenvolvedor

Sobre a O.S. SystemsSobre a O.S. Systems

● Empresa nacional, fundada em 2002 e sediada em Pelotas, RS

● Usa Yocto/OpenEmbedded desde 2008● Contribui ativamente para o desenvolvimento do

Yocto e de vários outros projetos de código aberto● Clientes e parceiros no Brasil e no mundo

Áreas de atuação da O.S. SystemsÁreas de atuação da O.S. Systems

● Personalização de Sistemas Operacionais● Especializada em desenvolvimento baseado no

kernel Linux● Serviço de Consultoria em diversas áreas● Desenvolvimento/customização de BSPs● Migração de outros sistemas de build para o Yocto● ...

Usando a máquina virtual para o Usando a máquina virtual para o treinamentotreinamento

● Antes de iniciar a VM– A VM está configurada para usar 3 cores e 3GB de RAM.

Se a sua máquina não tiver, no mínimo, 4 cores e 6GB de RAM, ajuste as configurações da VM antes de iniciá-la

● Depois de iniciar a VM– Usuário: yocto

– Senha: yocto

– Clique no ícone “Aquecer a máquina”

YoctoYocto

● Framework baseado em Linux para compilação cruzada (cross-compilation)

● De código aberto (mas pode ser usado para a compilação de código proprietário)

● Utilizado por fabricantes da indústria de dispositivos embarcados para várias arquiteturas (ARM, PPC, MIPS etc.)

O que o Yocto fazO que o Yocto faz

● Download de código fonte● Aplicação de patches● Compilação cruzada● Gerenciamento de pacotes

O que o Yocto geraO que o Yocto gera

● Pacotes binários● Imagens de sistemas Linux● Toolchains● SDKs (Software Development Kits)

HistóricoHistórico

Vantagens de se usar YoctoVantagens de se usar Yocto

● Controle fino sobre o produto final– Possibilidade de configurar software em tempo de compilação

● Grande facilidade para migração entre diferentes plataformas de hardware– Exemplo: migrar uma imagem inteira de x86 para ARM é trivial

● Vasta disponibilidade de software– Milhares de pacotes disponíveis

● Extensível– Adicionar pacotes é fácil

● Extensa comunidade de desenvolvedores– Desenvolvimento ativo, com participação de membros de grandes empresas da

indústria de embarcados

● Excelente desempenho– Possibilidade de paralelização de tarefas durante a compilação

ComponentesComponentes

● BitBake: escalonador e executor de tarefas● Metadados:

– Configuração (.conf): definições globais de variáveis

– Classes (.bbclass): herança e encapsulamento de lógica de compilação, empacotamento etc.

– Receitas (.bb): diretivas sobre como compilar software e imagens

● Poky: sistema de compilação (build system)

Poky = BitBake + Metadados

PacotesPacotes

● Conjunto de arquivos gerados pelo sistema de compilação, agregados em algum formato popular de empacotamento

● Exemplos de tipos de pacotes:– .ipk

– .deb

– .rpm

– .tar{.gz,.bz2}

ReceitasReceitas

● Conjunto de instruções (especificação de tarefas) sobre como compilar software, incluindo:– especificação de onde obter código fonte

– patches a serem aplicados

– dependências

– opções de configuração a serem aplicadas durante a compilação

– disposição dos arquivos gerados em pacotes

● Podem herdar comportamento de classes (.bbclass) e incluir arquivos com definições comuns (.inc)

● Admitem trechos de código em shell script e Python, além de uma linguagem de configuração própria

TarefasTarefas

● Etapas a serem executadas pelo sistema de compilação

● Especificadas em classes e/ou em receitas● Escalonadas pelo BitBake● Exemplos de tarefas padrão: do_fetch, do_unpack,

do_configure, do_compile, do_package

Camadas (layers)Camadas (layers)

● Conjunto de receitas, classes e arquivos de configuração que podem ser agregadas ao sistema de compilação de forma a estendê-lo

● Um BSP (Board Support Package) pode ser implementado sob forma de uma camada

● Exemplos de camadas: meta-fsl-arm, meta-fsl-demos, meta-fsl-arm-extras, meta-java, meta-browser

Exemplo de receitaExemplo de receita

DESCRIPTION = "BSD replacement for libreadline"HOMEPAGE = "http://www.thrysoee.dk/editline/"SECTION = "libs"LICENSE = "BSD"LIC_FILES_CHKSUM = "file://COPYING;md5=1e4228d0c5a9093b01aeaaeae6641533"

DEPENDS = "ncurses"

inherit autotools

SRC_URI = "http://www.thrysoee.dk/editline/${PN}-${PV}-3.0.tar.gz"

S = "${WORKDIR}/${PN}-${PV}-3.0"

SRC_URI[md5sum] = "e50f6a7afb4de00c81650f7b1a0f5aea"SRC_URI[sha256sum] = "51f0f4b4a97b7ebab26e7b5c2564c47628cdb3042fd8ba8d0605c719d2541918"

BitBakeBitBake

● Aplicativo de linha de comando feito em Python● Processa receitas● Executa e gerencia tarefas● bitbake -h

Usos freqüentes do BitBakeUsos freqüentes do BitBake

● bitbake <receita>– Processa todas as tarefas para a receita dada como argumento.

<receita> é o nome de uma receita qualquer disponível nos layers do diretório de trabalho (e.g., samba)

● bitbake -c cleansstate <receita>– “Limpa” todo o estado de tarefas relacionadas a <receita>.

Essa opção é freqüentemente usada durante o desenvolvimento de novas receitas

● bitbake -e– Exibe o estado global de variáveis usadas pelo BitBake.

Gerando uma imagemGerando uma imagem

$ cd ~/src/fsl-community-bsp

$ MACHINE=wandboard-dual source setup-environment build

$ bitbake core-image-minimal

Neste caso, core-image-minimal é uma receita que produz uma imagem, não apenas pacotes (pacotes também são gerados, mas por serem dependências).

Explorando o diretório de trabalho do Explorando o diretório de trabalho do Yocto (raíz)Yocto (raíz)

● Em ~/src/fsl-community-bsp:– build: diretório criado pelo sistema de compilação para

armazenar arquivos gerados durante todo o processo de compilação

– sources: metadados das camadas (layers)

– downloads: arquivos fonte a serem usados pelo sistema de compilação

Explorando o diretório de trabalho do Explorando o diretório de trabalho do Yocto (build)Yocto (build)

● Em ~/src/fsl-community-bsp/build:– cache: dados de cache utilizados pelo BitBake

– conf: diretório com os principais arquivos de configuração: local.conf e bblayers.conf

– sstate-cache: pacotes gerados, os quais podem ser reaproveitados sem a necessidade de recompilação

– tmp: diretório temporário do sistema de compilação. Neste diretório são gerados os arquivos resultantes da compilação: toolchains, binários para a plataforma alvo, imagens etc.

Explorando o diretório de configuração Explorando o diretório de configuração do Yocto (build/conf)do Yocto (build/conf)

● Em ~/src/fsl-community-bsp/build/conf– Principais arquivos: local.conf e bblayers.conf

● Algumas variáveis:– MACHINE: máquina para a qual gerar imagens

– DISTRO: distribuição a gerar

– BBLAYERS: caminhos para os diretórios de camadas

– BB_NUMBER_THREADS: número de threads do BitBake a serem executadas em paralelo

– PARALLEL_MAKE: número de threads do make a serem executadas em paralelo (-j)

●

Explorando o diretório de trabalho do Explorando o diretório de trabalho do Yocto (build/tmp)Yocto (build/tmp)

● Em ~/src/fsl-community-bsp/build/tmp● Alguns dos diretórios:

– deploy: produtos da compilação: imagens, pacotes, SDK

– sysroots: bibliotecas e headers compartilhados, para que possam ser reaproveitados durante a compilação de receitas. Os arquivos nesse diretório são separados por arquitetura

– work: diretório de trabalho usado para a compilação de receitas.

Explorando o diretório de trabalho do Explorando o diretório de trabalho do Yocto (build/tmp/work)Yocto (build/tmp/work)

● Em src/fsl-community-bsp/build/tmp/work● É um dos principais diretórios a serem explorados

para depuração de erros na compilação de receitas● Neste diretório:

– são extraídos os fontes dos softwares que serão compilados

– são armazenados os logs de configuração e execução de tarefas

– são armazenados os conteúdos dos pacotes gerados

– etc.

Organização do diretório Organização do diretório build/tmp/workbuild/tmp/work

<arch>/<recipe name>/<software version>/● Alguns diretórios desta árvore:

– temp: logs de configuração e execução de tarefas

– packages: conteúdo do(s) pacote(s), descompactado(s)

– packages-split: conteúdo dos pacotes, descompactados e segmentados

– <sources>: diretório com os fontes descompactados do software a ser compilado

BuildhistoryBuildhistory

● Mecanismo de log que registra o que foi gerado durante a compilação (pacotes e imagens)

● Útil para visualizar diferenças entre, por exemplo, duas versões de imagens

● Baseado em git

Ativando buildhistoryAtivando buildhistory

● Editar o arquivo

~/src/fsl-community-bsp/build/conf/local.conf

e adicionar:

INHERIT += "buildhistory"

BUILDHISTORY_COMMIT = "1"

● É necessário reexecutar o BitBake para que o buildhistory passe a registrar dados

Adicionando camadas (layers)Adicionando camadas (layers)

● Para adicionar uma camada, basicamente é preciso adicionar o caminho para ela à variável BBLAYERS, a qual fica no arquivo $BUILDDIR/conf/bblayers.conf

Anatomia de uma camadaAnatomia de uma camada

● Camadas normalmente seguem uma estrutura como:– <dir camada>/classes

– <dir camada>/conf

– <dir camada>/recipes-<categoria1>

– <dir camada>/recipes-<categoria...>

Onde <dir camada> normalmente é o nome da camada (e.g., meta-fsl-arm)

Anatomia de uma camada (conf)Anatomia de uma camada (conf)

● <dir camada>/conf deve possuir pelo menos o arquivo de configuração da camada: layer.conf, o qual pode ser usado para configurar variáveis.

● Exemplos de configurações:– Onde receitas podem ser encontradas na camada em

questão

– Prioridade da camada em caso de conflito de receitas

Anatomia de uma camada (layer.conf)Anatomia de uma camada (layer.conf)# We have a conf and classes directory, add to BBPATHBBPATH .= ":${LAYERDIR}"

# We have a packages directory, add to BBFILESBBFILES += "${LAYERDIR}/recipes-*/*/*.bb ${LAYERDIR}/recipes-*/*/*.bbappend"

BBFILE_COLLECTIONS += "fsl-arm"BBFILE_PATTERN_fsl-arm := "^${LAYERDIR}/"BBFILE_PRIORITY_fsl-arm = "5"

FSL_EULA_FILE = "${LAYERDIR}/EULA"

FSL_MIRROR ?= "http://www.freescale.com/lgfiles/NMG/MAD/YOCTO/"

MIRRORS += " \${FSL_MIRROR} http://download.ossystems.com.br/bsp/freescale/source/ \n \"

# Let us add layer-specific bbappends which are only applied when that# layer is included in our configurationBBFILES += "${@' '.join('${LAYERDIR}/%s/recipes*/*/*.bbappend' % layer \ for layer in BBFILE_COLLECTIONS.split())}"

Anatomia de uma camada Anatomia de uma camada (conf/machine)(conf/machine)

● O diretório <dir camada>/conf/machine contém arquivos de descrição de máquinas, normalmente usados para configurar variáveis relacionadas à arquitetura de hardware da máquina para a qual pretende-se compilar software (e.g., imx23evk.conf)

● Esse diretório é opcional, mas normalmente está presente em camadas que implementam BSPs

● Os nomes dos arquivos nesse diretório (sem extensão) são usados como valores para a variável MACHINE em $BUILDDIR/conf/local.conf

Anatomia de uma camada Anatomia de uma camada (conf/machines/imx23evk.conf) (conf/machines/imx23evk.conf)

#@TYPE: Machine#@NAME: Freescale i.MX23 Evaluation Kit#@SOC: i.MX23#@DESCRIPTION: Machine configuration for Freescale i.MX23 Evaluation Kit

include conf/machine/include/mxs-base.inc

SOC_FAMILY = "mxs:mx23"

IMXBOOTLETS_MACHINE = "stmp378x_dev"UBOOT_MACHINE = "mx23evk_config"

KERNEL_IMAGETYPE = "uImage"KERNEL_DEVICETREE = "${S}/arch/arm/boot/dts/imx23-evk.dts"

SDCARD_ROOTFS ?= "${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.rootfs.ext3"IMAGE_FSTYPES ?= "tar.bz2 ext3 uboot.mxsboot-sdcard sdcard"

MACHINE_FEATURES = "apm usbgadget usbhost vfat alsa touchscreen"

Anatomia de uma camadaAnatomia de uma camada(recipes-<categoria>)(recipes-<categoria>)

● Diretórios que contêm as receitas disponibilizadas pela camada, organizadas por categoria

● Exemplos: – recipes-qt: receitas relacionadas à biblioteca Qt

– recipes-kernel: receitas de kernels

Aplicando patchesAplicando patches

Considerando uma receita de nome “foo” e um patch “fix.patch”:● Patches são referenciados pela variável SRC_URI

no arquivo .bb (receita)● SRC_URI += “file://fix.patch”

Armazenamento de patchesArmazenamento de patches

● Patches ficam dentro de diretórios especiais no diretório da receita. Exemplos:– foo/files/fix.patch : o patch poderá ser referenciado por

qualquer receita no diretório “foo”

– foo/bar/fix.patch : o patch poderá ser referenciado apenas pela receita “bar” (qualquer versão)

– foo/bar-1.0/fix.patch : o patch poderá ser referenciado apenas pela receita “bar”, versão 1.0

Passo-a-passo: criação de uma camadaPasso-a-passo: criação de uma camada

Objetivo:● Criar uma camada meta-treinamento contendo uma

receita hello-freescale e agregá-la ao BSP fsl-community-bsp

Passo-a-passo: criação de uma camada Passo-a-passo: criação de uma camada

● yocto-layer create meta-treinamento -o \ ~/src/fsl-community-bsp/sources/meta-treinamento 4

Passo-a-passo: criação de uma camadaPasso-a-passo: criação de uma camada(agregando a camada ao diretório de trabalho)(agregando a camada ao diretório de trabalho)

echo 'BBLAYERS += " ${BSPDIR}/sources/meta-treinamento "' >> \

~/src/fsl-community-bsp/build/conf/bblayers.conf

Passo-a-passo: criação de uma camadaPasso-a-passo: criação de uma camada(criação de uma receita)(criação de uma receita)

● Entrando do diretório de fontes da camada– cd ~/src/fsl-community-bsp/sources/meta-treinamento

● Criando o diretório da receita– mkdir -p recipes-treinamento/hello-freescale

● Criando o diretório para o código da aplicação (não usual)– mkdir recipes-treinamento/hello-freescale/hello-freescale

● Escrevendo o código da “aplicação”– echo 'int main () { puts("Hello FreeScale"); }' > \

recipes-treinamento/hello-freescale/hello-freescale/hello-freescale.c

Passo-a-passo: criação de uma camadaPasso-a-passo: criação de uma camada(arquivo da receita)(arquivo da receita)

Em: ~/src/fsl-community-bsp/sources/meta-treinamento/recipes-treinamento/hello-freescale/hello-freescale_1.0.bb

DESCRIPTION = "A Hello World application"SECTION = "console/utils"LICENSE = "CLOSED"

SRC_URI = "file://hello-freescale.c"

S = "${WORKDIR}"

do_compile () { ${CC} -o hello-freescale hello-freescale.c}

do_install () { install -d ${D}/${bindir} install -m 755 hello-freescale ${D}/${bindir}/hello-freescale}

Passo-a-passo: criação de uma camadaPasso-a-passo: criação de uma camada(geração do pacote)(geração do pacote)

● Gerando o pacote para a receita– cd ~/src/fsl-community-bsp/build

– bitbake hello-freescale

Passo-a-passo: criação de uma camadaPasso-a-passo: criação de uma camada(verificação do pacote)(verificação do pacote)

● Verificando o conteúdo do pacote gerado– rpm -qlp \

tmp/deploy/rpm/armv7a_vfp_neon/hello-freescale-1.0-r0.armv7a_vfp_neon.rpm

– mkdir test

– cd test

– rpm2cpio \ ../tmp/deploy/rpm/armv7a_vfp_neon/hello-freescale-1.0-r0.armv7a_vfp_neon.rpm | cpio -i --make-directories

– file usr/bin/hello-freescale

usr/bin/hello-freescale: ELF 32-bit LSB executable, ARM, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.16, BuildID[sha1]=0xdf0a4bcbe5872d18a571d51e6ee10895198c84c6, stripped

Passo-a-passo: criação de uma camadaPasso-a-passo: criação de uma camada(aplicação de patch)(aplicação de patch)

● Gerar o patch– cd

~/src/fsl-community-bsp/sources/meta-treinamento/recipes-treinamento/hello-freescale

– cp hello-freescale/hello-freescale.c hello-freescale/hello-freescale.c.orig

– sed -i 's/Hello FreeScale/Hello, FreeScale./' hello-freescale/hello-freescale.c

– diff -u hello-freescale/hello-freescale.c.orig hello-freescale/hello-freescale.c > hello-freescale/fix.patch

– mv hello-freescale/hello-freescale.c.orig hello-freescale/hello-freescale.c

● Adicionar fix.patch a SRC_URI na receita– SRC_URI = "file://hello-freescale.c file://fix.patch"

● Usar bitbake para regerar o pacote

Passo-a-passo: criação de uma camadaPasso-a-passo: criação de uma camada(verificando aplicação de patch)(verificando aplicação de patch)

less ~/src/fsl-community-bsp/build/tmp/work/armv7a-vfp-neon-poky-linux-gnueabi/hello-freescale/1.0-r0/temp/log.do_patch

...NOTE: Applying patch 'fix.patch' (../sources/meta-treinamento/recipes-treinamento/hello-freescale/hello-freescale/fix.patch)

...

Passo-a-passo: criação de uma camadaPasso-a-passo: criação de uma camada(criação de uma imagem)(criação de uma imagem)

● A criação de uma imagem consiste em criar uma nova receita

● Novas imagens normalmente herdam características de imagens básicas disponíveis no Yocto (e.g., core-image)

Passo-a-passo: criação de uma camadaPasso-a-passo: criação de uma camada(receita da imagem)(receita da imagem)

● ~/src/fsl-community-bsp/sources/meta-treinamento/recipes-treinamento/images/treinamento-image.bb

DESCRIPTION = "Imagem para treinamento de Yocto"

LICENSE = "MIT"

inherit core-image

CORE_IMAGE_EXTRA_INSTALL += "hello-freescale"● bitbake treinamento-image

Passo-a-passo: criação de uma camadaPasso-a-passo: criação de uma camada(explorando buildhistory)(explorando buildhistory)

● Diretório onde ficam registrados dados relativos a histórico de compilação de receitas– ~/src/fsl-community-bsp/build/buildhistory

● Organizado por pacotes, imagens e SDKs

Passo-a-passo: criação de uma camadaPasso-a-passo: criação de uma camada(verificando imagem)(verificando imagem)

● Verificando se o pacote hello-freescale foi incluído na imagem (buildhistory)– cd

~/src/fsl-community-bsp/build/buildhistory/images/wandboard_dual/eglibc/treinamento-image

– grep hello-freescale installed-packages.txt

● Verificando se o arquivo binário foi incluído na imagem– grep hello-freescale files-in-image.txt

Passo-a-passo: criação de uma camadaPasso-a-passo: criação de uma camada(copiando imagem para cartão SD)(copiando imagem para cartão SD)

● Arquivos de imagens ficam em– ~/src/fsl-community-bsp/build/tmp/deploy/images

● Escrevendo imagem em cartão de memória– Conecte o cartão de memória no slot

– No VirtualBox, disponibilize dispositivo com o cartão de memória para a máquina virtual (menu Devices)

– Execute “dmesg” no sistema da máquina virtual e veja qual dispositivo ficou associado ao cartão de memória

– cd ~/src/fsl-community-bsp/build/tmp/deploy/images

– sudo dd if=treinamento-image-wandboard-dual.sdcard of=/dev/<dispositivo correspondente ao cartão> bs=1M

Passo-a-passo: criação de uma camadaPasso-a-passo: criação de uma camada(console serial)(console serial)

● Conectando-se à placa através de console serial– Use o cabo USB<->DB9 para conectar a placa ao seu

computador

– No VirtualBox, disponibilize dispositivo USB (ao qual o cabo está conectado) para a máquina virtual (menu Devices)

– sudo screen /dev/ttyUSB<n> 115200● <n> é um número (0 se nenhum outro dispositivo estiver

conectado)

Passo-a-passo: SDK com EclipsePasso-a-passo: SDK com Eclipse

Objetivos:● Configurar a IDE Eclipse com um SDK gerado

pelo Yocto● Criar um projeto/aplicação “helloworld” para testar

o SDK

Passo-a-passo: SDK com EclipsePasso-a-passo: SDK com Eclipse(configuração do ambiente)(configuração do ambiente)

● Instalação do plugin do Yocto no Eclipse:– http://www.yoctoproject.org/docs/1.4/dev-manual/dev-manual.html#adt-e

clipse

● Gerar o toolchain– bitbake meta-toolchain

● Após gerar o SDK, ele deve ser instalado:

$ cd tmp/deploy/sdk

$ sudo ./poky-<arch>-toolchain-<version>.sh● O SDK será instalado em:

/opt/poky/<version>/

http://www.yoctoproject.org/docs/1.4/dev-manual/dev-manual.html#adt-eclipse

http://www.yoctoproject.org/docs/1.4/dev-manual/dev-manual.html#adt-eclipse

Passo-a-passo: SDK com EclipsePasso-a-passo: SDK com Eclipse(configuração do ambiente)(configuração do ambiente)

● Configurar o plugin do Yocto no Eclipse para usar o SDK:– No Eclipse, clicar no menu “Window”, submenu “Preferences”

– Na lista à esquerda, clicar em “Yocto Project ADT”

– Na caixa “Cross Compiler Options”:● Selecionar “Standalone pre-built toolchain”● Em “Toolchain Root Location” colocar o diretório raiz do SDK

(e.g:, /opt/poky/<version>/)● Em “Sysroot Location” colocar o diretório do sysroot desejado

(/opt/poky/<version>/sysroots/<target_sysroot>)● Em “Target Architecture” selecionar a arquitetura da placa

– Na caixa “Target Options” selecionar “External HW”

Passo-a-passo: SDK com EclipsePasso-a-passo: SDK com Eclipse(criação do projeto helloworld)(criação do projeto helloworld)

● No Eclipse, clicar no menu "File", submenu "New", submenu "Project..."● Selecionar "C Project", clicar em "Next"● Digitar um nome para o novo projeto: “helloworld”● Expandir a pasta "Yocto Project ADT Project"● Selecionar "Hello World ANSI C Autotools Project", clicar em "Next"

– Existem outros dois templates que poderiam ser utilizados também: “Empty Project” e “Hello World GTK C Autotools”; todos são pré-configurados com Autotools

● Se desejado, incluir mais informações no projeto, como: "Author", "Copyright notice", "Hello world greeting", o diretório "Source" e "License". Clicar em "Finish"

● Nesse ponto o projeto “helloworld” está criado

Passo-a-passo: SDK com EclipsePasso-a-passo: SDK com Eclipse(build do projeto helloworld)(build do projeto helloworld)

● Para compilar:– No Eclipse, clicar no menu "Project", submenu

"Reconfigure Project". Isso deve ser feito apenas quando uma configuração de projeto mudar

– No Eclipse, clicar em "Project", submenu "Build Project"

● Nesse ponto, o binário do programa será gerado

Passo-a-passo: SDK com EclipsePasso-a-passo: SDK com Eclipse(geração da imagem)(geração da imagem)

● Adicionar ao arquivo $BUILDDIR/conf/local.conf:

IMAGE_FEATURES += "eclipse-debug"

● Gerar a imagem– bitbake treinamento-image

Passo-a-passo: SDK com EclipsePasso-a-passo: SDK com Eclipse(deploy do projeto helloworld)(deploy do projeto helloworld)

● Configuração da placa:– Colocar a placa em rede com a máquina de desenvolvimento

– Iniciar o sistema

– Verificar o IP da placa

$ /sbin/ifconfig (mostrará o IP)● Caso não estiver com IP, atribuir um IP estático. Ex.:

$ sudo ifconfig eth0 10.9.0.1

– Verificar se o “TCF Agent” está em execução

$ ps | grep tcf (deve mostrar o processo em execução)● Caso não estiver em execução, iniciar o serviço:

$ sudo /etc/init.d/tcf-agent start


● Configuração da máquina de desenvolvimento:– No Eclipse, clicar no menu "Run", submenu "Debug configurations"

– Na área da esquerda, expandir "C/C++ Remote Application"

– Localize o projeto para trazer as configurações para a área da direita

– No campo "Connection", se houver uma configuração pronta para a placa, basta selecioná-la. Estas conexões são vinculadas por IP da placa, ou seja, se o IP da placa for o mesmo, pode-se usar a mesma conexão. Caso seja necessário criar uma nova, deve-se:

● clicar no botão "New" para criar uma nova conexão com a placa● Selecionar "TCF" (Target Communication Framework), clicar em "Next"● Preencher o endereço IP da placa, o nome da conexão e se desejado, a descrição da

conexão. Clicar em "Finish" para criar a conexão

– Colocar um caminho absoluto (esse caminho ficará no sistema de arquivos da placa) para a aplicação, clicar em "Apply"


● Configuração da máquina de desenvolvimento (continuação):– Ainda na mesma janela, clicar em "Debug" para iniciar a aplicação na

placa

– A primeira vez que ela for executada, uma tela de login será exibida. Deve-se fazer o login com as credenciais da placa e clicar em "OK"

– Será pedida a mudança de perspectiva (elementos que compõem a interface) no Eclipse, aceitar ou negar conforme o gosto pessoal (na dúvida, aceitar)

● Neste ponto a aplicação está rodando em modo debug (com GDB) e está parada em um breakpoint. Para continuar a execução, pressionar “F8” no teclado

Obrigado

yocto: treinamento em português

Technology