EOS Book@0 Free - Down PDF

{2
Il primo EOS-Book monotematico!
E’ con viva e vibrante soddisfazione che sono a presentarvi il primo

EOS-Book monotematico, anzi, quasi bitematico! Infatti all’interno contiene 2 tuto-
rial partendo da zero, il primo su Embedded GNU/Linux, adatto a programmatori che
vogliono addentrarsi nell’affascinante mondo di Linux professionale, imparando a
compilare il Kernel, preparare il root filesystem fino ad arrivare a realizzare una distro
minimale ma funzionante per il RasPI.
Raspberry PI che poi sarà protagonista del secondo tutorial, una guida adatta a tutti,
informatici e “smanettoni” (al secolo makers) per imparare a configurarlo corretta-
mente, ottimizzarlo per la navigazione web, utilizzarlo per creare un Dropbox perso-
nale dove salvare i propri file per renderli accessibili dalla stessa rete Ethernet o Wifi
alla quale è connesso il nostro RasPI o addirittura tramite internet fino ad un altro PC
o dispositivo mobile. Vedremo anche come realizzare un media center completo di
telecomando IR, sfruttando uno dei tanti telecomandi che abbiamo in casa ;)
Infine, vorrei far notare sulla copertina il cambio di simbolo iniziale che precede la
numerazione e che identificherà anche in seguito gli EOS-Book extra riservati agli
abbonati Platinum!
EOS-Book @0 mettetevelo nello stack!
Emanuele Bonanni
3}
Embedded GNU/Linux
partendo da zero
1. Ricompilare il kernel
Introduzione lavorando.
C
reare un sistema GNU/Linux da zero costi- Per agevolare la lettura, l’articolo è strutturato in
tuisce un buon esercizio per comprendere più parti distinte:
alcuni aspetti chiave del suo funzionamen- • preparazione del kernel
to interno. • preparazione del root filesystem
Tuttavia, oltre all’aspetto didattico, ci sono an- • integrazione e test su QEMU [2]
che risvolti pratici Tutti i passaggi illustrati di seguito sono stati te-
interessanti: conoscere i componenti e gli stru- stati su un sistema desktop GNU/Linux usando
menti base che servono a costruire un sistema la recente distribuzione Ubuntu 12.04.1.
GNU/Linux ci permette spesso, specie in ambito

embedded, di generare ambienti più compat- Requisiti
ti ed efficienti rispetto alle soluzioni general- Il primo requsito per creare un sistema GNU/
purpose messe a disposizione dal fornitore del Linux consiste nello scegliere un’architettura
prodotto o della board di sviluppo su cui stiamo target. Dato che l’articolo ha un taglio prevalen-
temente orientato all’embedded e vista la pre-
Embedded G N U/Li nux par t endo da zer o {4
donimanza delle architetture ARM in tale setto-

re, opteremo per un’architettura ARM.
Una volta scelta l’architettura target abbiamo bi-
sogno di due componenti fondamentali:
1. una piattaforma di prova su cui testare il no-
stro sistema
2. una toolchain che ci permetta di cross-com-
pilare i binari che vanno a costituire l’intero
sistema operativo
Nel nostro caso prenderemo in esame la Versa-
tile Express (vexpress-a9) [5], visto che è quella
Board (virtuale) di sviluppo
supportata perfettamente dal kernel “mainline”
Il mercato mette a disposizione una vasta gam-
(la versione del kernel ufficiale, reperibile da
ma di board di sviluppo ARM-based, anche a
http://www.kernel.org), sia da QEMU, senza do-
basso costo. Tuttavia chi si vuole cimentare
ver applicare patch aggiuntive. Inoltre, la Versa-
nella creazione di un sistema GNU/Linux su
tile Express monta un core Cortex-A9, una CPU
ARM può farlo completamente a costo zero,
ARM-based utilizzata su gran parte dei tablet,
emulando virtualmente la piattaforma di svi-
smartphone e netbook di recente produzione.
luppo.
Emulare la piattaforma di sviluppo è piuttosto
Come software di emulazione ci baseremo su
semplice, basta lanciare il comando:
QEMU [4], che di fatto costituisce l’emulatore
$ qemu-system-arm -M vexpress-a9 -kernel flash.img
di architettura per eccellenza nel mondo Linux.
Dove flash.img è un file contenente l’immagine
QEMU permette di emulare diverse piattafor-
del nostro kernel/firmware che vogliamo far gi-
me ARM-based, ad esempio nella versione di
rare.
QEMU installata su Ubuntu 12.04 abbiamo a di-
Nei passi seguenti vedremo come generare tale
sposizione le seguenti piattaforme:
immagine.
Toolchain di cross-compilazione
La toolchain è un insieme di strumenti (tipica-
mente un compilatore, un linker e delle librerie)
che ci permettono di generare le applicazioni
per il sistema target a partire dai sorgenti. La
GNU toolchain tipica è costituita dal compilatore
GCC, le binutils (strumenti per la manipolazione
dei binari) e le librerie glibc.
Per questa prima fase ci vengono in aiuto le
toolchain pre-compilate (creare un sistema da
zero non implica necessariamente di doverci ri-
compilare anche gli strumenti per creare il siste-
ma stesso).
In rete si trovano molte toolchain pre-compilate, Per l’utente o il programmatore di alto livello
nel nostro caso utilizzeremo la Linaro Toolchain Linux è sempre lo stesso, indipendentemen-
Binaries [3], una toolchain ottimizzata per le più te da dove gira la propria applicazione.
recenti famiglie di CPU ARM (Cortex A8, A9, La prima fase della ricompilazione del kernel
etc.). consiste nel processo di configurazione. Esso
Il setup della toolchain è costituito dai seguenti permette di scegliere la particolare architettura
passaggi: che vogliamo utilizzare per il layer di basso li-
• download dei binari della toolchain da internet: vello, assieme a tutti i driver e le funzionalità di
https://launchpad.net/linaro-toolchain-binari- alto livello che vogliamo fornire alle applicazioni
es/trunk/2012.09/+download/... user-space.
• estrazione del pacchetto .tar.bz2:
Come abbiamo detto la piattaforma Versati-
le Express è già supportata
• setup della variabile di ambiente PATH per pienamente dal kernel Linux,
rendere disponibili i binari della toolchain quindi possiamo procedere direttamente alla
dalla shell corrente: configurazione senza dover applicare patch o
modificare codice:
Fase 1: preparazione del kernel

A questo punto abbiamo tutti gli strumenti ne- Le variabili di ambiente ARCH e CROSS_COM-
cessari per iniziare a sviluppare sulla board vir- PILE sono informazioni per il compilatore; esse
tuale. permettono di selezionare la particolare archi-
Il primo passo consiste nel reperire i sorgenti tettura (ARCH) e la particolare versione com-
“mainline” del kernel da http://www.kernel.org e pilatore (CROSS_COMPILE) per generare il
ricompilarli per la nostra archiettura target. codice oggetto.
Al momento della stesura di questo articolo l’ul- L’opzione “vexpress_defconfig” viene usata dal
timo kernel del ramo “stable” è il 3.5.4, proce- kernel nel processo di build: essa permette di
diamo quindi al download e all’estrazione dei selezionare la configurazione di default (defcon-
sorgenti: fig) stabilita dalla comunità di sviluppatori che
mantengono il codice per tale architettu-
ra. Le varie configurazioni *_defconfig per
ARM si trovano tutte in arch/arm/configs/*.
Il kernel Linux supporta un’ampia gamma di Infine resta da effettuare il passo di compilazio-
architetture e piattaforme eterogenee: fonda- ne vero e proprio:
mentalmente esso è composto da un layer di
basso livello
(./arch/*) che si interfaccia direttamente con il La ricompilazione di un intero kernel richiede
particolare hardware ed esporta ai livelli più alti dai 5 ai 10 minuti. Al termine, se tutto è andato
interfacce generiche indipendenti dall’hardware correttamente, troveremo il seguente file nelle
sottostante. directory dei sorgenti del kernel:
Il file zImage rappresenta l’immagine della flash

per la nostra board virtuale. In questo caso il
singolo kernel richiede 2.4MB. Al momento però
non abbiamo ancora nessuna applicazione, i
2.4MB rappresentano solo il “contenitore” dove
far girare le applicazioni utente.
Testare il kernel sulla board virtuale

E’ possibile testare il kernel appena generato
sull board virtuale QEMU lanciando il comando
seguente:
QEMU emula un ambiente identico ad una bo-

ard Versatile Express fisica, quindi per il kernel
non fa nessuna differenza, di fatto è come ese-
guirlo sull’hardware reale. Con le opzioni `-serial
stdio -display none` stiamo dicendo a QEMU di
collegare la seriale emulata direttamente alla
console da cui lanciamo il comando. Con `-ap-
pend console=ttyAMA0”` stiamo invece dicendo
al kernel di ridirigere tutti i suoi messagi verso
la seriale primaria. In pratica per noi sarà come
avere aperto una sessione seriale sulla board.
Ecco il risultato pratico una volta eseguito il co-
mando sopra:
In output possiamo vedere i messaggi di un tipi-

co boot di Linux. Il kernel è partito correttamen-
te, rilevando tutti i dispositivi hardware emulati
dalla board virtuale, come se questa fosse effet-
tivamente una board fisica.
Al termine della fase di boot otteniamo tuttavia
un kernel panic (cioè un
errore irreversibile che compromette il funziona-
mento del sistema). Il motivo di tale errore lo
possiamo trovare nei messaggi immediatamen-
te precedenti al panic:
In pratica per il kernel non esiste nessun root
filesystem. Come abbiamo detto il kernel è solo
un contenitore in cui girano le applicazioni, una
volta terminato il processo di boot il kernel cerca
di montare un filesystem radice (root) da uno
dei dispositivi a blocchi rilevati ed eseguire un
binario denominato “init”. Se questo binario non
viene trovato il kernel non sa cosa fare e entra
nella condizione di panic.
Nella prossima puntata vedremo come creare

un root filesystem adatto al kernel, continuando
a seguire stessa filosofia di questo tutorial: ge-
nerando tutto completamente da zero.
Riferimenti
1. http://en.wikipedia.org/wiki/Board_support_
package
2. http://en.wikipedia.org/wiki/QEMU
3. https://launchpad.net/linaro-toolchain-
binaries/+download
4. http://wiki.qemu.org/Main_Page
5. http://www.arm.com/products/tools/deve-
lopment-boards/versatile-express/i...
Di seguito il link per accedere direttamente all’articolo sul Blog e partecipare alla discussione:
http://it.emcelettronica.com/embedded-gnulinux-partendo-da-zero-ricompilare-kernel
2. Preparazione del root filesystem

Introduzione Tale archivio, chiamato initramfs [2], viene in-
N
ella prima puntata (http://it.emcelettronica. cluso nell’immagine del kernel ad una locazione
com/embedded-gnulinux-partendo-da-ze- prefissata e viene estratto dal kernel stesso in
ro-ricompil...) abbiamo visto come ricompi- RAM durante l’inizializzazione.
lare un kernel Linux per una generica board di Questa soluzione ha il vantaggio di non ri-
sviluppo virtuale ARM-based. Il kernel rappre- chiedere nessun device driver aggiuntivo
senta una sorta di contenitore di applicazioni per flash, dischi o supporti di memoria ester-
che girano in spazio utente. In questa nuova ni di qualsiasi natura, dato che per il kernel
puntata vedremo come preparare i contenuti è sufficiente poter accedere solo alla RAM per
dello spazio utente, ovvero come preparare un montare l’initramfs. Spesso questo approccio
root filesystem minimale.Il kernel rappresen- viene utilizzato in ambito embedded nelle fasi
ta una sorta di contenitore di applicazioni che iniziali di testing delle nuove board per avere
girano in spazio utente. In questa nuova pun- praticamente a tempo zero un sistema GNU/Li-
tata vedremo come preparare i contenuti dello nux funzionante.
spazio utente, ovvero come preparare un root Vediamo un esempio pratico di un initramfs con-
filesystem minimale. tenente un unico file: il classico esempio “hello
world”.
Creare un root filesystem in RAM: Per prima cosa scriviamo un semplice program-
l’initramfs ma C in /tmp/init.c:
Nella puntata precedente ci siamo lasciati con il
seguente errore restituito dal kernel che abbia-
mo compilato:
Il kernel è partito correttamente, ma non è ri- E lo cross-compiliamo con lo stesso cross-com-

uscito a trovare un root filesystem da montare pilatore che abbiamo usato nella puntata scorsa
per avviare il processo init e passare il controllo per compilare il kernel:
allo user-space.
La soluzione più semplice per creare un root fi-
lesystem è di usare parte della RAM come se
fosse un filesystem vero e proprio. Il kernel per- Quiz #1: come mai abbiamo usato l’opzione
mette di includere al suo interno un archivio in -static?
formato cpio [1] (in pratica è una sorta di tar o Risposta #1: Con l’opzione “-static” richiediamo
zip). al compilatore di includere direttamente nel bi-
Embedded GN U/Li nux par t endo da zer o {9
nario stesso tutte le librerie necessarie, invece più di tempo al boot per ridurre lo spazio oc-
di tentare di caricarle dinamicamente a run-time. cupato può essere vantaggioso, ad esempio se
Come abbiamo detto il nostro initramfs conterrà dovessimo collocare kernel e initramfs in una
un unico file, quindi a run-time non sarà possi- flash di dimensioni ridotte, o scaricarli da una
bile trovare le librerie dinamiche all’interno del connessione di rete lenta, etc.
filesystem. L’initramfs che abbiamo creato noi richiede uno
Quiz #2: come mai il programma C che abbia- spazio di 244KB:
mo scritto contiene un loop che non esce mai?
Risposta #2: In Linux ogni processo viene ge-
nerato come figlio di un altro processo. Quando
un processo padre termina prima del processo
figlio quest’ultimo viene immediatamente adot- E’ giunto il momento di testare se tutto funziona.
tato dal processo di sistema speciale “init” (il Utilizziamo quindi lo stesso comando visto nella
cui PID è 1), che ne diviene il nuovo processo puntata scorsa per avviare la board virtuale, con
padre. Questa operazione viene chiamata re- l’aggiunta dell’opzione “-initrd /tmp/initramfs”
parenting, ed avviene automaticamente a cura per caricare anche l’initramfs:
del kernel. La terminazione del processo “init”
viene vista dal kernel come un errore irreversi-
bile e quando accade il kernel entra nello stato
di panic. Per questo motivo il nostro init non può Il risultato è il seguente:
Booting Linux on physical CPU 0
terminare.
A questo punto possiamo spostarci in /tmp e
creare l’initramfs:
E’ importante notare che il binario contenuto
all’interno dell’initramfs è stato chiamato “init”.
Questo perché il kernel si aspetta di trovare un
file con questo nome; se rinominiamo il file que-
sto non verrà eseguito al termine del processo
di boot.
Notare inoltre che con “gzip -9” abbiamo com-
presso l’initramfs. Il kernel supporta vari formati
di compressione e riesce ad accedervi anche in
questo caso, a costo di spendere un po’ più di
tempo in fase di boot per effettuare la decom-
pressione. Tuttavia, in certi casi, perdere un po’
Molto bene! Il kernel ha avviato il nostro loop

“hello world” al termine del processo di boot.
Notare che a questo punto abbiamo un ker-
nel Linux completo a nostra disposizione.
Potremmo quindi modificare il semplice “hel-
lo world” (/tmp/init.c) per implementare anche
qualcosa di più complesso, come ad esempio
un piccolo echo server TCP/IP multi-task.
Il programma seguente crea un processo ser-
ver che accetta connessioni TCP/IP sulla por-
ta 8080; per ogni connessione ricevuta viene
creato un nuovo processo figlio che legge un
messaggio dal client e lo rimanda indietro tale e
quale (tutto tramite TCP/IP):
L’opzione “-redir tcp:8080:10.0.2.15:8080” per-

mette di creare una conessione di rete virtuale
dal sistema GNU/Linux host alla board virtuale
tramite la porta 8080, mentre con “ip=10.0.2.15”
diciamo al kernel di assegnare l’indirizzo IP
10.0.2.15 alla prima interfaccia di rete rilevata.
Una volta partita la board virtuale, il nostro ker-
nel e la nostra applicazione user-space possia-
mo testare l’echo server lanciando il comando
seguente sul sistema host:
Perfetto! La nostra applicazione ha risposto alla

richiesta di echo dalla board virtuale. Sul termi-
nale di quest’ultima compare il messaggio se-
guente:
Gli sviluppi futuri di questa applicazione sono

lasciati alla fantasia e alla creatività del lettore.
Nella prossima puntata vedremo come creare
Se sostituiamo l’esempio “hello world” con questo
un initramfs completo, dotato dei tipici comandi
codice e ripetiamo i passi di generazione dell’ini-
presenti in qualsiasi distribuzione GNU/Linux.
tramfs possiamo vedere in funzione l’echo server
TCP/IP creato completamente da zero. Riferimenti
Per prima cosa lanciamo la board virtuale con le 1. http://en.wikipedia.org/wiki/Cpio
seguenti opzioni: 2. http://lxr.linux.no/linux+v3.6.3/Documenta-
tion/early-userspace/README
http://it.emcelettronica.com/embedded-gnulinux-partendo-da-zero-preparazione-del-root-filesystem
3. Integrazione e test
Introduzione ded. Difatti praticamente tutte le note piattafor-
N
elle puntate precedenti (http:// me embedded Linux-based utilizzano BusyBox
it.emcelettronica.com/embedded-gnuli- (evaluation board, ricevitori, dispositivi mobile
nux-partendo-da-zero-ricompil... e http:// come tablet, smartphone, etc. anche Android!).
it.emcelettronica.com/embedded-gnulinux-par- Vediamo di seguito i passi necessari per inte-
tendo-da-zero-preparaz...) abbiamo analizzato grare BusyBox nel nostro sistema.
rispettivamente la ricompilazione del kernel e Per prima cosa possiamo reperire i sorgenti di-
la preparazione di un root filesystem minimale rettamente dal repository git di BusyBox:
usando l’initramfs.
In questa puntata vedremo come completare il $ git clone git://busybox.net/busybox.git
root filesystem dotandolo dei tipici comandi pre- Successivamente dobbiamo specificare la con-
senti in qualsiasi distribuzione GNU/Linux. Infi-
figurazione di ciò che vogliamo compilare e in-
ne vedremo alcuni esempi pratici per testare la
cludere nel nostro ambiente. Analogamente a
funzionalità della micro-distribuzione custom da
quanto abbiamo fatto con il kernel possiamo
noi creata.
lanciare un “make menuconfig” nel modo se-
guente:
I comandi della shell
$ cd busybox
La volta scorsa ci siamo lasciati con un root fi-
lesystem dotato di un unico binario eseguibile: / $ make ARCH=arm CROSS_COMPILE=arm-
init. Questo è sufficiente per permettere al ker- linux-gnueabihf- \
nel di lanciare una nostra applicazione custom OPTIMIZE_FOR_CPU=armv7-a CONFIG_
al termine del boot, ma è abbastanza diverso PREFIX=/tmp/initrd menuconfig
da quello che si aspetta di trovare in un tipico Al solito, con l’opzione CROSS_COMPILE ab-
sistema GNU/Linux. biamo dato indicazione al sistema id build di
Quello che manca è una vera e propria shell BusyBox quale cross-compilatore utilizzare (lo
completa, dotata dei comandi che caratterizza- stesso con cui abbiamo compilato precedente-
no qualsiasi distribuzione GNU/Linux. mente il kernel) e con ARCH=arm e OPTIMIZE_
FOR_CPU abbiamo specificato l’architettura
BusyBox target per i file binari che dovranno essere ge-
BusyBox[1] è conosciuto anche come il “coltel- nerati. Con CONFIG_PREFIX, invece, specifi-
lino svizzero” dell’embedded Linux. Si tratta di chiamo la directory dove vogliamo che BusyBox
un progetto open-source (GPLv2) in grado di vada ad installare tutti i binari.
fornire un intero set di comandi e utility presenti Se non vogliamo scorrere tutti i singoli menù del
nella suite GNU. “make menuconfig” di BusyBox possiamo utiliz-
L’intero progetto è stato scritto con un partico- zare la configurazione riportata come allegato a
lare occhio di riguardo all’ottimizzazione dello questo articolo (busybox-config.txt). Per fare ciò
spazio occupato dai binari, il che lo rendono basta lanciare i comandi seguenti:
particolarmente appetibile nell’ambito embed-
$ wget http://it.emcelettronica.com/files/ lrwxrwxrwx 1 righiandr righiandr 7 Dec 14 15:07

busybox-config_0.txt ash -> busybox
$ cp busybox-config.txt busybox/.config lrwxrwxrwx 1 righiandr righiandr 7 Dec 14 15:07
Una volta messa a punto la configurazione si base64 -> busybox
può compilare la suite di strumenti: -rwxr-xr-x 1 righiandr righiandr 1314624 Dec 14
15:07 busybox
$ make ARCH=arm CROSS_COMPILE=arm- lrwxrwxrwx 1 righiandr righiandr 7 Dec 14 15:07
linux-gnueabihf- \ cat -> busybox
OPTIMIZE_FOR_CPU=armv7-a CONFIG_ lrwxrwxrwx 1 righiandr righiandr 7 Dec 14 15:07
PREFIX=/tmp/initrd install catv -> busybox
E infine installarla nella directory di destinazio- lrwxrwxrwx 1 righiandr righiandr 7 Dec 14 15:07
ne: chattr -> busybox
lrwxrwxrwx 1 righiandr righiandr 7 Dec 14 15:07
$ make ARCH=arm CROSS_COMPILE=arm- chgrp -> busybox
linux-gnueabihf- \ ...
OPTIMIZE_FOR_CPU=armv7-a CONFIG_ Quiz #1: come mai BusyBox genera un solo bi-
PREFIX=/tmp/initrd install nario e sopratutto a cosa servono i link simbo-
Dopo l’installazione la directory di destinazione lici?
assume la tipica struttura che troviamo nella ra- Risposta #1: Come abbiamo visto nella puntata
dice di un qualsiasi sistema UNIX-based: precedente, nel filesystem che generiamo com-
pletamente da zero non abbiamo a disposizione
# ls -l /tmp/initrd le librerie dinamiche (glibc, etc.); le alternative
total 12 quindi sono di cross-compilare e installare an-
drwxrwxr-x 2 righiandr righiandr 4096 Dec 14 che tutte le librerie dinamiche richieste, oppure
15:07 bin di compilare staticamente i binari (cioè include-
drwxrwxr-x 2 righiandr righiandr 4096 Dec 14 re direttamente nel binario il codice delle librerie
15:07 sbin richieste).
drwxrwxr-x 4 righiandr righiandr 4096 Dec 14 Nel nostro caso abbiamo compilato BusyBox
15:01 usr staticamente, ma se per ciascun binario inclu-
In pratica con l’installazione di BusyBox abbia- dessimo al suo interno il codice delle librerie ri-
mo generato la struttura base del nostro tipico chieste, avremo una duplicazione e ridondanza
filesystem UNIX-based. del codice non necessaria.
All’interno della sotto-directory “bin” l’unico bi- BusyBox risolve questo problema implementan-
nario “busybox”; tutti gli altri comandi sono di- do il codice di ciascun comando all’interno dello
sponibili nel filesystem come link simbolici all’e- stesso binario (invece di avere una separazione
seguibile “busybox”: a livello di file, possiamo vedere un comando
della shell di BusyBox come una funzione all’in-
# ls -l /tmp/initrd/bin/ terno dello stesso binario).
total 1284 I link simbolici costituiscono una soluzione in-
telligente per distinguere un comando dall’al- qualsiasi informazione kernel allo user-space.
tro. Ad esempio quando eseguiamo il binario / Successivamente durante lo sviluppo della se-
bin/cat dalla shell, questo di fatto esegue /bin/ rie di kernel 2.5 è stato introdotto il sysfs, come
busybox, ma durante all’interno del codice il metodo più strutturato per separare le informa-
nome del binario risulta /bin/cat. zioni relative ai processi (procfs), rispetto alle
Alla fine possiamo immaginare il “main” di informazioni relative ai device o al sistema in
BusyBox nel modo seguente (con le dovute genere.
semplificazioni del caso): Infine la directory /dev [5] ospita tutti i file spe-
ciali che forniscono l’accesso ai device driver,
int main(int argc, char **argv) utilizzando le stesse interfacce per l’accesso ai
{ classici (open, read, seek, write, close, etc.). Ad
if (!strcmp(argv[0], “/bin/cat”)) { esempio /dev/sda rappresenta il primo di stora-
/* implementazione di cat */ ge rilevato dal sistema, /dev/console il termina-
} else if (!strcmp(argv[0], “/bin/ls”)) { le, etc. Anche in questo caso vale il principio
/* implementazione di ls */ dell’”everything is a file”, effettuando ad esem-
} else ... pio una read() su /dev/sda, il kernel attiva il de-
A questo punto ci mancano solo pochi passi per vice driver che gestisce il dispositivo di storage
completare un tipico root filesystem GNU/Linux: in questione, e ritorna all’applicazione utente
inizializzare /proc, /sys e /dev. un buffer contenente i dati reperiti sullo stora-
Il proc filesystem (o procfs) [3], montato gene- ge. Il mapping tra file e device driver in kernel
ricamente sotto /proc, è uno pseudo-filesystem space viene effettuato utilizzando una coppia
usato dal kernel per esportare le informazioni di numeri detti major e minor number (esistono
sui processi alle applicazioni che girano in spa- delle convenzioni sui nomi dei file che si trova-
zio utente. Tale filesystem si trova solitamente no sotto /dev, ma il nome del file dal punto di
montato nella directory /proc. Questo filesystem vista del kernel è totalmente arbitrario).
non utilizza nessun dispositivo di storage, è solo Per quanto riguarda /proc e /sys è sufficien-
un’astrazione messa a disposizione del kernel te creare i mount-point come directory vuote.
per dare una visione dei processi come file, nel Dopo che il kernel è partito dovremo predispor-
pieno rispetto della filosofia dell’”everything is a re uno script di inizializzazione per montare tali
file” [2]. filesystem nei mount-point predisposti.
Il sysfs, montato genericamente in /sys [4], è
anch’esso uno pseudo-filesystem. Anch’esso $ cd /tmp/initrd
viene utilizzato dal kernel per esportare infor- $ mkdir proc sys
mazioni allo spazio utente, ma che non hanno $ ls -l
niente a che vedere con i processi (es. la di- total 24
mensione di un disco, il numero di cpu, o infor- drwxrwxr-x 2 righiandr righiandr 4096 Dec 14
mazioni di debug. Inizialmente nei vecchi kernel 15:07 bin
(serie 2.4) esisteva solo il procfs, che veniva uti- drwxrwxr-x 2 righiandr righiandr 4096 Dec 14
lizzato come grande contenitore per esportare 17:11 proc
drwxrwxr-x 2 righiandr righiandr 4096 Dec 14 lo stesso meccanismo di BusyBox: creiamo un

15:07 sbin link simbolico a /sbin/init, all’interno dell’immagi-
drwxrwxr-x 2 righiandr righiandr 4096 Dec 14 ne del nostro initramfs:
17:11 sys
drwxrwxr-x 4 righiandr righiandr 4096 Dec 14 $ cd /tmp/initrd
15:01 usr $ ln -s sbin/init init
Per /dev, invece è necessario fare un passo $ ls -l
aggiuntivo, che consiste nell’inizializzare i file $ ls -l
di dispositivo base che il kernel e l’ambiente total 24
BusyBox si aspettano di trovare. drwxrwxr-x 2 righiandr righiandr 4096 Dec 15
Per questo possiamo usare il comando mknod: 00:29 bin
drwxrwxr-x 2 righiandr righiandr 4096 Dec 15
$ cd /tmp/initrd 00:29 dev
$ mkdir dev lrwxrwxrwx 1 righiandr righiandr 9 Dec 15 01:25
$ cd dev init -> sbin/init
$ sudo mknod tty1 c 4 1 drwxrwxr-x 2 righiandr righiandr 4096 Dec 15
$ sudo mknod tty2 c 4 2 00:29 proc
$ sudo mknod tty4 c 4 4 00:29 sbin
$ sudo mknod tty6 c 4 6 00:29 sys
$ sudo mknod console c 5 1 drwxrwxr-x 4 righiandr righiandr 4096 Dec 15
$ sudo mknod null c 1 3 00:29 usr
$ sudo mknod zero c 1 5 A questo punto abbiamo completato l’immagine
I primi sei dispositivi (tty1 ... tty6) rappresentano di un filesystem GNU/Linux minimale: la stessa
i terminali virtuali (quelli a cui possiamo acce- base di quello che troviamo in qualsiasi distribu-
dere su un tipico sistema GNU/Linux premen- zione GNU/Linux.
do la combinazione ALT+F1 ... ALT+F6); il file / Il passo finale è quindi di creare l’initramfs (sem-
dev/console è il terminale principale. Infine /dev/ pre come abbiamo visto nella puntata prece-
null e /dev/zero sono device virtuali: il primo, se dente) e far partire finalmente la nostra micro-
viene letto ritorna sempre un buffer vuoto, se ci distribuzione:
scriviamo sopra i dati vengono ignorati; infine /
dev/zero se letto ritorna un buffer pieno di zeri # cd /tmp/initrd/
(esattamente una quantità pari alla dimensione # find . | cpio -o --format=newc > ../initramfs
del buffer specificato per la lettura). 2667 blocks
L’ultimo passo, come visto nella puntata prece- # du -sh ../initramfs
dente, è di creare nell’initramfs un binario chia- 1.4M ../initramfs
mato /init, che il kernel provvederà ad eseguire Come possiamo notare la nostra distribuzione
al termine della fase di boot. Per questo usiamo occupa solo 1.4MB. Decisamente minimale.
Adesso possiamo far partire la board virtuale su

QEMU: / # mount -t proc none /proc
/ # ps
$ qemu-system-arm -M vexpress-a9 -kernel ./ PID USER TIME COMMAND
arch/arm/boot/zImage -serial stdio -display 1 0 0:01 init
none -append “console=ttyAMA0” -initrd /tmp/ 2 0 0:00 [kthreadd]
initramfs 3 0 0:00 [ksoftirqd/0]
Booting Linux on physical CPU 0 5 0 0:00 [kworker/u:0]
Initializing cgroup subsys cpuset 6 0 0:00 [migration/0]
Linux version 3.5.4 (righiandr@thinkpad) (gcc 7 0 0:00 [cpuset]
version 4.7.2 20120910 (prerelease) (crosstool- 8 0 0:00 [khelper]
NG linaro-1.13.1-2012.09-20120921 - Linaro 9 0 0:00 [kworker/u:1]
GCC 2012.09) ) #1 SMP Fri Dec 14 14:15:35 158 0 0:00 [sync_supers]
CET 2012 160 0 0:00 [bdi-default]
CPU: ARMv7 Processor [410fc090] revision 0 162 0 0:00 [kblockd]
(ARMv7), cr=10c53c7d 168 0 0:00 [ata_sff]
... 178 0 0:00 [khubd]
Freeing init memory: 172K 273 0 0:00 [rpciod]
can’t run ‘/etc/init.d/rcS’: No such file or directory 274 0 0:00 [kworker/0:1]
Please press Enter to activate this console. 280 0 0:00 [khungtaskd]
/ # ls -l 285 0 0:00 [kswapd0]
total 0 330 0 0:00 [fsnotify_mark]
drwxrwxr-x 2 1000 1000 0 Dec 14 23:29 bin 339 0 0:00 [nfsiod]
drwxrwxr-x 2 1000 1000 0 Dec 15 00:28 dev 410 0 0:00 [kpsmoused]
lrwxrwxrwx 1 1000 1000 9 Dec 15 00:25 init -> 413 0 0:00 [kworker/0:2]
sbin/init 463 0 0:00 [deferwq]
drwxrwxr-x 2 1000 1000 0 Dec 14 23:29 proc 468 0 0:00 -/bin/sh
drwx------ 2 0 0 0 Dec 14 13:11 root 469 0 0:00 init
drwxrwxr-x 2 1000 1000 0 Dec 14 23:29 sbin 471 0 0:00 init
drwxrwxr-x 2 1000 1000 0 Dec 14 23:29 sys 472 0 0:00 init
drwxrwxr-x 4 1000 1000 0 Dec 14 23:29 usr 481 0 0:00 ps
Oppure visualizzare il tipo di architettura da /
E al termine del boot otteniamo finalmente proc/cpuinfo:
una vera shell sulla nostra board virtuale!
A questo punto possiamo gestire la board come / # cat /proc/cpuinfo
gestiremo un generico sistema GNU/Linux. Processor : ARMv7 Processor rev 0 (v7l)
Possiamo usare il comando “ls” per listare i file processor :0
del root filesystem (come visto sopra). O mon- BogoMIPS : 129.43
tare il procfs e visualizzare la lista dei processi: Features : swp half thumb fastmult vfp edsp
neon vfpv3 tls

CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x0
CPU part : 0xc09
CPU revision : 0
Hardware : ARM-Versatile Express
Revision : 0000
Serial : 0000000000000000
Conclusioni
In questa puntata abbiamo visto come popola-
re l’initramfs implementando una vera e propria
micro-distribuzione GNU/Linux, integrando così
quello che avevamo visto nelle puntate prece-
denti e chiudendo la serie teorica “GNU/Linux
partendo da zero”.
Nella prossima puntata analizzeremo più in

dettaglio l’aspetto pratico, ripetendo tutti i
passi teorici visti nelle puntate precedenti
su una board reale: la Raspberry Pi.
Riferimenti
1. http://www.busybox.net/
2. http://en.wikipedia.org/wiki/Everything_
is_a_file
3. http://en.wikipedia.org/wiki/Procfs
4. http://en.wikipedia.org/wiki/Sysfs
5. http://en.wikipedia.org/wiki/Device_file
http://it.emcelettronica.com/embedded-gnulinux-partendo-da-zero-integrazione-e-test
4. Test sulla Raspberry Pi

Introduzione boot-loader (bootcode.bin), che è memorizzato
L
a Raspberry Pi [1] (o più brevemente RPi nella ROM del SoC Broadcom
da ora in poi) è un computer vero e proprio BCM2835. Il primo stage reperisce dalla prima
realizzato su una singola scheda elettronica partizione dell’SD card esterna il boot-loader di
sviluppato dalla Raspberry Pi Fundation, un’or- secondo livello (bootloader.bin), che si occu-
ganizzazione di beneficenza che ha sede nel pa di leggere tutti gli altri file necessari al boot,
Regno Unito. Lo scopo di tale progetto è di pro- compresa l’immagine del kernel (kernel.img),
muovere lo studio dell’informatica, in particolar caricando tutto nell’SDRAM. A questo punto il
modo in ambito accademico. Proprio per questa boot-loader ha terminato il suo compito e passa
ragione tale dispositivo è facilmente accessibi- il controllo al kernel.
le a costi molto contenuti (il prezzo va da $25 NOTA: ricompilare un kernel da zero su una bo-
per la prima versione a $35 per la seconda della
ard come la RPi può essere visto anche come
versione).
un’ottima opportunità per realizzare un labo-
Per maggiori dettagli sulle specifiche della bo-
ratorio di “kernel development”. La board po-
ard si rimanda all’articolo seguente:
trà essere utilizzata in seguito anche per fare
http://it.emcelettronica.com/computer-meno-di-
esperimenti sul kernel Linux senza aver paura
25-dollari-con-arm11-e-hdmi.
di danneggiare o compromettere il dispositivo
In questo nuovo articolo vedremo come ricom-
stesso. Difatti per ripristinare il kernel originale
pilare un kernel e come preparare un root filesy-
basta semplicemente sovrascrivere il file kernel.
stem minimale per la RPi, partendo dai sorgenti
img presente nella partizione di boot della SD
e da una SD card vuota.
card, ad esempio inserendo l’SD card in un PC.
Per una visione più generica sulla procedura di
ricompilazione del kernel si consiglia la lettura
Prerequisiti
degli articoli precedenti della serie “Embedded
• una RaspBerry Pi
GNU/Linux partendo da zero”:
• una SD card (la nostra sarà una distro ultra-
http://it.emcelettronica.com/embedded-gnuli-
minimale quindi va bene di qualsiasi dimen-
nux-partendo-da-zero-ricompil...
sione)
• un PC con una distribuzione GNU/Linux
nux-partendo-da-zero-preparaz...
• una connessione a Internet per scaricare i
sorgenti e il cross-compilatore
nux-partendo-da-zero-integraz...
Preparare l’ambiente di sviluppo

Procedura di avvio sulla RPi
Per prima cosa è necessario reperire il cross
La procedura di avvio della RPi utilizza un pro-
compilatore e tutti i sorgenti richiesti a creare
cesso di boot a più stage.
da zero la nostra distribuzione per la RPi. Per
Quando la RPi viene accesa la GPU inizia ad
quanto riguarda il boot-loader si può trovare una
eseguire il primo stage del
versione precompilata nel repository git “ufficia-
le” della RPi (github.com/raspberrypi). quest’ultimo. L’uso di altri cross-compilatori é

Per preparare l’ambiente di sviluppo della no- lasciato come esercizio per il lettore.
stra micro-distribuzione per la RPi è sufficiente
lanciare i comandi seguenti: Inizializzare l’SD card
Dopo aver reperito tutti i sorgenti e gli strumenti
$ mkdir raspberry per lo sviluppo possiamo formattare l’SD card
$ cd raspberry utilizzando un layout compatibile al boot della
$ git clone git://github.com/raspberrypi/firmwa- RPi.
re.git Possiamo quindi inserire l’SD card nel PC e (da
$ git clone git://github.com/raspberrypi/tools.git Linux) partizionarla usando il comando seguen-
$ git clone git://github.com/raspberrypi/linux.git te:
$ git clone git://busybox.net/busybox.git
Il primo repository git contiene i file binari del $ sudo sfdisk /dev/mmcblk0 << EOF
boot loader, che andremo a copiare direttamen- unit: sectors
te sull’SD card. Gli altri repository contengono /dev/mmcblk0p1 : start= 16, size= 97648, Id= c,
rispettivamente i cross-compilatori (e utility va- bootable
rie per la gestione dei binari), e infine i sorgenti /dev/mmcblk0p2 : start= 97664, size= 97648,
del kernel Linux e BusyBox per la parte user- Id=83
space, che andremo a ricompilare. /dev/mmcblk0p3 : start= 0, size= 0, Id= 0
NOTA #1: teoricamente potremo partire dai sor- /dev/mmcblk0p4 : start= 0, size= 0, Id= 0
genti “ufficiali” di Linux EOF
(denominati “vanilla”), disponibili su http://www. ATTENZIONE! Questo comando causa la
kernel.org tuttavia i kernel vanilla non hanno al perdita di tutti i contenuti che erano presen-
loro interno i driver e i moduli per gestire il SoC ti sull’SD card, quindi verificate di utilizzare
Broadcom BCM2835 presente sulla RPi. Per una SD card vuota o contenente informazio-
questo motivo usare un kernel vanilla generico ni che volete cancellare.
presupporrebbe una lunga e complessa fase Con questo comando abbiamo creato una parti-
di porting di tutte le patch specifiche della RPi zione primaria FAT (/dev/mmcblk0p1) che verrà
sull’eventuale kernel scelto come base di par- usata per il boot (cioè dove copieremo i file del
tenza. In questo caso ci affidiamo direttamente boot-loader e l’immagine del kernel che cross-
al kernel già patchato e messo adisposizione su compileremo nei passi successivi) e una parti-
GitHub alla comunità di utilizzatori. zione per il root filesystem (/dev/mmcblk0p2),
NOTA #2: è possibile utilizzare lo stesso cross- dove copieremo i binari user-space (BusyBox).
compilatore visto nelle NOTA: le dimensioni delle due partizioni sono
puntate Embedded GNU/Linux partendo da entrambe di 50MB. Il resto dell’SD card va ov-
zero, in fin dei conti siamo sempre su architet- viamente sprecato; tuttavia in questo caso tale
ture ARM. In questo caso, però, visto che nei spazio risulta addirittura sovradimensionato per
repository di sorgenti della RPi troviamo già un ospitare la nostra micro-distribuzione, ma in
cross-compilatore pronto all’uso, optiamo per questo modo siamo sicuri di rientrarci con le di-
mensioni e di poter supportare SD card di qual- configurazione con i comandi seguenti:

siasi taglio. $ cd linux
Una volta partizionata l’SD card con uno sche- $ make ARCH=arm CROSS_COMPILE=arm-
ma compatibile per il boot-loader andremo a bcm2708-linux-gnueabi- bcmrpi_defconfig
creare i filesystem su entrambe le partizioni: Per rendere la cosa un po’ più interessante
possiamo cambiare la versione del kernel,
$ sudo mkfs.vfat /dev/mmcblk0p1 appendendo alla fine della stringa originale
$ sudo mkfs.ext4 /dev/mmcblk0p2 una stringa personalizzata: es. “-eos”. Que-
La partizione primaria deve essere necessaria- sta stringa comparirà nella nostra distribu-
mente VFAT. Per la secondaria zione personalizzata, ogni volta che verrà
(root filesystem) possiamo scegliere un qualsia- stampata la versione del kernel.
si filesystem supportato da Per fare ciò possiamo lanciare:
Linux. In questo caso abbiamo scelto ext4.
$ make ARCH=arm CROSS_COMPILE=arm-
Ricompilare il kernel bcm2708-linux-gnueabi- menuconfig
E` infine giunto il momento di cross-compilare il E dall’interfaccia andare a modificare il parame-
kernel. Percorreremo tro:
velocemente questi passi, perché sono esatta-
mente gli stessi visti nei General setup ---> Local version - append to
precedenti articoli di questa serie. kernel release
Le uniche differenze consistono in: Aggiungendo la stringa “-eos” (o quella che più
1) aggiungere al PATH della shell il cross-com- ci piace).
pilatore giusto (lanciare il A questo punto è giunto il momento di lanciare il
comando dalla directory “raspberry” dove ab- passo di compilazione
biamo scaricato i repository git): effettiva del kernel:
export PATH=$PWD/tools/arm-bcm2708/arm-
bcm2708-linux-gnueabi/bin:$PATH $ make ARCH=arm CROSS_COMPILE=arm-
bcm2708-linux-gnueabi-
2) selezionare il branch rpi-3.2.27 (il ramo del Per generare un file immagine del kernel com-
kernel stabile che si trova nel repository git del patibile con il boot-loader della RPi dobbiamo
kernel della RPi) anche “pacchettizzarlo” in modo opportuno.
$ git checkout rpi-3.2.27 Questo passaggio non è sempre richiesto; in
questo caso può essere effettuato lanciando lo
3) configurare il kernel per abilitare i settaggi di script imagetool-uncompressed.py (che si trova
default per la RPi nel repository “tools” insieme al cross-compila-
(la configurazione di default per questa board è tore):
chiamata bcmrpi_defconfig).
Spostiamoci quindi nella directory dei sorgenti $ cd ../tools/mkimage
del kernel e lanciamo la $ ./imagetool-uncompressed.py ../../linux/arch/
arm/boot/zImage otfs i file speciali sotto /dev:

$ cd -
Infine installiamo i moduli esterni nella directory $ mkdir /tmp/rootfs/dev
temporanea /tmp/rootfs $ cd /tmp/rootfs/dev
(copieremo tutto nell’SD card successivamente, $ cat << EOF | sudo sh
insieme ai binari dello mknod tty1 c 4 1
user-space): mknod tty2 c 4 2
mknod tty3 c 4 3
$ make ARCH=arm CROSS_COMPILE=arm- mknod tty4 c 4 4
bcm2708-linux-gnueabi- \ mknod tty5 c 4 5
INSTALL_MOD_PATH=/tmp/rootfs/ modules_ mknod tty6 c 4 6
install mknod console c 5 1
mknod null c 1 3
Installazione di BusyBox mknod zero c 1 5
Anche per installare BusyBox i passi sono gli EOF
stessi visti nell’articolo $ cd -
nux-partendo-da-zero-integraz... (si può anche Trasferire i binari sull’SD card
utilizzare lo stesso file di configurazione, dispo- Il passaggio finale consiste nel copiare tutto sul-
nibile come allegato dell’articolo stesso). l’SD card e vedere se il
Spostiamoci nella directory di BusyBox e lancia- sistema parte veramente.
mo il passo di configurazione (prendendo il file Montiamo quindi le due partizioni dell’SD card
di configurazione dall’articolo precedente): (boot e rootfs):
$ cd ../busybox $ mkdir -p /tmp/sdcard/boot

$ wget http://it.emcelettronica.com/files/ $ mkdir -p /tmp/sdcard/rootfs
busybox-config_0.txt $ sudo mount /dev/mmcblk0p1 /tmp/sdcard/
$ cp busybox-config.txt busybox/.config
boot
Infine lanciamo la cross-compilazione di
$ sudo mount /dev/mmcblk0p2 /tmp/sdcard/ro-
BusyBox:
otfs
$ make ARCH=arm CROSS_COMPILE=arm- Copiamo i file del boot loader e la nostra imma-
bcm2708-linux-gnueabi- \ gine del kernel nella partizione di boot:

CONFIG_PREFIX=/tmp/rootfs install
Se tutto è andato per il verso giusto troveremo $ cd ..
i binari del nostro user-space minimale in /tmp/ $ sudo cp firmware/boot/* /tmp/sdcard/boot/
rootfs, insieme ai moduli esterni del kernel in- $ sudo cp tools/mkimage/kernel.img /tmp/
stallati al passo precedente.
sdcard/boot
L’ultimo passaggio consiste nel creare nel ro-
E infine trasferiamo anche il root filesystem
nell’altra partizione ext4 Se colleghiamo una tastiera possiamo interagi-

dell’SD card: re con l’ambiente della shell e lanciare comandi
come su una qualsiasi distribuzione GNU/Linux.
$ sudo rsync -avHS /tmp/rootfs/ /tmp/sdcard/ Ad esempio possiamo stampare a video la ver-
rootfs/
NOTA: per quest’ultima copia utilizziamo il co-
mando rsync che permette di preservare sia i
link simbolici creati durante l’installazione di
BusyBox, sia i file speciali creati nella /dev del
nostro root filesystem.
Perfetto! Possiamo smontare i filesystem del-
l’SD card e ammirare la nostra
micro-distribuzione all’opera:
$ sudo umount /tmp/sdcard/boot

$ sudo umount /tmp/sdcard/rootfs
Test finale
Per testare la distribuzione è sufficiente inserire
l’SD card nello slot
presente sulla RPi e riavviare la scheda, colle-
gandola ad un monitor o a un televisore HDMI e sione del kernel che sta girando sulla board con
vedere cosa compare a video. il comando “uname -r”.
Come possiamo vedere il kernel risulta essere
proprio la nostra versione: 3.2.27-eos+.
Riferimenti
[1] http://www.raspberrypi.org/
[2] http://it.emcelettronica.com/computer-meno-
di-25-dollari-con-arm11-e-hdmi
[3] http://it.emcelettronica.com/raspberry-pi-tu-
torial-installazione-distro-...
http://it.emcelettronica.com/embedded-gnulinux-partendo-da-zero-test-sulla-raspberry-pi
23}
Rasp berr yPI

t u t o ri al
1. Installazione distro, configura-

zione e stampa
Un pò di storia... Gli schemi ed il layout del circuito stampato
N
ato nel 2006 con l’intento di promuovere lo sono tutt’ora disponibili per l’auto-costruzione
studio dell’informatica, sopratutto a livello della prima versione di RasPI, ma chi di voi pro-
scolastico, e di realizzare un PC a basso verà a costruirlo non si aspetti la stessa fluidità
costo utilizzabile da tutti, inizialmente RasPI era del RasPI attuale: la prima versione, infatti, ave-
basato su un microcontrollore Atmel, e le sue di- va una frequenza di clock di 22.1MHz e 512 KB
mensioni erano molto diverse da quelle attuali. di SDRAM, contro gli attuali 700Mhz del proces-
sore ARM11 e i 512MB di SDRAM in dotazione
al Modello B.
Successivamente è stato rimodernato nel 2009
con la prima versione dotata di processore ARM
e di dimensioni notevolmente ridotte rispetto
alla versione del 2006. A questo punto RasPI
assomigliava ad una chiavetta USB e per la pri-
R a s p b e r r y P I Tu t o r i a l {24
ma volta è dotato di un uscita HDMI. Ma solo nel 45)

2011 è stata presentata la versione che noi ora - Periferiche di basso livello: 2x13 header
conosciamo, commercializzato in due versioni, pins for GPIO, SPI, I²C, UART, +3.3 V, +5V
Modello A e B. - Real-time clock: No
Le due versioni non presentano grandi diffe- - Consumo: 700 mA, (3.5 Watt)
renze, infatti la versione A è dotata di 256 MB - Alimentazione: 5 Volt via MicroUSB
di ram, una porta USB ed è priva di controller Tra l’Hardware non troviamo nessuna memoria
Ethernet, mentre la versione B è dotata di 512 di massa, questo perché il sistema operativo e
MB di ram, due uscite USB 2.0 ed un controller tutti i file che permettono il boot andranno me-
Ethernet integrato. Tuttavia nella versione A è morizzati su di una Memory Card e successi-
possibile ovviare alla mancanza del controller vamente inserita nell’apposito slot. Questo par-
Ethernet utilizzando una qualsiasi chiavetta Wifi ticolare permette di avere un unico modello di
per accedere alla rete. RasPI e di non dover produrre più versioni le-
gate allo spazio utile dell’eventuale memoria di
Un pò di Hardware massa integrata, un po’ come invece avviene
Nelle sue ridotte dimensioni, appena 85.60mm per i telefoni cellulari che vengono commercia-
× 53.98mm, RasPi contiene tutto il necessario lizzati in versioni da 8/16/32 GB.
per poterlo definire un vero e proprio PC.
- SoC: Broadcom BCM2835 (CPU, GPU, DSP, Ed il sistema operativo?
SDRAM ed USB) Su RasPI possiamo installare diversi sistemi
- CPU: 700 MHz ARM1176JZF-S core (famiglia operativi, alcuni creati “ad Hoc” altri invece sotto
ARM11) forma di “porting” e quindi adattati all’hardwa-
- GPU: Broadcom VideoCore IV, con supporto re. La distribuzione consigliata dal sito ufficiale
per le OpenGL ES 2.0, 1080p30 H.264 è Raspbian “wheezy”, una versione basata su
- Memoria (SDRAM): 512 Megabytes (condivi- Debian e sviluppata appositamente per RasPI la
sa con la GPU) quale, dopo una breve installazione su Memory
- USB: 2.0 ports (HUB integrato) Card, permette un avvio immediato mettendo-
- Output video: Connettore RCA per il video ci a disposizione un ambiente Desktop basato
composito, HDMI su LXDE molto semplice ma efficace, ben tre
- Output audio: 3.5 mm jack, HDMI browser per la navigazione in internet, un lettore
- Memoria: SD / MMC / SDIO card slot di file multimediali preinstallato e molto altro.
- Collegamenti di rete: Ethernet 10/100 (RJ- L’installazione di Raspbian su Memory Card è
particolare, infatti scaricando la distribuzione

dal sito ufficiale ed estraendo il file .zip salvato
sul computer, ci troviamo di fronte ad un file con
estensione .img il quale andrà in seguito scrit-
to su Memory seguendo il giusto procedimento
relativo al sistema operativo utilizzato. Qualora
qualcuno provasse a fare un semplice copia ed
incolla del file .img su Memory, sappia che in
Dopo aver verificato che l’unità scelta è esat-
questo caso RasPI non sarà in grado di esegui-
tamente la Memory Card che intendiamo utiliz-
re il Boot restando quindi inutilizzabile.
zare, con un click su “Write” inizierà il proces-
Prima di procedere alla scrittura del sistema
so di scrittura. A scrittura terminata possiamo
operativo scelto c’è da fare una piccola preci-
rimuovere la Memory ed inserirla su RasPI per
sazione sulla scelta della Memory Card: il file
il primo avvio.
.img contenente Raspbian è grande all’incirca
1,9 GB e viene quindi consigliata una Memo-
ry di 2GB o superiore. Scegliendo una Memory
Card da 2GB però, vi renderete presto conto
che lo spazio a disposizione per file e program-
mi è irrisorio. Se non l’avete ancora acquistata
quindi, vi consiglio di riflettere su ciò che avete
intenzione di realizzare con RasPI e scegliere la
Linux e Mac
giusta SD di conseguenza. Per avere la sicurez-
Se utilizziamo Linux o Mac, non abbiamo biso-
za di una piena compatibilità e stabilità vi consi-
gno di appoggiarci a nessun tipo di programma
glio inoltre di verificare, prima dell’acquisto, che
esterno ma procediamo utilizzando il terminale
la Memory in questione sia presente nell’elenco
ed un comando in grado di copiare e scrivere i
compatibilità.
file immagine: il comando “dd”.
Vediamo ora come scrivere Raspbian su Me-
Tale comando viene seguito da due parametri
mory Card con i tre principali sistemi operativi.
“if” ed “of”: con “if” si indica il percorso in cui
risiede il file .img di Raspbian, con “of” si indica
Windows
invece l’unità od il punto di mount della Memory
Per scrivere Raspbian su Memory Card, dob-
Card.
biamo utilizzare Win32DiskImager. Tale pro-
Prima di procedere alla scrittura però, dobbia-
gramma è in grado di operare con i file .img
mo assicurarci che nella Memory non vi siano
contenenti file system non supportati da Win-
partizioni, questo per evitare problemi durante
dows, come l’EXT4. Win32DiskImager ha un in-
la scrittura con il comando DD ed avere succes-
terfaccia grafica molto semplice ed immediata,
sivamente problemi di avvio con RasPI. Apria-
infatti ciò che ci viene immediatamente chiesto
mo quindi il Gestore Dischi su Linux o l’Utility
è l’inserimento del percorso del file e, succes-
sivamente l’unità rimovibile sul quale scriverlo. Disco su Mac e rimuoviamo tutte le partizioni
lasciando solo lo spazio libero. Dopo di che se- Oltre a RasPI abbiamo bisogno di:
gniamoci con quale nome il sistema chiama la - Mouse e tastiera;
Memory inserita (es. mmcblk0). - Un alimentatore con connettore micro USB (un
carica batterie per cellulari va benis-
simo, controllate eventualmente che
sia presente nell’elenco compatibili-
tà);
- Un monitor con ingresso HDMI o un
Ora siamo pronti a procedere: apriamo il termi- adattatore HDMI/DVI per i monitor più vecchiot-
nale e iniziamo a compilare il comando dd. ti;
Un esempio può essere: - Il cavo per la connessione ad internet via
dd if=/home/utente/Scrivania/Raspbian.img of=/ ethernet.
dev/mmcblk0 Pronti? Alimentiamolo!
Qualora fossero necessari i permessi da ammi- Appena viene alimentato, RasPI inizia subito a
nistratore basterà aggiungere un “sudo” funzionare visualizzando sul monitor la fase di
sudo dd if=/home/utente/Scrivania/Raspbian. boot ed avvio. Ad avvio terminato, ci trovere-
img of=/dev/mmcblk0 mo di fronte ad una schermata che ci mette a
disposizione le prime configurazioni
pre-avvio.
Non verrà segnalato in alcun modo lo stato

d’avanzamento e il cursore rimarrà a lampeg-
giare nella riga sottostante alla richiesta della
password , ma non preoccupatevi perchè tutto
procede per il verso giusto. Qualora il percorso
non sia stato digitato correttamente, il percorso
della Memory sia sbagliato, o il nome del file er-
rato, ci verrà segnalato e la scrittura non verrà Info: qualche semplice informazione riguardan-
eseguita. te il tool di configurazione.
A scrittura terminata, apparirà nuovamente la Expand_rootfs: abilitando questa funzione, al
riga di comando e potremo rimuovere la Memo- prossimo riavvio RasPI espanderà la partizione
ry e inserirla su RasPI. principale all’intera Memory Card, in modo tale
da avere a disposizione per i dati l’intero spazio
Il primo avvio! rimasto libero.
Ora che la Memory è stata caricata con Ra- Overscan: tale funzione abilita o disabilita la
spbian, siamo pronti per il primo avvio. visualizzazione a schermo intero. Qualora la vi-
sualizzazione su schermo presenti delle bande RasPI e avere quindi una maggior velocità del
nere laterali, abilitate l’overscan. sistema. Tuttavia, nonostante tutte le schede
Configure_keyboard: qua possiamo imposta- RasPI supportino l’incremento di frequenza im-
re il layout della tastiera per avere una piena posto da Raspbian senza perdere stabilità, ne
compatibilità con i simboli che altrimenti risulte- viene sconsigliato l’uso per non accorciare la
rebbero in posizioni diverse. Scegliamo quindi vita alla schedina.
Configure_keyboard e attendiamo che RasPI Ssh: abilita/disabilita il controllo di RasPI via
raccolga le dovute informazioni. Ci troveremo ssh. Già abilitato di default, permette di prende-
ora di fronte ad una lista di modelli preimposta- re i comandi di RasPI utilizzando un semplice
ti di tastiere. Se non siamo a conoscenza del programma per l’accesso via ssh da ethernet
modello esatto, o se non è presente nella lista, come Putty su windows, o il comando “ssh no-
scegliamo il valore di default e procediamo con meutente@ip_RasPI” su mac e linux.
la configurazione. Dobbiamo ora inserire il tipo Boot_behaviour: abilitando tale opzione, al
di layout basandoci sulla lingua utilizzata: pro- prossimo riavvio RasPI ci presenterà il suo De-
cediamo quindi scegliendo Italiano e confermia- sktop. Se non abilitato, al termine del prossimo
mo. Infine ci viene chiesta la funzione di alcuni avvio RasPI si avvierà in modalità testuale met-
tasti come AtlGr, se non conosciamo la funzione tendoci a disposizione la sola riga di comando
possiamo lasciare tutto di default e terminiamo e non l’ambiente Desktop, ricordiamoci quindi
la configurazione. di abilitarla.
Change_pass: con Change_pass cambiamo Update: con Update aggiorniamo i pacchetti
la password d’accesso a RasPI di default “ra- presenti in RasPI, compresi alcuni componenti
spberry” per l’utente “pi”. della lingua utilizzata per il sistema. Consiglio
Change_locale: permette di impostare una quindi di selezionare tale opzione prima proce-
lingua da utilizzare per il sistema. Tuttavia la dere al primo avvio vero e proprio, ricordando
lingua base rimane l’inglese in quanto molti che ciò richiede l’accesso ad internet.
dei pacchetti di Raspian utilizzano solo l’ingle- Configurato ciò che ci serviva? Allora clicchia-
se nell’interfaccia grafica. Si può quindi evitare mo Finish e aspettiamo che RasPI ci presenti il
questo passaggio. suo Desktop!
Change_timezone: imposta il fuso orario, la Se avete scelto di espandere la partizione prin-
data e l’ora. Ricordo però che RasPI non include cipale all’intera Memory, il primo avvio può du-
nel suo hardware un RTC(Realm Time Clock) e rare anche più di 5 minuti proprio perché RasPI
non è quindi in grado di ricordare l’ora e la data sta modificando la partizione principale. Potete
se viene rimossa l’alimentazione. La data e l’ora rendervi conto del fatto che sta “lavorando” dal
vengono comunque sincronizzate ogni qual vol- led ACT acceso di colore giallo.
ta vi sia una connessione ad internet.
Memory_split: modifica il quantitativo di me- L’ambiente desktop
moria disponibile alla GPU, di default 64. Terminato l’avvio, se ci siamo ricordati di abilita-
Overclock: l’overclock permette di aumentare re la visualizzazione del desktop, ci troveremo
la frequenza di clock del processore AMR di davanti all’ambiente desktop basato su LXDE
messo a disposizione da Raspbian. comandi i quali permettono di realizzare anima-

zioni, piccole applicazioni, giochi e molto altro.
Come possiamo notare, oltre al terminale, sul

desktop troviamo le icone di alcune delle appli- Per chi non dispone di una connessione Ether-
cazioni preinstallate nella distribuzione. Per chi net e vuole utilizzare una connessione Wifi, vi è
conosce il linguaggio di programmazione Py- poi Wifi Config che permette di configurare il di-
thon, ci sono IDLE ed IDLE3 i quali permettono spositivo con il quale andare in internet, cercare
di impartire comandi in Python e di interagire la rete ed effettuare l’accesso. Vorrei aggiun-
con i pin di I/O utilizzando le librerie integrate in gere un particolare: le chiavette Wifi, in genere,
Raspbian. assorbono una cospicua corrente dalla presa
USB, pertanto potrebbe succedere
che appena connessa la chiavetta
Wifi RasPI si spenga o si riavvi. Per
risolvere a questo inconveniente,
basterà collegare la chiavetta ad un
Hub USB alimentato separatamen-
te.
Infine, troviamo Midori, uno dei tre
browser preinstallati in Raspbian.
Midori, Dillo e Netsurf ci consentono
una navigazione in internet alquanto
fluida e piacevole. Nonostante fati-
chino un po’ nel caso in cui il sito
sia particolarmente pesante, nulla
Con Scratch presente sul desktop, ci torna in impedisce la normale navigazione.
mente l’intento di chi ha realizzato RasPI: av-
vicinare i bambini alla programmazione e all’in- Scriviamo e stampiamo
formatica. Scratch infatti è un ambiente di svi- Come primo passo nell’ambiente Raspbian, ve-
luppo con un’ interfaccia visuale dotata di molti diamo ora come configurare una nuova stam-
pante, ed utilizzare l’editor di testo preinstallato. lazione di una nuova stampante e l’eventuale
La configurazione di una nuova stampante ri- condivisione in rete. Terminata l’installazione,
chiede l’utilizzo di una connessione ad internet dovremo comunicare a CUPS che noi abbiamo i
per scaricare i driver necessari, inoltre sarà poi permessi per poter accedere alla gestione delle
possibile condividere la stampante installata in stampanti, quindi da riga di comandi digitiamo:
rete, in modo tale da poter rendere disponibile sudo usermod -a -G lpadmin pi
la stampante anche ad altri eventuali PC com- Se durante la fase di configurazione di RasPI
presi nella rete Ethernet. abbiamo cambiato il nome dell’utente principa-
Ma prima di stampare qualcosa, dobbiamo scri- le, dovremo sostituire il “pi” presente nel coman-
verlo... do con il nome del nuovo utente.
Per creare un nuovo file di testo possiamo clic- Confermiamo, e siamo pronti per accedere alla
care sul menù di start, andare su Other/Altro e schermata di configurazione della stampante.
cliccare su LeafPad, si aprirà così un file di testo Apriamo il browser internet, e andiamo all’indi-
bianco pronto per accettare tutto ciò che voglia- rizzo http://127.0.0.1:631 e ci troveremo nella
mo scrivere. pagina principale di CUPS.
Ora possiamo aggiungere una nuova stampan-

A questo punto, se vogliamo stampare il testo te aprendo la sezione Amministratore e cliccan-
appena scritto, dobbiamo procedere alla confi- do su Aggiungi stampante. Prima di procedere,
gurazione della stampante. CUPS ci chiederà username e password, solo
Colleghiamo quindi la stampante alla porta dopo ci mostrerà le stampanti trovate suddivi-
USB, ed avviamo il terminale per inserire il se- dendole tra quelle “locali” e quindi collegare a
guente comando: RasPI e quelle presenti in rete.
sudo apt-get install cups
Diamo conferma, ed inizierà così l’installazione
di CUPS. Tale software permette infatti l’instal-
Scegliamo la stampante corretta, nel mio caso E ora siamo pronti per stampare il nostro file di
testo precedentemente scritto
la Epson WP-4515 e confermiamo.
Nella pagina successiva possiamo dare un
nome alla stampante, ed eventualmente condi-
viderla in rete prima di procedere alla selezione
del modello corretto. Ci verrà proposta una lista
di modelli di stampanti, e noi dovremo scegliere
quello giusto affinché CUPS carichi i driver adat-
ti. Se il modello non è presente, potete provare
con un modello simile purché sia della stessa
marca, oppure scaricare dal sito del produttore
il file PPD contenente i driver della stampante
da voi utilizzata e fornirli a CUPS nell’apposita
casella.
Con un ultimo click su conferma, potremo im-
postare il tipo di carta utilizzato di default e ter-
minare l’installazione della stampante, magari
stampando anche un testo di prova per verifica-
re che tutto sia andato a buon fine.
http://it.emcelettronica.com/raspberry-pi-tutorial-installazione-distro-configurazione-e-stampa
2. Navigazione in internet e con-

trollo remoto
Browser internet...quale? tali browser vengano avviati quando a RasPI è
N
ella distribuzione che abbiamo installa- collegato uno schermo con una bassa risoluzio-
to la volta scorsa, Raspbian, troviamo ne, o nel caso in cui si utilizzi l’adattatore HDMI-
tre browser per la navigazione internet DVI o l’uscita S-Video.
preinstallati: Midori, Dillo e Netsurf. Questi tre Se avete seguito la guida precedente per la
browser sono molto leggeri e permettono una configurazione della stampante tramite CUPS,
navigazione abbastanza fluida, tuttavia vi sono vi potrà esser capitato una non corretta impagi-
alcune differenze riguardanti la compatibilità nazione della pagina di configurazione da parte
con i linguaggi ed i protocolli utilizzati nelle pa- di Midori come segue:
gine web come JavaScript, HTML5, FTP.

Netsurf e Dillo, per esempio, sono privi
del supporto a JavaScript, quindi duran-
te la navigazione tutte le funzionalità ed
i contenuti realizzati con tale metodo non
verranno riprodotti, tuttavia questo per-
mette, se pur a discapito dei contenuti, di
avere una navigazione più rapida e fluida
rispetto a Midori.
Da un lato non vi è il supporto a Java-
Script per Dillo e Netsurf, dall’altro questi
due browser hanno piena compatibilità
In questo caso, l’utilizzo del browser Dillo avreb-
con i protocolli come l’FTP, assente in Midori.
be risolto il problema dell’impaginazione.
Possiamo quindi scegliere il browser più adatto
al nostro tipo di navigazione in web basandoci Browser alternativi
proprio sui siti maggiormente frequentati e sop- L’errata impaginazione delle pagine web da
perire alla mancanza di un particolare supporto parte dei browser preinstallati, si risolve utiliz-
utilizzando un browser diverso. Un difetto co- zando un browser internet alternativo. Vediamo
mune a questi tre browser che è stato riscontra- quindi come installare due valide alternative ba-
sate su Firefox e Chrome, due tra i browser più
to da molti, è che non sempre l’impaginazione
conosciuti.
delle pagine avviene in maniera corretta, e il di-
fetto si presenta maggiormente nei casi in cui
Iceweasel, è un browser internet basato sul Sudo apt-get install chromium

progetto Gnuzilla, progetto che aveva l’obiettivo
di rendere disponibile il software della suite Mo-
zilla utilizzando però soltanto codice libero, ed
ecco perché il nome Gnu-zilla. Iceweasel, eredi-
ta gran parte delle features del fratello maggio-
re, oltre alla grafica infatti, gran parte dei plugin
messi a disposizione per Mozilla Firefox sono
compatibili con questo browser a codice libero.
Già presente tra i pacchetti di Raspbian, per in-
stallarlo dobbiamo semplicemente avviare il ter-
minale ed inserire il comando:
sudo apt-get install iceweasel Vi sono molte discussioni, sopratutto nel forum
Ad installazione terminata, se ci rechiamo nel ufficiale RasPI, su quale sia il miglior browser in
menù di start, troveremo Iceweasel nella cate- fatto di compatibilità con i vari linguaggi utiliz-
goria Internet insieme ai browser già presenti zati nel web, la velocità nel caricare le pagine e
in Raspbian. La navigazione con Iceweasel è la fluidità nello scorrerle, tuttavia ognuno dice il
abbastanza fluida e veloce, integra il supporto a suo parere e non si arriva mai ad una conclusio-
JavaScript quindi verranno visualizzati i conte- ne. A mio avviso, Iceweasel e Chromium sono
nuti in tale linguaggio e l’impaginazione avviene ottimi browser molto fluidi e veloci, ma facendo
sempre nel modo corretto. una ricerca in rete si trova sempre chi dice l’op-
posto. Lascio quindi a voi la possibilità di sce-
gliere quale usare, e perché no, provarne altri e
dirci come vi trovate.
Flash Player, video e SWF

Appena fatta un po’ di pratica con la navigazio-
ne internet e RasPI, vi accorgerete subito che
nessuno dei browser è in grado di riprodurre un
Chromium, come ricorda il nome, è un browser video su Youtube o delle animazioni in SWF,
internet basato sull’ormai famoso Google Chro- questo perché Adobe non ha rilasciato una ver-
me. Il progetto Chromium punta a fornire un sione di Flash Player compatibile con il proces-
browser Open Souce veloce, sicuro e molto sta-
sore AMR di RasPI, l’unica versione compatibile
bile. Anche qua, come per Iceweasel, la grafica
con tali processori è stata rilasciata per Android
è molto simile al browser da cui deriva, da quale
e non è quindi possibile installarla su Raspbian.
eredita anche la compatibilità con i vari addons.
Come prima, lo installiamo via terminale e sia- Per poter riprodurre i filmati ed i contenuti SWF,
mo pronti per navigare. è tuttavia possibile installare Gnash, un player

in grado di integrarsi con i browser installati e
di riprodurre i contenuti che di solito vengono va di abilitare o disabilitare la possibilità di colle-

visualizzati con Flash Player. garsi a RasPI via SSH. Ma cos’è questo SSH?
Come sempre, ci rechiamo sul terminale e con i SSH è un particolare protocollo di comunica-
seguenti comandi installiamo Gnash: zione di rete il quale permette di stabilire una
sudo apt-get install gnash connessione cifrata tra due dispositivi per poter
sudo apt-get install browser-plugin-gnash controllare il dispositivo “host” o dispositivo al
Installato Gnash, siamo pronti per visualizzare quale ci si collega, tramite linea di comando, un
qualche video da youtube, ma, non possiamo pò come avviare RasPI ed aprire il terminale,
aspettarci fluidità anche durante la visione. Ra- solo che da remoto e quindi da un qualsiasi altro
sPI infatti fatica molto a riprodurre i video pre- PC o dispositivo come Smartphone con Android
senti all’interno dei browser internet ed alcune o IOS collegato alla stessa rete. Se non abbia-
volte la riproduzione avviene a scatti ed è quasi mo disabilitato l’opzione ssh durante la fase di
impossibile seguire con fluidità il video, tuttavia inizializzazione siamo già pronti per cominciare,
ricordiamoci che stiamo già chiedendo molto ad in alternativa se l’avete disabilitata, magari per
un PC grande quanto una carta di credito... sbaglio, possiamo sempre tornare alla scher-
mata di inizializzazione digitando:
sudo raspi-config
da terminale. Abilitato il protocollo ssh, dobbia-
mo essere a conoscenza di alcuni dati fonda-
mentali: il nome utente e la password di RasPI
ed il suo IP. Sicuramente sapete già il nome
utente e la password, che se non avete cam-
biato di default sono “pi” e “raspberry” mentre
per l’ip, una volta connesso RasPI alla rete, da
terminale diamo il comando:
ifconfig
Controllo remoto e comandi via SSH e ci verranno proposti tutti i dati relativi alla con-
A volte può essere necessario poter controllare nessione Ethernet o Wifi. A noi interessa l’IP
RasPI da remoto per esempio nel caso in cui quindi ci segneremo l’indirizzo presente alla
non si abbia a disposizione uno schermo da po- voce “inet addr” o “indirizzo internet”.
tergli collegare, per questo ci viene incontro un
protocollo supportato da RasPI e già abilitato di
default.
Tra le opzioni di inizializzazione viste la volta
scorsa, vi era l’opzione “ssh” la quale permette-
In alternativa, possiamo utilizzare un compu- Windows

ter connesso alla stessa rete per visualizza- In Windows non è possibile usare il comando
re la pagina di configurazione del modem da “ssh” da terminale o Dos, dobbiamo quindi ap-
noi usato che solitamente si trova all’indirizzo poggiarci ad un software in grado di creare un
“192,168,1,1” e da li vedere i dispositivi connes- collegamento con protocollo SSH verso un altro
si ed il loro IP. A questo punto non ci rimane che dispositivo. Vi sono vari programmi più o meno
connetterci via SSH al nostro RasPI. In base al complessi per questo uso, uno in particolare è
sistema operativo da quale vogliamo connetter- Putty. Con un interfaccia molto semplice, Putty
ci, vi sono due modi: ci permette di stabilire una connessione con il
nostro RasPI ed avere, anche su Windows, una
Linux e Mac finestra contenete la riga di comando in attesa
Se utilizziamo Linux od un Mac, non dobbiamo di un nostro ordine. Installato ed avviato Putty,
installare nessun tipo di software aggiuntivo poi- immettiamo l’indirizzo IP su “Host Name” e se-
ché tutto quello che ci serve è il terminale. Av- lezioniamo SSH, così facendo verrà imposta-
viato il terminale dobbiamo inserire un comando ta automaticamente la porta 22, di default per
strutturato così: questo tipo di protocollo. Clicchiamo su “Open”
ssh NomeUtente@IpRasPI e non dovremo far altro che immettere nome
Utilizzando i dati di accesso di default ed ipo- utente e password.
tizzando l’indirizzo IP di RasPi come
192.168.1.5 avremo per esempio:
ssh pi@192.168.1.5
Confermiamo, e se i dati immessi sono
corretti ci verrà chiesta la password di
accesso all’utente “pi” ed infine apparirà
la linea di comando pronta ad attendere
le nostre comunicazioni. Ora però probabilmente vi starete chiedendo,
ma se volessi avere il controllo remoto del de-
sktop? Nulla di più semplice!
Dal terminale dell’interfaccia di RasPI o sempli-
cemente dalla riga di comando appena ottenuta
tramite connessione SSH, ci basterà installare
VNC, il classico software per il controllo remoto.
Digitiamo quindi:
sudo apt-get install tightvncserver
ed avverrà l’installazione del necessario per il
controllo remoto. Ad installazione terminata, client è TightVnc, molto semplice ed intuitivo,

non ci rimane altro che avviare il server VNC ed oltre ad essere anche multipiattaforma e quindi
impostare una password d’accesso per le future installabile su qualsiasi sistema operativo. Se
connessioni. Digitiamo: utilizziamo Windows possiamo scaricare il file
vncserver :1 -geometry 800x600 -depth 24 eseguibile (.exe) mentre se utilizziamo Linux o
Analizziamo questo comando: la prima parte in- Mac vi è un apposita versione in Java. Da utenti
dica che vogliamo avviare la funzione server di Windows, dopo l’installazione basterà sempli-
VNC ed il numero di questo server, “-geometry” cemente avviare il “Viewer” mentre per eseguire
indica la dimensione in pixel della finestra che il programma scaricato in Java avviamo il termi-
apparirà sullo schermo del nostro computer, nale, e dopo esserci spostati nel percorso in cui
mentre “-depth 24” stabilisce semplicemente un si trova il file digitiamo:
set di colori a 24 bit, più che sufficienti per la vi- java -jar NomeProgramma.jar
sualizzazione ottimale dello schermo in remoto e ci si aprirà TightVNC in attesa dell’inserimento
di RasPI. dei dati di connessione. Alla richiesta “Remo-
Confermato il comando, ci verrà richiesta una te Host” inseriamo semplicemente l’indirizzo IP
password che dovrà poi essere immessa da co- del nostro RasPI, mentre su “Port” va indicata la
lui che tenterà di accedere al desktop remoto, porta di accesso la quale, se non abbiamo av-
ed infine se vogliamo inserire una password di viato più di un server VNC su Raspi, sarà 5901
“sola lettura” ovvero nella connessione remota od in alternativa 590x ed al posto di x andrà
che verrà a stabilirsi utilizzando tale password messo il numero precedentemente comunicato
non potremo modificare nessun tipo di file, ma da RasPI. Confermiamo cliccando su connetti,
solo aprirli e leggerli. Inseriti i dati richiesti, ci ed ecco che dopo la richiesta dell’inserimento
verrà comunicato che il server VNC è ora in fun- della password apparirà il desktop del nostro
zione ed anche il numero di tale server. RasPI!
Ora RasPI è configurato correttamente, non ci

rimane altro che scaricare ed avviare l’applica-
zione lato “client” sul nostro PC o Smartphone
collegato alla stessa rete di RasPI. Un buon
In conclusione
Se siete interessati al mondo RasPI ma non
avete ancora fatto il passo dell’acquisto perchè
limitati dalla mancanza di un monitor per poterlo
usare, ora sapete che il monitor può essere vi-
sto come un “accessorio opzionale” ed è quindi
possibile prendere il totale controllo di RasPi
da remoto via linea di comando o con tutto l’am-
biente desktop. Più avanti vedremo come rea-
lizzare un piccolo server simile a DropBox con
RasPi e potremo sfruttare il controllo remoto per
lasciare RasPi in una posizione a noi comoda
anche priva di monitor durante tutto il tempo in
cui lavorerà come server per ospitare i nostri
dati.
http://it.emcelettronica.com/raspberry-pi-tutorial-navigazione-internet-controllo-remoto
3. Realizziamo il nostro “DropBox”

con RasPI!
S
icuramente ormai tutti conoscerete DropBox, sono sempre alla portata di un utente qualsiasi
il servizio che gratuitamente permette di che magari deve andare in vacanza e vuole fare
avere 2GB di spazio internet nel quale po- un backup di tutte le foto che scatta su un server
ter caricare file e foto per poterle poi condivide- sicuro. Allora facciamoci aiutare da RasPI!
re su più dispositivi. Come DropBox, esistono
molti altri siti, ma tutti mettono a disposizione Protocollo SFTP
L’ultima volta abbiamo visto l’SSH, un protocol-
un limitato numero di GB che può però aumen-
lo di rete che permette di stabilire una connes-
tare (fino ad un massimo di 16GB per DB) nel
sione remota tramite due dispositivi nella stessa
caso in cui si invitino altre persone, si aggiuga-
rete per l’invio di comandi da terminale, l’SFTP
no dispositivi, si carichino foto e via dicendo.
( SSH File Transfer Protocol) invece è un proto-
I problemi con questi siti però, si riducono sem-
collo di rete che ci permette di inviare o spostare
pre agli stessi: i nostri file si trovano sul server
file tra un Host ed un Client in maniera sicura e
di qualcun altro e nel momento in cui lo spazio cifrata. L’SFTP utilizza come base il protocollo
messo gratuitamente a disposizione non ci do- SSH, che come abbiamo già visto è supportato
vesse più bastare, i costi per aumentarlo non nativamente da RasPI, il che semplifica molto la
fase di configurazione per effettuare poi il colle-

gamento per il trasferimento dei dati.
Iniziamo con la sicurezza

Come prima cosa, dato che metteremo i nostri
Ora che abbiamo creato un nuovo utente, an-
dati nella Memory di RasPI, è bene innanzitutto
dremo a modificare la porta di accesso a RasPI
cambiare, qualora non l’avessimo fatto, la pas-
tramite protocollo SSH (e quindi anche SFTP)
sword per l’utente di default “pi”. Tale utente in-
che, come abbiamo visto l’altra volta, di default
fatti rimarrà in RasPi per il normale utilizzo e ne
è la numero 22. Questo accorgimento serve
creeremo un altro per lo stoccaggio dei file e
l’accesso via SFTP. Dal terminale diamo il solito sempre per aumentare la privacy dei nostri dati
comando “sudo raspi-config” ed alla voce “chan- in modo tale che non bastino nome utente e
ge_pass” impostiamo una password diversa da password per accedervi, ma si dev’essere an-
“raspberry” per evitare che qualcuno vi acceda che a conoscenza della porta nella quale “pas-
utilizzando proprio la password di default. sano” i comandi per l’accesso. Andiamo quindi
a cambiare un parametro nei file di configura-
zione del protocollo SSH, apriamo il terminale
e digitiamo:
sudo nano /etc/ssh/sshd_config
E ci verrà aperto, con il solito editor di testo
Nano, il file di configurazione SSH. Il primo co-
mando che contiene questo file di configurazio-
ne è “port 22” ed è proprio quello che serve a
noi. Facendo riferimento all’elenco delle porte
TCP e UDP, possiamo scegliere quale porta uti-
Ora che abbiamo cambiato la password, dob- lizzare, purché non sia già utilizzata da qualche
biamo creare un nuovo utente con nome e pas- altro programma. Per evitare una ricerca tra le
sword a nostra scelta i quali verranno successi- porte utilizzate, sappiate che tutte le porte com-
vamente utilizzati per l’accesso via SFTP. Per prese tra la 49152 e la 65535 sono libere, quindi
la creazione di un nuovo utente e l’inserimento possono essere utilizzate per i fini dell’utente.
della relativa password useremo da terminale i Scelta la porta, ed inserita al posto del 22 nell’e-
comandi “useradd” e “passwd” così strutturati: ditor di testo, confermiamo con CTRL + X, “y”
sudo useradd NomeUtente ed invio per sovrascrivere il file.
sudo passwd NomeUtente
Se abbiamo sbagliato nell’inserire il nome dell’u-
tente, o se per qualche altro motivo lo vogliamo
cancellare, dovremo usare il comando:
sudo userdel NomeUtente
A questo punto sarà necessario un riavvio, connessi a RasPI, vedremo i file presenti sulla
dopo il quale per connetterci via SSH non sarà Memory. In alto, troviamo quattro TextBox, nella
più possibile, qualora la connessione avvenisse prima inseriremo il tipo di protocollo e l’indirizzo
da Linux o Mac, utilizzare il semplice comando: IP di RasPI, nel secondo il nome utente dell’u-
ssh NomeUtente@IndirizzoIP tente appena creato, in seguito la password,
ma dovremo usare: ed infine la porta da noi precedentemente se-
ssh -p NumeroPorta NomeUtente@IndirizzoIP lezionata. Con un click su Connessione Rapi-
un esempio: da potremo accedere a tutti i file contenuti nella
ssh -p 51000 pi@192.168.1.4 Memory. In alternativa possiamo inserire nella
Se utilizziamo Windows invece, dovremo sem- prima TextBox il comando così composto:
plicemente impostare il numero della porta in sftp://NomeUtente:Password@IP_RasPI:Porta
Putty o nel programma utilizzato. Usando i dati di default ed un IP e porta a caso:
sftp://pi:raspberry@192.168.1.5:50265
Connessione dalla rete locale
Ora che RasPI è pronto per lo scambio di file
con i dati da noi impostati, possiamo già pro-
varlo utilizzando un PC o Smartphone collegato
alla stessa rete. Per farlo, ci faremo aiutare da
Filezilla, un programma gratuito che permette di
collegarci ad un dispositivo Host con i più dif-
fusi protocolli di invio e ricezione file. Una volta
scaricata la versione Client dal sito ufficiale e
dopo averlo installato, ci troveremo di fronte alla
seguente interfaccia grafica: Via web?
Ora viene “il bello”, ovviamente non è possibile
stabilire una connessione con RasPI dall’ester-
no della nostra rete LAN o WiFi, infatti se per
puro sfizio provate avviare Filezilla su un PC
connesso ad una diversa connessione internet,
e ad inserire l’indirizzo l’IP della connessione in-
ternet alla quale è connesso RasPI che potete
trovare cercando “my ip” su google con Midori,
Filezilla vi comunicherà che non è stato possibi-
le stabilire una connessione. Perchè? Semplice,
il vostro Modem blocca ogni accesso dal Web
Come possiamo notare, il programma è suddi- alla vostra rete privata, e guai se non lo facesse!
viso in due parti, “sito locale” e “sito remoto”. Per poter accedere dal web, magari da un altro
In Sito Locale troviamo il nostro computer con PC connesso ad internet, dobbiamo ora aprire
tutti i suoi file mentre in Sito Remoto, una volta la porta che abbiamo precedentemente inserito
nel file di configurazione SSH, nel nostro mo- potete trovare l’apertura delle porte sotto la voce
dem di casa. In commercio vi sono centinaia di “Port Forwarding” “Port Mapping” o “Virtual Ser-
modem, uno diverso dall’altro, pare evidente ver” o in alternativa con una semplice ricerca in
quindi che sarebbe impossibile indicare passo- internet inserendo il modello del vostro modem
passo i procedimenti per aprire le porte deside- troverete la guida su come aprire le porte per
rate su ogni modello, tuttavia il percorso è molto certi “programmini”. A questo punto, apriamo la
simile per tutti i modem. Innanzitutto dobbiamo porta che abbiamo impostato su RasPI e natu-
conoscere l’indirizzo IP del nostro modem: ralmente indichiamo il suo indirizzo IP, mentre
alla richiesta del protocollo indicheremo TCP,
Windows salviamo, e chiudiamo il browser internet.
Indifferentemente dal tipo di Windows utilizzato,
andiamo su Start>Programmi>Accessori>Prom
pt dei comandi E nel terminale appena aperto
inseriamo il comando “ipconfig”. Alla voce Ga-
teway predefinito troveremo l’indirizzo IP del
modem.
Se tutto è andato correttamente, possiamo av-

viare Filezilla su un PC collegato ad una diversa
connessione internet, ed inserendo l’indirizzo IP
Linux, Mac e RasPI della connessione internet che utilizza RasPI,
Dopo aver cercato ed avviato il Terminale, con il nome utente, password e la porta da noi scelta,
comando route -n potremo facilmente identifica- potremo visualizzare i file della Memory card!
re l’indirizzo del modem presente nella colonna Se Filezilla ci comunica che la connessione non
Gateway. è andata a buon fine invece, probabilmente non
abbiamo aperto correttamente le porte del mo-
dem, e non è quindi raggiungibile.
Memorizzato l’indirizzo del modem, apriamo

un qualsiasi browser internet ed inseriamolo al
posto dell’indirizzo internet della nostra Home e
ci verranno chiesti dei dati per l’autenticazione.
Per accedere alla configurazione del modem in-
fatti, dovremo inserire il suo nome utente e la
password, che solitamente sono “admin e ad-
min” o “user e user”, in alternativa potete trovarli
scritti sotto il modem.
Ora la procedura indicata è “generale” quindi
dovrete essere voi ad adattarla al vostro caso,
Il nostro RasPI-DropBox è ora pronto! Possia- ci spostiamo nella cartella appena decompres-
mo aprire, salvare, e spostare file da RasPI al sa
PC in uso attraverso Internet o via Ethernet. cd noip-2.1.9-1
installiamo il DUC
No-IP! sudo make
Rimane un problema, e se il modem si riavvia sudo make install
e l’indirizzo IP cambia? Come faccio a comu- avviamolo, ed eseguiamo la prima configurazio-
nicare con RasPI se non conosco più il suo ne
IP? Semplice, No-IP! No-ip è un servizio gra- sudo /usr/local/bin/noip2
tuito con il quale possiamo avere un indirizzo Ci verranno ora chiesti i dati con cui ci siamo
internet simile a mariorossi.no-ip.org il quale ci registrati sul sito noip.com, iniziando con la mail
reindirizzerà verso l’IP della nostra connessione e la password, successivamente dovremo in-
Internet alla quale è connesso RasPI, non solo, serire ogni quanti minuti sincronizzare l’IP con
nel momento in cui il modem venisse riavviato, il dominio e ci viene consigliato un intervallo di
un software che installeremo su RasPI comu- 30 minuti. Non inserite un tempo tropo ristret-
nicherà automaticamente il nuovo IP in modo to come possono essere 5 o 10 minuti, 20-30
tale che collegandoci all’indirizzo fornito, potre- minuti sono più che accettabili e non obbliga-
mo sempre connetterci con RasPI! Ma andiamo no RasPI a continue comunicazioni con noip.
per gradi, innanzitutto dobbiamo registrarci su Infine, indicheremo il dominio precedentemen-
www.noip.com indicando, durante la registra- te creato, ed ecco il nostro RasPI-Box pronto
zione, il nome del nostro futuro “dominio” nella ad essere raggiunto inserendo al posto dell’IP
sezione Hostname. L’Hostname che indichere- in Filezilla, l’indirizzo che abbiamo precedente-
mo, sarà quello a cui dovremo connetterci con mente creato.
Filezilla per comunicare con RasPI, sarà quin-
di opportuno salvarlo da qualche parte insieme
alla mail e la password utilizzata per la registra-
zione. A registrazione effettuata, dobbiamo in-
stallare l’applicazione DUC (Dynamic Update
Client) su RasPI, quindi da terminale daremo i
seguenti comandi:
Creiamo una nuova cartella e la chiamiamo noip
mkdir /home/pi/noip
ci spostiamo all’interno della cartella
cd /home/pi/noip
scarichiamo il file d’installazione del DUC wget
http://www.no-ip.com/client/linux/noip-duc-li- Non ci rimane che far si che il DUC si avvii ogni
nux.tar.gz qual volta viene acceso RasPI! Sempre da ter-
decomprimiamo il file appena scaricato minale quindi, creeremo uno script per avviare
tar vzxf noip-duc-linux.tar.gz il DUC ad ogni accensione:
Creiamo un nuovo file Da utente Android, dato che ho parlato della

sudo nano /etc/init.d/NoIPstartup possibilità di accedere a RasPI via sftp anche
All’interno dell’editor di testo scriveremo: da Smartphone, segnalo l’applicazione Andftp
#! /bin/sh che oltre ad essere gratuita permette la connes-
# /etc/init.d/noip sione ad un dispositivo Host per lo scambio di
### BEGIN INIT INFO file via Wifi e 3G utilizzando sftp, ftp, etc.
# Provides: noip
# Required-Start: $remote_fs $syslog
# Required-Stop: $remote_fs $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
### END INIT INFO
case “$1” in image credits | adafruit.com
start)
echo “Starting noip”
/usr/local/bin/noip2
;;
stop)
echo “Stopping noip”
killall noip2
;;
*)
echo “Usage: /etc/init.d/noip {start|stop}”
exit 1
;;
esac
exit 0
e come sempre, confermeremo con CTRL+X,
“y” ed Invio. Rendiamo lo script appena creato
eseguibile
sudo chmod 755 /etc/init.d/NoIPstartup
ed infine lo rendiamo eseguibile all’avvio
sudo update-rc.d NoIPstartup defaults
Ecco RasPI pronto per ospitare i nostri dati pre-
via autenticazione con nome utente e password.
http://it.emcelettronica.com/raspberrypi-tutorial-realizziamo-nostro-dropbox-con-raspi
4. Controlliamo il Media Center con

un comune telecomando IR!
Raspbmc segnali IR avremo bisogno di:
A
ndiamo per gradi, prima di addentrarci nella - Un telecomando IR, possibilmente non già uti-
ricezione dei comandi impartiti da un tele- lizzato da un altro dispositivo per evitare conflitti
comando IR, dobbiamo necessariamente - Un sensore IR siglato TSOPxxxx
prendere confidenza con la distribuzione che - Semplici cavetti per collegare il sensore ai pin
andremo ad utilizzare: Raspbmc. di I/O di Rpi
Raspbmc è una distribuzione basata su Debian Come avrete notato, il punto forte è sicuramen-
come anche Raspbian, la quale porta sulla note l’esiguo numero di componenti necessari,
stra piccola schedina il più diffuso programma oltre al fatto che un TSOPxxx non costa più
per MediaCenter: XBMC. Insieme a XBMC, ar- di 1,5€ ed è reperibile in quasi tutti i negozi di
riva la quasi totale compatibilità con gli Add-on componentistica elettronica. Il telecomando IR
per esso messi a disposizione, possiamo quindi che andremo ad utilizzare non deve avere par-
vedere direttamente sul televisore in streaming ticolari caratteristiche, ma per una più facile in-
tutte le puntate dei più famosi programmi televi- terazione tra noi e Raspbmc l’ideale sarebbe un
sivi, film, e molto altro. telecomando con le quattro frecce direzionali ed
Procediamo quindi con l’installazione di Ra- il tasto OK centrale, per poterci muovere age-
spbmc! Sul sito ufficiale troviamo tre Download, volmente nel menù.
il primo si riferisce ad un programma con una Per quanto riguarda il sensore TSOP invece,
semplice interfaccia grafica il quale ci guiderà c’è da fare una piccola precisazione prima di
nell’installazione di Raspbmc in un supporto procedere all’acquisto. Vi sono svariati sensori
esterno da noi scelto, il secondo ed il terzo fan- con tale sigla, i quali differiscono in tensione di
no rifermento al classico file .img da scaricare e
alimentazione, frequenze captate e tipo di se-
scrivere successivamente su Memory Card con
gnale in uscita.
lo stesso procedimento con cui, negli articoli
Come già saprete, su Rpi sono presenti dei pin
precedenti, abbiamo installato Raspbian. I due
file .img messi a disposizione differiscono nel di I/O per il collegamento di sensori, pulsanti,
fatto che il primo è un file molto leggero il quale, relè e per far interagire RPI con il “mondo ester-
dopo averlo scritto su Memory ed avviato in Rpi, no”. Tali pin, se utilizzati come ingressi per la
scaricherà tutto il necessario dalla rete Internet. ricezione di un segnale, accettano come tensio-
Il secondo invece contiene l’intera distribuzione ne massima in ingresso 3.3V, dovremo quindi
Raspbian la quale richiede solo di esser scritta scegliere un sensore IR in grado di ricevere
su Memory e poi avviata.
fedelmente i comandi impartiti dal telecoman-
Dopo aver preso un po’ di confidenza con que-
do con una tensione inferiore ai classici 5V dei
sta distribuzione, possiamo passare alla “lista
segnali TTL.
della spesa”. Per permettere a Rpi di ricevere i
Tra questi, vi è il TSOP34138 il quale presen- Per aiutarvi nell’individuazione dei pin, potete
ta proprio le caratteristiche e l’affidabilità da noi utilizzare l’immagine qui riportata.
ricercate, potrete utilizzare anche modelli diffe-
renti, ma non sempre la ricezione del comando
avverrà in modo corretto ne verrà garantita una
buona distanza tra il ricevitore ed il telecoman-
do. Le prove iniziali le ho realizzate con un sen-
sore IR recuperato da un vecchio registratore, Controllate più volte che il collegamento avven-
ed infatti dopo il metro e mezzo mi era impos- ga nei giusti pin, un errore potrebbe portare alla
sibile impartire i comandi dal telecomando e ho rottura del vostro Rpi, come ad esempio alimen-
quindi dovuto acquistare un sensore più adatto tare il sensore dai 5V e non dai 3.3V. A collega-
allo scopo. mento effettuato, possiamo passare a conosce-
Passiamo al lato pratico e iniziamo quindi a pre- re LIRC.
disporre “l’hardware” per la ricezione degli infra-

LIRC
rossi. Per il collegamento del sensore al connet-
Per la decodifica dei segnali ricevuti dal tele-
tore presente sul PCB di Rpi, potete utilizzare
comando, useremo il pacchetto LIRC ormai
dei connettori facilmente reperibili in vecchi PC presente di default in tutte le nuove versioni di
in quanto utilizzati per il collegamento dei vari Raspbmc. LIRC è in grado di identificare ogni
pulsanti/led alla scheda madre, così si eviteran- singola pressione sul telecomando, per poi as-
no eventuali saldature. segnare il giusto comando al tasto premuto.
Quello che andremo a fare ora, sarà innanzitut-
to permettere a LIRC di decodificare il segnale
ricevuto e successivamente mapperemo i vari
tasti del telecomando. Con il sensore collega-
to, avviamo Raspbmc, e successivamente dal
menù dello spegnimento premiamo Esci per ac-
cedere al terminale e quindi alla linea di coman-
do, la configurazione di LIRC verrà infatti fatta in
modalità testuale.
Il sensore che andremo ad utilizzare, presenta
Entrati in modalità testuale, ci verranno richiesti
tre terminali i quali fanno riferimento a GND, Vs
i dati per l’accesso, i quali come anche in Ra-
ed il segnale in uscita, i quali andranno rispetti-
spbian sono:
vamente collegati pin 6,1 e 12 di Rpi.
User: pi
Password: raspberry
Ora che siamo davanti alla linea di comando,
come prima cosa dobbiamo assicurarci che
LIRC sia presente nel Kernel di Raspbmc, quin-
di utilizzeremo il comando modprobe per cari- venienti dal telecomando, LIRC dovrà innanzi-
carlo: tutto decifrarli, per poi permetterci di mappare il
sudo modprobe lirc_rpi telecomando. Procediamo con i comandi:
successivamente chiuderemo i processi che sudo kill $(pidof lircd)
tengono impegnato LIRC: sudo irrecord -d /dev/lirc0 ~/lircd.conf
sudo kill $(pidof lircd) ed inizierà quindi la fase di apprendimento.
ed ora siamo pronti per verificare che Rpi sia in Come ci viene anche riportato sul terminale,
grado di ricevere i segnali provenienti dal tele- dobbiamo premere uno ad uno i vari tasti del
comando. Dopo aver dato il comando: telecomando, premendo ogni singolo tasto per
mode2 -d /dev/lirc0 circa un secondo. Alla pressione del tasto, ap-
Rpi rimarrà in attesa della pressione di un ta- pariranno uno o più punti sul terminale, verran-
sto sul telecomando. Se il sensore IR è corret- no così composte due linee da 80 punti al ter-
tamente collegato a Rpi, alla pressione di un mine delle quali sarà possibile indicare l’esatto
qualsiasi tasto vedremo apparire una serie di comando da dare ad ogni singolo tasto.
dati simili a:
pulse 576 Mappatura dei tasti
space 548 Terminata la procedura di apprendimento, ci
pulse 602 verrà ora chiesto di mappare i tasti che voglia-
space 1663 mo utilizzare con XBMC. Se vogliamo avere un
pulse 549 interazione base, ci bastano le sole frecette ed
space 549 il tasto OK. Dovremo ora inserire testualmente il
comando da assegnare al tasto premuto, dall’e-
lenco che potete trovare allegato all’articolo tro-
vate una lista di tutti i comandi assegnabili, qui
riporto i soli comandi base:
KEY_UP
KEY_DOWN
KEY_LEFT
KEY_RIGHT
KEY_ENTER
Se non appare nulla, controllate che il sensore L’inserimento è case sensitive, quindi dovrete
IR sia connesso sui giusti pin, ripetete la serie di rispettare il maiuscolo. Può succedere che du-
comandi sopra indicati, o provate ad allontanar- rante la scrittura nel terminale, la tastiera non
vi o avvicinarvi al sensore. Se vi trovate troppo corrisponda per quanto riguarda i segni, per in-
vicini non sarà in grado di ricevere correttamen- serire l’underscore o “trattino basso” quindi, do-
te i comandi, posizionatevi quindi alla distanza vrete premere la combinazione Shift + ?. Per
di circa un metro. comodità, potete anche eseguire tutta la confi-
Decodifica dei segnali gurazione di LIRC via SSH, quindi da un qualsi-
Ora che Rpi è in grado di ricevere i segnali pro- asi PC connesso alla stessa rete di RPi potrete
visualizzarne il terminale ed inserire tutti i co- mente riavviare Raspbmc:

mandi necessari. sudo reboot
Abilitiamo il telecomando
Ci rimane solo da abilitare l’utilizzo
del telecomando in Raspbmc :)
Terminato il riavvio, rechiamoci in
Programmi > Raspbmc Settings e
nel tab IR Remote abilitiamo Ena-
ble GPIO TSOP IR Receiver.
Su GPIO IR Remote Profile sce-
Terminata la mappatura dei tasti, alla pressione gliamo ora il profilo che abbiamo sostituito, in
del tasto Enter la procedura di configurazione alternativa se non abbiamo copiato il file di con-
terminerà, e verrà così creato un file contenente figurazione nella cartella di LIRC e l’abbiamo
tutte le assegnazioni dei tasti con i comandi. lasciato nella home, indicheremo “Custom(lircd.
Può succedere che ci venga chiesto di premere conf on pi’s home folder)”.
un singolo tasto ripetutamente il più veloce pos- Riavviamo, e navighiamo nel menù di Raspbmc
sibile prima di terminare la configurazione, fate con il nuovo telecomando.
attenzione a premere sempre e solo lo stesso
tasto, altrimenti verrà invalidato il processo in
atto.
Non ci rimane altro dire a LIRC di utilizzare il
file di configurazione appena creato. Dovremo
ora andare a copiare il file contenente la nostra
configurazione nella cartella di LIRC, sostituen-
do un file già presente ed integrato in Raspbmc:
sudo cp /home/pi/lircd.conf /etc/lirc/xbox-lircd. Infine, se volete rieseguire la procedura di con-
conf figurazione per via di un evenutale errore nella
Non avendo nessuna XBOX in casa, ho sostitui- mappatura, o per cambiare il telecomando da
to quello relativo al suo telecomando, in alterna- utilizzare, ricordatevi di rimuovere il file presen-
tiva potete sostituire la configurazione appena te nella home, altrimenti LIRC vedendo già un
creata con uno dei seguenti file preesistenti: file di configurazione esistente, non ci permette-
Nulla vieta di non sostituire un file di configura- rà di eseguire una nuova mappatura.
zione preesistente, e di utilizzare il file appena sudo rm /home/pi/lircd.conf
creato che ora si trova in /home/pi, ma copian-
dolo nell’apposita cartella di LIRC rimane tutto Sono a disposizione nei commenti per ogni
più ordinato. eventuale domanda.
Come ultimo passaggio, dobbiamo semplice-
http://it.emcelettronica.com/raspberrypi-controlliamo-media-center-con-comune-telecomando-ir

EOS Book@0 Free - Down PDF

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

EOS Book@0 Free - Down PDF

Caricato da

Copyright:

Formati disponibili

{2

Il primo EOS-Book monotematico!

E’ con viva e vibrante soddisfazione che sono a presentarvi il primo

EOS-Book @0 mettetevelo nello stack!

tuisce un buon esercizio per comprendere più parti distinte:

alcuni aspetti chiave del suo funzionamen- • preparazione del kernel

to interno. • preparazione del root filesystem

GNU/Linux ci permette spesso, specie in ambito

donimanza delle architetture ARM in tale setto-

Fase 1: preparazione del kernel

Il file zImage rappresenta l’immagine della flash

Testare il kernel sulla board virtuale

QEMU emula un ambiente identico ad una bo-

In output possiamo vedere i messaggi di un tipi-

Nella prossima puntata vedremo come creare

2. Preparazione del root filesystem

Il kernel è partito correttamente, ma non è ri- E lo cross-compiliamo con lo stesso cross-com-

Molto bene! Il kernel ha avviato il nostro loop

L’opzione “-redir tcp:8080:10.0.2.15:8080” per-

Perfetto! La nostra applicazione ha risposto alla

Gli sviluppi futuri di questa applicazione sono

$ wget http://it.emcelettronica.com/files/ lrwxrwxrwx 1 righiandr righiandr 7 Dec 14 15:07

drwxrwxr-x 2 righiandr righiandr 4096 Dec 14 lo stesso meccanismo di BusyBox: creiamo un

Adesso possiamo far partire la board virtuale su

neon vfpv3 tls

Nella prossima puntata analizzeremo più in

4. Test sulla Raspberry Pi

Preparare l’ambiente di sviluppo

le” della RPi (github.com/raspberrypi). quest’ultimo. L’uso di altri cross-compilatori é

mensioni e di poter supportare SD card di qual- configurazione con i comandi seguenti:

arm/boot/zImage otfs i file speciali sotto /dev:

$ cd ../busybox $ mkdir -p /tmp/sdcard/boot

bcm2708-linux-gnueabi- \ gine del kernel nella partizione di boot:

nell’altra partizione ext4 Se colleghiamo una tastiera possiamo interagi-

$ sudo umount /tmp/sdcard/boot

Rasp berr yPI

1. Installazione distro, configura-

ma volta è dotato di un uscita HDMI. Ma solo nel 45)

particolare, infatti scaricando la distribuzione

Non verrà segnalato in alcun modo lo stato

messo a disposizione da Raspbian. comandi i quali permettono di realizzare anima-

Come possiamo notare, oltre al terminale, sul

Ora possiamo aggiungere una nuova stampan-

2. Navigazione in internet e con-

tre browser per la navigazione internet DVI o l’uscita S-Video.

alcune differenze riguardanti la compatibilità nazione della pagina di configurazione da parte

con i linguaggi ed i protocolli utilizzati nelle pa- di Midori come segue:

gine web come JavaScript, HTML5, FTP.

Iceweasel, è un browser internet basato sul Sudo apt-get install chromium

Flash Player, video e SWF

mo pronti per navigare. è tuttavia possibile installare Gnash, un player

di riprodurre i contenuti che di solito vengono va di abilitare o disabilitare la possibilità di colle-

In alternativa, possiamo utilizzare un compu- Windows

controllo remoto. Ad installazione terminata, client è TightVnc, molto semplice ed intuitivo,

Ora RasPI è configurato correttamente, non ci

3. Realizziamo il nostro “DropBox”

fase di configurazione per effettuare poi il colle-

Iniziamo con la sicurezza

Se tutto è andato correttamente, possiamo av-

Memorizzato l’indirizzo del modem, apriamo

Creiamo un nuovo file Da utente Android, dato che ho parlato della

4. Controlliamo il Media Center con

Passiamo al lato pratico e iniziamo quindi a pre- re LIRC.