Raspberry Pi

Installazione sistema su SD

In questa pagina si presuppone di utilizzare un PC di appoggio con sistema Ubuntu/Linux e di dare i comandi su terminale, e si parla della distribuzione base raspbian.

Scaricare dalla pagina raspberrypi.org/downloads il file immagine zippato della distribuzione scelta, ad esempio raspbian.
Cliccando su 'more info' si vede l'impronta sha-1, da confrontare con quella ottenibile dal file scaricato con il comando:
sha1sum <nomefile.zip>

Esempio:
sha1sum 2014-01-07-wheezy-raspbian.zip

Se l'impronta è corretta si può dezippare il file:
unzip 2014-01-07-wheezy-raspbian.zip

Ed infine scrivere il file .img su scheda SD.

Prima configurazione

Al primo avvio appare una finestra testuale che da la possibilità di impostare il funzionamento globale di RaspberryPi. Questo programma di configurazione può essere avviato in ogni momento scrivendo a terminale:
sudo raspi-config

Di seguito le cose principali:

Con 'Expand filesystem' si può usare tutto lo spazio sulla SD per il sistema.
Con 'Change user password' si può variare la password predefinita 'raspberry', il proprio nome utente predefinito invece è 'pi'.
Con 'Internationalisation options' si può modificare la lingua (Locale), il fuso orario (Time zone) e il tipo di tastiera (Keyboard layout).
Con 'Advanced' si può modificare il nome del computer (come appare in rete), abilitare il server SSH per effettuare un login testuale da remoto, specificare se far uscire l'audio dal jack 3,5mm o dal connettore HDMI.

Al termine della configurazione, e ai successivi riavvi, il sistema si presenta in modalità testuale e richiede il login con il proprio nome utente e password.

Una volta loggati si può continuare a lavorare in modalità testuale, oppure avviare l'ambiente grafico LXDE scrivendo: startx

Per effettuare il logout scrivere exit

Tastiera WiFi Logitech K400 italiana

Modificare con permessi di root il file:
/etc/xdg/lxsession/LXDE/autostart

Aggiungendo alla fine:
@setkbmap it

Avviare: raspi-config
Change keyboard layout
   Logitech generic keyboard
      Other -> Italian
        Tasti muti rimossi

Login SSH

Se si abilita il server SSH è possibile usare il terminale di un altro PC come se fosse un terminale remotizzato del RaspberryPi (che può quindi essere usato senza alcuna connessione ad un monitor o a una tastiera).

Sul terminale del PC scrivere:
ssh -l <nomeutente> <IP>

Esempio:
ssh -l pi 192.168.1.20

Viene richiesta la password. Per terminare la sessione scrivere exit

L'IP a cui collegarsi può essere un IP fisso se impostato tale, o un IP dinamico da scoprire di volta in volta.

Reboot / Shutdown

Reboot da terminale:
sudo reboot

Spegnimento da terminale:
sudo shutdown -h now

Oppure:
sudo halt

Risoluzione monitor

Se l'immagine video risulta circondata da un bordo nero, modificare con permessi di root il file:
/boot/config.txt

Scrivendo:
disable_overscan=1

Ed eventualmente commentando le righe inizianti con:
overscan_left=
overscan_right=
overscan_top=
overscan_bottom=
disable_overscan=0

Impostare IP fisso

Modificare con permessi di root il file:
/etc/network/interfaces

Cercare la riga con:
iface eth0 inet dhcp

Modificarla in:
iface eth0 inet static

Aggiungere:
address <IP da assegnare al RPi>
netmask <maschera LAN>
gateway <IP LAN del router>
broadcast <IP LAN.255>

Esempio:
address 192.168.1.20
netmask 255.255.255.0
gateway 192.168.1.1
broadcast 192.168.1.255

Impostare DNS

Modificare con permessi di root il file:
/etc/resolv.conf

Esempio:
domain NB
search NB
nameserver 192.168.1.1 <-- il router fa da DNS

Esempio:
domain NB
search NB
nameserver 208.67.222.222 <-- open DNS
nameserver 208.67.220.220

http://superuser.com/questions/617796/how-do-i-set-dns-servers-on-raspberry-pi

Verificare impostazioni porta ethernet

ifconfig

Disabilitare screensaver / blank screen

Installare pacchetto xscreeensaver

Andare su: Menu principale -> Preferenze -> Screensaver
Nella casella di scelta 'Modalità' impostare: 'Disable screen saver'

Caricare un'immagine da hard disk su SD

Determinare il nome della SD
Smontare tutte le partizioni della SD trovate con df -h

Copiare l'immagine sulla SD:
dd bs=4M if=<fileimmagine> of=<nomeSD>

Esempio:
dd bs=4M if=2014-01-07-wheezy-raspbian.img of=/dev/sdb

ATTENZIONE: se in of si indica l'unità errata tutti i dati di quell'unità vengono persi!

NOTA: la scrittura su SD può non avvenire correttamente, per verificarlo è necessario salvare il contenuto della SD su un nuovo file immagine e confrontarlo con l'originale.

Il confronto si può fare ad esempio tra le impronte sha1 o md5 dei due files ottenibili rispettivamente con:
sha1sum <nomefile>
md5sum <nomefile>

Oppure usando il comando:
diff -s <nomeprimofile> <nomesecondofile>

Esempio:
diff -s 2014-01-07-wheezy-raspbian.img backup_sd.img

Salvare immagine di una SD su hard disk

Il salvataggio del contenuto della SD su un file immagine su hard disk serve sia per verificare che sia stata scritta correttamente, sia per fare una copia di backup di un sistema funzionante personalizzato.

Determinare il nome della SD

Salvare l'immagine della SD:
dd if=<nomeSD> of=<nomefileimmagine>

Esempio:
dd if=/dev/sdb of=backup_sd.img

Connettore GPIO

In verde sono indicati i pin per uso generale, sda e scl sono il bus i2c, tx e rx sono trasmissione e ricezione della porta seriale interna, mosi miso sclk ce0 ce1 sono il bus SPI.

                                     1   2
                                   .-------.
                            +3,3V  | o   o |  +5V
   (R1: 0)      8     (sda)     2  | o   - |
   (R1: 1)      9     (scl)     3  | o   o |  GND
                7     (clk)     4  | o   o |  14   (tx)         15
                                   | -   o |  15   (rx)         16
                0              17  | o   o |  18   (pcmclk)      1
   (R1: 21)     2              27  | o   - |
                3              22  | o   o |  23                 4
                                   | -   o |  24                 5
               12    (mosi)    10  | o   - |
               13    (miso)     9  | o   o |  25                 6
               14    (sclk)    11  | o   o |   8   (ce0)        10
                                   | -   o |   7   (ce1)        11
                                   '-------'
                                    25   26
                ^               ^              ^                 ^
                |               |              |                 |
                |               '---GPIO BCM---'                 |
                |                                                |
                |                                                |
                '------------------GPIO Wiring-------------------'

Dai pin GPIO si possono prelevare fino a 16 mA, per un totale complessivo tra tutti i pin di 50 mA.
Dal pin +3,3V si possono prelevare al massimo 30 mA.
Il pin +5V è la linea interna di alimentazione, si può prelevare tutta la corrente che serve fino al limite permesso dal fusibile in serie al connettore microusb, circa 300mA meno la corrente eventualmente assorbita attraverso le porte USB.
I sei pin senza utilizzo indicati con - sono da considerare e lasciare scollegati.
R1: indica la numerazione GPIO BCM nella revisione 1 di Raspberry Pi dove diversa da quella della revisione 2.
Tutti i pin GPIO sono a livelli 3,3V e non tollerano connessioni a 5V.

Alimentazione

Il Raspberry Pi va alimentato a 5V e assorbe circa 700 mA. La via "canonica" di alimentazione è il connettore microusb (che serve solo per l'alimentazione) a cui è collegato un fusibile da 1A.

La seconda via da cui può essere alimentato è il pin +5V del connettore GPIO, qui non ci sono fusibili di protezione.

La linea interna +5V raggiunge anche le due porte USB attraverso ulteriori due fusibili da 140mA, e questa è la corrente massima erogabile da ciascuna delle porte. A causa della presenza di questi due fusibili non si può alimentare il Raspberry Pi dalle porte USB, in quanto non potrebbe passare sufficiente corrente.

Temperatura CPU

/opt/vc/bin/vcgencmd measure_temp

Per non scrivere tutto il comando ogni volta è possibile scrivere un alias creando un file di nome .bash_aliases nella propria directory home:
cd ~
nano .bash_aliases

Aggiungere la seguente riga:
alias temperatura='/opt/vc/bin/vcgencmd measure_temp'

Salvare e fare reboot, per avere la temperatura sarà sufficiente scrivere: temperatura

Fonte: raspberrypi.org/forums/viewtopic.php?f=91&t=34994

Ascoltare radio Shoutcast in streaming

Bisogna installare il programma mplayer

Dai link del sito shoutcast.com salvare i files playlist (.pls) dandogli un nome opportuno, ad esempio chromaNewAge.pls

I .pls sono dei files di testo, ad esempio:

[playlist]
numberofentries=1
File1=http://46.4.121.138:8048
Title1=(#1 - 14/200) Chroma NewAge
Length1=-1
Version=2

Questi files possono essere passati come input a mplayer:
mplayer -playlist chromaNewAge.pls

Per interrompere l'ascolto premere Q

Si può avviare l'ascolto anche usando un terminale remoto SSH (l'audio ovviamente non esce sul PC remoto ma sempre dal RaspberryPi). Però non si riesce ad interrompere con Q. In questo caso è necessario collegarsi al RaspberryPi con un secondo terminale SSH, effettuare un nuovo login, e killare il processo mplayer con il comando kill dopo averne identificato il PID tramite i comandi top o ps -a

In alternativa lo si può avviare con l'opzione quiet, in questo modo anche da collegamento SSH si riesce ad interrompere con Q:
mplayer -quiet -playlist chromaNewAge.pls

Ulteriore possibilità, avviare mplayer in modalità slave, in questo modo da terminale (anche SSH) si possono inviare comandi testuali:
mplayer -slave -quiet -playlist chromaNewAge.pls

loadlist nuovofile.pls 0 Avvia nuovo ascolto
loadfile http://46.4.121.138:8048 0 Avvia nuovo ascolto
pause Mette in pausa e riprende ascolto
Q oppure stop Interrompe

Esperimenti con Python

Avviare uno script Python

Uno script Python normalmente è un file di testo salvato con estensione .py

Può essere avviato (lanciato) invocando esplicitamente l'interprete:
python <nomedelloscript>

Esempio:
python mio_programma.py

Tramite una riga (obbligatoriamente scritta per prima), chiamata shabang, è possibile indicare all'interno dello script l'interprete che lo dovrà eseguire. In questo modo lo script può essere avviato direttamente (dopo avergli dato i permessi di esecuzione).

Esempio, salvare questo script con il nome mio_programma.py:

#! /usr/bin/env python
print('Hello world!')

chmod a+x mio_programma.py

Lo si può ora avviare scrivendone direttamente il nome (per motivi di sicurezza se è nella directory corrente va anteposto ./)
./mio_programma.py

Oppure si può specificare il percorso completo:
/home/nomeutente/sottodirectory/mio_programma.py

Autostart script Python non grafico e non interattivo all'accensione

Modificare con permessi di root il file:
/etc/rc.local

Esempio aggiungere alla fine:
/home/pi/nomescript.py &

Il simbolo & avvia lo script in un sottoprocesso senza bloccare il processo di boot principale.

Autostart script Python grafico all'avvio di LXDE

Modificare con permessi di root il file:
/etc/xdg/lxsession/LXDE/autostart

Esempio aggiungere alla fine:
@python /home/pi/nomescript.py

Spegnimento con script Python

#! /usr/bin/env python
import os
os.system('sudo shutdown -h now')

Sintesi vocale con google

Bisogna installare il programma mplayer

#! /usr/bin/env python
import subprocess, urllib
#---------------------------------------------------------------------
def parla(s):
    s = urllib.quote(s)
    s = 'http://translate.google.com/translate_tts?tl=en&q=' + s
    subprocess.call(['mplayer', s], shell=False, 
                    stdout=subprocess.PIPE, stderr=subprocess.PIPE)
#---------------------------------------------------------------------
parla('have a nice day')

Fonte: rollcode.com/talking-raspberry-pi-using-python/

Lettura pulsante con GPIO e invio messaggi TCP/IP

In questo programma si assume di aver collegato un pulsante (normalmente aperto) tra il pin +3.3V e il pin GPIO 24 della numerazione BCM (corrispondente al pin GPIO 5 della numerazione wiring e al 18 del connettore fisico). Inoltre è collegata una resistenza di pull-down da 4.7kΩ tra il GPIO 24 e la massa (GND).

    +3.3V   ----------------.
                            |
                            o |
                              |=|
                            o | 
                            |
    GPIO 24 ----------------●
                            |
                  4.7k      |
    GND     -----/\/\/\/----'

Quando viene premuto, il pulsante fornisce un livello logico 1 sul pin GPIO 24. Alla lettura viene applicato un debounching (antirimbalzo) software tramite una piccola macchina di Moore a quattro stati (pressioni e rilasci troppo veloci sono scartati), ad ogni variazione di stato "accettata" dal debouncher viene inviato un pacchetto TCP/IP contenente lo stato del pulsante sotto forma di stringa aperto/chiuso.

NOTA: i programmi che devono accedere ai pin GPIO vanno avviati come root.

#! /usr/bin/env python
#---------------------------------------------------------------------
# RaspberryPi TCP client - Python 2 & 3 - By C.Fin 2014
#---------------------------------------------------------------------
import RPi.GPIO as gpio
import time
import socket
#---------------------------------------------------------------------
class Debouncher(object):

    def __init__(self, initial_value=0, cyc=1):
        self.cyc = cyc
        self.state = 2 if initial_value == 0 else 0
        self.counter = 0

    def debounch(self, value):
        if self.state == 0:
            if value == 0:
                self.counter=self.cyc
                self.state = 1
            return 1

        elif self.state == 1:
            if value == 1: self.state = 0
            else:
                self.counter -= 1
                if self.counter == 0: self.state = 2
            return 1

        elif self.state == 2:
            if value == 1:
                self.counter = self.cyc
                self.state = 3
            return 0

        else:
            if value == 0: self.state = 2
            else:
                self.counter -= 1
                if self.counter == 0: self.state = 0
            return 0
#---------------------------------------------------------------------
def message(msg):
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.settimeout(1)
    REMOTE_ADDR = '192.168.1.25', 4005
    try:
        sock.connect(REMOTE_ADDR)
        sock.sendall(msg.encode('ascii'))
        sock.close()
    except socket.error: pass
#---------------------------------------------------------------------
def main():
    ACT = 1  # 0=chiuso verso massa  1=chiuso verso Vcc
    gpio.setmode(gpio.BCM)
    gpio.setup(24, gpio.IN)
    if gpio.input(24) == ACT: closed = True  ; message('CHIUSO')
    else:                     closed = False ; message('APERTO')
    debouncher = Debouncher(ACT if closed else ACT^1, cyc=9)
    while True:
        time.sleep(0.010)
        contact = debouncher.debounch(gpio.input(24))
        if contact == ACT:
            if not closed: closed = True ; message('CHIUSO')
        else:
            if closed: closed = False ; message('APERTO')
#---------------------------------------------------------------------
main()

#! /usr/bin/env python
#---------------------------------------------------------------------
# Server TCP - Python 2 & 3 - By C.Fin 2014
#---------------------------------------------------------------------
try:
    from socketserver import TCPServer, BaseRequestHandler
except ImportError:
    from SocketServer import TCPServer, BaseRequestHandler
#---------------------------------------------------------------------
class Gest(BaseRequestHandler):

    def handle(self):
        sock = self.request
        data = sock.recv(1024)
        addr = self.client_address
        print(
            'From (%s:%s) Recieved: <%s>' %
            (addr[0], addr[1], data.decode('ascii'))
        )
#---------------------------------------------------------------------
def main():
    LOCAL_ADDR = '192.168.1.25', 4005
    server = TCPServer(LOCAL_ADDR, Gest)
    server.serve_forever()
#---------------------------------------------------------------------
main()

Varie Linux

Modificare con permessi di root

Per modificare un file di testo di sistema bisogna avviare l'editor anteponendo sudo:
sudo leafpad <nomedelfile> (se in modo grafico)
sudo nano <nomedelfile> (se in modo testuale)

Esempio:
sudo leafpad /boot/config.txt

Commentare

Commentare significa "disabilitare" una particolare riga in modo che non venga presa in considerazione, generalmente è sufficiente scrivere all'inizio della riga il carattere #

Esempio:
#disable_overscan=0

Installare un pacchetto/programma

Installare un pacchetto da terminale:
sudo apt-get install <nomepacchetto>

Esempio:
sudo apt-get install python-serial

Determinare nome SD

Da terminale dare il seguente comando una volta con e una volta senza la SD inserita:
df -h

L'unità, ad esempio /dev/sdb, che una volta appare e l'altra no, è la SD

Smontare partizione

Da terminale dare:
umount /dev/<partizione>

Esempio:
umount /dev/sdb1

Convenzioni sui nomi dei files

In Linux il simbolo tilde ~ identifica la propria directory home, quindi se il proprio nome utente è pippo il simbolo ~ identifica la directory /home/pippo

Dare il permesso di esecuzione ad un file

In modo grafico: aprire il gestore file pcmanfm, cliccare col tasto destro sul file e scegliere proprietà, sotto 'Permessi' selezionare 'Rendi il file eseguibile'.

Da terminale usare il comando:
chmod a+x <nomefile>

Esempio:
chmod a+x mio_programma.py

RaspberryPi (model B)