Esempio di sviluppo per Raspberry Pi con Windows e Ubuntu

Lo sviluppo per Raspberry Pi di applicazioni è uno di quegli argomenti di cui si fa un gran discutere nei forum e nei gruppi di discussione in genere. Tuttavia, predisporre un ambiente di sviluppo ben strutturato è uno dei passi fondamentali per produrre software in modo rapido ed efficace.

In questa sintetica guida ho voluto descrivere come predisporre un ambiente di sviluppo, volutamente più complesso del necessario, che prevedesse l’uso di un PC Windows unicamente come workstation centrale. Ho voluto andare a favore di coloro che desiderano mantenere il proprio ambiente Desktop di Microsoft Windows.

Sono profondamente convinto che lo sviluppo di software dovrebbe essere fatto in un ambiente quanto più omogeneo possibile. Come dire: se sviluppo software per GNU/Linux, uso tutti strumenti GNU/Linux; soprattutto voglio evitare il più possibile emulazioni di ogni tipo.

A tale proposito ho voluto prevedere un sistema di sviluppo basato su Xubuntu, che nella fattispecie sarà virtualizzato con VirtualBox, che sarà equipaggiato con tutti gli strumenti necessari (compilatori, librerie, eccetera) per produrre eseguibili per architettura ARM in poco tempo e senza troppi inutili grattacapi.

Introduzione allo sviluppo software

Articoli di Riferimento

Al fine di una migliore comprensione di questa guida permettermi di suggerirti la lettura dei seguenti articoli, i quali ti potrebbero essere di aiuto se deciderai di replicare l’ambiente qui descritto.

• Come Installare VirtualBox sul Proprio PC Windows. Un’utilissima guida su come installare una infrastruttura di virtualizzazione che utilizzeremo successivamente per creare Macchine Virtuali.
• Come Creare una Macchina Virtuale VirtualBox per Ubuntu. Ci sarà molto utile comprendere cone creare una istanza di Macchina Virtuale dove andremo ad installare un sistema Ubuntu dedicata allo sviluppo software.
• Come installare Xubuntu 16.04 in macchina virtuale VirtualBox. Una sintetica guida dedicata a come installare Ubuntu come Macchina Virtuale, invece di utilizzare una più costosa macchina fisica.
• Come fare Cross Compile per Raspberry Pi con Ubuntu X86. Un How-To che approfondisce il cross-compile; ossia, come usare un sistema di sviluppo per produrre software per sistemi con CPU di architetture di diversa natura.

Tuttavia, per una migliore comprensione dell’intero percorso di avvicinamento alla creazione di un ambiente integrato per la compilazione di software per Raspberry Pi, direi che è molto utile includere anche:

• Come Trasferire il Sistema Operativo Raspbian su SD per Raspberry Pi

• Come accedere con Remote Desktop di Windows a XUbuntu

Obbiettivo da Raggiungere

L’obbiettivo che questa guida intende raggiungere, consiste nel creare un ambiente di sviluppo eterogeneo con lo scopo finale di poter sviluppare software per Raspberry Pi (con processore RISC ed architettura ARM) tramite un sistema di sviluppo su sistema operativo GNU Linux, senza rinunciare all’ambiente Microsoft Windows del proprio PC (con processore CISC ed architettura X86) al quale molti sono ormai abituati e non intendono in alcun modo abbandonare del tutto.

L’ambiente di sviluppo che andrò ad illustrare è rappresentato schematicamente in questa immagine.

L’immagine precedente rappresenta soltanto una struttura logica che ha bisogno di essere dettagliata in modo più approfondito per rappresentarla nel mondo reale.

Ebbene, queste sono le caratteristiche fisiche dell’ambiente, così come è stato effettivamente realizzato in laboratorio.

• La LAN Laboratorio è effettivamente una Local Area Network che mette in comunicazione tutte le macchine. Essa è realizzabile anche tramite il LAN Switch a 4 porte, solitamente integrato nel Modem/Router che abbiamo a casa pr collegarci con l’ADSL ad internet.
• La macchina PC-Windows è un normale computer desktop (abbastanza recente) con un processore Intel i5 oppure i7, RAM quanto basta, 1 Hard Disk con diversi Gigabytes di spazio libero. Insomma, niente di speciale.
• La macchina GNU/Linux (Ubuntu) è il vero motore del sistema di sviluppo. Tuttavia, questa non è una macchina fisica, bensì una macchina virtuale installata all’interno del PC-Windows in esecuzione all’interno dell’ambiente di virtualizzazione VirtualBox.
• La macchina Raspberry Pi Versione 3B è il celeberrimo Single Board Computer a basso costo, nel quale è stato preventivamente installato il sistema operativo Raspbian. Esso rappresenta la macchina “Target“, ovvero quella dove sarà effettivamente mandato in esecuzione il software prodotto con la macchina di sviluppo GNU/Linux (Ubuntu).

E le frecce rosse nell’immagine, cosa sono? Presto detto!

I Flussi di dati

Le linee rosse tratteggiate, e relative frecce, indicano le comunicazioni da macchina e macchina. Ma scendiamo nel dettaglio per capire un po meglio come questo avviene e cosa significhino realmente

• Dalla macchina PC-Windows ci collegheremo alla macchina (in questo caso “virtuale” ma potrebbe benissimo essere una macchina fisica) GNU/Linux (Ubuntu) utilizzando il Remote Desktop di Windows, che usa il protocollo RDP sulla porta TCP/3389. Attraverso questa soluzione, è possibile accedere al desktop della macchina GNU/Linux (Ubuntu) dal desktop del nostro PC-Windows,senza troppe complicazioni.
• Dalla macchina PC-Windows Potremo collegarci al Raspberry Pi utilizzando il noto Tool PuTTY per Windows, che utilizza il protocollo SSH sulla porta TCP/22. Attraverso questa soluzione è possibile interagire con la macchina Raspberry Pi tramite linea di comando.
• Dalla macchina GNU/Linux (Ubuntu) potremo eventualmente collegarci al Raspberry Pi con il protocollo SSH sulla porta TCP/22, per interagire tramite linea di comando. Potremo inlotre utilizzare i protocolli SCP sulla porta TCP/22, FTP sulla porta TCP/21 ed il protocollo RSYNC sulla porta TCP/873 per trasferire i files dalla macchina GNU/Linux (Ubuntu) al Raspberry Pi.

Installazione del software utile allo sviluppo

Macchina PC-Windows

Potrebbe senz’altro esserci molto utile installare i seguenti software aggiuntivi nel nostro PC-Windows, per ragioni che saranno presto ben chiare.

• PuTTY – Software Open Source per la comunicazione tramite protocollo SSH, Telnet , emulazione Terminale su Porta Seriale (e non solo) in ambiente Microsoft Windows.
• XMing – Software di emulazione di X-Server per Windows; utile per esportare le singole finestre di un ambiente grafico GNU/Linux (Gnome, Xfce, ecc.) nell’ambiente grafico di Microsoft Windows.
• FileZilla – Software Client Open Source per la communicazione FTP (e non solo) in ambiente Microsoft Windows.
• VirtualBox – Software di virtualizzazione, la cui installazione e configurazione è ampiamente dettagliata in uno degli articoli menzionati più sopra, in questa guida.

Macchina GNU/Linux – Xubuntu

Essendo questa la vera e propria macchina di sviluppo, qui andremo ad installare i seguenti software:

1. Openssh-Server – Per poter accedere da remoto alla riga di comando di questa macchina.
2. Compilatore C/C++ – I Build Tools C/C++ per la compilazione del codice sia per architettura X86 che per ARM (in modo da poter creare codice per entrambe le architetture)
3. CodeBloks – L’ambiente integrato per lo sviluppo (IDE – Integrated Development Environment) che utilizzeremo per sviluppare il codice.

installazione ed attivazione ssh

L’unico pacchetto da installare per attivare il servizio ssh è openssh-server; la cui installazione, da riga di comando, è di fatto molto semplice:

$ sudo apt-get install openssh-server

Al completamento dell’installazione di openssh-server, è verificare che l’installazione del pacchetto openssh-server abbia anche avviato ed attivato il servizio ssh.

$ sudo service ssh status
● ssh.service - OpenBSD Secure Shell server
   Loaded: loaded (/lib/systemd/system/ssh.service; enabled; vendor preset: enabled)
   Active: active (running) since sab 2017-04-01 21:18:36 CEST; 2min 11s ago
 Main PID: 12956 (sshd)
   CGroup: /system.slice/ssh.service
           └─12956 /usr/sbin/sshd -D
apr 01 21:18:36 jeremy systemd[1]: Starting OpenBSD Secure Shell server…
apr 01 21:18:36 jeremy sshd[12956]: Server listening on 0.0.0.0 port 22.
apr 01 21:18:36 jeremy sshd[12956]: Server listening on :: port 22.
apr 01 21:18:36 jeremy systemd[1]: Started OpenBSD Secure Shell server.
apr 01 21:19:25 jeremy sshd[13050]: Accepted password for massimo from 192.168.0.200 port 33536 ssh2
apr 01 21:19:25 jeremy sshd[13050]: pam_unix(sshd:session): session opened for user massimo by (uid=0)
$

Il cui risultato, ci informa che il servizio ssh.service è running.

Installazione Compilatori C/C++ per X86 e ARM

Installiamo ora i seguenti pacchetti software per:

• build-essential per X86
• Cross-Compile ARM

Pacchetti di build-essential per X86

Anche se non strettamente necessario per il cross compile, installeremo il necessario per compilare per X86 (ti potrebbe tornare utile comunque per eventuali compilazioni di codice per target nativo).
Il ché si traduce nell’installazione di una serie di pacchetti software raggruppati come build-essential, la cui installazione può essere effettuata con questi semplici comandi da finestra terminale.

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install build-essential

… e sempre da terminale, verifica che il compilatore gcc sia correttamente eseguibile e quale sia la versione in uso, con il seguente comando

$ gcc --version
gcc (Ubuntu 5.4.0-6ubuntu1~16.04.4) 5.4.0 20160609
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
$

Stessa cosa per il compilatore c++, con il seguente comando

$ c++ --version
c++ (Ubuntu 5.4.0-6ubuntu1~16.04.4) 5.4.0 20160609
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
$

Che corrisponde esattamente a quanto atteso.

Pacchetti per il Cross-Compile ARM

Installiamo ora tutto il necessario per il cross-compile, con i seguenti comandi da terminale.

sudo apt-get install gcc-arm-linux-gnueabi
sudo apt-get install g++-arm-linux-gnueabi
sudo apt-get install binutils-arm-linux-gnueabi

Noterai, che non c’è un pacchetto software simile a build-essential per ARM, ma ciò che serve va installato manualmente pacchetto per pacchetto.

facciamo una rapida verifica del compilatore gcc:

$ arm-linux-gnueabi-gcc --version
arm-linux-gnueabi-gcc (Ubuntu/Linaro 5.4.0-6ubuntu1~16.04.4) 5.4.0 20160609
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
$

Stessa cosa anche per il compilatore cpp:

$ arm-linux-gnueabi-cpp --version
 arm-linux-gnueabi-cpp (Ubuntu/Linaro 5.4.0-6ubuntu1~16.04.4) 5.4.0 20160609
 Copyright (C) 2015 Free Software Foundation, Inc.
 This is free software; see the source for copying conditions.  There is NO
 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
$

Installazione dello IDE Code::Block

Procediamo ora con l’installazione dello IDE Code::Blocks per lo sviluppo, con il seguente comando da terminale

$ sudo apt-get install codeblocks

Che possiamo anche provare ad avviare da riga di comando:

$ codeblocks

… E se tutto è andato secondo le previsioni, Code::Blocks dovrebbe apparire sullo schermo in tutto il suo splendore.

Ovviamente non sarà necessario avviare Code::Block ogni volta da riga di comando; noterai infatti che nel menu principale del desktop di Xubuntu, nella sezione Sviluppo, è ora disponibile un nuovo elemento dedicato proprio all’avvio di Code::Blocks direttamente dall’ambiente grafico.

Configurazione della ToolChain di Code::Block

Ora che sono stati installati tutti gli strumenti necessari, è necessario configurare Code::Blocks in modo che i progetti che decideremo di compilare per i sistemi ARM (Raspberry Pi) vengano efettivamente compilati con il compilatore appropriato.

Per fare questo, dovrai avviare Code::Blocks (dal menu dell’interfaccia grafica di Xubuntu o da riga di comando) ed eseguire la seguente breve procedura:

Dalla barra di menu di Code::Blocks, clicca su: Settings → Compiler. Si aprirà la schermata relativa al settaggio dei parametri del compilatore.

Quindi, nella sezione Selected compiler, clicca su Copy. Si aprirà una piccola schermata che ti permetterà di inserire un nuovo nome.

Inserisci il nuovo nome per questo settaggio: GNU GCC Compiler per ARM e clicca su OK, per tornare alla schermata precedente.

Qui assicurati che sia selezionato il nuovo compilatore appena creato e modifica i valori, come mostrato nella figura seguente.

Clicca su OK, per salvare e chiudere.

Ora sei pronto per creare il tuo primo programma da compilare ed eseguire su Raspberry Pi.

Primo test di compilazione ed esecuzione su Raspberry

Puoi provare il tuo primo test di compilazione, creando un nuovo progetto di tipo Console Application con Code::Blocks e compilarlo per ARM utilizzando il setup di compilatore illustrato più sopra. Prova con il classico helloworld.c, per cominciare.

/* Hello World program */
 include 
 main()
 {
     printf("Hello World");
     return 0;
 }

Una volta compilatore linkato (completato il Build del progetto), trasferiscilo sul tuo Raspberry Pi ed eseguilo.

Conclusioni

Come vedi, anche se l’ambiente che ho voluto predisporre era volutamente più complesso del necessario, non è stato poi così complicato. Anzi, mi sentirei di dire l’esatto contrario.

L’enorme vantaggio dell’obbiettivo che abbiamo raggiunto, consiste nel fatto che l’ambiente di sviluppo appena realizzato è replicabile per qualsiasi altro tipo di sviluppo di software, non solo per Raspberry Pi. L’aver impiegato una macchina virtuale infatti ha fatto si che l’ambiente di sviluppo risultante sia estremamente flessibile, oltre che sicuro.

Note su questo Post

Questo post nasce dall’esigenza di rendere il più possibile fruibili, alcuni specifici argomenti squisitamente tecnici, che per via della loro natura necessitano di essere arricchiti da illustrazioni, approfondimenti, esempi, suggerimenti, commenti e quant’altro sia utile ad una chiara comprensione delle tematiche trattate, ivi compresi, un linguaggio tecnico appropriato e l’impiego di link esterni a siti autoritativi di riferimento.

In particolar modo, questo post mira ad essere un supporto per gli studenti delle scuole di informatica che a vario titolo partecipano ad alcuni nostri progetti interni, i quali sono mirati ad una stretta collaborazione con le scuole nell’ambito della Alternanza Scuola Lavoro, del quale maggiori approfondimenti sono riportati alla pagina del Progetto Scuola.

Condividi