Tutorial: programmiamo il Sense HAT

Zzed 16 Luglio 2016 Corsi, Domotica, Elettronica & GPIO, Hardware 2 Comments 7,689 Visualizzazioni

Dopo aver Conosciuto a fondo il Sense HAT con l’articolo precedente..

Programmiamo il Sense HAT

Installare l’hardware

Il Sense HAT è una scheda dotata di diversi sensori interessanti, un dispositivo di output (display a matrice di LED), e un dispositivo di input (micro joystick a 5 posizioni). Segue lo standard HAT, anche nelle dimensioni. E’ direttamente compatibile con i Raspberry con GPIO da 40 pin, quindi Modello B+, Raspberry Pi 2 e 3. Io ci aggiungo il Pi Zero, e anche i modelli precedenti, se si adattano i collegamenti, invece di usare il pettine GPIO (la scheda usa SPI e I2C).
Il montaggio è semplicissimo: basta inserire la scheda nel pettine GPIO. Nella confezione ricevuta dal nostro nuovo partner Kubii.it vi sono anche 4 viti 2,5 MA e relativi distanziali, per fissarla meccanicamente in modo perfetto con il Raspberry sottostante.

Contenuto del pacco da Kubii.it: Sense HAT con scatola di Element14, foglio con istruzioni di sicurezza, viti e distanziali e alcuni sticker

Installare il software

Una volta effettuato l’avvio, dalla finestra del terminale, digitate:
sudo apt-get update
sudo apt-get install sense-hat
sudo pip-3.2 install pillow
(è necessario avere una connessione a internet)
Avrei preferito trovare queste semplici indicazioni sul foglietto illustrativo di accompagnamento, che invece riporta solo le indicazioni di sicurezza obbligatorie (non immergere in acqua, non incendiare..) in 16 lingue diverse. Poco male: RaspberryItaly serve anche a questo, no?

Ora riavviate, e se il Sense Hat spegne tutti i sui led multicolore, siete pronti per cominciare a giocare con la vostra scheda, in modo semplice tramite Python.
Il nostro programma Python avrà, nell’ intestazione, queste righe:

from sense_hat import SenseHat
sense = SenseHat()

1 2	from sense_hat import SenseHat sense = SenseHat()

servono a importare la libreria Python del sense hat, che renderà molto facili le cose altrimenti difficili, e a abbreviare il modo di richiamarne i comandi.

Usare il display RGB

Scritta scorrevole

A seguire, cominciamo con una cosa veloce, ma di grande effetto:

sense.show_message("Ciao a tutti da RaspberryItaly.com")

1	sense.show_message("Ciao a tutti da RaspberryItaly.com")

questo semplice comando mostrerà la vostra stringa di testo sul display LED RGB, e la farà scorrere per poterla leggere per intero.
Quindi il programma completo sarà:

from sense_hat import SenseHat
sense = SenseHat()
sense.show_message("Ciao a tutti da RaspberryItaly.com")

from sense_hat import SenseHat

sense = SenseHat()

sense.show_message("Ciao a tutti da RaspberryItaly.com")

Naturalmente starete già cambiando il contenuto della stringa, per sperimentare. Bene! Potete modificare anche altre cose, come il colore della scritta, dello sfondo, e la velocità di scorrimento utilizzando dei parametri per il comando.

text_colour modifica il colore del testo, utilizzando le tre componenti RGB (rosso, verde, blu), in valori dallo 0 al 255. esempio [255,0,0] sarà rosso, [255,255,255] sarà bianco.
back_colour modifica il colore dello sfondo, e funziona nella stessa maniera di text_colour

scroll_speed modifica la velocità di scorrimento del testo. di default è 0.1 , più è grande il numero, più lento è lo scorrimento.
Si può visualizzare una singola lettera, invece di una stringa, usando il comando sense.show_letter, che ha i medesimi parametri di sense.show_message.
Ma il display non fa solo questo:

Usare i singoli LED

E’ possibile accendere anche singoli LED, invece di usare caratteri predefiniti, è sufficiente usare il metodo

sense.set_pixel()

1	sense.set_pixel()

La matrice di LED usa delle coordinate per i pixel, da 0 a 7, con l’origine nell’ angolo in alto a sinistra.
Ad esempio,

from sense_hat import SenseHat
sense = SenseHat()
sense.set_pixel(0, 6, [0, 255, 0])
sense.set_pixel(4, 1, [0, 0, 255])

from sense_hat import SenseHat

sense = SenseHat()

sense.set_pixel(0, 6, [0, 255, 0])

sense.set_pixel(4, 1, [0, 0, 255])

accenderà i pixel indicati in figura.
coordinates

Può risultare un pò scomodo lavorare un pixel alla volta, no?
Allora si può usare

sense.set_pixels

1	sense.set_pixels

(attenzione alla “s” finale) per settare tutti i pixel uno di seguito all’altro, ad esempio:

sense.set_pixels([[255, 0, 0], [255, 0, 0], [255, 255, 0], [0, 0, 255],......])

1	sense.set_pixels([[255, 0, 0], [255, 0, 0], [255, 255, 0], [0, 0, 255],......])

Ma se devo descrivere intere schermate non è che sia molto più comodo.
Le cose cambiano un po’ se usiamo delle variabili in cui immagazzinare le nostre informazioni di colore:

r = [255, 0, 0]
o = [255, 127, 0]
y = [255, 255, 0]
g = [0, 255, 0]
b = [0, 0, 255]
i = [75, 0, 130]
v = [159, 0, 255]
e = [0, 0, 0]  # questo significa led completamente spento

r = [255, 0, 0]

o = [255, 127, 0]

y = [255, 255, 0]

g = [0, 255, 0]

b = [0, 0, 255]

i = [75, 0, 130]

v = [159, 0, 255]

e = [0, 0, 0] # questo significa led completamente spento

e definiamo la nostra immagine sulla matrice, dove ogni lettera corrisponde a un colore:

image = [
e,e,e,e,e,e,e,e,
e,e,e,r,r,e,e,e,
e,r,r,o,o,r,r,e,
r,o,o,y,y,o,o,r,
o,y,y,g,g,y,y,o,
y,g,g,b,b,g,g,y,
b,b,b,i,i,b,b,b,
b,i,i,v,v,i,i,b
]

image = [

e,e,e,e,e,e,e,e,

e,e,e,r,r,e,e,e,

e,r,r,o,o,r,r,e,

r,o,o,y,y,o,o,r,

o,y,y,g,g,y,y,o,

y,g,g,b,b,g,g,y,

b,b,b,i,i,b,b,b,

b,i,i,v,v,i,i,b

]

quindi il programma completo sarà simile a

from sense_hat import SenseHat

sense = SenseHat()

r = [255,0,0]
o = [255,127,0]
y = [255,255,0]
g = [0,255,0]
b = [0,0,255]
i = [75,0,130]
v = [159,0,255]
e = [0,0,0]

image = [
e,e,e,e,e,e,e,e,
e,e,e,r,r,e,e,e,
e,r,r,o,o,r,r,e,
r,o,o,y,y,o,o,r,
o,y,y,g,g,y,y,o,
y,g,g,b,b,g,g,y,
b,b,b,i,i,b,b,b,
b,i,i,v,v,i,i,b
]

sense.set_pixels(image)

from sense_hat import SenseHat

sense = SenseHat()

r = [255,0,0]

o = [255,127,0]

y = [255,255,0]

g = [0,255,0]

b = [0,0,255]

i = [75,0,130]

v = [159,0,255]

e = [0,0,0]

image = [

e,e,e,e,e,e,e,e,

e,e,e,r,r,e,e,e,

e,r,r,o,o,r,r,e,

r,o,o,y,y,o,o,r,

o,y,y,g,g,y,y,o,

y,g,g,b,b,g,g,y,

b,b,b,i,i,b,b,b,

b,i,i,v,v,i,i,b

]

sense.set_pixels(image)

Caricare immagini

Dulcis in fundo, è possibile caricare direttamente immagini 8×8 pixel in formato png o jpeg, con il metodo

sense.load_image("la_mia_immagine.png")

1	sense.load_image("la_mia_immagine.png")

E’ inoltre possibile ruotare l’orientamento del display a 0, 90, 180 e 270 gradi, specchiare le immagini orizzontalmente o verticalmente, diminuire la luminosità eccetera. Per la documentazione completa anche di queste opzioni rimando alla documentazione ufficiale su https://pythonhosted.org/sense-hat/

Il Sense HAT paragonato al Raspberry Pi Zero. Questa combinazione consente di avere un completo computer dotato di sensori fisici in uno spazio molto compatto (una volta accoppiati, lo Zero "sparisce" sotto il Sense HAT) — Il Sense HAT paragonato al Raspberry Pi Zero. Questa combinazione consente di avere un completo computer dotato di sensori fisici in uno spazio molto compatto (una volta accoppiati, lo Zero “sparisce” sotto il Sense HAT)

Usare i sensori ambientali

Come detto, abbiamo a disposizione sulla scheda i seguenti sensori d’ambiente:

Temperatura
Umidità
Pressione

Che possono essere lette rispettivamente con i metodi:

sense.get_temperature() – ritorna la temperatura in gradi Celsius
sense.get_humidity() – ritorna l’umidità relativa in percentuale
sense.get_pressure() – ritorna la pressione atmosferica in millibar

Esempio d’uso:

from sense_hat import SenseHat
sense = SenseHat()

while True:
    t = round(sense.get_temperature(),1) 
    u = round(sense.get_humidity(),1)
    p = round(sense.get_pressure(),1)
   

    msg = "Temperatura = %s, Umidita = %s, pressione= %s" % (t,u,p)

    sense.show_message(msg, scroll_speed=0.05)

from sense_hat import SenseHat

sense = SenseHat()

while True:

t = round(sense.get_temperature(),1)

u = round(sense.get_humidity(),1)

p = round(sense.get_pressure(),1)

msg = "Temperatura = %s, Umidita = %s, pressione= %s" % (t,u,p)

sense.show_message(msg, scroll_speed=0.05)

Usare i sensori di orientamento

Abbiamo a disposizione sulla scheda anche i seguenti sensori di orientamento:

Giroscopio – rileva l’orientamento della scheda
Accelerometro – rileva i movimenti della scheda
Magnetometro – rileva i campi magnetici

Siccome però non siamo abituati a ragionare di forze nelle tre dimensioni, è bene ripetere i termini che verranno utilizzati:

Beccheggio (Pitch – su e giù come la rotazione per il decollo e l’atterraggio)
Imbardata (Yaw – rotazione a destra e a sinistra, come sterzare con una macchina)
Rollio (Roll – avvitamento, come la rotazione di un cavatappi o di un cacciavite)

Per rilevare l’orientamento del Sense HAT puoi utilizzare il metodo

sense.get_orientation()

1	sense.get_orientation()

Ecco come:

ori = sense.get_orientation()
beccheggio = ori['pitch']
rollio = ori['roll']
imbardata = ori['yaw']

ori = sense.get_orientation()

beccheggio = ori['pitch']

rollio = ori['roll']

imbardata = ori['yaw']

questo legge i tre dati di orientamento (in gradi) e li memorizza in 3 variabili (beccheggio, rollio, imbardata).
Esempio d’uso:

from sense_hat import SenseHat
sense = SenseHat()
while True:
    ori = sense.get_orientation()
    beccheggio= ori['pitch']
    rollio = ori['roll']
    imbardata = ori['yaw']
    print("beccheggio=%s, rollio=%s, imbardata=%s" % (beccheggio,rollio,imbardata))

from sense_hat import SenseHat

sense = SenseHat()

while True:

ori = sense.get_orientation()

beccheggio= ori['pitch']

rollio = ori['roll']

imbardata = ori['yaw']

print("beccheggio=%s, rollio=%s, imbardata=%s" % (beccheggio,rollio,imbardata))

Analogamente, possiamo misurare le accelerazioni di movimento che subisce la nostra scheda col metodo

sense.get_accelerometer_raw()

1	sense.get_accelerometer_raw()

L’ esempio mostra i G di accelerazione:

from sense_hat import SenseHat

sense = SenseHat()

while True:
    acc = sense.get_accelerometer_raw()
    x = acc['x']
    y = acc['y']
    z = acc['z']

    x=round(x, 0) #arrotondiamo
    y=round(y, 0)
    z=round(z, 0)

    print("x=%s, y=%s, z=%s" % (x, y, z))

from sense_hat import SenseHat

sense = SenseHat()

while True:

acc = sense.get_accelerometer_raw()

x = acc['x']

y = acc['y']

z = acc['z']

x=round(x, 0) #arrotondiamo

y=round(y, 0)

z=round(z, 0)

print("x=%s, y=%s, z=%s" % (x, y, z))

Per misurare il campo magnetico, invece, usiamo il metodo

sense.get_compass()

1	sense.get_compass()

Ecco un programma di esempio che indica i gradi rispetto al Nord magnetico:

from sense_hat import SenseHat
sense = SenseHat()

while True:
        nord = sense.get_compass()
        print("Nord: %s" % nord)

from sense_hat import SenseHat

sense = SenseHat()

while True:

nord = sense.get_compass()

print("Nord: %s" % nord)

Si noti che per ottenere una misura precisa, è bene calibrare il magnetometro tramite il programma posto in RTIMULib/Linux/RTIMULibCal. Il programma di calibrazione creerà un file di calibrazione chiamato RTIMULib.ini, che andrà posto nella stessa cartella del programma in Python (questa operazione risulta a molti problematica).

Joystick

Con una certa lungimiranza, il joystick è pre-mappato per emulare i tasti cursore della tastiera e il tasto Invio (con il tasto centrale). Con queste informazioni, si potranno gestire gli input esattamente come si gestiscono le pressioni dei tasti di una tastiera.
Ecco un esempio, visualizzerà delle frecce stilizzate nella direzione verso la quale viene spostato il piccolo joystick. O un simbilo se premuto al centro:

#!/usr/bin/python
from sense_hat import SenseHat
import os
import time
import pygame  # Vedi http://www.pygame.org/docs
from pygame.locals import *

print("Premi ESC per ucire")
time.sleep(1)

pygame.init()
pygame.display.set_mode((640, 480))

sense = SenseHat()
sense.clear()  # Pulisce la matrice di LED

# 0, 0 = Angolo in alto a sinistra
# 7, 7 = Angolo in basso a destra
UP_PIXELS = [[3, 0], [4, 0], [2, 1], [5, 1], [1, 2], [6, 2]]
DOWN_PIXELS = [[3, 7], [4, 7], [2, 6], [5, 6], [1, 5], [6, 5]]
LEFT_PIXELS = [[0, 3], [0, 4], [1, 2], [1, 5], [2, 1], [2, 6]]
RIGHT_PIXELS = [[7, 3], [7, 4], [6, 2], [6, 5], [5, 1], [5, 6]]
CENTRE_PIXELS = [[3, 3], [4, 3], [3, 4], [4, 4], [2, 2], [5, 2], [5, 5], [2, 5]]

def set_pixels(pixels, col):
    for p in pixels:
        sense.set_pixel(p[0], p[1], col[0], col[1], col[2])

def handle_event(event, colour):
    if event.key == pygame.K_DOWN:
        set_pixels(DOWN_PIXELS, colour)
    elif event.key == pygame.K_UP:
        set_pixels(UP_PIXELS, colour)
    elif event.key == pygame.K_LEFT:
        set_pixels(LEFT_PIXELS, colour)
    elif event.key == pygame.K_RIGHT:
        set_pixels(RIGHT_PIXELS, colour)
    elif event.key == pygame.K_RETURN:
        set_pixels(CENTRE_PIXELS, colour)

running = True
NERO = [0, 0, 0]
ROSSO = [200, 0, 0]

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == KEYDOWN:
            if event.key == K_ESCAPE:
                running = False
            handle_event(event, ROSSO)
        if event.type == KEYUP:
            handle_event(event, NERO)

#!/usr/bin/python

from sense_hat import SenseHat

import os

import time

import pygame # Vedi http://www.pygame.org/docs

from pygame.locals import *

print("Premi ESC per ucire")

time.sleep(1)

pygame.init()

pygame.display.set_mode((640, 480))

sense = SenseHat()

sense.clear() # Pulisce la matrice di LED

# 0, 0 = Angolo in alto a sinistra

# 7, 7 = Angolo in basso a destra

UP_PIXELS = [[3, 0], [4, 0], [2, 1], [5, 1], [1, 2], [6, 2]]

DOWN_PIXELS = [[3, 7], [4, 7], [2, 6], [5, 6], [1, 5], [6, 5]]

LEFT_PIXELS = [[0, 3], [0, 4], [1, 2], [1, 5], [2, 1], [2, 6]]

RIGHT_PIXELS = [[7, 3], [7, 4], [6, 2], [6, 5], [5, 1], [5, 6]]

CENTRE_PIXELS = [[3, 3], [4, 3], [3, 4], [4, 4], [2, 2], [5, 2], [5, 5], [2, 5]]

def set_pixels(pixels, col):

for p in pixels:

sense.set_pixel(p[0], p[1], col[0], col[1], col[2])

def handle_event(event, colour):

if event.key == pygame.K_DOWN:

set_pixels(DOWN_PIXELS, colour)

elif event.key == pygame.K_UP:

set_pixels(UP_PIXELS, colour)

elif event.key == pygame.K_LEFT:

set_pixels(LEFT_PIXELS, colour)

elif event.key == pygame.K_RIGHT:

set_pixels(RIGHT_PIXELS, colour)

elif event.key == pygame.K_RETURN:

set_pixels(CENTRE_PIXELS, colour)

running = True

NERO = [0, 0, 0]

ROSSO = [200, 0, 0]

while running:

for event in pygame.event.get():

if event.type == pygame.QUIT:

running = False

if event.type == KEYDOWN:

if event.key == K_ESCAPE:

running = False

handle_event(event, ROSSO)

if event.type == KEYUP:

handle_event(event, NERO)

Conclusioni

Naturalmente gli esempi qui proposti sono in linea di massima abbastanza banali, ma servono a comprendere cosa la scheda può fare per noi. Combinando queste funzionalità tra loro e con il tuo codice, potrai ottenere progetti assai meno banali, ad esempio un drone volante a guida autonoma, un visore per realtà aumentata, un robot intelligente che sta in equilibrio da solo.. il limite è sempre la fantasia. Buona sperimentazione!

Documentazione

La documentazione ufficiale completa del Sense HAT e dei vari comandi, la potete trovare qui

https://pythonhosted.org/sense-hat/

Forum

La discussione relativa al Sense HAT sul forum è disponibile qui

RaspberryItaly Community Italiana

Tutorial: programmiamo il Sense HAT

Programmiamo il Sense HAT

Installare l’hardware

Installare il software

Usare il display RGB

Scritta scorrevole

Usare i singoli LED

Caricare immagini

Usare i sensori ambientali

Usare i sensori di orientamento

Joystick

Conclusioni

Documentazione

Forum

A proposito di Zzed

Vedi Anche

Nuovi Hardware Ufficiali Raspberry Pi

2 Commenti