yocto: treinamento em português
TRANSCRIPT
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
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>/
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
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"
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
Obrigado