Em todo processo de desenvolvimento de software temos basicamente os seguintes passos:

Codificar -> Compilar -> Testar

Porém, quando estamos desenvolvendo uma aplicação que será compilada em uma plataforma mas executada em outra, entre as etapas de compilação e teste existe mais uma, responsável pela transferência da aplicação (ou binário) da máquina de desenvolvimento (host) para a plataforma alvo (target):

Codificar -> Compilar -> Tranferir -> Testar

Esta etapa é comum em sistemas embarcados. E é crítica, pois dependendo do mecanismo utilizado, pode consumir um bom tempo do processo de desenvolvimento.

Me lembro que uns 10 anos atrás, quando ainda estava iniciando na área de software embarcado, eu trabalhava com um equipamento de automação que utilizava uma EPROM como memória de programa.

A EPROM é uma memória de apenas leitura, mas que pode ser apagada através da incidência de luz ultravioleta em uma janelinha pequena situada na parte superior do chip:

A vida nesta época não era fácil. Não tínhamos uma ferramenta de debug decente. Para cada simples alteração no código, tínhamos que apagar uma EPROM e gravar o novo binário para testar. Este processo de compilar, gerar o binário, apagar a EPROM e gravar a imagem podia levar até 30 minutos, dependendo do tamanho do programa. Cada mudança no código precisava então ser muito bem pensada para que o processo de gravação do binário na memória não tomasse muito tempo durante o desenvolvimento da aplicação.

Já hoje este processo ficou muito mais simples, rápido e fácil. Com a evolução das memórias flash e das ferramentas de debug, conseguimos carregar a aplicação na memória facilmente via conexões JTAG, RS232 ou Ethernet. Temos a opção de trabalhar com ferramentas disponibilizadas pelos fabricantes (gravar na flash via serial ou JTAG, por exemplo), ou então podemos aproveitar as funcionalidades disponibilizadas pelo sistema operacional que estamos 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 alterado para o rootfs do equipamento usando ferramentas de rede como o ssh ou o ftp.

Um outro mecanismo, também muito utilizado no desenvolvimento de sistemas embarcados com Linux, é montar o sistema de arquivos (rootfs) remotamente através do protocolo NFS (Network File System).

Desta forma, o sistema de arquivos da plataforma alvo fica na máquina de desenvolvimento. No boot do equipamento o kernel irá buscar na rede e montar remotamente o sistema de arquivos através do protocolo NFS.

Este processo facilita o desenvolvimento, já que qualquer alteração que fizermos no sistema de arquivos configurado da máquina de desenvolvimento será refletido no equipamento.

Vamos ver então como configurar uma máquina de desenvolvimento com Linux e o kit FriendlyARM mini2440 para trabalhar com um sistema de arquivos em rede.

Estas serão as configurações básicas que utilizaremos:

• IP do host (máquina de desenvolvimento): 10.0.0.1
• IP do target (mini2440): 10.0.0.2
• Local do sistema de arquivos: /home/mini2440/rootfs

Todos os comandos que veremos a seguir serão baseados nestas configurações. Mude se achar necessário.

CONFIGURANDO O PC COM LINUX

Configure a interface de rede conectada à mini2440 (no meu caso estou usando a interface eth1, mude se necessário):

sudo ifconfig eth1 10.0.0.1

Instale e configure o servidor NFS com os comandos abaixo (estou usando o gerenciador de pacotes do Ubuntu, portanto adapte os comandos 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

Precisaremos disponibilizar o sistema de arquivos no diretório "/home/mini2440/rootfs". Para isso, você pode gerar um rootfs com o Buildroot (expliquei isso aqui). A imagem será gerada dentro do diretório do Buildroot em "output/images/rootfs.ext2". Você pode montar 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 também utilizar um já disponível como o do Emdebian que usei neste artigo aqui. Lembre-se de descompactá-lo no diretório que definimos "/home/mini2440/rootfs".

CONFIGURANDO O KIT MINI2440

Inicie a placa pelo U-boot (se seu kit não tiver o U-boot instalado veja como fazer isso neste artigo aqui), e execute os comandos 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 testar a conexão de rede, digite 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 receber, reveja suas conexões de rede.

Reinicie o equipamento e veja na console o kernel montando o rootfs remotamente. Acesse a console com usuário "root" e senha vazia. Agora, para qualquer alteração que você quiser fazer no equipamento, basta atualizar 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!

Sergio Prado