Cross-compiling para Raspberry

Cross-compiling para Raspberry

Cross-compiling para Raspberry

O intuito primário era falar sobre o sshfs, mas o processo é muito simples, então decidi agregar recursos ao artigo. Por isso, veremos dessa vez como preparar um ambiente de cross-compiling para Raspberry.

Quanto ao sshfs, o processo é o mesmo para qualquer sistema, mas a vantagem de ter um filesystem sobre ssh em um Raspberry é o fato de poder programar para o Raspberry a partir de um notebook e apenas fazer a compilação remota do programa. É um tutorial curto, mas que casará bem com outros tutoriais que estão evoluindo nos rascunhos de minhas publicações.

Instalar o SSHFS

O primeiro passo é instalar o sshfs. Para isso, apenas faça:

sudo apt-get install sshfs

Agora basta montar o sistema de arquivos remoto em algum diretório local:

mkdir ~/sshfs_pi
sudo sshfs -o allow_other,default_permissions pi@ns1:/home/pi/projects sshfs_pi/

Depois, um ‘ls’ no diretório local:

sshfs
sshfs

Preparando o ambiente de cross-compiling

Sugiro fortemente a instalação de alguns pacotes previamente:

sudo apt-get install rsync cmake ia32-libs git binutils-multiarch

Clone o repositório das ferramentas para Raspberry Pi:

git clone https://github.com/raspberrypi/tools.git

Isso deve levar um belo tempo, tenha paciência. O próximo passo é fazer o export do path para o compilador:

mkdir raspberry && mv tools raspberry
export PATH=$PATH:$HOME/raspberry/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/

Você pode colocar isso em algum script de inicialização, mas se colocar no ~/.bashrc sugiro que tenha alguma verificação se o path já não foi inserido, porque a cada vez que você abrir um terminal o arquivo .bashrc é executado novamente e seu path pode se transformar em um texto gigante.

Dentro do diretório contendo as ferramentas, adicione as libs do Raspberry. No caso, tenho um RPi que que uso para controlar algumas coisas da casa e dele mesmo (como reboot, ligar monitor, habilitar ssh), tudo por MQTT. COmo o desenvolvimento será testado nele, dele copiei os diretórios /lib e /usr para dentro do diretório ~/raspberry/rootfs:

rsync -rl --safe-links pi@ns1:/{lib,usr} ~/raspberry/rootfs/

Deve levar mais um bocado de tempo. Enquanto isso, aproveite para criar o arquivo cmake para a compilação manual (pi.cmake dentro do diretório ~/raspberry):

SET(CMAKE_SYSTEM_NAME Linux)
SET(CMAKE_SYSTEM_VERSION 1)
SET(CMAKE_C_COMPILER $ENV{HOME}/raspberry/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/arm-linux-gnueabihf-gcc)
SET(CMAKE_CXX_COMPILER $ENV{HOME}/raspberry/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/arm-linux-gnueabihf-g++)
SET(CMAKE_FIND_ROOT_PATH $ENV{HOME}/raspberry/rootfs)
SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

E já crie também o diretório build:

mkdir -p ~/raspberry/source/build

Entre primeiramente no diretório source e crie o arquivo CMakeLists.txt:

cmake_minimum_required (VERSION 2.6)
project (hello)
add_executable(hello hello.c)

Claro, dentro de sources você precisa ter um arquivo hello.c. Crie um assim:

#include <stdio.h>

int main()
{
  printf("Hello, man!\n");
  return 0;
}

Para fazer a compilação manual (após o término da cópia das libs do RPi), simplesmente faça isso:

cd ~/raspberry/source
#crie um arquivo basico para teste e...
cd build
cmake -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberry/pi.cmake ../
make

Isso deverá gerar seu binário para RPi. Claro, não será possível executá-lo localmente devido à diferença das plataformas. Repare na imagem a seguir como foi todo o processo:

cross-compiling
cross-compiling

A partir desse ponto, você tem duas opções; ou linkar o diretório de compilação para o seu sshfs, ou fazer a compilação local e copiar para o Raspberry posteriormente. Eis o teste do binário no RPi:

hello world
hello world

Mas dá pra melhorar. Por exemplo, podemos adicionar o cross-compiler à IDE do Code::Blocks, de forma a produzir binários diretamente, sem maiores complicações. Bem, existem as complicações iniciais, mas nem são tantos passos.

Adicionar toolchain à IDE do Code::Blocks

No menu Settings, clique na opção Compiler. Abrir-se-á uma janela com o título em “Global compiler settings”. Vá diretamente ao botão “Copy”. Uma nova janela se abrirá e nela você deve especificar um nome. Eu coloquei  simplesmente “Raspberry Pi”.

Na quarta aba dessa mesma janela (entitulada como “Toolchain executables”) você deverá adicionar o path do toolchain. Deve ficar mais ou menos assim:

Configurar toolchain no Codeblocks
Configurar toolchain no Codeblocks

Quando criar um novo projeto, o Wizard sempre lhe dá a opção de escolher o toolchain em sua última aba. Basta escolher agora “Raspberry Pi”. Compile o main do projeto novo e já deverá obter algo pra testar:

codeblocks
codeblocks

Copie o binário para o Raspberry e execute-o:

teste final
teste final

E isso é tudo por ora. Estou com alguns rascunhos quase finalizados e os posts tem saido de forma mais lenta devido ao meu envolvimento em projetos complexos, mas acredito que consiga liberar mais uns dois ou três artigos patrocinados essa semana.

Recomendo também que dê uma lida nesse artigo de emulação com QEmu.

Inscreva-se no nosso newsletter, alí em cima à direita e receba novos posts por email.

Siga-nos no Do bit Ao Byte no Facebook.

Prefere twitter? @DobitAoByte.

Inscreva-se no nosso canal Do bit Ao Byte Brasil no YouTube.

Nossos grupos:

Arduino BR – https://www.facebook.com/groups/microcontroladorarduinobr/
Raspberry Pi BR – https://www.facebook.com/groups/raspberrybr/
Orange Pi BR – https://www.facebook.com/groups/OrangePiBR/
Odroid BR – https://www.facebook.com/groups/odroidBR/
Sistemas Embarcados BR – https://www.facebook.com/groups/SistemasEmbarcadosBR/
MIPS BR – https://www.facebook.com/groups/MIPSBR/
Do Bit ao Byte – https://www.facebook.com/groups/dobitaobyte/

Próximo post a caminho!

Agregador de Links - Loucuras da Net

Deixe uma resposta