Em todo processo de desen­volvi­mento de soft­ware temos basi­ca­mente os seguintes passos:

Cod­i­ficar -> Com­pi­lar -> Tes­tar

Porém, quando esta­mos desen­vol­vendo uma apli­cação que será com­pi­lada em uma plataforma mas exe­cu­tada em outra, entre as eta­pas de com­pi­lação e teste existe mais uma, respon­sável pela trans­fer­ên­cia da apli­cação (ou binário) da máquina de desen­volvi­mento (host) para a plataforma alvo (target):

Cod­i­ficar -> Com­pi­lar -> Tran­ferir -> Testar

Esta etapa é comum em sis­temas embar­ca­dos. E é crítica, pois depen­dendo do mecan­ismo uti­lizado, pode con­sumir um bom tempo do processo de desenvolvimento.

Me lem­bro que uns 10 anos atrás, quando ainda estava ini­ciando na área de soft­ware embar­cado, eu tra­bal­hava com um equipa­mento de automação que uti­lizava uma EPROM como memória de programa.

A EPROM é uma memória de ape­nas leitura, mas que pode ser apa­gada através da incidên­cia de luz ultra­vi­o­leta em uma janelinha pequena situ­ada na parte supe­rior do chip:

A vida nesta época não era fácil. Não tín­hamos uma fer­ra­menta de debug decente. Para cada sim­ples alter­ação no código, tín­hamos que apa­gar uma EPROM e gravar o novo binário para tes­tar. Este processo de com­pi­lar, gerar o binário, apa­gar a EPROM e gravar a imagem podia levar até 30 min­u­tos, depen­dendo do tamanho do pro­grama. Cada mudança no código pre­cisava então ser muito bem pen­sada para que o processo de gravação do binário na memória não tomasse muito tempo durante o desen­volvi­mento da aplicação.

Já hoje este processo ficou muito mais sim­ples, rápido e fácil. Com a evolução das memórias flash e das fer­ra­men­tas de debug, con­seguimos car­regar a apli­cação na memória facil­mente via conexões JTAG, RS232 ou Eth­er­net. Temos a opção de tra­bal­har com fer­ra­men­tas disponi­bi­lizadas pelos fab­ri­cantes (gravar na flash via ser­ial ou JTAG, por exem­plo), ou então podemos aproveitar as fun­cional­i­dades disponi­bi­lizadas pelo sis­tema opera­cional que esta­mos utilizando.

O Linux facilita este processo para nós. Através de uma conexão em rede com nossa plataforma alvo, podemos copiar o arquivo alter­ado para o rootfs do equipa­mento usando fer­ra­men­tas de rede como o ssh ou o ftp.

Um outro mecan­ismo, tam­bém muito uti­lizado no desen­volvi­mento de sis­temas embar­ca­dos com Linux, é mon­tar o sis­tema de arquivos (rootfs) remo­ta­mente através do pro­to­colo NFS (Net­work File Sys­tem).

Desta forma, o sis­tema de arquivos da plataforma alvo fica na máquina de desen­volvi­mento. No boot do equipa­mento o ker­nel irá bus­car na rede e mon­tar remo­ta­mente o sis­tema de arquivos através do pro­to­colo NFS.

Este processo facilita o desen­volvi­mento, já que qual­quer alter­ação que fiz­er­mos no sis­tema de arquivos con­fig­u­rado da máquina de desen­volvi­mento será refletido no equipamento.

Vamos ver então como con­fig­u­rar uma máquina de desen­volvi­mento com Linux e o kit Friendl­yARM mini2440 para tra­bal­har com um sis­tema de arquivos em rede.

Estas serão as con­fig­u­rações bási­cas que utilizaremos:

• IP do host (máquina de desen­volvi­mento): 10.0.0.1
• IP do tar­get (mini2440): 10.0.0.2
• Local do sis­tema de arquivos: /home/mini2440/rootfs

Todos os coman­dos que ver­e­mos a seguir serão basea­dos nes­tas con­fig­u­rações. Mude se achar necessário.

CONFIGURANDO O PC COM LINUX

Con­fig­ure a inter­face de rede conec­tada à mini2440 (no meu caso estou usando a inter­face eth1, mude se necessário):

sudo ifconfig eth1 10.0.0.1

Instale e con­fig­ure o servi­dor NFS com os coman­dos abaixo (estou usando o geren­ci­ador de pacotes do Ubuntu, por­tanto adapte os coman­dos ao seu sistema):

sudo apt-get install nfs-kernel-server portmap
sudo chmod a+w /etc/exports
sudo echo -e "\n/home/mini2440/rootfs 10.0.0.2(rw,no_root_squash,sync)\n" >> /etc/exports
sudo /etc/init.d/portmap restart
sudo /etc/init.d/nfs-kernel-server restart

Pre­cis­are­mos disponi­bi­lizar o sis­tema de arquivos no diretório “/home/mini2440/rootfs”. Para isso, você pode gerar um rootfs com o Buil­d­root (expliquei isso aqui). A imagem será ger­ada den­tro do diretório do Buil­d­root em “output/images/rootfs.ext2″. Você pode mon­tar este arquivo “rootfs.ext2″ com comando abaixo:

sudo mount -o loop rootfs.ext2 /home/mini2440/rootfs

Se você não quiser gerar um rootfs do zero, pode tam­bém uti­lizar um já disponível como o do Emde­bian que usei neste artigo aqui. Lembre-se de descompactá-lo no diretório que defin­i­mos “/home/mini2440/rootfs”.

CONFIGURANDO O KIT MINI2440

Ini­cie a placa pelo U-boot (se seu kit não tiver o U-boot insta­l­ado veja como fazer isso neste artigo aqui), e exe­cute os coman­dos abaixo:

setenv serverip 10.0.0.1
setenv ipaddr 10.0.0.2
setenv bootargs mini2440=0tb console=ttySAC0,115200 ip=10.0.0.2 root=/dev/nfs rw nfsroot=10.0.0.1:/home/mini2440/rootfs
saveenv

TESTANDO

Para tes­tar a conexão de rede, dig­ite na linha de comando do U-boot “ping 10.0.0.1″ e veja se recebe a resposta “host 10.0.0.1 is alive”. Se não rece­ber, reveja suas conexões de rede.

Reini­cie o equipa­mento e veja na con­sole o ker­nel mon­tando o rootfs remo­ta­mente. Acesse a con­sole com usuário “root” e senha vazia. Agora, para qual­quer alter­ação que você quiser fazer no equipa­mento, basta atu­alizar os arquivos no diretório “/home/mini2440/rootfs” na sua máquina de desenvolvimento.

Fácil, não?

Um abraço e até a próxima!

Ser­gio Prado