Introduzione

Ho sempre voluto poter comandare le mie apparecchiature elettroniche e multimediali con un sistema semplice e flessibile, che potesse essere facilmente installabile e configurabile.
Dopo aver lavorato tanto con i PIC e aver provato Arduino, ho trovato la soluzione definitiva: il Raspberry Pi.

Ciò che lo accomuna agli altri due è la poca spesa e la possibilità di configurarlo a piacimento, ma è ciò che lo distingue ad affascinare: il Raspberry Pi è un vero e proprio computer, che supporta un vero sistema operativo, con tutte le caratteristiche per rendere estremamente semplice e divertente lavorare con progetti di elettronica complessi.

La vera forza di questa schedina è che possiamo interfacciare facilmente l'elettronica con applicazioni di alto livello, come può essere un web server, ad esempio con un sito web con cui programmiamo l'irrigazione del giardino o gestiamo l'accensione delle luci di casa o leggiamo il carico dell'impianto elettrico. E poi controllare le nostre mail e accendere un LED quando ce n'è una non letta (questo esempio lo vediamo in fondo all'articolo!), o scrivere su display LCD le previsioni del tempo e perchè no, accendere lo stereo e mettere su una playlist di canzoni quando entriamo in casa... Le possibilità sono pressochè infinite!

Obiettivo dell'articolo

In questo articolo seguiremo passo-passo la procedura per installare e configurare correttamente il Raspberry Pi e impareremo a scrivere alcuni semplici programmi per controllare un circuito con LED e pulsante.
Non è richiesta alcuna conoscenza particolare di Linux, python o di elettronica, ma da oggi (settembre 2013) a quando metterete le mani sul vosto primo Raspi possono essere cambiate tante cose, quindi questa guida è solo a scopo introduttivo ed è necessario informarsi sulle nuove feautures aggiunte nel corso del tempo per poter sfruttare al massimo il Raspberry Pi (e semplificarne l'uso).
È fondamentale la conoscenza dell'inglese tecnico: tutti i documenti/datasheet/guide/FAQ più aggiornati che si trovano in rete sono raramente tradotti in italiano.
Per tutte le domande su programmazione e uso del terminale di Linux, Google è il vostro miglior alleato. Su internet si trovano molti forum e chat da cui potete attingere o chiedere informazioni.
Il miglior punto di partenza per tutto è comunque il sito ufficiale del Raspberry Pi, che trovate all'indirizzo:

http://www.raspberrypi.org/

Il Raspberry Pi

Il Raspberry Pi - Raspi per gli amici - è un piccolo computer, ha proprio tutto quello che potremmo volere: un processore ARM da 700MHz, RAM, USB, Ethernet, ma soprattutto sulla scheda elettronica è saldato un pettine collegato direttamente al processore, che ci permette di avere degli ingressi/uscite digitali (configurabili a piacere) controllabili direttamente da sistema operativo.
Esistono due versioni del Raspi, il modello A e il B. La differenza sta tutta nell'hardware, il modello B rispetto al suo fratellino ha in più il connettore Ethernet, due prese USB anzichè una e la memoria RAM più capiente (512MB contro i 256 del modello A). Ovviamente anche il prezzo è diverso: ad oggi il modello B può essere acquistato per 37€, mentre il modello A costa solo 28€.
Il modello A è più leggero ed è quindi ottimo per le applicazioni embedded (dedicate) dove il peso è un problema e dove le caratteristiche in più del modello B risultano superflue.
D'altro canto, il modello B è decisamente più versatile, può essere collegato alla rete informatica e può gestire più applicazioni e processi del modello A.

Il Raspberry Pi è acquistabile da RS oltre che da un'altra marea di distributori che trovate qui.

Hardware

Ma quindi con questi 37€ cosa mi porto a casa?
Una bella schedina, tutto sommato.

"...ero convinto di aver chiesto una pizza."

Le dimensioni sono quelle di una carta di credito (8.6cm x 5.4cm x 1.7cm), con a bordo:

• Processore Broadcom BCM2835 full HD^[+]
• CPU ARM da 700MHz (overcloackabile fino a 800MHz)
• 512MB di SDRAM
• Porta Ethernet 10/100 (RJ45)
• Due connettori USB 2.0
• Uscita video HDMI e composita
• Uscita audio jack 3.5mm e HDMI
• Slot per scheda SD

"Come sarebbe RS non consegna pizze a domicilio?"

L'alimentazione va fornita tramite MicroUSB con un alimentatore adatto. Il modello B richiede da specifiche 5 V di tensione e almeno 700 mA di corrente^[+]. In realtà, per quello che andremo a fare a breve, il carica batterie del cellulare è più che sufficiente, ma ricordate che se avete intenzione di "spremere" il Raspberry Pi con progetti più esosi di risorse (come può essere il mediacenter XBMC, o RaspBMC nella versione compilata apposta per il Pi) vi servirà un alimentatore più potente. Se non volete correre rischi, al momento dell'acquisto vi propineranno tutta una lista di "cose di cui il tuo RaspberryPi ha assolutamente bisogno", tra le varie scatoline di plastica e schede SD troverete anche un alimentatore adatto.
Per verificare che non ci siano problemi di alimentazione, e che quindi il vostro alimentatore non si "sieda" ed eroghi 5V costanti, sul Raspberry Pi sono presenti due piazzole appositamente pensate per inserire i puntali del multimetro e verificare l'alimentazione in ingresso. Sulla scheda hanno il nome TP1 per il positivo e TP2 per il negativo^[+].

GPIO

Ovvero quella trentina di piazzole che ci interessano davvero.
I General Purpose Input/Output pin (chiamati più semplicemente GPIO) sono quei contatti del BCM2835 che possiamo programmare come più ci piace. Possono essere ingressi o uscite, possono essere configurati per dialogare con altri apparecchi con protocolli come UART, I²C, SPI eccetera, o possono essere configurati come uscite PWM.
Nel Raspberry Pi, questi pin sono collegati al pettine più grosso presente sulla scheda, il pettine P1.

Pinout del pettine P1 - elinux.org

AVVERTENZE:

• Il microprocessore è DIRETTAMENTE COLLEGATO al pettine e non ci sono protezioni di nessun tipo tra i due
  
• Ogni singolo pin può assorbire o fornire fino a 16 mA di corrente^[+]
• La corrente massima fornibile dai pin 3,3 V è di 50 mA complessivamente^[+] (3 mA per ogni GPIO)
• MAI collegare un cavo con una tensione superiore ai 3,3 V ad un pin GPIO: il BCM non è costruito per lavorare con tensioni più grandi e rischiate di danneggiare irreparabilmente il vostro Raspi
• Ricontrollate sempre il vostro circuito prima di dare tensione
• Calcolate sempre le correnti in gioco e non superate le soglie indicate o brucerete irrimediabilmente il processore o il regolatore di tensione.

Altri contatti

Tra le altre cose che possono tornare utili sulla scheda del Raspi:

• Jumper P6: composto da due piazzole, una per il segnale di reset e l'altra per lo 0V. Ponticellando questi due contatti si riavvia il processore del Raspi. Da fabbrica il jumper non è saldato.
• Connettore P5: utile se si vuole aggiungere una seconda linea I²C o una linea di handshake per l'UART. Anche questo connettore non è saldato.

Altri connettori che possono tornare utili per progetti più complessi sono S2, usato come DSI (Display Serial Interface)^[+] per collegare alcuni schermi LCD o OLED compatibili per applicazioni embedded^[+], e il connettore S5 che fornisce un attacco MIPI/CIS^[+] per videocamere compatibili^[+].
Per l'elenco completo dell'hardware del Raspberry Pi e tutte le sue specifiche, fate riferimento a questi link:

• http://elinux.org/RPi_Hardware
• http://elinux.org/RPi_Low-level_peripherals

Sotto la lente

Vediamo ora velocemente alcune caratteristiche elettroniche della scheda.

ALIMENTAZIONE

Stadio di alimentazione, davvero niente di eccezionale

La prima cosa che si nota di questo angolo di scheda è che lo stadio di alimentazione 3,3V è banalmente composto da qualche condensatore e un regolatore lineare^[+].
Molti elettronici modellisti si sono lamentati di questa soluzione, principalmente perchè i regolatori lineari sono meno efficienti dei regolatori switching e le batterie ne risentono. Ovviamente la ragione per cui è stato adottato il regolatore lineare è il costo inferiore.
Per questo motivo su internet si trovano diverse guide fai-da-te per utilizzare un regolatore switching al posto di quello originale^[+].
Sulla scheda sono poi presenti altri due regolatori, RG1 e RG3, che forniscono rispettivamente 1,8V e 2,5V.

PROCESSORE

H9TKNNN4GDMP?

Queste due righe sono solo per ricordare che il processore è montato sotto al componente di cui si legge la sigla. Molte volte si sente di qualcuno che chiede come mai non c'è il marchio Broadcom e la sigla BCM2835 stampati. La risposta è semplicemente che per risparmiare spazio il chip di SDRAM è montato direttamente sopra al microprocessore e che quindi la sigla che si legge non è altro che il modello di memoria installato.

LAN E USB

Questo pezzo sembra importante.

L'altro integrato presente sulla scheda è un LAN9512 di SMSC.
Siccome il BCM2835 non gestisce nativamente la connessione Ethernet^[+], l'integrato si occupa di passare i dati da Ethernet al bus USB del microprocessore. In questo modo il LAN9512 viene riconosciuto dal sistema operativo come un adattatore Ethernet e come HUB USB, infatti è anche collegato alle due porte USB presenti sulla scheda.

"Upstream USB PHY" è dove il BUS USB del BCM2835 è collegato.

Il BCM2835 ha un solo bus USB e dunque il LAN9512 è il principale collo di bottiglia nella gestione del flusso dati del nostro Raspi.

DALL'ALTRA PARTE
Girando la scheda del Raspi, le uniche cose interessanti che si possono trovare, tra resistenze e condensatori, sono i due oscillatori al quarzo X1 (25MHz) e X2 (19,2MHz), che si occupano rispettivamente del clock del LAN9512 e del BCM2835^[+].

DATASHEET E SCHEMI
Fortunatamente i ragazzi della Raspberry Pi Foundation hanno deciso di creare un sistema open-source che quindi ci permette di avere accesso a tutta la documentazione di cui potremmo aver bisogno:

• Schema elettrico del Raspberry Pi
• Datasheet Broadcom BCM2835
• Datasheet SMSC LAN9512
  

Software

Il Raspberry Pi è diventato in breve tempo molto popolare tra gli hobbisti di informatica ed elettronica, sia per il prezzo contenuto sia per la sua grande versatilità, tant'è vero che dopo l'annuncio dell'inizio produzione per averne uno ci si doveva mettere in lista d'attesa e si aspettava anche sei mesi prima di poter metterci le mani sopra.
Il processore ARM supporta molti sistemi operativi (la maggior parte basati su Linux) e questo permette ad ognuno di lavorare nel suo ambiente preferito. No, Windows non è compatibile con gli ARM e anche se lo fosse, davvero lo usereste su una cosa così? Immaginate quante schermate blu... sarebbe sempre piantato. E no, nemmeno OSX ha intenzione di girare su ARM!

Dopo che i primi Raspi vennero consegnati in giro per il mondo, molti sviluppatori fecero a gara per ricompilare i kernel delle distribuzioni Linux più famose appositamente per l'hardware di questa scheda e infatti oggi abbiamo una notevole quantità di sistemi operativi ripensati e adattati proprio per dare il massimo delle prestazioni del Raspberry Pi.
Tra questi i più famosi sono Raspbian (una versione più leggera di Debian), Pidora (figlia della più famosa Fedora), Arch Linux ARM (rivisitazione di Arch Linux). Poi ci sono anche sistemi operativi che girano nativamente, come Android 4.0, Google Chromium OS, alcune distribuzioni di UNIX come Free BSD e tante altre (per l'elenco completo vedi qui).
Il sito RaspberryPi.org ha una sua lista ufficiale di sistemi operativi supportati che potete trovare qui.

In questo articolo vedremo come installare e configurare Raspbian.
La scelta è ricaduta su questa distro perchè Debian (la mamma di Raspbian) è molto famosa ed è ben documentata, dunque è più semplice trovare soluzioni e supporto in caso di problemi durante l'utilizzo.
Con un sistema operativo di questo genere possiamo facilmente realizzare applicazioni interessanti come un mediacenter, un webserver, un server per le nostre email, torrent, database, ftp... tutto questo condibile con tutta l'elettronica che vogliamo.
Oggi però faremo solo il primo passo, impareremo a comandare le uscite e a leggere gli ingressi dei GPIO utilizzando il linguaggio python e poche righe di codice.

Let's get to business

Cosa ci serve

Prima di iniziare bisogna recuperare tutto il materiale che ci servirà:

• Il Raspberry Pi (e fin qua...)
• Alimentatore MicroUSB (vale quanto detto nella sezione Hardware)
• Una scheda SD da almeno 2GB
• Un computer con lettore di schede SD
• Un cavo HDMI o composito
• Un monitor/TV con ingresso HDMI o composito
• Una tastiera USB
• Un cavo Ethernet
• Un pettine femmina da almeno 13 contatti
• Una breadboard o millefori
• Un LED qualsiasi
• Una resistenza (il cui valore calcoleremo più avanti)
• Un pulsante da scheda
• Un buon album di musica a tenervi compagnia (essenziale)

Lo schermo non ci stava nella foto

Installiamo il sistema operativo

Come detto in precedenza, il SO che utilizzeremo sarà Raspbian, una distribuzione Linux ricompilata da Debian.
Al momento in cui stendo questo articolo ho notato che il sito ufficiale del Raspberry Pi suggerisce l'installer NOOBS per i nuovi utenti. In questa guida salteremo questa procedura (che in sostanza vi permette di scegliere quale SO caricare sul Raspi) e andremo direttamente ad installare l'immagine RAW di Raspbian.

Iniziamo con lo scaricare l'immagine di Raspbian che metteremo sulla scheda SD. L'elenco di tutti i SO e i link si trovano a questo link: http://www.raspberrypi.org/downloads

Tutte le versioni di Debian portano il nome di un personaggio di Toy Story

Il primo link è il link diretto al file zip dell'immagine, ossia scarica il file direttamente dal server di raspberrypi.org, mentre il secondo link è di tipo torrent, utilizzabile con torrent client come BitTorrent, Vuze e utorrent. Il download con i torrent è solitamente più veloce di quello diretto.
Una volta scaricato lo zip, estraiamone il contenuto. Avremo un file delle dimensioni di circa 1,8GB con estensione .img.
Questo file dovrà essere caricato sulla scheda SD. Ovviamente non basta copiarlo e incollarcelo sopra, sarebbe troppo facile, bisogna utilizzare un tool apposta.

Windows
Per preparare la scheda SD da windows la procedura è la seguente:

1. Scaricate il tool Win32Diskimager
2. Estraetelo in una cartella e avviate l'eseguibile
3. In Image File selezionate l'immagine di Raspbian scaricata ed estratta precedentemente
4. In Device selezionate la vostra scheda SD; attenzione a non selezionare uno dei dischi rigidi altrimenti il tool ci scriverà sopra rischiando di cancellare i dati presenti
5. Cliccate su Write

Win32 Disk Imager

Linux
Per gli appassionati del pinguino basta eseguire il comando

sudo dd bs=4M if=~/raspbian.img of=/dev/schedaSD

if rappresenta il percorso del file sorgente (l'immagine di raspbian), mentre of è la destinazione (la scheda SD). Se non siete sicuri del percorso della vostra scheda potete trovarlo eseguendo il comando

sudo lshw -class disk

Sotto la voce "logical name" troverete il percorso giusto.
Anche in questo caso attenzione a non sbagliare percorso o finirete per sovrascrivere un hard disk.


La procedura di scrittura dell'immagine su scheda SD richiede circa 5/6 minuti, durante i quali vi consiglio la lettura di uno di questi fantastici articoli.

Preparata la scheda SD, è ora di dedicarci al Pi.
Colleghiamo tastiera e monitor, inseriamo la scheda SD e alimentiamo. Se siamo nei pressi del router di casa possiamo anche già collegare il cavo Ethernet, ma non è essenziale.

Dalla Quickstart Guide - raspberrypi.org/quick-start-guide

Se la scheda SD è stata preparata bene, all'avvio si accenderanno sul Raspi la spia rossa PWR (alimentazione collegata) e la spia verde ACT (accesso alla scheda SD). Dopo pochi secondi vedremo apparire sullo schermo il logo di Raspberry Pi (il lampone) e una serie di scritte che ci informano sullo stato dell'avvio del sistema operativo.

Al primo avvio ci viene proposta una schermata con le opzioni di configurazione del Raspberry Pi.

Non sono in grado di fare foto dritte

Inizialmente il sistema operativo ha solo 1,8GB di memoria disponibile (le dimensioni dell'immagine che abbiamo copiato sulla scheda), selezionando la prima opzione del menu espanderemo la memoria a tutta la capacità della scheda SD, quindi premiamo INVIO e lasciamo che la procedura termini.
Alla fine ci verrà ripresentata la stessa schermata d'avvio.
Con Change User Password andiamo a modificare la password d'accesso del Raspberry Pi. La password di default (raspberry) può anche essere cambiata successivamente.
Con Enable Boot to Desktop impostiamo l'avvio dell'interfaccia grafica all'avvio del Raspi. Questa opzione è utile se si vuole utilizzare il Raspi come PC, quindi con mouse e tastiera e un ambiente più simile a quello a cui siamo abituati quando lavoriamo su un desktop.

L'ambiente grafico è LXDE

In questo articolo non tratterò l'utilizzo dell'ambiente grafico, in quanto intendo comandare il Raspi dal mio computer personale. L'interfaccia grafica diventerebbe inutile e sprecherebbe solo delle risorse.
L'interfaccia grafica è studiata per creare un ambiente di lavoro più user friendly (ricordo che il Raspberry Pi è stato pensato per insegnare ai bambini a programmare senza dover comprare un costoso portatile) ed è piena di tool per scrivere i programmi in poche e semplici mosse.

Scratch è il tool più famoso per imparare a programmare in python

La quarta opzione, Internationalisation Options, ci consente di cambiare lingua e layout della tastiera.
Se non vi piace l'inglese e/o se avete intenzione di usare il Raspi con ambiente grafico, selezionate questa voce e seguite la procedura guidata per configurare i parametri.
Enable Camera è l'opzione per attivare e configurare la videocamera opzionale (se l'avete acquistata), Add to Restrack è una piccola procedura che vi permette di registrare il vostro Pi su Rastrack, che altro non è che un sito su cui viene visualizzato graficamente la posizione dei Raspberry Pi venduti nel mondo. Questa procedura è opzionale e non comporta nessun vantaggio o svantaggio, generalmente ci si registra solo per contribuire all'espansione della mappa. Notare che per concludere la procedura il Raspi deve essere già collegato ad internet. In alternativa ci si può registrare in un secondo momento direttamente al sito.
Proseguendo con le opzioni troviamo Overclock. Come detto in precedenza il Raspberry Pi può essere overclockato fino a 800MHz. Spingere il processore a questa frequenza lo consumerà più in fretta e nessuna garanzia vi salverà. Questa opzione è da usare solo se strettamente necessario e può comunque essere modificata in un secondo momento.
Infine, troviamo Advanced Options. Premiamo INVIO ed entriamo nel sottomenu.

L'opzione caffè non c'è nemmeno qui?

A questo punto abbiamo qualche altra opzione:

• Overscan per sistemare eventuali problemi di compatibilità HDMI
• Hostname per cambiare il nome del Raspberry Pi nella rete locale e nel terminale dei comandi
• Memory Split per decidere quanta memoria RAM assegnare al processore grafico
• SSH per attivare il server SSH
• Update per aggiornare il tool di installazione (utile se avete una distribuzione vecchia scaricata tempo fa)

Selezioniamo SSH e attiviamo il server.
SSH è quel protocollo che ci permette di inviare comandi al Raspi (o qualunque macchina con un server SSH attivo) direttamente dalla tastiera del nostro PC. SSH è l'acronimo di Secure SHell ed è l'evoluzione di telnet.
Rispetto a telnet, SSH offre una connessione crittografata (telnet comunica in chiaro, password incluse!) e utilizza un processo di autenticazione a chiave pubblica^[+].

Una volta che abbiamo finito di sistemare tutte le opzioni che ci interessano, selezioniamo Back (con il tasto TAB) e poi Finish.
Quando ci viene chiesto, riavviamo il Raspberry Pi.

Se intendete usare il Raspi da locale, lasciate collegati tastiera e monitor e, se non l'avete ancora fatto, collegate il cavo Ethernet tra il Pi e il router di casa.
Se invece pensate di usare i comandi da remoto, potete scollegare tutto tranne alimentazione e cavo Ethernet.
La connessione ad internet serve solo per fare le prime installazioni ed aggiornamenti, quindi se lavorate in locale potrete lasciare il Pi scollegato dalla rete una volta terminata la procedura di aggiornamento, mentre se lavorate in remoto, ovviamente, il cavo di rete deve essere sempre collegato.

Accesso al Pi

Da Locale

Dopo che il Raspberry Pi si è avviato, vi verranno chiesti i dati di login.
Se non avete modificato la password durante la configurazione iniziale, il login di default è:
User: pi
Password: raspberry
E siete già pronti per lavorare.

Da Remoto

Per accedere al Raspi da remoto, dobbiamo procurarci il tool per stabilire la connessione SSH.
Per Windows esistono diverse soluzioni, il mio tool preferito è PuTTY perchè è piccolo e funziona bene, ma ne esistono per tutti i gusti, basta dare un'occhiata qui.

Se invece lavorate con Linux, SSH è solitamente installato di default (se così non fosse, sudo aptitude install openssh-client e avete risolto), e si lancia da terminale con il comando

ssh user@serverip

Pi, dove sei?

Adesso per poterci connettere abbiamo bisogno di sapere l'indirizzo IP del Raspberry Pi.
Sfortunatamente la maggior parte dei router assegna gli indirizzi abbastanza casualmente, quindi non è semplice stabilire l'indirizzo esatto al primo colpo.
Per trovare il Raspi abbiamo due strade: la prima è andare tra le impostazioni del proprio router (generalmente basta digitare nella barra degli indirizzi del browser l'indirizzo del router - spesso è 192.168.1.1 - per arrivare alla pagina di setup).
Una volta dentro alla configurazione del router dobbiamo spulciare le varie schede finchè non troviamo Tabella di assegnazione indirizzi DHCP o simile.

Busted!

Se non avete modificato l'hostname durante la configurazione (come invece io ho fatto) troverete in tabella raspberrypi.
Annotiamoci l'indirizzo corrispondente, ci servirà per aprire la connessione SSH.

La seconda strada per trovare l'indirizzo IP del nostro Raspi è usare nmap.
Nmap è un tool pensato per scansionare una rete o una macchina in particolare, per determinare quali porte e quali servizi sono attivi.
Questa procedura la raccomando agli smanettoni e a chi ha voglia di provare qualcosa di nuovo. Nmap è un programma molto potente che però non vedremo in dettaglio, raccomando quindi la lettura della reference guide.
Per gli utenti Windows, scaricate l'eseguibile da qui (Latest release self-installer), installate il programma seguendo la procedura guidata e avviatelo.

nmap può anche essere avviato dal prompt dei comandi

Nella casella obbiettivo (ce le hanno messe loro le due b) inseriamo l'indirizzo di tutta la nostra rete: faremo una scansione di tutti gli apparecchi collegati al router. La rete interna di casa è solitamente identificata con 192.168.1.0/24 (dove /24 è la maschera di sottorete 255.255.255.0), ma in alcuni casi può essere anche 192.168.0.0/24. Per averne certezza controllate l'indirizzo IP del vostro computer e rimpiazzate l'ultimo numero con uno 0.
Selezioniamo come metodo di scansione quella veloce e avviamo la scansione.

Ci hanno messo due b per davvero

Dopo pochi istanti il programma ci sputerà fuori la lista delle macchine collegate tra cui comparirà anche il nostro Raspi.
Lo distinguete subito dagli altri perchè è l'unico host con solo la porta 22 (SSH) aperta e perchè il MAC address identifica come costruttore "Raspberry Pi Foundation".

Busted!

Per gli utenti di Linux basta installare nmap con il solito

sudo aptitude install nmap

e lanciare la scansione con

sudo nmap 192.168.1.0/24

Il comando sudo non è essenziale, ma se non lo usate nmap non visualizzerà i MAC address degli host.

nmap lanciato da bash

Per una lista completa delle opzioni di comando:

nmap --help

oppure (meglio)

man nmap

Primo accesso

Da Windows lanciamo PuTTY e accediamo finalmente al Raspberry Pi.
Inseriamo l'indirizzo IP che abbiamo trovato prima e clicchiamo su Open

Ci sono millemila opzioni

Alla prima connessione comparirà un avviso che ci avverte che il computer non conosce l'host al quale si sta collegando, e vi chiede se può fidarsi o meno. Clicchiamo su Sì e proseguiamo.

E siamo dentro!

Inseriamo il nome utente di default pi, premiamo [INVIO] e inseriamo la password di default raspberry (se non l'avete cambiata durante la configurazione iniziale).
Premiamo [INVIO] ancora una volta e il Raspberry Pi ci accoglierà con un po' di informazioni relative al sistema operativo.

Da Linux il procedimento è simile a quanto già descritto; apriamo il terminale e digitiamo

ssh pi@indirizzoip

dove ovviamente indirizzo ip va sostituito con l'indirizzo del Raspi.
SSH ci avviserà che il computer non conosce l'host a cui si sta collegando e ci chiede conferma per continuare. Digitiamo yes e premiamo [INVIO], inseriamo la password quando richiesto, premiamo [INVIO] e il gioco è fatto.

La bestia sullo sfondo è un gatto

Tips 'n' Tricks - parte 1

Alcuni suggerimenti per rendere il Pi più comodo da usare.

INDIRIZZI STATICI
Siccome ogni volta che accendiamo il Raspi il router potrebbe cambiargli indirizzo IP, è buona norma impostare un indirizzo statico (riferitevi al manuale del vostro router per i dettagli sulla procedura) in modo che il Raspberry Pi si trovi sempre allo stesso indirizzo.

Il Raspberry Pi con indirizzo locale statico

BRIDGING
Non sempre si ha il router nei pressi del proprio banco di lavoro o il posto dove generalmente conduciamo le nostre prove. Quindi ci sarebbe da tirare un cavo ethernet per tutta la casa... non proprio il massimo della comodità.
Ad esempio, nel mio caso, il mio PC è collegato in wifi e ho necessità di lavorare sulla stessa scrivania, lontana dal router.
La soluzione al problema è semplice: basta collegare la porta Ethernet del PC con quella del Raspberry Pi, e creare un bridge tra l'interfaccia wifi del PC e l'interfaccia Ethernet dello stesso. In questo modo, tutto il traffico proveniente dal router viene girato sulla porta Ethernet e viceversa.
In internet si trovano molte guide^[+] per fare il bridging di due interfacce, e con Windows è una procedura decisamente semplice e indolore.

Tutto qua

WI-FI
In alternativa all'opzione bridging, si possono comprare dei piccoli adattatori wifi (wifi dongle) per collegarci al Raspi senza fili.
Questa procedura può sembrare difficile se non siete pratici di Linux, ma in realtà non è niente di complesso. Ancora, di guide se ne trovano moltissime, basta una veloce ricerca con Google^[+].

Aggiornare il Raspi

Prima di metterci all'opera, è buona norma aggiornare (e tenere aggiornato) il software del Raspberry Pi.
L'operazione è automatica e ci consente di avere sempre le ultime versioni di tutti i programmi che usiamo, primo tra tutti Python e le sue librerie.
Da terminale digitiamo

sudo aptitude update

Aptitude è il programma che gestisce gli aggiornamenti e la modifica dei pacchetti (parti di software). Con l'istruzione update, diciamo ad aptitude di aggiornare il proprio database di pacchetti disponibili. Una volta terminato il processo rilanciamo il comando con l'opzione upgrade, che aggiornerà il software vecchio all'ultima versione disponibile. Le versioni dei programmi installati vengono comparate con quelle presenti nel database di aptitude, ecco perchè bisogna fare update prima di upgrade.

sudo aptitude upgrade

Aptitude ci mostrerà una lista dei programmi che verranno aggiornati e ci chiederà conferma prima di proseguire. Digitiamo Y (che sta ovviamente per yes) e lasciamo che aptitude faccia il suo mestiere.

"Ma sei un acher??" [cit. chiunque vi veda lavorare da terminale]

Siamo quasi pronti per iniziare con l'elettronica, ma prima...

I comandi di base

La prima volta che si devono eseguire delle operazioni da terminale ci si sente sempre un po' scombussolati. Copiare file, creare cartelle, scrivere un programma... Come si fa senza mouse?
In questo elenco vediamo molto molto velocemente i comandi che utilizzeremo (che sono anche i più comuni).
Ricordate sempre che tutti i programmi sono provvisti di manuale, che potete visualizzare lanciando il comando

man comando

La maggior parte dei comandi può anche fornire un elenco veloce di opzioni utili con cui possono essere lanciati. Per leggere questo elenco usate l'opzione --help. Ad esempio lanciate il comando

ls --help

e rimarrete impressionati dalla quantità di cose che ls può fare.
Inoltre, non mi stanco mai di ricordarlo, Google è il vostro miglior amico.
Per un utilizzo più comodo del terminale, ricordate che i comandi che avete lanciato sono tenuti in memoria (fino a 1000 se non cambiate la configurazione di bash) e si possono scorrere in ordine cronologico premendo i tasti freccia su e giù. Inoltre se volete cercare un comando che avete eseguito un po' di tempo fa, potete cercarlo digitando Ctrl+R e scrivendo una parte del comando. Per scorrere i risultati premete Ctrl+R fino a quando non avrete trovato quello che vi interessa.
Come ultimo suggerimento, la combinazione Ctrl+U cancella tutto quello che è stato scritto prima del cursore del terminale. Questa scorciatoia è utile quando dovete cancellare dei comandi lunghi senza tenere premuto Backspace per dieci minuti e per quando avete sbagliato a digitare la password e volete cancellarla interamente.

Interrompere un programma in esecuzione: CTRL+C
Se lanciate un programma per errore o volete terminarlo senza aspettare che esca normalmente usate la combinazione Ctrl+C per cancellare il processo. Questa shortcut è utile per fermare i nostri script in python se abbiamo previsto dei cicli senza fine o se ci siamo dimenticati del comando exit() in fondo al programma.

Spegnere il Raspberry Pi: poweroff
Quando abbiamo finito di lavorare è bene spegnere il Raspi tramite il comando poweroff e non tagliare di netto l'alimentazione. Il comando poweroff necessita dei privilegi di amministrazione per poter essere lanciato.

sudo poweroff

L'alimentazione potrà essere tolta quando tutte le spie salvo quella rossa (PWR) saranno spente.

Chiudere la connessione SSH: logout
Per disconnettersi dal terminale del Raspberry Pi senza spegnerlo, basta digitare:

logout

Ottenere i privilegi amministrativi: sudo
Questo comando l'abbiamo già usato diverse volte in testa ad altri comandi. Il suo scopo è di lanciare un programma con i diritti amministrativi (Super User DO). In sostanza, certe modifiche - installazione, disinstallazione pacchetti, rimozione file di sistema, cambio dei permessi degli utenti, ... - possono essere fatte solo da chi dispone dell'autorizzazione.
Il comando sudo chiede sempre la password per autorizzare un programma a girare con i diritti di root (il Super User), tranne nel caso del Raspberry Pi in cui è stato modificato un parametro per lanciare sudo senza chiedere nulla.

http://xkcd.com/149/

Quando un programma si rifiuta di funzionare per problemi di privilegi va preceduto da sudo.
Provate a fare un aggiornamento con aptitude senza usare sudo in testa; dopo l'elenco degli errori vi verrà chiesto: are you root?

Leggere il contenuto di una cartella: ls
ls (che sta per List) è un semplice comando che elenca il contenuto di una cartella. ls può essere lanciato con o senza opzioni. Le opzioni più comuni sono:

• -l elenca i file dettagliatamente
• -a mostra anche i file nascosti (all)
• -h scrive le dimensioni dei file in formato human-readable

Tutte le opzioni si possono trovare digitando ls --help.

ls -lah è l'equivalente di ls -l -a -h

Le colonne visualizzano (da sinistra verso destra):

1. permessi del file/cartella (drwx e tutta la sfilza di trattini); i permessi li vedremo più avanti
2. numero di hard link esistenti per ogni elemento, questo dato non ci interessa
3. utente con i permessi di owner (di solito è il creatore del file)
4. nome del gruppo che ha i permessi sul file (se non pocciate con la gestione utenti corrisponde all'utente owner)
5. dimensioni (per le cartelle è sempre 4K essendo solo un link e non un file vero e proprio)
6. mese, giorno, anno (o orario se l'anno è quello corrente) di creazione del file
7. nome del file

Da ricordare che i file che iniziano con un punto sono file nascosti e senza l'opzione -a non vengono visualizzati.

Cambiare cartella: cd
Il comando cd si usa per spostarsi tra le cartelle (Change Directory). Se nessuna cartella è specificata dopo il comando, si ritorna nella cartella home. La cartella home è quella in cui ci troviamo non appena effettuiamo il login, ed è indicata con il simbolo tilde ~ (posto dopo la scritta utente@hostname: e prima del dollaro $) che significa che ci troviamo in /home/pi o più in generale in /home/utente.
Se ad esempio vogliamo accedere alla cartella "documenti", supponendo sia nella nostra cartella home, digitiamo

cd documenti/

Attenzione a non mettere lo slash / prima del nome della cartella, altrimenti "documenti" verrà cercato nella cartella di base di tutto il sistema che è appunto / (noi stiamo cercando /home/pi/documenti, non /documenti). Per fare un confronto con Windows, possiamo immaginare la cartella / di Linux come il C:\ di Win e il /home/pi come C:\Users\pi (o C:\Documents & Settings\pi per i nostalgici).
Attenzione anche alle maiuscole e minuscole, cd è case sensitive e non troverà "Documenti" se la cartella inizia con una d minuscola.
Un'altra cosa utile è il percorso .. che ci permette di salire di un livello. Ad esempio se siamo in ~/documenti/programmi e vogliamo tornare in ~/documenti, ci basterà digitare cd ..

Cambiare cartella SENZA MOUSE? ERESIA!

La cartella sulla quale state lavorando è sempre scritta prima del dollaro $

Cambio di cartella con un percorso relativo: sale di un livello e cerca la cartella Videos

Protip:
Bash ha la magnifica funzione autocomplete che completa i nomi dei percorsi e dei file senza che l'utente stia a scrivere tutto. Digitate cd, scrivete l'iniziale della cartella che vi interessa e premete due volte TAB.

Creare e rimuovere una cartella: mkdir e rmdir
Per creare una cartella

mkdir documenti

Per eliminarla

rmdir documenti

Notare che rmdir cancella solo cartelle vuote, se dentro rimane un file (anche nascosto) si rifiuterà di procedere. Usate ls -a per visualizzare tutti i file all'interno.

Creazione di un file: touch
Anche questo è un comando semplice, non fa altro che creare un file vuoto. Per usarlo basta invocare il comando con il nome del file che si vuole creare, ad esempio:

touch script.py

Se provate a fare ls -l troverete un file dalle entusiasmanti dimensioni di 0 Byte.

Spostare/rinominare un file: mv
Se vogliamo spostare (o rinominare) un file ci basterà invocare mv specificando il file attuale e la nuova destinazione

mv script.py vecchioscript.backup (rinomina script.py in vecchioscript.backup)

mv script.py documenti/script.py (sposta script.py nella cartella documenti)

Si possono anche spostare più file contemporaneamente a patto che la destinazione sia la stessa. Se ad esempio volessimo spostare due script nella cartella python:

mv script1.py script2.py python/

Oppure se vogliamo spostare tutti gli script presenti nella cartella python:

mv *.py python/

In questo modo tutti i file che finiscono con ".py" vengono spostati.

Protip:
Possiamo selezionare tutti i file che iniziano con le stesse parole, che terminano con le stesse parole o che contengono delle parole uguali usando delle combinazioni diverse del testo con il carattere speciale asterisco *. Vediamo alcuni esempi comuni:

mv script.* archivio/ - sposta tutti i file che iniziano con script, ad esempio script.py e script.backup

mv *script* archivio/ - sposta tutti i file che contengono la parola script, ad esempio primo_script.py, primo_script.backup, secondo_script.py

mv * archivio/ - sposta tutti i file nella cartella archivio

Copiare un file: cp
Questo comando si usa nello stesso modo di mv.
Da ricordare l'opzione -r che permette di copiare anche i file presenti nelle sottocartelle. Se abbiamo due file nella cartella documenti e un altro nella cartella documenti/archivio, il comando:

cp -r documenti/* backup/

copierà tutto ciò che è presente in documenti nella cartella backup. Quindi alla fine avremo anche la cartella backup/archivio con il suo file all'interno.

Eliminare un file: rm
Banalmente:

rm script.py

Per una lista di opzioni invocate rm con l'opzione --help.

Cambiare i permessi: chmod
Il comando chmod permette di cambiare le modalità di accesso ad un file. Quando invochiamo il comando ls -l i file ci vengono elencati assieme alle loro caratteristiche. La prima colonna specifica i permessi.

-rwxrw-r--

I permessi si leggono in questo modo: il primo carattere è una d se l'elemento è una cartella, mentre è un trattino - se si tratta di un file.
Gli altri nove caratteri sono divisibili in tre terne. La prima rappresenta i permessi che ha l'utente creatore (owner) del file, la seconda rappresenta i permessi del gruppo di cui l'owner fa parte e la terza rappresenta i permessi di tutti gli altri utenti del sistema.
I permessi sono così descritti:

• r - permesso di lettura (include la sua visibilità in elenco quando si invoca ls)
• w - permesso di scrittura (modifica/eliminazione del file)
• x - permesso di esecuzione (il file può essere invocato come comando ed eseguito a terminale)

Essendo un argomento complesso, vediamo solamente il comando che ci interessa durante l'uso del Pi. Per approfondimenti leggete qui e qui.
La cosa importante per gli script che andremo a scrivere sarà renderli eseguibili. Di default, quando un utente crea un file, gli vengono assegnati d'ufficio i permessi di lettura e scrittura. Per rendere un file eseguibile, ci basta digitare:

chmod u+x script.py

In questo modo abbiamo stabilito che l'owner (u) ha anche i permessi di esecuzione x. Per rimuovere uno dei permessi, ad esempio per rendere un file non modificabile e non eseguibile, useremo lo stesso comando utilizzando il - al posto del +:

chmod u-wx script.py

Cambiare la password: passwd
Per cambiare la password ci basta invocare passwd. Ci verrà chiesro di introdurre la password attuale, quella nuova e di ridigitare la nuova password.
Se tutto è andato bene, la procedura guidata uscirà senza errori, altrimenti visualizzerà il messaggio Password unchanged!

Il circuito

Il circuito che useremo per la prima prova sarà composto semplicemente da un LED di bassa potenza e la sua resistenza. Utilizzeremo il pin di 3,3V del pettine per l'alimentazione e un GPIO del Raspberry Pi per chiudere il circuito a massa.
Niente vieta di fare l'opposto, cioè di usare il GPIO per fornire l'alimentazione e il pin 0V del pettine per la massa. Nel mio caso ho scelto la prima opzione perchè uso un LED RGB ad anodo (positivo) comune.

Sorgente FidoCadJ | Ingrandisci | Cos'è Fidocad

La resistenza R1 si calcola con la formula:



Questa formula non è altro che la Legge di Ohm^[+] con la tensione ai capi della resistenza calcolata come la tensione d'alimentazione (3,3 V) a cui viene sottratta la caduta di tensione del LED.
Se ad esempio abbiamo un LED la cui c.d.t. è 1,6V e vogliamo che la sua corrente sia di 8mA, calcoleremo la resistenza in questo modo:



Che diventa 220Ω se consideriamo i valori commerciali ^[+].
Se non avete a disposizione il valore della tensione di caduta del led, potete facilmente trovarlo con un multimetro (tester).

Sorgente FidoCadJ | Ingrandisci | Cos'è Fidocad

Se usate tensioni più grandi per il test (ad esempio 12V) la resistenza deve anch'essa essere più grande (almeno 2kΩ).

Se non conoscete la corrente con cui deve essere alimentato il LED, generalmente 4-8mA vanno bene. Se non volete correre rischi, usate una resistenza da 1kΩ e se il LED non si accende, provate a scendere a 470Ω. Ovviamente prima verificate che il LED sia collegato nel verso giusto (il piedino più corto verso massa e quello più lungo verso il positivo).

Il secondo circuito che realizziamo serve per testare gli ingressi del Raspi ed è composto solo da un pulsante. Questo circuito lo useremo anche insieme al primo per vedere come usare input e output del Raspi contemporaneamente.

Sorgente FidoCadJ | Ingrandisci | Cos'è Fidocad

Rpd è la resistenza di pull-down, che serve a dare un segnale logico di riferimento al GPIO. Se questa fosse assente quando SW1 è aperto, il GPIO sarebbe a tutti gli effetti scollegato dal circuito, cioè non avrebbe nè un riferimento positivo nè uno negativo e quindi potrebbe arrivare a "inventarsi" lo stato dell'ingresso dandoci delle false letture. La resistenza Rpd fa in modo che quando il pulsante è aperto il GPIO sia collegato verso massa, lasciandogli quindi sempre un segnale logico ben preciso.
Nello schema il ramo di Rpd è tratteggiato perchè useremo le resistenze interne al BCM2835. Comunque le resistenze di pull-down e pull-up si incontrano in molti circuiti elettronici digitali ed è importante capire il loro funzionamento. Un esperimento interessante è provare la lettura degli ingressi senza resistenze di pull-up/pull-down e vedere come in effetti il minimo disturbo elettrico causa delle false letture nel programma.

Python

Eccoci arrivati al punto in cui impariamo a comandare le uscite. Python integra già una libreria chiamata RPi.GPIO che permette di comandare le uscite e leggere gli ingressi.

L'interpreter

Vediamo subito come accendere il LED del primo circuito. Lanciamo python con il comando

sudo python

sudo è necessario per permettere all'interpreter di accedere al controllo dei GPIO.
A questo punto possiamo dare i comandi direttamente all'interpreter python.

L'interpreter di python

I comandi che eseguiamo sono:

import RPi.GPIO as gpio

gpio.setmode(gpio.BCM)

gpio.setup(3, gpio.OUT, initial=1)

gpio.output(3, 0)

gpio.output(3, 1)

gpio.cleanup()

exit()

Ed ecco a cosa servono:
import RPi.GPIO as gpio dice a python di caricare la libreria RPi.GPIO che serve per gestire i pin del BCM2835 e che da qui in poi ci riferiremo alla libreria semplicemente con gpio.
gpio.setmode(gpio.BCM) chiama la funzione setmode della libreria, e specifica che nel corso del programma i GPIO verranno selezionati con il numero di pinout del microprocessore (modo BCM) anzichè con il numero del pin del pettine (modo BOARD). La scelta del metodo va a gusti personali e la differenza sta nel fatto che se scrivete programmi complessi e li caricate su revisioni diverse del Raspberry Pi, col metodo BCM dovete cambiare il numero del pin collegato secondo le specifiche di ogni revisione, mentre col metodo BOARD il programma funzionerà indipendentemente dalle connessioni del microprocessore^[+].
gpio.setup(3, gpio.OUT, initial=1) configura il pin chiamato GPIO3 (vedi schema nella sezione Hardware dell'articolo) come uscita e setta lo stato della porta a livello logico alto (3,3V). In questo modo il LED rimane spento.
gpio.output(3, 0) cambia lo stato del GPIO3 portandolo a livello logico basso, che elettricamente corrisponde a 0V. A questo punto, se il circuito è stato fatto correttamente, il LED si accende.
gpio.output(3, 1) riporta lo stato del GPIO3 ad alto (3,3V). Il LED si spegne.
gpio.cleanup() cancella tutte le configurazioni che abbiamo fatto e riporta tutti i GPIO che abbiamo utilizzato ai valori di default.
exit() chiude l'interpreter. Al suo posto si può anche usare Ctrl+D.

Il comando gpio.output ha come argomenti canale e stato, dove stato può essere 1 o 0 ma anche True o False.

Il pettine femmina ha un'aria abbastanza casalinga

Adesso proviamo anche il secondo circuito per verificare il funzionamento degli ingressi.

The Rising Of The GPIO, al cinema

I comandi iniziali e finali sono gli stessi, mentre cambiano nella fase di lettura:

import RPi.GPIO as gpio

gpio.setmode(gpio.BCM)

gpio.setup(4, gpio.IN, pull_up_down=gpio.PUD_DOWN)

gpio.wait_for_edge(4, gpio.RISING)

gpio.cleanup()

exit()

In breve:
import RPi.GPIO as gpio e gpio.setmode(gpio.BCM) li abbiamo già visti nell'esempio sopra.
gpio.setup(4, gpio.IN, pull_up_down=gpio.PUD_DOWN) specifica che il GPIO4 deve essere configurato come ingresso e deve essere attivata la sua resistenza di pull-down.
gpio.wait_for_edge(4, gpio.RISING) mette in attesa l'interpreter e aspetta che il GPIO4 cambi stato logico, e passi da basso ad alto (RISING). Questo è il momento giusto per premere il pulsante SW1.
gpio.cleanup() e exit() chiudono il programma come nell'esempio precedente.

Durante il setup del gpio si può scegliere se usare la resistenza di pull-up, pull-down o nessuna delle due. pull_up_down può essere gpio.PUD_DOWN per la resistenza di pull-down o gpio.PUD_UP per la resistenza di pull-up. Per disattivare le resistenze interne si può omettere questa parte di comando, chiudendo la parentesi subito dopo gpio.IN
gpio.wait_for_edge può essere configurato per aspettare il fronte di salita (gpio.RISING), di discesa (gpio.FALLING) o entrambi (gpio.BOTH).

Per altri metodi di lettura degli ingressi leggete qui.
Ricordate che se avete dei problemi di lettura e non riuscite a passare il comando gpio.wait_for_edge potete interrompere l'esecuzione dell'interpreter con la shortcut Ctrl+D.

Il mio primo programma

Adesso che abbiamo cominciato a mettere le mani in pasta è ora di passare a qualcosa di più gustoso. Cominceremo con lo scrivere un semplice programma per accendere il LED alla pressione di SW1.

Prima di tutto ci serve un editor per scrivere il nostro programma. Il comando nano (preinstallato su Raspbian) lancia un editor grafico semplice ed intuitivo. Oggi useremo questo editor, ma se siete programmatori professionisti probabilmente apprezzerete l'editor vim. Anche se è davvero poco intuitivo, è estremamente configurabile e di solito una volta imparato ad usare non lo si lascia più.

Ma vediamo brevemente l'editor nano. Digitiamo il comando

nano

e premiamo [INVIO]. Ci apparirà una schermata vuota con un menu in basso.

Una parte del menu

Il simbolo ^ indica che insieme alla lettera che lo segue deve essere premuto Ctrl. Quindi per uscire (e per salvare) dobbiamo usare la combinazione Ctrl+X.

Usciamo da nano e creiamo il file che conterrà il nostro programma, che chiameremo, in questo esempio, primo.py (dove py è l'estensione di un file python)

touch primo.py

ed apriamolo subito con nano

nano primo.py

Il programma in python possiamo pensarlo come la lista dei comandi che poco fa stavamo dando direttamente all'interpreter. E in effetti troviamo parte dei comandi che abbiamo già usato.
Per scrivere il programma inizieremo caricando le librerie necessarie (che saranno RPi.GPIO e time per la funzione di attesa), configureremo i due GPIO che usiamo nel circuito e faremo partire un ciclo infinito che altro non fa che leggere lo stato dell'ingresso e cambiare l'uscita di conseguenza.
Una cosa del genere può già funzionare:

#! /usr/bin/python
import time                                             # Importa libreria per la gestione dei timer

# Inizializzazione GPIO
import RPi.GPIO as gpio                                 # Importa libreria GPIO
gpio.setmode(gpio.BCM)                                  # Numerazione BCM
gpio.setwarnings(False)                                 # Disattiva messaggi d'avviso 

gpio.setup(3, gpio.OUT, initial=1)                      # GPIO3 output, default: 1
gpio.setup(4, gpio.IN, pull_up_down=gpio.PUD_DOWN)      # GPIO4 input, abilita pull-down

print("Pronto!")

# Ciclo infinito  
while 1:
       if gpio.input(4):                                # Se l'ingresso è alto accendi il LED
               gpio.output(3, 0)                                            
       else:                                            # Altrimenti spegnilo
               gpio.output(3, 1)                                  
       time.sleep(0.05)                                 # Aspetta 50ms

La primissima riga è un commento speciale e serve a lanciare lo script da terminale. È un modo per spiegare al terminale che lo script deve essere interpretato con il programma che si trova in /usr/bin/python, che è poi il solito interpreter.
Nella fase di inizializzazione dei GPIO è apparso un nuovo comando: gpio.setwarnings. È possibile avere più script in funzione contemporaneamente e se python rileva che un pin che stiamo per configurare non si trova nello stato di default (input) ci avverte che potrebbe esserci un conflitto tra programmi. Disattiviamo gli avvisi mettendo tra parentesi False oppure attiviamoli scrivendo True.
Il comando print scrive a terminale il contenuto della parentesi e in questo caso ha la sola funzione di darci un feedback quando il programma ha terminato la fase di inizializzazione.
Il while segna l'inizio di un ciclo, che termina quando la sua condizione diventa falsa. In questo caso il ciclo che vogliamo è infinito e quindi la condizione 1 (che viene interpretata come 1=1) è sempre vera.
Dentro al ciclo while è piazzato un if...else che testa l'ingresso GPIO4. Se l'ingresso risulta vero, quindi alto, quindi pulsante premuto, viene spenta l'uscita GPIO3, accendendo il LED. Altrimenti l'uscita viene portata a livello alto, spegnendo il LED.
In coda al programma ho aggiunto la funzione sleep che blocca l'esecuzione dello script per 50ms, per permettere alla CPU di occuparsi di altri processi.

Da notare che la sintassi di python è estremamente semplice. Non ci sono punti e virgola, non ci sono comandi per chiudere il ciclo while o il test if. In questo linguaggio l'inizio e la fine dei comandi sono determinati dall'indentazione. Se la funzione time.sleep fosse stata scritta nella stessa colonna del while, python avrebbe interpretato quell'istruzione come fuori dal ciclo.

Una volta finito di scrivere lo script, premiamo Ctrl+X e successivamente Y per confermare il salvataggio delle modifiche. Ci verrà chiesta conferma anche per il nome del file, premiamo [INVIO] e nano uscirà ripresentandoci il terminale.

A questo punto non ci rimane che rendere lo script eseguibile con

chmod u+x primo.py

e lanciarlo con

sudo python primo.py

oppure con

sudo ./primo.py

Quando siamo soddisfatti della prova premiamo Ctrl+C per interrompere l'esecuzione dello script.

python mostra l'evento che ha causato il blocco dello script (KeyboardInterrupt)

Altri esempi

SPEGNIMENTO RITARDATO
Questo programma, molto simile al primo, aspetta che venga premuto il tasto per accendere e tenere acceso il LED per due secondi.

#! /usr/bin/python
import time                                         # Importa libreria per la gestione dei timer

# Inizializzazione GPIO
import RPi.GPIO as gpio                             # Importa libreria GPIO
gpio.setmode(gpio.BCM)                              # Numerazione BCM
gpio.setwarnings(False)                             # Disattiva messaggi d'avviso
 
gpio.setup(3, gpio.OUT, initial=1)                  # GPIO3 output, default: 1
gpio.setup(4, gpio.IN, pull_up_down=gpio.PUD_DOWN)  # GPIO4 input, abilita pull-down

print("Pronto!")

# Ciclo infinito
while 1:
     gpio.wait_for_edge(4, gpio.RISING)              # Attendi fronte di salita
     gpio.output(3, 0)                               # Accendi LED
     time.sleep(2)                                   # Aspetta 2s
     gpio.output(3, 1)                               # Spegni LED

LAMPEGGIO CONTROLLATO COL PULSANTE (CON ANTIRIMBALZO)
In quest'altro esempio invece, facciamo lampeggiare un LED ogni 0.5s quando viene premuto il tasto e fermiamo il lampeggio quando viene ripremuto il tasto. Questo script usa gli interrupt e un controllo antirimbalzo per il pulsante.

#! /usr/bin/python
import time                                         # Importa libreria per la gestione dei timer
 
# Inizializzazione GPIO
import RPi.GPIO as gpio                             # Importa libreria GPIO
gpio.setmode(gpio.BCM)                              # Numerazione BCM
gpio.setwarnings(False)                             # Disattiva messaggi d'avviso

gpio.setup(3, gpio.OUT, initial=1)                  # GPIO3 output, default: 1
gpio.setup(4, gpio.IN, pull_up_down=gpio.PUD_DOWN)  # GPIO4 input, abilita pull-down

# Variabili
lampeggio = False                                   # Memoria lampeggio attivo

# Funzioni
def cambia_stato(pin):
    global lampeggio                                # Importa la variabile globale lampeggio
    if lampeggio:                                   # Se il lampeggio è attivo
        lampeggio = False                           #  disattiva lampeggio
        gpio.output(3, 1)                           #  spegni il LED
    else:                                           # Altrimenti
        lampeggio = True                            #  attiva lampeggio
        gpio.output(3, 0)                           #  accendi il LED

# Interrupt
# inseriamo un evento che causerà la chiamata della funzione "cambia_stato"
# ogni volta che viene rilevato un fronte di salita sul pin 4
gpio.add_event_detect(4, gpio.RISING, callback=cambia_stato, bouncetime=200)

print("Pronto!")

# Ciclo infinito
while 1:
    if lampeggio:                                   # Se il lampeggio è attivo
        if gpio.input(3):                           #  Se il LED è spento
            gpio.output(3, 0)                       #   accendi il LED
        else:                                       #  Altrimenti
            gpio.output(3, 1)                       #   spegni il LED
    time.sleep(0.5)                                 # Aspetta 0.5s

Questo script non è così complicato come sembra: dopo le solite operazioni di inizializzazione viene dichiarata la variabile lampeggio che tiene in memoria se abbiamo attivato o disattivato il lampeggio. All'inizio il lampeggio è disattivato.
Dopo la variabile troviamo la funzione cambia_stato. Questa parte di codice viene chiamata ogni volta che il pulsante viene premuto e inverte lo stato della variabile lampeggio oltre a spegnere o accendere il LED a seconda delle condizioni.
La dichiarazione global lampeggio è necessaria per permettere alla funzione di modificare il valore della variabile lampeggio, che altrimenti sarebbe utilizzabile in sola lettura.
Qualche riga più in basso troviamo la dichiarazione dell'interrupt. Gli interrupt permettono di interrompere il programma principale (la parte dentro il while) ed eseguire dell'altro codice (in questo caso la funzione cambia_stato) per poi riprendere il programma principale da dove era stato interrotto.
La dichiarazione add_event_detect ha come argomenti il GPIO su cui effettuare il test (GPIO4), la condizione di rilevamento (gpio.RISING ossia il fronte di salita), la funzione da chiamare (cambia_stato) e il bouncetime (opzionale).
Il bouncetime si usa quando si lavora con i pulsanti meccanici ed è un piccolo timer (in questo caso di 200ms) che sopprime il rimbalzo del tasto per evitare letture di più fronti di salita durante una singola pressione del pulsante.

Ecco cosa succede quando si chiude un contatto meccanico

Dopo la dichiarazione dell'interrupt abbiamo la sezione principale che controlla la variabile lampeggio. Se questa è vera (quindi lampeggio attivato) si controlla lo stato dell'uscita del LED (sì, si deve usare gpio.input per questa operazione!) e la si inverte.
Se la variabile lampeggio è falsa, il LED viene lasciato spento (viene spento la prima volta durante la funzione cambia_stato).
Prima di ricominciare il ciclo, il programma viene fermato mezzo secondo per permetterci di vedere il LED lampeggiare.

Questi programmi non hanno in fondo la funzione gpio.cleanup() perchè è previsto che vengano interrotti da tastiera. Se scrivete un programma che invece prevede una fine, è sempre bene inserire questo comando.

C'È POSTA PER TE
(con un LED al posto di Maria De Filippi)
Questo programmino è solo per gli account Gmail e utilizza il modulo feedparser di python per controllare il numero di email non lette nella propria casella di posta.
Siccome dovete mettere dentro username e password, occhio a non copiare il programma in posti poco sicuri... tipo internet insomma.

Per prima cosa dobbiamo scaricare la libreria feedparser che di default non è installata. Andiamo sulla pagina del modulo, che potete trovare qui, e scarichiamo il file .tar.bz2. Però non scaricatevelo sul vostro pc che poi Windows piange perchè non sa cos'è un file tar, scaricatelo direttamente sul Raspberry Pi.

wget link

dove link va ovviamente sostituito con il link al file tar.bz2.
Una volta che wget finisce di scaricare il file, scompattiamolo con

tar -xf nome_del_file

(ricordo la funzione autocomplete: scrivete le prime lettere del file e premete due volte TAB).
A questo punto se invocate ls troverete una nuova cartella con lo stesso nome del file che avete scaricato. Spostatevici dentro (con cd) ed eseguite il comando

sudo python setup.py install

In pochi secondi avrete installato il nuovo modulo.

Mentre eseguivo queste operazioni, ho lanciato il setup del modulo e python mi ha risposto che gli mancava la libreria setuptools. Se vi succede lo stesso, ripetete il procedimento qui sopra con il file scaricabile da qui e una volta installato, riprendete l'installazione di feedparser.

Adesso vediamo il codice:

#! /usr/bin/python
import RPi.GPIO as gpio, feedparser, time   # Importa tutte le librerie

usr = "username"                            # Dati utente (username SENZA @gmail.com)
passwd = "password"
   
mail_check_freq = 60                        # Controlla ogni 60 secondi

# Inizializzazione GPIO
gpio.setmode(gpio.BCM)
gpio.setwarnings(False)
gpio.setup(3, gpio.OUT, initial=1)

# Ciclo infinito
while 1:

    # Controlla il numero di email
    newmail = int(feedparser.parse("https://" + usr + ":" + passwd +"@mail.google.com/gmail/feed/atom")["feed"][fullcount"])

    if not newmail:                         # Se non ci sono nuove email
        gpio.output(3, 1)                   #  spegni il LED
    else:                                   # Altrimenti
        gpio.output(3, 0)                   #  accendi il LED

    time.sleep(mail_check_freq)             # Aspetta il valore di mail_check_freq

Oltre le solite cose (importazione delle librerie, setup dei GPIO) troviamo tre variabili configurabili da utente: username, password e mail_check_freq. I primi due servono ad autenticare l'utente con i dati di accesso di Gmail, mentre il terzo stabilisce ogni quanti secondi deve essere controllata la casella di posta.
Dentro al ciclo, la prima funzione che utilizza feedparser estrae il numero di email non lette dal feed RSS di Google e lo carica nella variabile newmail.
La variabile newmail viene controllata e se equivale a zero (che equivale a False, ecco perchè si usa un controllo di tipo booleano) viene spento il LED, altrimenti viene acceso.
Dopodichè lo script viene messo in pausa per il tempo stabilito dalla variabile mail_check_freq.
Il difficile in questo script è estrapolare dal feed il numero di email non lette. Per approfondimenti su come funziona feedparser cliccate qui.

Tips 'n' Tricks - parte 2

NON-ASCII CHARACTER
Alcune volte può capitare che copiando e incollando un testo di uno script finiscano in mezzo al file che andate a salvare dei caratteri che non vengono riconosciuti. Se succede, lanciando il programma vi verrà risposto no encoding declared.
Per ovviare al problema specifichiamo a python il tipo di encoding del testo (utf8 va benissimo) inserendo all'inizio del programma (ma comunque sotto al commento speciale #!) la riga

# coding: utf8

"Ma cos'è poi questo \xc3?"

RICONOSCIMENTO DELLA SINTASSI PYTHON CON NANO
Nano è tutto brutto e grigio di default, ma fortunatamente possiamo evidenziare la sintassi di alcuni linguaggi. Per sapere quali basta guardare dentro la cartella /usr/share/nano (sempre con il buon ls) e troveremo anche il file python.nanorc.
Per attivare il riconoscimento della sintassi dobbiamo creare il file nascosto .nanorc nella home e inserire il comando include seguito dalla posizione del file che ci interessa.
Se vogliamo esagerare e fare tutto in un unico comando (assicuratevi di essere in home):

echo "include /usr/share/nano/python.nanorc" > .nanorc

Al prossimo riavvio di nano, vi troverete più o meno così

Magic, you can't explain that.

LANCIARE UNO SCRIPT ALL'AVVIO

• Nota: la soluzione seguente era stata partorita dalla mia mente smanettona senza approfondite ricerche. E' una soluzione sbagliata che non assicura il corretto avvio degli script. Consiglio di utilizzare i tool integrati di Debian, potete trovare una guida qui.
  

E se volessimo far partire un programma non appena il Raspberry Pi viene acceso? Niente di più semplice! Assicuratevi che il vostro programma sia eseguibile (verificate con ls -l che il file sia contrassegnato con la x nella prima terna) e segnatevi il suo percorso (assoluto).
Se avete dubbi a proposito del percorso, il comando

pwd

vi restituirà il percorso assoluto della cartella in cui è contenuto lo script.
A questo punto, editiamo il file /etc/rc.local che è quella lista di comandi da eseguire all'avvio.

sudo nano /etc/rc.local

Ci troveremo dentro un sacco di commenti, una piccola funzione che ricava l'IP del Raspberry Pi e il comando exit 0. Inseriamo il percorso dello script che vogliamo lanciare preceduto da sudo tra la funzione già presente (che volendo possiamo anche togliere) e il comando exit 0 (che invece è importante e va lasciato in fondo al file).
Salvate e riavviate (sudo reboot), il programma partirà automaticamente.

Editing con vim. La scelta del blu per i commenti non è stata una gran mossa

Se avete problemi all'avvio e lo script non vuole saperne di partire, potete provare a inserire il comando python tra sudo ed il percorso dello script.

SERVER FTP
Se amate alla follia il vostro editor che avete sul pc e non ne volete sapere di usare nano o vim, questo è un metodo per mandare il file che avete già preparato sul vostro pc al Rasperry Pi per poi lanciarlo da terminale.
Il server FTP si installa velocemente con

sudo aptitude install ftpd

Dopo un minuto circa, il server sarà già pronto e configurato, verifichiamo che stia funzionando con il comando

netstat -lt

che ci mostra quali porte sono aperte. Se tutto è andato come previsto, troveremo che ci sono servizi in ascolto sulla porta 21 (ftp) e 22 (ssh).
A questo punto scarichiamo un FTP client, come può essere FileZilla, inseriamo utente e password del Raspberry Pi (specifichiamo la porta solo se è diversa dalla 21) e colleghiamoci cliccando su "Quickconnect".
Adesso possiamo navigare tra le cartelle del Raspi comodamente e scambiare i file velocemente.

Spero che il vostro editor di fiducia non sia Blocco Note

LOGIN SENZA PASSWORD
(solo Linux)
Come dicevo qualche centinaio di righe fa, il protocollo SSH utilizza un tipo di autenticazione a chiave pubblica, che significa, tra le altre cose, che se abbiamo una coppia di chiavi (pubblica e privata) possiamo accedere al Raspi usando la nostra chiave privata.
Non starò a spiegare come funziona l'autenticazione, ma se siete interessati (e sarebbe bello che lo foste) ci sono già migliaia di articoli sparsi per internet che aspettano solo di essere trovati da una ricerca di Google.
Se ancora non avete una coppia di chiavi, generatela (sul vostro pc, non sul Raspberry Pi!) con il comando

ssh-keygen -t rsa

Salvate la chiave con il percorso di default e, quando vi viene chiesto, lasciate in bianco i campi Passphrase, altrimenti vi verrà chiesta la password che immettete, rendendo tutta l'operazione di fatto inutile.
Una volta terminata l'operazione, carichiamo la chiave pubblica sul Raspi lanciando (sempre dal pc) il comando:

ssh-copy-id -i ~/.ssh/id_rsa.pub pi@indirizzoip

Vi verrà chiesta la password dell'utente pi, per essere sicuri che la copia della chiave pubblica viene effettuata da un utente che ha già l'accesso al Raspberry Pi.
Finito questo passaggio proviamo a loggarci con il comando

ssh pi@indirizzoip

e se tutto è andato bene, entriamo direttamente.

"Ai miei tempi qui era tutta campagna"

Conclusioni

Abbiamo esplorato un po' di python e buttato le basi per lavorare con i GPIO. L'articolo è venuto lunghissimo ma spero di aver soddisfatto le necessità dei neofiti e di aver solleticato la curiosità di chi scopre per la prima volta il Raspberry Pi.
Ci sono tantissime altre cose che avrei voluto inserire, tante funzioni che sto provando con altrettanti programmi ma che purtroppo non posso scrivere qui per una questione di spazi.
Spero di avere a breve abbastanza materiale per mettere insieme un nuovo articolo di esempi pratici e vedere come sfruttare al meglio le capacità di questo piccolo computer.
La cosa che mi preme e che spero sia passata è che il Raspberry Pi ha delle potenzialità incredibili, è davvero facile da usare e si trovano migliaia di progetti su internet da cui prendere spunto.

Ho fatto del mio meglio per documentare tutto ciò che ho scritto, ma se trovate delle imprecisioni vi prego di lasciare un commento e farò in modo di aggiustare l'articolo.
Grazie come sempre alla comunità di ElectroYou e a tutti quelli che contribuiscono!

Jon