1. Yocto: Sua próxima Plataforma de Desenvolvimento
para Linux Embarcado
Otavio Salvador
Diretor Técnico
Mario Goulart
Desenvolvedor

2. 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

3. Á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
● ...

4. Usando a máquina virtual para oUsando 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”

5. 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.)

6. O que o Yocto fazO que o Yocto faz
● Download de código fonte
● Aplicação de patches
● Compilação cruzada
● Gerenciamento de pacotes

7. O que o Yocto geraO que o Yocto gera
● Pacotes binários
● Imagens de sistemas Linux
● Toolchains
● SDKs (Software Development Kits)

8. HistóricoHistórico

9. 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

10. 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

11. 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

12. 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}

13. 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

14. 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

15. 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

16. 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"

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

18. 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.

19. 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).

20. Explorando o diretório de trabalho doExplorando 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

21. Explorando o diretório de trabalho doExplorando 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.

22. Explorando o diretório de configuraçãoExplorando 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)
●

23. Explorando o diretório de trabalho doExplorando 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.

24. Explorando o diretório de trabalho doExplorando 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.

25. Organização do diretórioOrganizaçã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

26. 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

27. 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

28. 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

29. 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)

30. 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

31. Anatomia de uma camada (layer.conf)Anatomia de uma camada (layer.conf)
# We have a conf and classes directory, add to BBPATH
BBPATH .= ":${LAYERDIR}"
# We have a packages directory, add to BBFILES
BBFILES += "${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 configuration
BBFILES += "${@' '.join('${LAYERDIR}/%s/recipes*/*/*.bbappend' % layer
for layer in BBFILE_COLLECTIONS.split())}"

32. Anatomia de uma camadaAnatomia 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

33. Anatomia de uma camadaAnatomia 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"

34. 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

35. 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”

36. 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

37. 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

38. Passo-a-passo: criação de uma camadaPasso-a-passo: criação de uma camada
● yocto-layer create meta-treinamento -o
~/src/fsl-community-bsp/sources/meta-treinamento 4

39. 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

40. 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

41. 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
}

42. 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

43. 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.rp
m | 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

44. 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/hell
o-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

45. 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-lin
ux-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)
...

46. 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)

47. 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/reci
pes-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

48. 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

49. 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/wandboar
d_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

50. 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

51. 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)

52. 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

53. 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>/

54. 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”

55. 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

56. 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

57. 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

58. 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

59. Passo-a-passo: SDK com EclipsePasso-a-passo: SDK com Eclipse
(deploy do projeto helloworld)(deploy do projeto helloworld)
● 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"

60. Passo-a-passo: SDK com EclipsePasso-a-passo: SDK com Eclipse
(deploy do projeto helloworld)(deploy do projeto helloworld)
● 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

61. Obrigado