Embarcados UNIFOR

domingo, 1 de dezembro de 2013

Aula 6 - Integração Buildroot 2013.05 com eclipse

Aula 6 - Integração Buildroot 2013.05 com Eclipse

Configurando o Buildroot

Entre nas opções de configuração do Builroot:

make menuconfig

Em Toolchain -> marque

[*] Register Toolchain within Eclipse Builroot plug-in

Recompile o Builroot:

make

Adcionando plug-in no Eclipse

Execute o Eclipse e acesse o menu Help -> Install New Software. No campo “Work with”, adicione a URL http://buildroot.org/downloads/eclipse/(juno/ ou kepler/) e instale o SDK do Buildroot.

Criando um novo projeto

Acesse File ->New -> C Project, selecione Executable e em Toolchain Builroot Arm, clique em finish.

Escreva um código simples, faça um build e o execute.

Aula 8 - Debugando remotamente uma aplicação

Instalando Dependências

Caso tenha gerado a imagem no buildroot, ele fornece a instalação desses ferramentas ao marca-las.

Para a placa de desenvolvimento:

sudo apt-get update
sudo apt-get install gdbserver
sudo apt-get install ssh

Para o Ambiente de desenvolvimento (Eclipse):

C/C++ DFS GDB Debugger Integration
C/C++ Remote Launch
Remote System Explorer End-User Runtime
Remote System Explorer User Actions

Preparando a Conexão

Descubra o endereço da placa de desenvolvimento:

sudo ifconfig

Caso esteja debugando uma aplicação em uma rede local, você pode configurar um ip estático para a placa de desenvolvimento e em /etc/host do ambiente de desenvolvimento, adicionar o ip dessa placa e um nome para lincagem.

O /etc/host é responsável por lincar endereços locais e nomes de computadores

sudo gedit /etc/host

Adicione o ip da placa de desenvolvimento e um nome para referência:

ip_placa nome_referencia

Teste a conexão:

ping nome_referencia

No ambiente de desenvolvimento:

ssh nome_referencia

Responda YES.

Configurando Eclipse

No Eclipse, com seu projeto aberto, execute Windows -> Open Perspective ->Other e selecione Remoter System Explorer

Em File ->Nem -> Other, expanda o Remote System Explorer e selecione Connection.

Clique em Next e selecione Linux.

Clique em Next, Em Host Name forneça o endereço de ip da placa de desenvonvimento e em Connection name um nome para a conexão.

Clique Next, em Configuration selecione ssh.files.

Clique Next, selecione processes.shell.Linux.

Clique Next, selecione ssh.shells

Clique Next, selecione ssh.terminals e clique Finish.

Em Remote Systems, clique com o botão direito em cima do nome da conexão e selecione propriedades.

Você pode mudar algumas configurações da conexão. Em Default User ID você tem a optção de fazer com que a aplicação execute como root, atribuindo a seu campo root, clique OK.

Criando .gdbinit

No ambiente de desenvolvimento, entre na pasta do projeto pelo terminal.

cd /diretorio_projeto

Crie um arquivo vazio.

touch .gdbinit

Configurando o Debug

No Eclipse, selecione Run -> Debug Configurations.

Na aba C/C++ Remote Application, selecione a sua configuração criada.

Na aba Main, em Connection, selecione sua conexão criada.

Em Project, selecione o nome de seu projeto.

Em Build Configuration, selecione Use Active, assim poderá utilizar a configuração criada anteriormente.

Em Remote Absolute File Path Fot C/C++ Application, escolha o diretório e o arquivo que você deseja fazer o upload do arquivo executável na placa de desenvolvimento.

Em Commands to execute before applications, você do atribuir comandos antes do arquivo executável ser iniciado, por motivo de permição de usuário, é recomendado executar o chmod por prevenção.

comando /ditorio_aplicacao/arquivo_executavel

Selecione a aba Debugger, no campo GDB debugger especifique o cliente gdb. Talvez tenha que fazer uma mudança de porta para o debugger.

Clique Apply.

As configurações essenciais terminaram, o projeto pode ser debugado remotamente.

sábado, 30 de novembro de 2013

Aula 7 - Criando um Device Driver

Este tutorial descreve a criação de um device drive básico

Comando Úteis

modprobe argumento - Carrega o módulo do kernel do Linux, verificando suas dependências.
modinfo argumento - Fornece informações sobre o módulo.
insmod argumento - Carrega o módulo no kernel do Linux.
rmmod argumento - Remove o módulo no Kernel do Linux.

Informações

No diretório /dev está contido arquivos de dispositivos, arquivos especiais e simples nós para a arvore do sistema de arquivo.

Identificação:

Major number: identifica o driver associado com o dispositivo, especificando o tipo de dispositvo.
Minor number: identifica o dispositivo a ele referenciado.

Data Structures Importantes

File Operations: o file_operations structure é o meio em que o dispositivo "char" estabelece um conexão. Cada campo do file_operations structure implementa específicas funções para manipulação do dispositivo. Cabendo desenvolvedor estabelecer links esntre as funções do file_operation structure e o código. Ex:

struct file_operations scull_fops = {

.owner = THIS_MODULE,

.llseek = scull_llseek,

.read = scull_read,

.write = scull_write,

#retirada nas versão mais novas do kernel

.ioctl = scull_ioctl,

.open = scull_open,

.release = scull_release,

};

File Structure: representa abrir um arquivo(open file), ele é criado pelo kernel na abertura sendo passado para qualquer função que opera no arquivo até o último fechamento.
Inode Structure: é usada internamente pelo kernel para representar arquivos.

Código Exemplo

Quando for programar código para o kernel (módulos, drivers, etc), a Standily Liby C não é usada, por padrão, a implementação tem que usar as funções do próprio kernel.

/*
* "Hello, world!"
*/

/*
* Alguns headers necessário para o Device Driver
*/
#include <linux/init.h>
#include <linux/module.h>

/*
* A função init() é a primeira função executada quando o módulo
* é carregado. Ele executará somente uma vez quando o módulo
* é carregado
*/

static int __init
hello_init(void)
{
printk("Hello, world!\n");
return 0;
}

/*
* A função macro do Kernel
*/

module_init(hello_init);

/*
* Similar a init(), essa função é chamada quando queremos
* descarregar o módulo no kernel
*/

static void __exit
hello_exit(void)
{
printk("Goodbye, world!\n");
}

module_exit(hello_exit);

/*
* Algumas informações para o módulo
*/
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jack Beagle <http://embarcadosunifor.blogspot.com.br>");
MODULE_DESCRIPTION("\"Hello, world!\" modulo mínimo");
MODULE_VERSION("printk");

Makefile

Abaixo o exemplo de um makefile, para geração de um modulo para o Hello Word.

# obj-m é uma lista para os modulodos do kernel para build.
# O .o e outros objetos serão automaticamente gerados

obj-m := hello.o

# KDIR é a localização dos arquivos do kernel que
# serão utlizados para da build

KDIR := /lib/modules/$(shell uname -r)/build

# PWD é o diretório atual e da localização do nosso
# módulo.
PWD := $(shell pwd)

# Faz a linkagem de nosso modulo e o arquivos do kernel para
# compilar e gerar os arquivos necessários..
default:
$(MAKE) -C $(KDIR) M=$(PWD) modules

Carregando o módulo

Entre no diretório do projeto:

make

Para carrega o módulo:

sudo insmod ./hello.ko

Verificar:

dmesg | tail

Remover módulo:

sudo rmmod hello

Verificar:

dmesg | tail

Debugando

Printk: Fornece mensagens de acordo com o logleves das mensagens

printk (KERN_DEBUG "Erro:% s:% i \ n", __ FILE__, __ line_ & _);

printk (KERN_CRIT "Erro Grave % p \ n", ptr);

Há oito possíveis seqüências de LogLevel definidos no <linux/kernel.h> :

KERN_EMERG

Usado para mensagens de emergência, geralmente aqueles que precedem um acidente.

KERN_ALERT

Uma situação que requer ação imediata.

KERN_CRIT

Condições críticas, muitas vezes relacionados com graves falhas de hardware ou software.

KERN_ERR

Usado para relatar condições de erro; drivers de dispositivos, muitas vezes, usar KERN_ERR relatar dificuldades de hardware.

KERN_WARNING

Avisos sobre situações problemáticas que não, em si mesmos, criar sérios problemas com o sistema.

KERN_NOTICE

Situações que são normais, mas ainda digno de nota. Uma série de condições relacionadas à segurança são relatados a este nível.

KERN_INFO

Mensagens informativas. Muitos motoristas imprimir informações sobre o hardware que encontram no momento da inicialização, a este nível.

Aula 5 - Configurando servidor e cliente usando NFS/TFTP

Aula 5 - Configurando servidor e cliente usando NFS/TFTP

Instalando NFS Cliente e NFS Servidor (Ubuntu/Debian)

Parte1:

Parte 2:

Servidor:

sudo apt-get update
sudo apt-get install nfs-kernel-server nfs-common

Cliente:

sudo apt-get update
sudo apt-get install nfs-common

Opções do NFS

Algumas opções que podemos utilizar em "/etc/exports" para compartilhamento de arquivos:

ro : Fornecer acesso somente leitura para os arquivos compartilhados para o cliente.

rw : Fornece a escrita e leitura para os arquivos compartilhados para o cliente.

sincronização : Sincronização confirma pedidos para o diretório compartilhado apenas uma vez as mudanças foram cometidos.

no_subtree_check : Esta opção evita que o sub verificação. Quando um diretório compartilhado é o subdiretório de um sistema de arquivos maior, nfs realiza varreduras de todos os diretórios acima dele, a fim de verificar suas permissões e detalhes. Desativando o sub verificação pode aumentar a confiabilidade do NFS , mas reduzir a segurança .

no_root_squash : permite o root se conectar ao diretório referente.

Comando importantes do NFS

showmount -e : Informa os compartilhamentos disponíveis de sua máquina local
showmount -e <ip_servidor>: Lista de disponíveis compartilhamentos para o servidor remoto
showmount -d :Informa as lista de todos os subdiretórios.
exportfs -v : Informa uma lista de todos os arquivos compartilhados e opções do servidor.
exportfs -a : Exporta todas as lista de modificações do servidor /etc/exports
exportfs -u : Não exporta as lista compartilhadas em /etc/exports
exportfs -r : Atualiza a lista de modificações do servidor /etc/exports

Configurando o NFS Servidor

Crie um diretório para ser usado pelo servidor:

mkdir /diretório

Acesse o arquivo presente nesse diretório "/etc/exports", aparecerá :

# /etc/exports: the access control list for filesystems which may be exported
# to NFS clients. See exports(5).
#
# Example for NFSv2 and NFSv3:
# /srv/homes hostname1(rw,sync,no_subtree_check) hostname2(ro,sync,no_subtree_check)
#
# Example for NFSv4:
# /srv/nfs4 gss/krb5i(rw,sync,fsid=0,crossmnt,no_subtree_check)
# /srv/nfs4/homes gss/krb5i(rw,sync,no_subtree_check)
#
//começo da configurações

//Exemplo de configuração:
//pasta_a_ser_compartilhada ip_do_cliente(opções_de_configuração)

//Neste caso o servidor fina na própria máquina
/home/david/Nfs 127.0.0.1(rw,sync,no_root_squash)

No terminal:

Execute o comando para resetar o servidor:

sudo /etc/init.d/nfs-kernel-server restart

Execute o comando atualiza e exporta a lista de "etc/exports"

sudo exportfs -ra

Configurando NFS Cliente:

Execute o comando abaixo e verifique se a pasta do servido está dusoinível:

showmount -e ip_do_servidor

Crie uma pasta onde será montado a pasta do servidor:

mkdir /mnt/local_montagem

Para montar a pasta do servidor, execute:

mount -t nfs ip_do_servidor:/pasta_compartilhada /mnt/local_motagem

Para verificar informações da montagem, execute:

sudo mount | grep nfs

Para uma montagem automática, entre no arquivo "etc/fstab":

sudo nano /etc/fstab

Adicione a lina e reinicie a máquina:

ip_do_servidor:/pasta_servidor /local_montagem nfs defaults 0 0

Instalando TFTP Cliente e TFTP Servidor (Ubuntu/Debian)

Servidor:

sudo apt-get update
sudo apt-get install tftpd-hpa xinetd

Client:

sudo apt-get update
sudo apt-get install tftp

Configuração

Verifique a instalação:

/usr/sbin/in.tftpd -V

Crie um arquivo /etc/xinetd.d/tftp

sudo gedit /etc/xinetd.d/tftp

Edit o arquivo criado:

No campo user forneça o usuário que irá acessar a pasta.

No campo server_args forneça o diretório da pasta o qual será acessado.

Crie a pasta sendo o mesmo diretório em server_args

sudo mkdir /tftpbood

Mude a permissão da pasta, neste caso foi setado todas as permissões:

sudo chmod -R 777 /tftpboot

Mude o dono da pasta para, sendo o mesmo em user ou pode usar o parâmetro nobody para deixar a pasta sem dono:

sudo chown -R nobody /tftpbood

Restart o serviço do xinetd

sudo /etc/init.d/xinetd restart

Verificando a troca de arquivos

Verifique se o acesso local do tftp:

netstat -l -u | grep ftp

Crie um arquivo na pasta setada para o servidor:

touch /tftpboot/test

Se estiver testando na máquina local :

tftp localhost (127.0.0.1)

Se o servidor está em outra máquina:

Teste a conexão:

ping ip_servidor

Estabelecendo conexão:

tftp ip_servidor

Use ? para lista os comandos:

Escreva algo no arquivo do diretório do servidor, neste caso em test e use o comando abaixo para receber o arquivo::

get test /diretorio_alvo

Feche a conexão:

quit

terça-feira, 27 de agosto de 2013

Aula 4 - Instalando e configurando BuildRoot no Fedora

Este tutorial descreve a instalação e configuração do BuildRoot

Descrição

BuildRoot é um sistema utilizado para criar sistemas Linux embedded, podendo gerar: toolchain, bootloader, kernel e rootfs.

Instalação do BuildRoot

Entre no site do BuildRoot (http://buildroot.uclibc.org/download.html) e faça download da última versão

Ou pode ir no terminal, entre na pasta alvo (usando o comando cd) e digite:

wget http://buildroot.net/downloads/buildroot-"versão".tar.bz2

Neste caso versão: 2013.05

Entre no diretório onde foi baixado o buildroot e no terminal execute:

tar -jxvf buildroot-2013.05.tar.bz2

Será necessário instalar algumas dependencias para o BuildRoot, execute:

Para o Fedora 19:

sudo yum update
sudo yum install -y wget subversion binutils bzip2 gawk gettext flex ncurses-devel zlib-devel make patch unzip perl-ExtUtils-MakeMaker glibc glibc-devel glibc-static quilt ncurses-lib sed sdcc intltool sharutils bison

Para o Debian 7(Wheezy):

sudo apt-get update
sudo apt-get install subversion build-essential libncurses5-dev zlib1g-dev gawk

Entre na pasta do BuildRoot e execute:

make menuconfig

Aparecerá uma interface gráfica simples, a base de cursor para a configuração.
Algumas destas configurações é necessário analisar o datasheet do processador ou do kit de desenvolvimento.

Em Target Architetecture, deverá escolhe a arquitetura do processador para o sistema alvo, no caso estamos gerando para um ARM, então deve ser verificado se o mapeamento de memória utilizado pelo seu ARM é little endian ou big endian, para o Cortex A8 seria o little endian.

Em "Target Architecture Variant", deve ser escolhida a família do processar, neste caso Cortex A8.

Em "Build options": tem a opção de mudar diretório base, algumas configurações do compilador e debug.
Neste caso foi apenas adicionado 1 em "Number of jobs to run simultaneously", isto é responsável por configurar o número de cores que vão ser utilizados na máquina alvo.

Em "Toolchain": tem a opção de escolher a versão do kernel headers, a Toolchain, o uClibc, o GCC e Binutils Options.
Para cada módulo apresenta um conjunto de opções para incluir quando o sistema for gerado, neste caso:

O "Enable large file (files > 2 GB) suppport".

"Enable WCHAR support" foi abilitado.

Em "System configuration": tem a opção de escolher o nome do sistema, a codificação de senha, permições, taxa de transmição e número da porta.

Neste caso foi escolhido o nome LinuxEmbedded em "System hostname".

E a porta ttyO2 em "Port to run a getty (login prompt) on".

Em "Package Selection for the target: tem a opção de obter outros pacotes que o usuário achar necessário.

Em "Host utilities": aparecerá opções de utilitátios para o Host, sendo que ele tem que ser compatíveis com o bootloader escolhido, sendo analisado mais a frente. Marque as opções "host omap-u-boot-utils" e "host u-boot tools".

Em "Filesystem images": pode escolher o tipo do filesystem de acordo com a necessidade, neste caso foi escolhido "ext2/3/4 root filesystem", pois o dispositivo de armazenamento é um SD-Card, e em seu subtópico ext2(rev0))(apresenta um menor consumo de espaço em disco).

No caso de usar uma Memoria Flash Externa, marque "Ubifs root filesystem", umas das sucessoras do jffs2, ela apresenta um desempenho melhor comparada ao seu antecessor, desmarque "tar the root filesystem".
Pode ser necessário configurar os endereços referente a memória flash alvo, faça as modificações necessárias e salve.

Em "Bootloaders": pode ser selecionado o tipo do bootloader, neste caso o U-Boot, pois seus utilitários já foram escolhidos anteriormente e é um dos mais usados, sendo possível fazer algumas configurações. Pode ser modificado o nome em "U-Boot board name", sua versão em "U-Boot Version", a extensão do U-Boot em "U-Boot binary format".

O nome tem que ser um disponível no repositório do U-Boot e que sirva para a arquitetura do micro, neste caso ():

Versão do U-Boot escolhida 2013.05:

O formato da extensão será .img:

Marque "U-Boot SPL support" e renomeie para MLO.

Em "Kernel", marque "Linux Kernel"; modifique "Defconfig name" pode ser escolhido a arquitetura alvo, em arch/<type>/configs/ aparecerá as arquiteturas suportadas pelo kernel, neste caso (), "Kernel version"pode ser escolhido a versão do kernel, faça as modificações que achar necessário e salve as configurações.

Volte para o terminal e de execute o comando "make" para gerar os arquivos com as configurações setadas anteriormente, pode ser necessário baixar alguns arquivos, mas estes serão baixados automaticamente.

Os arquivos gerados vão esta na pasta alvo.

quarta-feira, 21 de agosto de 2013

Aula 3 - Instalação do eclipse (C/C++) no Fedora

Este tutorial descreve a instalação do eclipse.

Instalação do Eclipse

Entre no site do Eclipse Juno (http://www.eclipse.org/juno/) e baixe o Eclipse para o C/C++ na distribuição Linux 32 bits.

Instale o compilador de C/C++ a partir do repositório do Fedora, entre no terminal e digite(Comando para Fedora 19):

sudo yum update
sudo yum install make automake gcc gcc-c++ kernel-devel.
sudo tar -vzxf diretório/nome_do_arquivo

Entre na pasta do Eclipse e execute seu aplicativo.

Para criar um projeto C:

File > New > C Project

Projeto padrão:

Digite o nome do projeto, sua localização, escolha Empty Project e ToolChains escolha Linux, clique Finish.

Projeto exemplo em C(Hello World):

Digite o nome do projeto, sua localização, escolha "Hello World" e ToolChains escolha Linux, clique Finish.

Para criar um projeto em C++:

File > New > C++ Project

Aparecerá o projeto criado na janela a esquerda do Eclipse, clique com o botão direito e escolha propriedades:

Entre opção C/C++ Build.

Em Builder Settings, na Opção Builder Type pode ser escolhido um compilador interno ou externo, neste caso optaremos pelo externo, então escolha a opção External Builder, clique OK.

Para testar o projeto exemplo (Hello World), escolha Build Project, após o Binários serem gerados, execute o Run.

Quando a mensagem aparecer significa que o Eclipse foi devidamente configurado.

sábado, 10 de agosto de 2013

Aula 2 - Instalando o Fedora na Máquina Virtual

Este tutorial descreve a instalação do Fedora numa Máquina Virtual.

Requerimentos:

Mínimo de 1Gb de memória RAM e 10GB de memória livre no disco rígido
VirtualBox instalado

Instalação do Fedora

Entre no site do Fedora (http://fedoraproject.org/), baixe seu instalador de 32 bits (devido ao maior suporte) e a GUI de sua preferencia(Neste exemplo o usa-se o Fedora 19).

Execute o VirtualBox e escolha a opção "Novo" para criar e configurar uma nova máquina virtual.

Escolha um nome para a máquina virtual pela opção "Name", caso ele não identifique o Sistema Operacional automaticamente, caso não identifique, escolha o tipo do Sistema Operacional em "Type" e a distribuição em "Version" e escolha a opção continuar.

Escolha a quantidade de memória RAM a ser utilizada pela máquina virtual, a escolhida neste caso foi de 2GB, este valor pode ser mudado quando criado a máquina virtual e escolher a opção "Configuração", clique em continue.

Após isso aparecerá 3 opções:

Não criar disco de armazenamento virtual.
Cria um novo disco rígido virtual associado a maquina virtual.
Utiliza um disco rígido virtual criado anteriormente para associar-se a máquina virtual.

A opção escolhida neste caso seria a 2, pois estamos criando uma máquina virtual do zero, clique em "Criar".

Aparacerá um lista de tipos de aquivo para o novo disco rígido virtual, escolhemos a "VDI(VirtualBox Disk Image)", pois é a padrão do VirtualBox, clique em próximo.

Você deverá escolher o tipo de armazenamento em disco:

Dinamicamente alocado - Ele ocupará espaço no disco físico a medida que forem adicionados novos arquivos até o tamanho máximo do espaço ocupado pelo disco virtual. O tamanho máximo de seu disco virtual pode ser aumentado com uso de outras ferramentas.
Tamanho fíxo - Ele começara ocupando espaço no disco físco igual ao tamanho máximo do espaço ocupado pelo disco virtual.

A 1º opção de Dinamicamente alocado foi escolhido neste caso.

Você devera escolher o nome do novo disco virtual, sua localização e o limite máximo que o disco virtual ocupará no disco físico, clique em "Criar".

Selecione o espaço desejado para o disco virtual.

Após criado a máquina virtual, escolha a opção "Configurações", aparecerá informações extras da maquina virtual e sugestões de modificações.

Entre em configurações e selecione as configurações que julgar necessárias como:

Compartilhar um pasta entre a máquina virtual e sua máquina física na opção "Pasta compartilhadas".

Habilitar o envio de arquivos via drag and drop.

Habilitar a USB na opção "USB".

Alterar o tamanho da memória RAM utilizada na opção "Sistema", "Placa-Mãe" e "Memória Base".

Inicie a maquina virtual, aparecerá um informativo do VirtualBox feche a janela ou escolha para não aparecer mais, logo após pedirá para escolher uma .iso para instalação, entre na pasta onde está a distribuição do Fedora e o escolha.

Inicie o Fedora por boot da ISO.

Escolha o idioma desejado e clique em "Continuar".

Esta tela permitirá alterar configurações de Data e Hora, Layout do Teclado, Configuração de rede e a Instalação.

Na opção "Teclado", aparecerá sugestões de layout para o teclado, podendo adicionar novas na opção "+" ou remover na opção "-", o layout no topo será o utilizado como padrão.

Na opção "Instalação", poderá configurar o disco para instalar o Fedora, pode adicionar e configurar um disco manualmente na opção "Adicionar um disco.." ou utilizar o disco reconhecido, neste caso o disco virtual, clique em finalizar.

Aparecerá 2 opções de configuração:

Configurar automaticamente - O próprio instalador particiona e configurar a instalação(Opção usada).
Reve/Modificar - O usuário pode modificar o particionamento e a configuração da instalação.

O tipo de partição utilizado é o LVM (Padrão no Fedora).

Após esses passos clique em "Continuar".

A instalação voltará para a tela de opções, se não tiver mais modificações clique em "Iniciar a Instalação".

O sistema começará a ser instalado e será necessário configurar uma conta de "ROOT" e de usuário, recomenda-se usar senhas mais "forte" para o "ROOT", pois ele é o administrador com maior privilégio no sistema.