[TommyThebiker]

Ciao a tutti

Vorrei condividere un piccolo progetto creato da me e da un mio amico, ossia un allarme sonoro che scatti in automatico in caso di surriscaldamento del raspy. Si tratta di un progetto a bassissimo costo e dall'impatto sul sistema praticamente nullo, inoltre la parte hardware è riutilizzabile per mille altri scopi (spiegherò più avanti).

REQUISITI

-un cicalino piezoelettrico: deve essere di tipo passivo e che funzioni a basso voltaggio (3v o meno). Su eBay ce ne sono a migliaia a prezzi ridicoli, se non sapete scegliere cercatene uno per Arduino e andrà benissimo. Io ho scelto un modello molto simile a questo per via delle sue dimensioni ridotte (10x5 mm circa) visto che volevo integrarlo nel case del raspy; spedizione inclusa, ho speso 1€ per cinque cicalini.

-due cavi dupont (jumper), singolo pin femmina-femmina; per intenderci, sono questi qua. Anche questi li trovate comodamente su eBay, io ho speso 1€ per quaranta cavi da 10 cm.

-un pin GPIO libero sul raspy, cercate su Google immagini lo schema della vostra board per identificarlo

-un pin di massa (ground) libero, come sopra

PARTE HARDWARE

Banalissimo: il cicalino avrà due pin, un positivo e un negativo; collegate il positivo al GPIO scelto e il negativo al pin di massa utilizzando i dupont. Fine!

Ci sono solo due cose a cui prestare attenzione, io le ritengo scontate ma essendo un tutorial basilare è bene ricordarle:

1)Il raspy deve essere privo di alimentazione. I pin si interfacciano direttamente con la board senza protezione alcuna, perciò Raspberry ed hot plugging non vanno d'accordo.

2)Alcuni buzzer non hanno polarità, cioé è indifferente quale pin venga collegato al positivo e quale al negativo; non date per scontato che anche il vostro lo sia, però. Se non vedete etichette o segni che identifichino chiaramente il positivo, nel dubbio testate il cicalino con una pila stilo.

PARTE SOFTWARE

Per il lato software, verrà utilizzato uno script Python. Se non avete mai programmato in Python non preoccupatevi, tutto il necessario è già preinstallato di default in Raspbian e io vi guiderò passo passo

Per prima cosa aprite un editor di testo, possibilmente uno che abbia la sintassi colorata (per esempio nano, anche questo lo trovate di default in Raspbian). Create dunque un file con nome a piacere ed estensione .py in un percorso adeguato, ad esempio
/home/pi/.oha.py
dove "oha" sta per OverHeatingAlarm (allarme surriscaldamento) e il puntino prima del nome rende il file nascosto, mentre il percorso è la mia home.

Ora, io ho diviso il codice in più spezzoni in modo da spiegarne il funzionamento; se non vi interessa, copiate semplicemente gli spezzoni nel file di testo e scorrete fino al prossimo step del tutorial.

Innanzitutto dobbiamo importare un po' di roba:

Codice:

import os
import RPi.GPIO as GPIO
import time
import re
import locale

Passo numero uno, misurare la temperatura della CPU. Per farlo useremo vcgencmd, un comodissimo tool command-line che fornisce un sacco di informazioni sulla board, come ad esempio voltaggio, clock eccetera. L'output che ne deriva è nel formato temp=45.3'C quindi dovremo ripulirlo per ottenere solo il valore numerico.

Codice:

def get_cpu_temperature():
    res = os.popen('vcgencmd measure_temp').readline() # misura la temperatura della CPU
    return re.findall("\d*\.\d*",res)[0]               # ripulisce l'output

Numero due, alimentare il buzzer. Cercate su internet lo schema dei pin della vostra board, dopodiché inserite nel codice il numero del GPIO da voi utilizzato. Attenzione a non confondere il numero del GPIO col numero del pin! Per esempio, io ho un Raspberry 3 ed ho utilizzato il pin n°40, che corrisponde al GPIO n°21, perciò nel codice ho messo 21.

Codice:

class Buzzer:
    def __init__(self):
        GPIO.setmode(GPIO.BCM)
        self.buzzer_pin = 21                           # GPIO del positivo del cicalino
        GPIO.setup(self.buzzer_pin, GPIO.IN)
        GPIO.setup(self.buzzer_pin, GPIO.OUT)
    def __del__(self):
        class_name = self.__class__.__name__

Adesso viene il bello Abbiamo due temperature-soglia, ossia ossia "kinda hot" (un po' caldo) e "too hot" (troppo caldo). Una volta lanciato, lo script controlla la temperatura della CPU, dopodiché
-se è sotto "kinda hot": non fa nulla (idle)
-se è tra"kinda hot" e "too hot" : biip brevi e sporadici
-se è sopra "too hot" : biip lunghi e frequenti
Una volta fatto, lo script riparte da capo in automatico.

Codice:

    def get_cpu_temperature(self, current_temp, kinda_hot, too_hot):
        while True:
            current_temp=get_cpu_temperature()
            #print time.ctime()
            #print current_temp
            if locale.atof(current_temp) > (too_hot):
#
#                     SOGLIA "TOO HOT"
# Default: beep per un secondo, zitto un secondo, beep un secondo ecc ecc
#
                #print time.ctime()
                #print current_temp
                GPIO.output(self.buzzer_pin, True)
                time.sleep(1)                          # bippa 1 secondo
                GPIO.output(self.buzzer_pin, False)
                time.sleep(1)                          # zitto 1 secondo
            elif locale.atof(current_temp) > (kinda_hot):
#
#                    SOGLIA "KINDA HOT"
# Default: beep 0.25 secondi, zitto 5 secondi, beep 0,25 secondi ecc ecc
#
                #print time.ctime()
                #print current_temp
                GPIO.output(self.buzzer_pin, True)
                time.sleep(0.25)                       # bippa 0.25 secondi
                GPIO.output(self.buzzer_pin, False)
                time.sleep(5)                          # zitto 5 secondi
            else:
#
#                    IDLE MODE
# Più il valore è basso e più lo script impegna la CPU
# Un tempo accettabile a parer mio è 10 secondi
                time.sleep(10)                         # idle per10s

I più attenti avranno notato due linee commentate ripetute più volte, ossia print time.ctime() e print current_temp. Sono state aggiunte per un eventuale debugging, se le decommentate (basta cancellare il # all'inizio della riga) ogni volta che lo script fa un check verranno mostrati timestamp e temperatura.

A questo punto restano solo da impostare le due temperature-soglia; i valori di default sono 80 e 85 gradi. Non usate valori troppo bassi o troppo ravvicinati tra di loro, altrimenti inizierà a bippare come un ossesso facendovi voglia di defenestrare il Raspberry! (esperienza diretta...)

Codice:

buzzer = Buzzer()
buzzer.get_cpu_temperature(get_cpu_temperature(), 80.0, 85.0)

Salvate e chiudete l'editor (se usate nano: CTRL+X, conferma con S/Y, Invio) e lo script è finito

ESEGUIRE E AUTOMATIZZARE LO SCRIPT

Ora che abbiamo lo script, dobbiamo farlo funzionare. Aprite una shell (ALT+F2, "lxterminal" senza virgolette, invio) e date il comando:

cd /home/pi/.config/autostart 
(occhio al puntino prima di "config")

Quindi, create un file con nome a piacere ed estensione .desktop:
sudo nano oha.desktop

Fatto ciò, copiate e incollate quanto segue:

Codice:

[Desktop Entry]
Name=OverHeatingAlarm
Exec=python "home/pi/.oha.py"
Type=Application

Modificate nome e percorso dello script alla terza riga se necessario, quindi salvate e chiudete nano.

Infine, date allo script i permessi di esecuzione e riavviate:
sudo chmod +x /home/pi/.oha.py
sudo reboot

E con questo è davvero tutto! Se avete domande, chiedete pure  

[Painbrain]

Interessante!

Grazie per averlo condiviso sul forum