• Costo contenuto
• Connettore di espansione (GPIO, UART, SPI, I2C) per interfacciarsi con il mondo esterno.
• Tutte le principali periferiche sono presenti, Ethernet, USB, SD card, ecc.
• L'unica nota negativa è forse relativa alla documentazione che è, si abbondante, ma è sparpagliata su diversi siti Internet.

INIZIAMO

Se avete un minimo di conoscenze dell'Inglese vi suggeriamo di leggere la versione in Inglese perchè ha dei paragrafi in più.

Se leggete qui significa che avete tra le mani una scheda RaspBerry Pi e magari siete impazienti di usarla ma, se non vi siete documentati prima, adesso dovete procurarvi anche:

• SD Card da 4/8Gbyte su cui installare il sistema operativo che useremo. Mi raccomando, scegliete una SD veloce perchè le prestazioni del vostro RaspBerry Pi saranno influenzate dalla velocità della SD che scegliete.
• Tastiera USB
• Mouse USB
• Cavo RJ45 per collegare il vostro RaspBerry Pi al vostro Modem ADSL e/o Router
• Monitor o TV con ingresso HDMI
  
• Alimentatore USB da 1A o meglio 1,5A (vi serve anche per le eventuali schede di espansione)
• Cavo da USB-A a Micro-USB che useremo per alimentare il nostro RaspBerry Pi.
• Opzionalmente una chiavetta USB-WiFi
  

Più avanti vedremo come fare per eliminare la Tastiera, il Mouse e il Monitor (o TV) e prendere il controllo da remoto con un PC.

In pratica dovremo collegare le periferiche evidenziate sotto in rosso:

Sistema Operativo

Il RaspBerry Pi è stato progettato per funzionare con LINUX che come sappiamo ne esistono diverse versioni.
In questo manuale faremo riferimento a Raspbian versione nominata WHEEZZY (derivata da Debian) che è la versione raccomandata per RaspBerry Pi.
Per prima cosa dovremo scaricare e installare Raspbian sulla nostra SD card.
Visto che su Internet ci sono decine di spiegazioni su come fare mi limito a segnalare le seguenti:

Per utenti con PC con Windows seguite questa guida:
http://www.raspberrypi.org/wp-content/uploads/2012/12/Raspberry_Pi_-_Guida_veloce.pdf (In Italian language)
http://www.raspberrypi.org/wp-content/uploads/2012/04/quick-start-guide-v2_1.pdf (In English language)

Per utenti LINUX o MAC seguite questa guida:
http://www.raspberrypi.org/downloads

Questa è la mia guida per scaricare e installare la distribuzione RaspBian su una SD card da 8GB.

• Procuratevi una SD card da 8GB e formattatela come FAT32, per chi ha LINUX basta usare gparted.
  Per chi usa Windows consiglio Win32DiskImager.

• Scaricate RaspBian da qui:
  http://www.raspberrypi.org/downloads
  entrati nella pagina sopra scorretela verso il basso sino a trovare RaspBian

• Una volta scaricato, scompattatelo e avrete un file con estensione .img
• Per installare questo file sulla SD card da Linux possiamo usare ImageWriter, se sul vostro Linux non è installato usate il vostro Software Center e installatelo.

-

NOTA:

La scheda RaspBerry Pi non ha un interruttore di alimentazione per cui si accende dando alimentazione via Micro-USB.
Prima di togliere alimentazione dovremo digitare il comando:

sudo shutdown -h now

oppure più brutalmente

sudo halt

Aspettate sino a che il led ACT finisce di lampeggiare e poi togliete alimentazione.

ATTENZIONE:

Quando spegnete il vostro RaspBerry Pi scollegate anche il cavo HDMI perchè in alcuni casi (TV) mantiene alimentato il RaspBerry Pi e quando gli ridate tensione può non ripartire correttamente.

Questo problema non sussiste se usate il vostro RaspBerry Pi da remoto per cui non avete collegato nulla se non il cavo RJ45 della vostra LAN (Ethernet).

-

Note sui LED presenti sul RaspBerry Pi

Sul RaspBerry Pi sono presenti 5 leds che sono:

Colore                 Nome
ARANCIONE    100
VERDE             LINK
VERDE             FDX
ROSSO             PWR
VERDE             ACT

In funzionamento i led 100, LINK, FDX e PWR sono accesi mentre saltuariamente lampeggia il led ACT (indica accessi alla SD card).
Quando la scheda è spenta, ovvero abbiamo dato il comando:

sudo shutdown -h now

è acceso solo il led PWR (tutti gli atri sono spenti). In questa condizione possiamo togliere alimentazione al RaspBerry Pi.

Se usate solo una chiavetta USB WiFi per collegarvi al vostro RaspBerry Pi, vedrete acceso solo il led PWR mentre saltuariamente lampeggia il led ACT (indica accessi alla SD card).

-

Raspi Config

Questa è un'utility che viene lanciata la prima volta che accendete il vostro RaspBerry Pi ma la potete rilanciare in un qualsiasi momento tramite il comando:

sudo raspi-config

Per navigare nel menù si usano i tasti freccia e il tasto tab.

Le cose fondamentali che dovete fare sono:

1. configurare la tastiera (configure_keyboard)

2. fare l'update della vostra installazione (update).

3. espandere lo spazio di memoria utilizzabile sino alla massima capienza della vostra SD card. Per fare ciò si seleziona la voce expand_rootfs.

4. impostare il fuso orario e un server da cui prendere i dati per sincronizzare l'orologio del RaspBerry Pi.
   Vi ricordo che questa scheda non ha un RTC per cui quando si spegne perde i dati dell'orologio. Se alla riaccensione è presente un collegamento a Internet in modo automatico verrà riconfigurato l'orologio.

5. ssh è molto importante abilitarla perchè ci permetterà di gestire il nostro RaspBerry Pi da remoto e quindi non avremo più bisogno della tastiera, del mouse e del monitor ma faremo tutto attraverso un PC collegato in rete.

6. boot_behavior ci permette, se abilitata, di avere un'interfaccia grafica per la gestione del RaspBerry Pi.
   Visto che noi useremo questa scheda per sistemi embedded non la abiliteremo.
   In ogni caso è possibile in qualsiasi momento lanciare l'interfaccia grafica digitando startx.

NOTA:
-
L'utente predefinito è:

raspberry login: pi
password: raspberry

potete cambiare la password tramite il menù change_pass

-

Arrivati a questo punto il nostro RaspBerry Pi è configurato e funzionante.

Visto che noi useremo il nostro RaspBerry Pi senza monitor, tastiera e mouse è importante sapere l'indirizzo IP che è stato assegnato alla nostra scheda dal nostro A.P. a cui ci siamo collegati.

Per scoprirlo date il comando (da RaspBerry Pi):

ifconfig

lo Link encap:Loopback locale
indirizzo inet:127.0.0.1 Maschera:255.0.0.0
indirizzo inet6: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:16436 Metric:1
RX packets:47074 errors:0 dropped:0 overruns:0 frame:0
TX packets:47074 errors:0 dropped:0 overruns:0 carrier:0
collisioni:0 txqueuelen:0

L'indirizzo assegnato al nostro RaspBerry Pi è quello evidenziato in giallo sopra (192.168.1.9) .

Guardate anche la modalità: nmap

UP

-

Scoprire l'indirizzo del RaspBerry Pi da un PC remoto

Se siamo su una rete e non sappiamo l'indirizzo del RaspBerry Pi e a questo non è collegata nè tastiera, nè monitor, nè mouse, cosa facciamo ?

Se sul PC che volete usare per collegarvi con il vostro RaspBerry Pi avete LINUX date il comando:

nmap -sP 192.168.1.1-255

ovviamente il 192.168.1.1 dovrà essere cambiato con l'IP di base del Access Point o Router su cui siete collegati.

Il risultato del comando nmap sarà simile a questo sotto riportato.

Da qui notiamo che il mio RaspBerry Pi si chiama rpi1.station e ha come IP 192.168.1.5

ATTENZIONE: se nmap sulla vostra distribuzione Linux, installatelo usando il comando:
sudo apt-get install nmap
oppure
sudo su
install nmap

UP

-

Se usate un PC con Windows, per scoprire l'indirizzo IP del vostro RaspBerry Pi, vi consiglio di usare Angry IP Scanner che è gratuito.

Qui sotto vi ho messo la videata di una scansione.

-

Controllare RaspBerry Pi da remoto

Normalmente il RaspBerry Pi viene usato in applicazioni di controllo e viene chiuso in armadi elettrici o in posti difficilmente accessibili, per questo motivo è fondamentale poter controllare il nostro RaspBerry Pi da remoto con un PC.
Per fare quanto scritto sopra ci sono diverse possibilità che sono:

• Via rete locale Ethernet

• Via RS232

Lasciando perdere la possibilità di usare l'RS232 a causa del fatto che sui PC moderni non esiste più, ci concentreremo sul controllo da remoto via Ethernet.

Per controllare via Internet il RaspBerry Pi è fondamentale aver abilitato, in fase di configurazione, il server SSH. Se non lo avete ancora fatto leggete qui.

In pratica il controllo avviene come evidenziato dalla figura sotto riportata.

-

Di seguito vedremo come usare un PC su cui gira LINUX e Windows per collegarsi al RaspBerry Pi come terminale a caratteri (shell di Linux).

La prima cosa da fare è installare PUTTY o KITTY (sia su PC con LINUX che su PC con Windows) che ci permettono di remotizzare il terminale a linea di comando (shell).

Noi useremo PUTTY che è il miglior terminale remoto scritto per il mondo LINUX e disponibile anche per Windows.

Anche in questo caso esistono diverse guide su come configurare PUTTY reperibili su Internet e qui sotto ve le ho segnalate.

Le cose fondamentali da fare sono:

• Inserire l'indirizzo IP del RaspBerry Pi, su come fare a individuare l'indirizzo IP vedere qui.

• Salvare la configurazione.

Per vostra comodità qui sotto ho messo le principali finestre di PUTTY che dovrete compilare, vedere i rettangoli rossi.

ATTENZIONE:

ATTENZIONE:

LINK

• http://www.vincenzov.net/taccuino/RaspberryPI/ssh.htm

• http://www.engeene.it/controllare-da-remoto-una-raspberry-pi/

• http://raspberrypi4dummies.wordpress.com/2013/03/17/connect-to-the-raspberry-pi-via-ssh-putty/

• http://cplus.about.com/od/raspberrypi/a/How-Do-I-Setup-Ssh-On-Raspberry-Pi.htm

-

Se sul vostro PC usate LINUX per collegarvi al vostro RaspBerry Pi dovrete:

Sapere l'indirizzo IP del RaspBerry Pi, su come fare vedere qui oppure potete usare il comando nmap vedere qui.
Per collegarvi al vostro RaspBerry Pi avete due possibilità: via terminale usando il comando ssh o usare PUTTY.

• SSH
  Usare da terminale direttamente il comando:
  ssh IndirizzoIPdelRaspBerry -l pi
  dove pi è il login di default del vostro RaspBerry Pi, se lo avete cambiato
  cambiatelo anche qui.

  ESEMPIO:
  ssh 192.167.111.31 -l pi
  ovviamente 192.167.11.31 è l'indirizzo IP del mio RaspBerry Pi, voi
  sostituitelo con il vostro indirizzo IP
  ATTENZIONE:
  

  Sul mio PC dove ho XUBUNTU, saltuariamente, usando da terminale il
  comando ssh mi capita di non riuscire a fare il login alla riaccensione del PC,
  vedere qui.
  

  
  

• PUTTY
  Questa è la modalità che vi consiglio perchè PUTTY è disponibile sia per
  LINUX che per Windows e funziona perfettamente.

  Per installarlo andate in Software Center e scaricatelo sul vostro PC.

UP

-

La Grafica da remoto

Sul nostro RaspBerry Pi con installato Raspbian c'è anche un'interfaccia grafica che si chiama X.
Direttamente da shell di RaspBian possiamo lanciare l'interfaccia grafica dando il comando:

startx

Se vogliamo usare la grafica da PC remoto dovremo avere installato un emulatore grafico di X o la stessa interfaccia X.

Vedere qui sotto.

-

Grafica da PC remoto con LINUX

Se sul PC remoto avete Linux avete diverse possibilità, qui ne elenco due.

1) Server VNC

Lato RaspBerry Pi

Installiamo il server VNC sul nostro RaspBerry Pi, per fare ciò, dopo esservi connessi dal PC remoto al vostro RaspBerry, date il comando:

	sudo apt-get install tightvncserver tightvnc-java

Adesso avviate il server usando il comando:

	vncserver :1 -geometry 1200x700 -depth 24

Dopo aver premuto invio vi verrà chiesto di inserire una password, inseritene una a vostro piacimento.
Ovviamente sostituite 1200x700 con la risoluzione del vostro PC remoto.

Per far partire automaticamente il vncserver all'accensione del RaspBerry Pi fate così:

NOTE:

• Date una risoluzione inferiore a quella del vostro PC remoto cosi da avere una finestra in cui non ci siano le sbarre di scorrimento verticale e orizzontale.
• Se spegnendo il vostro RaspBerry Pi e poi riaccendendolo non doveste più riuscire a collegarvi da PC remoto via vncviewer ridate il comando: vncserver :1 -geometry 1200x700 -depth 24
Ovviamente il comando sopra lo date dal PC remoto che deve essere già collegato al vostro RaspBerry Pi.
Vi ricordo che il comando per collegarsi da PC remoto al RaspBerry Pi è:
ssh 192.168.1.3 -l pi
sostituite 192.168.1.3 con l'IP del vostro RaspBerry Pi (nmap)



Lato RaspBerry PC remoto

Sul vostro PC remoto adesso installate vncviewer, aprite un altro terminale e date il comando:

sudo apt-get install vncviewer

Per lanciare vncviewer per collegarvi, con il supporto della grafica, al vostro RaspBerry Pi date il comando

vncviewer 192.168.1.3:1

Ovviamente sostituite 192.168.1.3 con l'indirizzo IP del vostro RaspBerry Pi, vedere qui.

2) ssh

ssh -X 192.167.111.31

al solito 192.167.111.31 è l'indirizzo del vostro RaspBerry Pi.

Adesso se scrivete il nome di un programma che usa la grafica questo verrà eseguito e lo potrete controllare anche dal vostro PC.

Per esempio, per lanciare l'interfaccia grafica di RaspBian, scrivete: startx

-

Grafica da PC remoto con Windows

Se sul PC remoto avete Windows allora vi consiglio questo emulatore di X che è free.

Altra possibilità è usare Xming che è un server X open source.
Questa applicazione non trasferisce l'intero desktop ma unicamente la o le finestre grafiche dei singoli applicativi.

UP

-

Gestione file da PC remoto a RaspBerry Pi usando LINUX

Potrebbe capitare di dove trasferire dei file dal PC remoto al RaspBerry Pi e per fare questa operazione consiglio SecPanel che potete installare attraverso il Software Center.

Da consolle del PC remoto potete usare i comandi sotto riportati.
Leggete queste NOTE che sono riportate alla fine di questo capitolo.

Copiare file da PC remoto a RaspBerry Pi

scp percorsoFileLocale nomeUtenteRemoto@indirizzoIP:PercorsoDestinazioneRemota

esempio:

scp geo.pdf pi@192.168.1.3:~/geo.pdf

Copiare file da RaspBerry Pi a PC remoto

scp pi@192.168.1.3:~/PY/P1.py P1.py

In questo caso (sempre usando il PC remoto collegato al RaspBerry Pi) si prende il file P1.py dalla directory di di RaspBerry Pi /home/pi/PY e lo si copia sul nostro PC

Copiare directory da PC remoto a RaspBerry Pi si deve:

Su RaspBerry Pi si deve creare la directory di destinazione, per esempio si va in una directory esistente, supponiamo:

cd /var/www

Si crea la nuova directory, per esempio:

sudo mkdir phpMyAdmin-4.1.2-all-languages

Si abilitano tutti i permessi/utenti sulla nuova directory usando il comando:

sudo chmod 777 phpMyAdmin-4.1.2-all-languages

Poi dal PC remoto si va dove c'è la directory da copiare e si da il comando:

scp -rpC phpMyAdmin-4.1.2-all-languages pi@192.168.1.3:/var/www/

NOTE:

il ~/ prima del nome del file (geo.pdf) indica la cartella home che nel mio caso è: /home/pi

phpMyAdmin-4.1.2-all-languages questa è la directory che avete sul PC remoto e che volete copiare su RaspBerry Pi. Ovviamente mettete il nome della vostra directory.

pi@192.168.1.3 è l'indirizzo del vostro RaspBerry Pi

/var/www/ è la directory del RaspBerry Pi in cui andremo a copiare i file della directory che abbiamo sul PC remoto (phpMyAdmin-4.1.2-all-languages)

UP

-

Gestione file da PC remoto a RaspBerry Pi usando Windows

Per chi usa sul PC remoto Windows consiglio di usare WinSCP che trovate qui:

http://winscp.net/eng/download.php

-

Collegare una chiavetta WiFi SITECOM N300

Collegarsi al nostro RaspBerry Pi usando il cavo RJ45 è sicuramente molto affidabile ma anche scomodo, sicuramente è più comodo sfruttare un collegamento via chiavetta WiFi.

Per fare ciò si possono usare un'infinità di chiavette WiFi, qui vi è un'elenco delle chiavette compatibili con il nostro RaspBerry Pi.

Io, volendo avere una distanza notevole tra il mio A.P. e il mio RaspBerry Pi, ho scelto una chiavetta WiFi con un'antenna esterna e la scelta è caduta su SITECOM N300.

Questa chiavetta è tra quelle che vengono riconosciute immediatamente da RaspBian, ovvero non è necessario installare driver SW, l'unica cosa che serve fare è configurarla seguendo i passi sotto riportati.

enrico@enrico-MM061:~$ nmap -sP 192.168.1.1-255
Starting Nmap 5.21 ( http://nmap.org ) at 2013-12-28 01:00 CET
Nmap scan report for vodafone.station (192.168.1.1)
Host is up (0.0011s latency).
Nmap scan report for android-9e52b9407176d692.station (192.168.1.2)
Host is up (0.051s latency).
Nmap scan report for android-b1a38c6c82d7340e.station (192.168.1.3)
Host is up (0.032s latency).
Nmap scan report for fritz.repeater.station (192.168.1.4)
Host is up (0.062s latency).
Nmap scan report for enrico-MM061.station (192.168.1.6)
Host is up (0.00038s latency).
Nmap scan report for enricohp.station (192.168.1.7)
Host is up (0.034s latency).
Nmap scan report for rpi1.station (192.168.1.9)
Host is up (0.0099s latency).
Nmap scan report for DCS-930L-DestroCortile.station (192.168.1.10)
Host is up (0.00080s latency).
Nmap scan report for DCS-930L-Pedonale.station (192.168.1.11)
Host is up (0.00075s latency).
Nmap scan report for DCS-930L-SinistroCortile.station (192.168.1.12)
Host is up (0.00075s latency).
Nmap scan report for rpi1.station (192.168.1.14)
Host is up (0.034s latency).
Nmap done: 255 IP addresses (11 hosts up) scanned in 3.40 seconds
enrico@enrico-MM061:~$

enrico@enrico-MM061:~$ nmap -sP 192.168.1.1-255
Starting Nmap 5.21 ( http://nmap.org ) at 2013-12-28 01:22 CET
Nmap scan report for vodafone.station (192.168.1.1)
Host is up (0.0018s latency).
Nmap scan report for android-b1a38c6c82d7340e.station (192.168.1.3)
Host is up (0.012s latency).
Nmap scan report for fritz.repeater.station (192.168.1.4)
Host is up (0.0057s latency).
Nmap scan report for enrico-MM061.station (192.168.1.6)
Host is up (0.00028s latency).
Nmap scan report for enricohp.station (192.168.1.7)
Host is up (0.0030s latency).
Nmap scan report for DCS-930L-DestroCortile.station (192.168.1.10)
Host is up (0.0012s latency).
Nmap scan report for DCS-930L-Pedonale.station (192.168.1.11)
Host is up (0.0011s latency).
Nmap scan report for DCS-930L-SinistroCortile.station (192.168.1.12)
Host is up (0.0012s latency).
Nmap scan report for rpi1.station (192.168.1.14)
Host is up (0.0057s latency).
Nmap done: 255 IP addresses (9 hosts up) scanned in 3.44 seconds
enrico@enrico-MM061:~$

-

Verificare la temperatura della cpu del RaspBerry Pi

Per sapere la temperatura della cpu da terminale date il comando:

vcgencmd measure_temp

UP

---

-

Controllare RaspBerry Pi da Android

Con i telefoni che usano come sistema operativo ANDROID si può controllare da remoto il nostro RaspBerry Pi.

Se andate su:

https://play.google.com/store/apps

e cercate RaspBerry Pi vi compariranno molte applicazioni disponibili per i più diversi campi d'uso.

Alcuni applicativi, i più evoluti, quelli che controllano direttamente i GPIO, richiedono l'installazione di un SW dedicato sul RaspBerry Pi, ma se volete solo sapere se il vostro RaspBerry Pi è funzionante allora vi consiglio RasPi Check che trovate qui:

https://play.google.com/store/apps/details?id=de.eidottermihi.rpicheck

Sotto potete vedere alcuni dei parametri che vi verranno visualizzati.

Questo applicativo permette di effettuare anche lo spegnimento del RaspBerry Pi.

UP

-

Installare un server Apache2 più PHP5 e le relative librerie

Per installare Apache2 usate il comando:

sudo apt-get install apache2

Per installare PHP5 usate il comando:

sudo apt-get install php5

Per installare la libreria di ponte tra Apache2 e PHP5 usate il comando:

sudo apt-get install libapache2-mod-php5

Adesso per poter usare Apache2 come Web Server visibile anche da un computer esterno (rispetto a RaspBerry Pi) serve effettuare la modifica qui sotto spiegata.

Cambiamo directory dando il comando:

cd /etc/apache2/sites-enabled/

Modifichiamo il contenuto del file 000-default usando l'editor nano, date il comando:

sudo nano 000-default

nel file che aprite dovete sostituire None con All, vedere sotto box rosso.

Fatta la modifica salvate il file (Ctrl X).

Adesso serve riavviare Apache2 e per farlo date il comando:

sudo service apache2 restart

Per verificare se tutto è andato a buon fine apriamo il nostro browser (sempre dal PC remoto) e scriviamo l'indirizzo IP della nostra scheda RaspBerry PI.
Se abbiamo fatto tutto correttamente ci deve comparire una pagina simile a questa.

UP

-

Installare il data base MySQL, modulo di connessione con PHP5 e libreria per Python

Per installare MySQL su RaspBerry Pi da terminale remoto scrivete:

sudo apt-get install mysql-server mysql-client

Durante l'installazione ci verrà richiesto di inserire una password per MySQL root user, vedere sotto.
Ricordatevi che l'utente MySQL root si chiamerà root.

Installate le librerie per PHP5 usando il comando sotto riportato.

sudo apt-get install php5-mysql

Adesso installiamo le librerie per Python usando il comando sotto riportato.

sudo apt-get install python-mysqldb

Ripuliamo il sistema dai file non utilizzati usando il comando sotto riportato.

sudo apt-get autoremove

Facciamo ripartire il server MySql usando il comando qui sotto riportato.

sudo service mysql restart

Per verificare se l'installazione è andata a buon fine date il comando:

sudo service mysql status

dovete ottenere una risposta simile a questa sotto riportata.

UP

-

Interfaccia grafica per MySQL

Per amministrare con un'interfaccia grafica MySQL suggerisco di installare anche l'interfaccia grafica phpMyAdmin, seguite le istruzioni sotto riportate.

Dal PC remoto aprite il vostro browser e andate a questo indirizzo:

http://www.phpmyadmin.net/home_page/index.php

Poi premete sul tasto di download.

Una volta scaricato scompattatelo e dovreste avere qualche cosa di simile a quello riportato qui sotto.

Prendete la directory: phpMyAdmin-4.1.2-all-languages
e copiatela su RaspBerry Pi nella cartella: /var/www
per fare la copia usate i comandi sotto elencati.

Da PC remoto collegatevi al RaspBerry Pi e andate nella directory:

cd /var/www (directory di RaspBerry Pi)

Create la directory di destinazione:

sudo mkdir phpMyAdmin-4.1.2-all-languages

Date tutti i permessi alla directory appena creata:

sudo chmod 777 phpMyAdmin-4.1.2-all-languages

Da una shell del PC remoto si va dove c'è la directory da copiare dal PC remoto al RaspBerry Pi e si da il comando:

scp -rpC phpMyAdmin-4.1.2-all-languages pi@192.168.1.3:/var/www/

Per ulteriori informazioni su scp leggete qui.

Rinominate la directory in phpmyadmin, usate i comandi sotto:

sudo su

mv phpMyAdmin-4.1.2-all-languages phpmyadmin

Per verificare se avete fatto tutto correttamente aprite sul PC remoto il vostro browser e date l'indirizzo del vostro RaspBerry Pi e /phpmyadmin ovvero scrivete:

192.168.1.3/phpmyadmin/

Dovete vedere un'immagine simile a quella qui sotto riportata.

Adesso inserite il nome utente (di MySQL) che avete scelto come root (di solito root) e poi la password che avete impostato quando avete installato, vedere qui.

Dopo qualche secondo dovete ottenere l'immagine sotto riportata.

Bene, tutto funziona perfettamente.
Per uscire da questa interfaccia grafica cliccate sull'icona sotto evidenziata.

-

PYTHON

A chi si chiede perchè usare Python come linguaggio di programmazione le mie risposte sono:

• linguaggio relativamente facile da apprendere

• multipiattaforma

• esistono moltissime librerie dedicate ai ctrl industriali

L'alternativa che potevo immaginare è il C ma è sicuramente più difficile da imparare.
Python è un linguaggio interpretato.

UP

-

Versioni di Python

Ad oggi esistono due versioni di Python che sono la 2.x.x e la 3.x.x
Le differenze tra le due versioni le trovate qui:
http://www.cs.carleton.edu/faculty/jgoldfea/cs201/spring11/Python2vs3.pdf
http://okpanico.wordpress.com/2011/09/12/python-differenze-fra-le-versioni-2-e-3/

Le librerie standard di Python le trovate qui:

• http://docs.python.org/2/library/

• http://docs.python.org/3/library/

In questo manuale si è usata la versione 2.7.3 di Python.

Per verificare se su RaspByan Pi è installato Python e sapere che versione è installata, usate il comando:

python -V

la risposta che dovrete ottenere sarà simile a questa qui sotto riportata.

Se scrivete semplicemente Python entrate nell'interprete di comandi in cui potete provare direttamente i comandi, la sintassi, ecc di Python.

Per uscire scrivete exit()

Molto utile è installare l'utility pip che permette di gestire le librerie di Python.
Per installare pip scrivete:

sudo apt-get install python-pip

Fondamentalmente la struttura dei programmi si realizza semplicemente identando (allineando a destra con il TAB) le istruzioni che scrivete.
Non è più necessario dichiarare le variabili prima di usarle.
I tipi dati sono assegnati automaticamente a secondo dei contenuti e delle forme usate durante le assegnazioni.
Il linguaggio ha solo 34 parole riservate che sono qui sotto elencate.

Gestione Errori
try, except, finaly, raise, assert, with

Varie
print, pass, del

Condizionali
if, else, elif, not, or, and, is, True, False, None

Loop
for, in, while, as, continue

Classi – Moduli – Funzioni
class, def, global, lambda, nonlocal, yield, import, return, from

Qui sotto trovate alcuni link per approfondire il linguaggio Python.
http://www.emcu.it/Python/Python.html
http://www.python.org/
http://www.tutorialspoint.com/python/index.htm
http://docs.python.org/2/tutorial/datastructures.html
http://www.python.it/doc/
http://docs.python.it/html/tut/tut.html
http://www.sthurlow.com/python/
http://www.learnpython.org/
https://www.youtube.com/watch?v=_iX9CSX09Z8

Per lanciare un programma in Python si scrive:

python nome-file

NOTA:
In un programma reale che sarà un file, la prima riga deve contenere il puntatore all'interprete di comandi Python, su RaspBerry Pi con sistema operativo RaspBian dovrà essere:

#!/user/bin/python

Creiamo un semplice programma di prova che chiamiamo P1.py
Prima di tutto creiamo una nuova cartella per le nostre prove nella directory /home/pi del nostro RaspBerry Pi e la chiamiamo PY.

Per fare ciò dal PC remoto collegato come terminale al RaspBerry Pi scrivete:

cd /home/pi
mkdir PY
cd PY
nano P1.py

Nell'editor nano che vi si sarà aperto scrivete:

#!/user/bin/python

print "Ciao da RaspBerry Pi"

Salvate il file (ctrl + X) e poi scrivete:

python P1

Se avrete fatto tutto correttamente vedrete questo.

-

Ovviamente esistono anche ambienti integrati di sviluppo (IDE) che rendono la vita più facile ai programmatori.

Guardate per esempio qui:
https://wiki.python.org/moin/IntegratedDevelopmentEnvironments

Tutorial in italiano su Python:
https://www.youtube.com/watch?v=_iX9CSX09Z8

UP

-

Libreria GPIO per RaspBerry Pi

Per gestire le varie periferiche del nostro RaspBerry Pi esistono numerose librerie sviluppate per Python e la prima che scaricheremo è quella per la gestione dei GPIO.

Per fare ciò scrivete:

sudo apt-get install python-rpi.gpio

La documentazione la trovate qui:
https://pypi.python.org/pypi/RPi.GPIO
http://code.google.com/p/raspberry-gpio-python/wiki/BasicUsage

UP

-

Librerie varie per Python

Per il linguaggio Python sono state create numerose librerie pronte all'uso per gli ambiti applicativi più diversi che potete trovare qui:

• http://docs.python.org/2/library/

• http://docs.python.org/3/library/

• https://pypi.python.org/pypi?:action=browse&c=533&show=all
  
  

• WiFi library:
  
  • https://pypi.python.org/pypi/python-wifi
    
    
  • https://wifi.readthedocs.org/en/latest/
    For install it use the command: sudo pip install wifi
  
  
• Twitter library: https://github.com/ryanmcgrath/twython
  For install it use the command: sudo pip install twython
  
  
• For drive the Serial COM I suggest:
  
  pySerial
  http://pyserial.sourceforge.net/index.html

UP

-

GPIO usati come USCITE (OutPut)

-

Modifichiamo il programma P1.py (nano P1.py) come riportato sotto per fare “lampeggiare” l'uscita GPIO4.

#!/user/bin/python

import time

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(4, GPIO.OUT)

print "Ciao da RaspBerry Pi"
print "Gestione GPIO4 che lampeggia con frequenza di 2sec"
print "Per fermare questo programma premere ctrl + c"

while True:
    GPIO.output(4, True)
    time.sleep(2)
    GPIO.output(4, False)
    time.sleep(2)

Salvatelo e lanciatelo da super utente ovvero scrivete:

sudo su

e poi

python P1.py

Se collegate un multimetro, configurato per misurare una tensione in continua, sul connettore GPIO tra il pin7 (positivo, GPIO4) e il pin6 (negativo, GND) noterete che la tensione passa da 0 a 3,3V (circa) con intervalli di 2sec (2sec a 0V e 2sec a 3,3V).

Se avete collegato sul vostro RaspBerry Pi la scheda di I/O FT1060M vedrete lampeggiare il led denominato LD5.

Andiamo nei dettagli del programma appena realizzato.

#!/user/bin/python
puntatore all'interprete di comandi Python

import time
inclusione della libreria time di cui useremo il metodo sleep in modo da temporizzare il lampeggio del led.

import RPi.GPIO as GPIO
con la riga sopra importiamo la libreria Rpi.GPIO e gli diamo un nome di riferimento GPIO che verrà usato nel proseguo del programma

GPIO.setmode(GPIO.BCM)
con questa riga impostiamo la numerazione dei pin del GPIO.
Per la numerazione ci sono due modi che sono:

• Riferimento alla numerazione dei pin del connettore GPIO del RaspBerry Pi - GPIO.setmode(GPIO.BOARD)

• Riferimento per BCM che è più a basso livello e si riferisce al Broadcom SOC, è ovvio che servirà una mappa per capire a quale pin del GPIO si fa riferimento. Questo metodo non è sicuramente comodo da usare ma è stato qui riportato per dovere di cronaca.

  Il modo migliore è quello evidenziato nell'esempio P2.py

GPIO.setup(4, GPIO.OUT)
questa istruzione inizializza il GPIO4 e ne imposta la direzione che nel nostro caso è in uscita.
Se avessimo usato la numerazione: GPIO.setmode(GPIO.BOARD)
avremmo scritto: GPIO.setup(7, GPIO.OUT) per accedere al GPIO4

GPIO.output(4, True)
qui diciamo che il pin4 è a 1 o True

GPIO.output(4, False)
qui diciamo che il pin4 è a 0 o False

while True:
con questa riga creiamo un loop infinito della parte di codice che si trova identato dopo di essa.
Da questo programma si esce premendo ctrl + c.

P2.py – Lampeggio led e funzioni di Python

Qui sotto è riportato un programma simile al precedente ma che usa la chiamata a funzioni e la definizione dei GPIO: GPIO.setmode(GPIO.BOARD)

#!/user/bin/python

import RPi.GPIO as GPIO     ## Import GPIO library
import time                 ## Import 'time' library. Allows us to use 'sleep'
GPIO.setmode(GPIO.BOARD)    ## Use board pin numbering
GPIO.setup(7, GPIO.OUT)     ## Setup GPIO Pin 7 to OUT
##Define a function named Blink()
def Blink(numTimes,speed):
    for i in range(0,numTimes):     ## Run loop numTimes
        GPIO.output(7,True)         ## Switch on pin 7
        time.sleep(speed)           ## Wait
        GPIO.output(7,False)        ## Switch off pin 7
        time.sleep(speed)           ## Wait
        print "Done ",              ## When loop is complete, print "Done"
        print i

## Ask user for total number of blinks and length of each blink
iterations = raw_input("Enter total number of times to blink: ")
speed = raw_input("Enter length of each blink(seconds): ")

## Start Blink() function. Convert user input from strings to numeric data types and pass to Blink() as parameters
Blink(int(iterations),float(speed))

GPIO.cleanup() # Released the resources that we are used - GPIO

Per saperne di più sulle funzioni guardate i link qui sotto riportati.
http://www.python.it/doc/Howtothink/Howtothink-html-it/chap03.htm#6
http://www.tutorialspoint.com/python/python_functions.htm

Per scaricare questi esempi andate qui.

-

GPIO usati come INGRESSI (InPut)

Per usare i GPIO come ingressi ci sono diverse possibilità ma vale la pena soffermarci sul fatto che qui stiamo usando un sistema LINUX e quindi dobbiamo per forza usare qualche risorsa del kernel del RaspBian che ci avvisi quando cambia lo stato di un GPIO questo perchè se li leggessimo noi direttamente potremmo perdere la pressione del tasto, i GPIO non hanno un buffer di ingresso.
Per risolvere questo problema si usa la soluzione ad eventi che permette di dichiarare e registrare una sorgente di eventi e poi di ascoltarla in polling delegando ciò al kernel.

Praticamente quasi ogni risorsa può essere usata come sorgente di un evento, si può usare un pin del GPIO, un socket di comunicazione, una pipe, ecc.

Fondamentalmente serve:

• registrare il descrittore del file che rappresenta la sorgente dell'evento (metodo register)

• attivare l'ascolto da parte del kernel con il metodo epoll

Resta un ulteriore problema che è il bouncing (rimbalzo) che si ha quando viene premuto un pulsante che genera una serie di transazioni spurie che possono durare dai 5 ai 30ms (vedere sotto).

La filtratura dell'ingresso su schede come il nostro RaspBerry Pi deve essere risolta via HW usando dei filtri a Pi-Greco accoppiati con dei trigger di Schmitt o meglio ancora usare una mcu piccola che si occupa di filtrare i pulsanti e poi segnalarci il valore letto (vedere qui).

Tutto questo però esula da questo manuale per cui qui useremo una soluzione più grossolana che si basa sul creare un filtro di 1sec di non ascolto del pulsante dopo che se ne è rilevato il cambiato di stato.

Qui sotto vi è l'elenco delle istruzioni base necessarie a creare il processo di polling sopra descritto.

1) import select
…
2) pin_base = '/sys/class/gpio/gpio27/'
…
3) # Creazione file descrittori per GPIO27
pin_base = '/sys/class/gpio/gpio27/'
os.system("echo 27 > /sys/class/gpio/export")

3b) # Impostazione GPIO17 come ingresso
os.system("echo 'in' > /sys/class/gpio/gpio27/direction")

3c) # Impostazione innesco evento su fronte di discesa
os.system("echo 'falling' > /sys/class/gpio/gpio27/edge")

4) f = open(pin_base + 'value', 'r')

5) po = select.epoll()

6) po.register(f, select.POLLPRI)
…
7) events = po.poll(60000)

1. viene importata la libreria select

2. impostiamo il file descrittore del GPIO27. Il file va messo in /sys/class/gpio/

3. da 3 a 3c, vengono creati i descrittori del pin di InPut

4. apriamo in lettura il file descrittore del GPIO27

5. viene creata l'instanza epoll espresso nell'oggetto select

6. registriamo, usando il metodo register, la sorgente dell'evento, cioè il file descrittore del GPIO27

7. questa linea inizializza la richiesta di evento e resta in attesa del verificarsi dell'evento, la pressione del pulsante. 60000 indica che se non viene intercettato nessun evento in un intervallo di 60sec, viene comunque innescato un evento che può essere intercettato dal programma e che serve a evidenziare che il meccanismo è in funzione.

Nella libreria select sono disponibili diverse modalità di gestione dell'evento (vedere immagine qui sotto).

Per maggiori dettagli vedere qui.

Per fare le prove useremo un pulsante collegato al GPIO27 (pin13) del connettore GPIO del nostro RaspBerry Pi, si veda lo schema sotto (per la resistenza va bene qualsiasi valore compreso tra 1 e 10K), oppure la scheda di I/O FT1060M e agiremo su P2.

ATTENZIONE:
la resistenza da un lato va collegata al GPIO27 (pin13) e dall'altro lato va collegata al 3,3V pin1 del connettore GPIO.
Ponete particolare attenzione a questo collegamento in quanto i GPIO sopportano tensioni massime di 3,3V.

Il programma che scriveremo dovrà essere lanciato da super utente (sudo su) perchè andrà ad accedere a directory protette del RaspBerry Pi.

Di seguito è riportato il listato di GPIOInt.py

Il file pronto all'uso lo potete scaricare da qui.

In sistemi complessi basati su sistemi operativi (SO) come Linux usato sul nostro RaspBerry Pi è molto facile che due o più processi cerchino di accedere contemporaneamente alla stessa risorsa.
Nei SO sono state implementati dei meccanismi per segnalare ai vari processi se la periferica è disponibile o è già impegnata.

La stessa cosa può capitare a noi se sviluppiamo programmi complessi su RaspBerry Pi, soprattutto se suddividiamo i nostri programmi in piccoli programmi ognuno dei quali si occupa di una sola cosa e poi un programma che evidenzia i risultati finali delle varie elaborazioni.

Supponiamo di voler realizzare una applicazione che:

1. Legga gli INGRESSI di contatti o pulsanti (per fare ciò sfrutteremo il kernel - eventi e polling)
   

2. Pilotare delle USCITE per esempio dei LED e/o Relè
3. Leggere una NTC interfacciata via I2C (la I2C prima va abilitata nel kernel e poi la si potrà usare)
   
4. Usare un DAC interfacciato sempre via I2C
5. Visualizzare su una pagina accessibile via browser (sfrutteremo Apache) lo stato di quanto fatto sopra

Per sviluppare questa applicazione facciamo ricorso a programmi minimali che si incaricano ognuno di gestire una singola parte (1, 2, 3, 4 e 5).
Questa struttura è molto modulare e quindi poi diventa più semplice gestire (aggiornare) i singoli moduli ma abbiamo un problema di concorrenza perchè abbiamo due programmi che prima o poi cercheranno di usare contemporaneamente la periferica I2C.
Nasce anche la necessità di salvare da qualche parte quanto viene fatto dai programmi 1, 2, 3 e 4 così da tenerne traccia e dare la possibilità al programma 5 di visualizzarne i risultati.

Le soluzioni a questo problema sono diverse, noi abbiamo deciso di usare un data base in particolare MySQL che ci aiuterà a risolvere il problema della concorrenza mettendo in fila i processi che cercano di accedere al data base medesimo.
In pratica sfrutteremo questo meccanismo del data base e prima di accedere alla sorgente I2C andremo a leggerne lo stato nel data base e se è occupata (data base occupato) aspetteremo sino a che si libera.

Useremo il data base medesimo per tenere traccia dello stato degli Ingressi, delle Uscite, del valore del NTC e del valore a cui è stato impostato il DAC.
Sfrutteremo poi un server Apache per pubblicare una pagina HTML/PHP che ci riassume lo stato degli Ingressi il valore della NTC (temperatura in °C) e del DAC.

Presto troverete un'esempio copleto in questa sezione.

-

Abilitare I2C bus su RaspBerry Pi

Nel kernel del RaspBian il I2C bus è disabilitato (è nella blacklisted) perchè questo bus usa i GPIO2 (pin3) e GPIO3 (pin5) e si preferisce dare la priorità ai GPIO.
Per abilitare il I2C bus seguite la procedura sotto elencata.

sudo nano /etc/modprobe.d/raspi-blacklist.conf

Con l'editor nano mettete sotto commento la linea dell'I2C, vedere sotto rettangolo rosso.

Salviamo le modifiche (ctrl + X e poi Y), spegnamo e riaccendiamo il RaspBerry Pi per rendere effettive le modifiche.

Ora serve che il nuovo modulo venga caricato al boot del RaspBerry Pi, vogliamo che diventi parte integrante del kernel di RaspBian.

Per fare ciò date il comando:

sudo nano /etc/modules

e aggiungete in fondo al file la riga:

i2c-dev

Salvate il file (ctrl+X e poi Y).
Per vedere se il modulo è stato caricato usate il comando

lsmod

che vi deve dare una risposta simile a questa sotto riportata, vedere rettangolo rosso.

Già che ci siamo conviene anche caricare l'utility i2c-tools che ci fornisce delle funzioni utilizzabili direttamente da shell.
Per fare ciò seguite le istruzioni qui sotto riportate.
Installiamo il pacchetto.

sudo apt-get install i2c-tools

aggiungiamo il nostro utente pi al gruppo I2C

sudo adduser pi i2c

Spegnamo e riaccendiamo il RaspBerry per attivare le nuove configurazioni.

Per alcune applicazioni in Python, quelle basate sulla scheda FT1060M, dovremo usare una libreria I2C e ce ne sono tante disponibili, noi abbiamo scelto di usare la libreria SMBUS.

Per installare questa libreria dal PC remoto collegato al RaspBerry Pi date il comando:

sudo apt-get install python-smbus

Per usare questa libreria si deve fare attenzione a quale revisione di RaspBerry Pi si sta usando, ovvero nel programma d'esempio di Marco Magagnin, TempLux.py c'è la definizione sotto riportata che va cambiata come evidenziato.

bus = SMBus(1) – se si ha la rev.2
bus = SMBus(0) – se si ha la rev.1

-

Versioni ad oggi disponibili di RaspBerry Pi

Ad oggi esistono due modelli di RaspBerry Pi che sono Modello A e Modello B.

Il Modello A non ha l'interfaccia Ethernet e la RAM è di 256KB.
Il Modello B ha l'interfaccia Ethernet e la versione 1 ha 256KRAM ma oggi viene commercializzata quasi solo la versione 2 che ha 512KRAM.

Tra il Modello B versione 1 e versione 2 vi è anche una differenza sul connettore dei GPIO che ho evidenziato qui sotto.:

Modello B versione 1:      Modello B versione 2:
GPIO pin 3 è GPIO0         GPIO pin 3 è GPIO2
GPIO pin 5 è GPIO1         GPIO pin 5 è GPIO3
GPIO pin.13 è GPIO21       GPIO pin.13 è GPIO27

Per sapere la versione del vostro RaspBerry Pi da shell date il comando:

cat /proc/cpuinfo

vi deve comparire una risposta simile a questa sotto riportata.

Una dettagliata descrizione dei connettori del RaspBerry Pi, compresi anche alcuni non documentati la trovate qui:
http://elinux.org/RPi_Low-level_peripherals#GPIO_hardware_hacking

Qui trovate la mappatura dei GPIO nelle varie versioni del RaspBerry Pi.
http://elinux.org/RPi_BCM2835_GPIOs
http://www.panu.it/raspberry/
http://elinux.org/RPi_HardwareHistory#Board_Revision_History
http://www.mosaic-industries.com/embedded-systems/microcontroller-projects/raspberry-pi/gpio-pin-electrical-specifications#fn__3

Qui sotto c'è la disposizione degli I/O del connettore GPIO del Modello B versione 2.

-

Termistori NTC e formule per linearizzare la risposta

I termistori NTC (Negative Temperature Coefficent) vengono comunemente usati nella misura della temperatura.
http://it.wikipedia.org/wiki/Termistore
http://en.wikipedia.org/wiki/Thermistor

Questi componenti hanno la caratteristica di variare il loro valore resistivo al variare della temperatura, in particolare la sua resistenza decresce con l'aumentare della temperatura.

La variazione del loro valore resistivo non segue linearmente la variazione di temperatura e per questo motivo serve “linearizzarne” la risposta.

Per fare ciò si possono usare delle formule matematiche, vedere sotto, oppure su piccole mcu a 8bit si preferisce usare delle lookup table che richiedono meno risorse computazionali.
http://it.wikipedia.org/wiki/Look-Up_Table
http://en.wikipedia.org/wiki/Look-up_table

Equazione di Steinhart-Hart

Questa è una delle equazioni più precise che arriva ad avere una risoluzione anche di 0,002 °C, approssimazione del terzo ordine.
http://it.wikipedia.org/wiki/Equazione_di_Steinhart-Hart
http://en.wikipedia.org/wiki/Steinhart%E2%80%93Hart_equation
Steinhart-Hart Thermistor Calculator
http://it.wikipedia.org/wiki/Termistore
http://en.wikipedia.org/wiki/Thermistor

La formula è:

T temperatura in kelvin
R resistenza in ohm del termistore al momento della misura
A, B, C e D sono i coefficenti di Steinhart e Hart che variano in base al modello di termistore e al range di temperatura scelto. Di solito questi parametri sono presenti nel datasheet del termistore che si sceglie di usare.

Nel caso in cui sul datasheet del nostro termistore non fossero specificati tutti i parametri che ci servono si può optare per un secondo metodo che si basa sul parametro B del termistore e la cui formula è:

R0 è il valore del termistore alla temperatura T0 che di solito è dato per 25°C.

B è una costante reperibile sul datasheet del NTC.

Per i nostri esperimenti useremo una NTC da 10K e useremo i seguenti valori:

A = 0,00335402
B = 0,000256985
C = 2,62013e-6
D = 6,38309e-8

La formula di Steinhart e Hart non tiene conto degli effetti del fattore di dissipazione K del termistore, ovvero dell'autoriscaldamento.
Il fattore K è a sua volta reperibile sul datasheet del termistore.
Per il nostro termistore abbiamo:

K = 6

Il valore in gradi da togliere al risultato della formula di Steinhart e Hart è:

Td = V*V / K*Rth

Il circuito che tipicamente viene usato per rilevare le variazioni di una NTC è il seguente.

Su questo schema occorre fare alcune considerazioni che sono:

• La tensione di alimentazione (3,3V) deve essere molto stabile per evitare che introduca errori sulla misura che faremo

• La resistenza R deve essere di precisione almeno 1% o migliore

• L'ADC deve avere un riferimento di tensione preciso per evitare che introduca errori sulla misura che faremo

Per le prove che faremo useremo la scheda FT1060M che usa lo schema sopra riportato interfacciando il NTC a una mcu che poi parla in I2C con il nostro RaspBerry Pi.
La mcu sopra menzionata ha un ADC a 8bit di precisione (V=3,3/256)

Il valore di tensione che avremo sarà:

V = (ValADC * Vref) / 256

Dove Vref è 3,3V e ValADC è il valore ritornato dal convertitore ADC che deve essere in decimale

Noi avremo come ritorno questa tensione e per avere il valore della resistenza useremo la formula:

Rth = (R*V) / (Vin-V)

R è la resistenza del circuito visto sopra ed è 15K.
Vin è il riferimento di tensione che è 3,3V.

In pratica, in Python, scriveremo:

R1 = 15000.0 # Resistenza R
R_th0 = 10000.0 # Resistenza riferimento termistore a 25 c
V_IN = 3.3 # Tensione alimentazione partitori tensione
V_REF = 3.3 # Tensione riferimento misura ADC
A = 0.00335402 # Steinhart-Hart Costante A
B = 0.000256985 # Steinhart-Hart Costante B
C = 2.62013e-6 # Steinhart-Hart Costante C
D = 6.38309e-8 # Steinhart-Hart Costante D
K = 6.0 # Fattore dissipazione K 6mV C
pB = 4100,0 # Costante del Parametro B
...
# Dopo aver acquisito il canale del ADC dove è collegata la NTC
# faremo i seguenti calcoli e conversioni
print "NTC - Hex ADC_0 = ",
print hex(raw_val)
# Elimina i primi due caratteri 0x dal valore letto ed eventuale L finale
# Trasforma il risultato in decimale
hex_val = hex(raw_val)[2:].rstrip('L')
dec_val = int(hex_val,16)
print "NTC -Dec ADC_0 = ",
print dec_val

# Trasformazione in tensione del valore letto
V = (dec_val * V_REF) / 256.0 # V = (ValADC * Vref) / 256
print "Volt NTC = ",
print V

# Calcolo della resistenza
R_th = (R1 * V) / (V_IN – V) # Rth = (R*V) / (Vin-V)
print "Resistenza NTC = ",
print R_th

# Calcolo dei gradi Kelvin con la formula di Steinhart-Hart
logR = math.log(R_th / R_th0)
logR2 = logR**2
logR3 = logR**3
Stein = 1.0 / (A + B * logR + C * logR2 + D * logR3)

# Conversione in gradi Celsius e applicazione fattore di dispersione
Celsius = round(Stein - 273.15 - V**2 / (K * R_th),2)
# Stampa del risultato
print "Steinhart - Celsius = ",
print Celsius

# Calcolo dei gradi Kelvin con la formula del parametro B
RRo = (R_th / 10000.0)
logRRo = math.log(RRo)
parB = 1.0 / ((1.0 / 298.15) + (logRRo / pB))

# Conversione in gradi Celsius e applicazione fattore di dispersione
Celsius2 = round(parB - 273.15 - V**2 / (K * R_th),2)

# Stampa del risultato
print "parametro B - Celsius = ",
print Celsius2

Qui sotto c'è il listato completo del programma Temp.py che leggendo una NTC ci dice la Temperatura ambiente

#!/usr/bin/env python

# Temp.py
# By www.emcu.it
# Gen. 2014

# Import librerie
from smbus import SMBus
import math
import time

#bus = SMBus(0) # RaspberryPi modello A
bus = SMBus(1) # RaspberryPi modello B

adc_address1 = 0x4F # Imposta indirizzo 000 ADC su alcuni Rpi è 48
adc_channel1 = 0x40 #
adc_channel2 = 0x41 # Imposta indirizzi canali
adc_channel3 = 0x42 # con risoluzione di 8 bit
adc_channel4 = 0x43 #

R1 = 15000.0 # Resistenza R1
R_th0 = 10000.0 # Resistenza riferimento termistore a 25 c

V_IN = 3.3 # Tensione alimentazione partitori tensione
V_REF = 3.3 # Tensione riferimento misura ADC
A = 0.00335402 # Steinhart-Hart Costante A
B = 0.000256985 # Steinhart-Hart Costante B
C = 2.62013e-6 # Steinhart-Hart Costante C
D = 6.38309e-8 # Steinhart-Hart Costante D
pB = 4100.0 # Costante parametro B
K = 6.0 # Fattore dissipazione K 6mV C

# Inizio elaborazione

# Lettura canale 0 ADC - un byte esadecimale
# La prima istruzione imposta la richiesta di campionamento su ADC 0
# Si eseguono tre letture per evitare 0x80 all'accensione e per la precisone

# incrementale del convertire
bus.write_byte(adc_address1,adc_channel1)
raw_val = bus.read_byte(adc_address1)
raw_val = bus.read_byte(adc_address1)
raw_val = bus.read_byte(adc_address1)

print "NTC - Hex ADC_0 = ",
print hex(raw_val)

# Elimina i primi due caratteri 0x dal valore letto ed eventuale L finale
# Trasforma il risultato in decimale
hex_val = hex(raw_val)[2:].rstrip('L')
dec_val = int(hex_val,16)
print "NTC -Dec ADC_0 = ",
print dec_val

# Trasformazione in tensione del valore letto
V = (dec_val * V_REF) / 256.0
# Stampa del risultato
print "Volt NTC = ",
print V

# Calcolo della resistenza
R_th = (R1 * V) / (V_IN – V)
# Stampa del risultato
print "Resistenza NTC = ",
print R_th

# Calcolo dei gradi Kelvin con la formula di Steinhart-Hart
logR = math.log(R_th / R_th0)
logR2 = logR**2
logR3 = logR**3
Stein = 1.0 / (A + B * logR + C * logR2 + D * logR3)

# Conversione in gradi Celsius e applicazione fattore di dispersione
Celsius = round(Stein - 273.15 - V**2 / (K * R_th),2)
# Stampa del risultato
print "Steinhart - Celsius = ",
print Celsius

# Calcolo dei gradi Kelvin con la formula del parametro B
RRo = (R_th / 10000.0)
logRRo = math.log(RRo)
parB = 1.0 / ((1.0 / 298.15) + (logRRo / pB))

# Conversione in gradi Celsius e applicazione fattore di dispersione
Celsius2 = round(parB - 273.15 - V**2 / (K * R_th),2)
# Stampa del risultato
print "parametro B - Celsius = ",
print Celsius2

Questo programma è disponibile pronto all'uso qui.

UP

---

-
Lanciare dei processi di LINUX in background (sottofondo)

Spesso può nascere la necessità di lanciare dei processi (programmi) in background, per fare ciò ci sono diverse possibilità che di seguito vedremo.

Lanciare un processo da shell (terminale) che ci liberi la linea di comando

Per fare ciò si mette alla fine del comando il carattere & e si da per DUE volte Invio/Enter.

esempio:
sudo python P1.py  &

Il programma (fa lampeggiare un LED) resta in esecuzione in background ma la line di comando del terminale resta disponibile, vedere immagine sotto riportata.



Se però chiudiamo il terminale il processo verrà terminato.
Se vogliamo terminare il processo senza chiudere il terminale dobbiamo usare il comando kill. per vedere i soli processi attivi di PYTHON potete usare il comando ps -ef | grep python

 
Lanciare un processo da shell che ci liberi la linea di comando e che resti attivo anche chiudendo la shell

Per fare ciò dovete lanciare il vostro programma anteponendo il comando nohup, terminarlo con & e si da per DUE volte Invio/Enter.

esempio:
sudo nohup python P1.py >/dev/null &

In questo modo oltre ad avere la linea di comando disponibile non riceviamo sullo schermo i messaggi del programma P1.py (>/dev/null) e se chiudiamo la shell il programma continua a funzionare.

Se abbiamo scritto un programma che in certe ore del giorno deve fare delle misure e memorizzarle e magari ci interessa che per il resto delle ore sia fermo possiamo usare il comando del kernel di LINUX cron.

UP

---

-

Comandi base di LINUX

Qui sotto trovate un sunto dei comandi LINUX più usati.
Nella parte finale ho messo dei riferimenti su internet a elenchi più esaustivi.

• Super Utente
• Controllare il disco
• Modificare le partizioni e/o formattare il disco fisso o le chiavette USB
• Verificare la RAM
• Uso della CPU
• Versione dell'HW che si sta usando
• Elenco dei device USB collegati
  
• Processi attivi
• Albero dei processi
  
• Eliminare i processi attivi
• Elenco dei file e/o directory e dei relativi privilegi
• Modifica dei privilegi
• Copiare file e o directory
  
• Cancellare file e/o directory
• Muovere file
• Schedulatore (Scheduler)
• NANO editor minimale
• Lavorare sui pacchetti SW, installarli, aggiornarli, ecc
• Gestire il WiFi e la rete locale
  
• Conoscere i device collegati al router

su

Questo comando ci permette di entrare nella modalità Super Utente o Root
Dopo aver dato il comando su, ci verrà chiesta la password.
L'indicazione che siamo diventati Super Utenti è il carattere finale della riga del “prompt” che è diventato #

esempio:
root@enrico-MM061:/home/enrico#
Per uscire scrivete exit.

Su alcune distribuzioni Linux sarà necessario scrivere sudo su, per il resto vale quanto scritto sopra.

df -h

Ci dice lo spazio del disco (o SD su sistemi embedded) e quanto ne stiamo usando

free -m

Ci dice la quantità di RAM a disposizione e quanta ne stiamo usando

top

Ci dice quanta CPU stiamo usando e chi la sta usando.
Per uscire ctrl+c

-
ps aux

Ci da l'elenco dei processi attivi e il relativo PID che ci può servire per eliminare un processo che non risponde.
ps -ef | grep python
ci da l'elenco dei processi PYTHON attivi. Qui sotto, nel rettangolo rosso, c'è il numero di processo o Num.PID

Ci permette di eliminare dei processi attivi.
kill <numero-processo (Num.PID)>

Se il processo non lo avete creato voi, per eliminarlo scrivete sudo kill Num.PID
Se il processo non vuole saperne di fermarsi usate il comando sudo kill -9 Num.PID

pstree

Vi evidenzia l'albero dei processi.

cat /proc/cpuinfo

Vi dice la versione del vostro HW

lsusb

Elenca tutti i device USB collegati al vostro PC

ls -l

Visualizza il contenuto della cartella (directory) in cui ci troviamo.

ls -alp

Visualizza il contenuto della cartella (directory) in cui ci troviamo compreso i files nascosti che sono i files che iniziano con . (punto).
Qui sotto c'è un esempio di ciò che viene visualizzato dando il comando ls -l

0123456789 A B       C      D     E           F

drwxrwxr-x 2 enrico enrico 4096   gen 6 2013 CNC

-rw-rw-r-- 1 enrico enrico 307018 set 22 00:07 C:\nppdf32Log\debuglog.txt

Il significato da sinistra a destra è:

0) indica se è un file o una cartella (d)

1...9) indicano i permessi di utilizzo che sono
r lettura
w scrittura
x esecuzione
- permesso non assegnato

Questi permessi sono indicati per:
1,2,3) permessi assegnati al proprietario
4,5,6) permessi assegnati al gruppo al quale appartiene
7,8,9) permessi assegnati a tutti gli utenti

A) indica il numero di collegamenti al componente mentre per le cartelle indica il numero di blocchi extra.
B) nome proprietario del file o della cartella
C) gruppo di appartenenza
D) dimensioni
E) data e ora di creazione o di ultima modifica

chmod a=rwx <nome_file>

Questo comando permette di modificare i permessi su file.
Nell'esempio sopra abbiamo assegnato a tutti (a) tutti i permessi.
a = all
u = proprietario
g = gruppo
o = altri utenti

chmod -R <permesso> <directory>

Questo comando permette di modificare i permessi di una directory e di tutti i files in essa contenuti.
Se vogliamo dare a tutti i permessi scriveremo:
chmod -R 777 <directory>

chown <proprietario o gruppo> <nome_file>

Per cambiare il proprietario o il gruppo di appartenenza

cp <nome_file_sorgente> <nome_file_destinazione>

Copia di file

rm <nome_file>

Cancella il file specificato

mv xyz1 xyz2

Rinomina xyz1 in xyz2

xyz1/2 possono essere file o directory, potrebbe essere necessario prima logarsi come super utente (sudo su).

-
cron

Questo è uno schedulatore (scheduler) che permette di eseguire dei comandi ad orari prefissati o di ripeterli con intervalli prefissati.
Guardate i link qui sotto riportati:

• http://en.wikipedia.org/wiki/Cron
• Spiegazioni in Italiano, vedere qui

nano <nome_file>

Ci permette di modificare il file specificato usando l'editor nano.

sudo apt-get install pacchetto

Con questo comando si installa il pacchetto che viene specificato.
ESEMPIO:
sudo apt-get install gedit
Installa l'editor gedit

sudo apt-get update

Ci permette di aggiornare i pacchetti presenti nel nostro sistema.
Se un pacchetto necessita l'installazione o la rimozione di nuove dipendenze allora il pacchetto non verrà aggiornato dal comando update. Per rendere effettive anche tali modifiche si deve usare upgrade (vedere sotto).

sudo apt-get clean

        Rimuove i files non più usati nel nostro sistema.

sudo apt-get autoremove

        Rimuove i files marchiati come non più usati

Manage your WiFi / Network

ifconfig

iwconfig

cat /proc/net/wireless
watch -n 1 cat /proc/net/wireless

Wavemon WiFi monitor

iwlist wlan0 scan

gparted

Questa è l'utility che permette di lavorare sui dischi del vostro PC (HD, SD card o USB card).
Se sul vostro sistema non è installato, lo potete installare usando il comando:

        sudo apt-get install gparted

Per lanciarlo scrivete:

gparted

Su internet esistono diverse guide su come usare gparted e qui sotto trovate alcuni link.

• http://it.wikipedia.org/wiki/GParted

• http://www.nerio.it/linux/aulataliercio/distro/fedoracore6/AULA-TALIERCIO/guide/howto-gparted.html

• http://www.istitutomajorana.it/index.php?option=com_content&task=view&id=377&Itemid=33

nmap vedere qui.

sensors
Questo non è un comando LINUX ma un'applicazione che si lancia da terminale e ci dice la temperatura della CPU.

Per installarlo scrivete:

sudo apt-get install lm-sensors

dopo averlo installato scrivete:

sensors

Su RaspBerry Pi per sapere la temperatura della cpu vedere qui.

LINK

• http://linux.collectiontricks.it/wiki/Guida_ai_comandi_base_della_shell_in_GNU/Linux

• http://www.mimante.net/doc/comandi.txt

• http://ss64.com/bash/

• http://linuxcommand.org/lc3_learning_the_shell.php