Embed Size (px)
Citation preview
paolo macchi - serena arena
RasPython RaspberryPi+Python
RasPython: Raspberry+Python ISIS Cipriano Facchinetti - Castellanza 2016-2021
Introduzione a RasPython = Raspberry+Python https://tinyurl.com/y896gyyu
Questo testo è pubblicato sotto licenza Creative Commons - Attribuzione - Non commerciale - Condividi allo stesso modo 3.0 Unported - Per le condizioni consulta: http://creativecommons.org/licenses/by-nc-sa/3.0/deed.it . Le utilizzazioni consentite dalla legge sul diritto d'autore e gli altri diritti non sono in alcun modo limitati da quanto sopra.
Il documento è scaricabile da http://moodle.isisfacchinetti.it/mod/data/view.php?d=21&rid=713 per fini esclusivamente didattici e non commerciali Segnalazioni di errori, critiche e consigli sono molto graditi e possono essere inoltrati a [email protected] , oppure lasciando un commento al momento del download, per gli studenti registrati.
Sono grato alla prof. SERENA ARENA con cui ho condiviso il progetto iniziale e senza la quale non avrei mai cominciato. E’ sua la parte relativa alla gestione delle bash. - Paolo Macchi -
ISIS “Cipriano Facchinetti” via Azimonti, 5 - 21053 Castellanza (VA) - http://www.isisfacchinetti.gov.it/ Tel. 0331635718 fax 0331679586
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -1-
RasPython
Convenzioni usate nel testo:
rappresenta una curiosità o un approfondimento
INDICE Raspi : cosa, perché, per chi
Introduzione
L’hardware
Il software
Python
Emulatore e corsi
Download
Note di programmazione in PYTHON
Variabili
LOOP
Funzioni
Sitografia essenziale Python
Python con Raspbian
Modalità di programmazione
Modalità Interattiva di programmazione (interprete Python)
Modalità Python Shell (IDLE)
ESERCIZI
My first program
Test1.py
CLASS
Librerie per WEB
URLLIB
Request
JSON
GPIO-General Purpose Input/Output
OUTPUT
Esercizio O.0. Accensione di un LED
Esercizio O.1 led0.py
Il programma permette di accendere il LED posizionato su GPIO24 (pin fisico 18) . Per prima cosa il programma importa la libreria GPIO (import RPi.GPIO as GPIO) e relativa numerazione dei pin ( GPIO.setmode(GPIO.BCM) - Broadcom SOC channel)
Pin utilizzati: GPIO24 (pin 18) in OUTPUT
Esercizio O.2 led1.py
INPUT
Esercizio I.1 Input button
Esercizio IO.1 Input button / Output LED
Scheda FT1060M
Btnled2.py (realizzata su scheda FT1060M)
GIOCO RIFLESSI PRONTI-(rifle3.py su scheda FT1060M)
Esercitazione 4 PWM - (Output analogico)
Raspbian SHELL
Es.S1 01_LED_Blink.sh
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -2-
es.S2 02_PushButton_OnOff.sh
Es.S3 03_LED-PushButton.sh
LABORATORIO - IOTlab
Gestione remota del Raspberry
Progetti
Semaforo
SIMPHY - CLIENT-SERVER application
APPENDICE 1 - Installazione e gestione remota
Installazione
Configurazione di Raspberry
STEP 1 - Impostazione IP statico
Modalità grafica (consigliata)
CAMBIO NOME
VERIFICA
STEP 2 - Installazione XRDP-Remote Desktop Protocol su Raspberry
STEP 3 - Accesso a Raspberry da “Desktop Remoto” di Windows
Server Web e installazione LAMP
STEP 1 – PREPARAZIONE
STEP 2 – APACHE, il server web
STEP 3 – PHP, il linguaggio di scripting
STEP 4 – MySQL, il database
STEP OPZIONALE – PHPMYADMIN, il gestore di database
FTP
Idee e progetti
RASPBERRY PI LOCATION TRACKER
4G + GPS Shield for Arduino and Raspberry Pi Tutorial (LTE / WCDMA / HSPA+ / 3G / GPRS)
Morse
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -3-
Raspi : cosa, perché, per chi
Introduzione Raspberry Pi (Raspi per gli amici, Pi sta per linguaggio Python) è un “single-board computer” open-source,
basato su un microcontrollore. La scheda, poco più di una carta di credito, è un computer completo a tutti gli effetti, che include, oltre al processore e alla memoria, la scheda video, l’interfaccia di rete e un comodo sistema per interfacciarsi con il mondo esterno. Raspberry può essere collegata al televisore di casa, al monitor o essere inserito in una rete.
Raspberry è stato ideato e realizzato nel Regno Unito dall'omonima fondazione e che comprende diverse versioni che integrano elementi aggiuntivi, quali ad esempio, CPU migliorate, connettività wireless, ma che non stravolgono la struttura del progetto e non intaccano i principi di funzionamento e il costo.
Per cosa viene usato?
● Educazione, Raspberry Pi è tagliato su misura per l'insegnamento della programmazione nelle scuole di ogni ordine e grado (http://www.computingatschool.org.uk/ )
● Domotica. Date le sue dimensioni piuttosto ridotte e le sue specifiche tecniche, Raspberry Pi viene utilizzato spesso e volentieri come controller in un sistema di home automation come ad esempio il controllo della luminosità, sistemi di sicurezza casalinghi
● Server domestico . Utilizzando le adeguate schede di espansione, un Raspberry Pi può essere utilizzato anche come piccolo server personale.
● Media center ● Stazione meteo (https://blog.retep.org/2012/07/30/installing-a-usb-weather-station-on-a-raspberry-pi-part-1/ )
L’hardware Raspberry Pi è un computer implementato su un'unica scheda elettronica che comprende il processore ARM
(http:// www.arm.com/ ), l'acceleratore grafico dalla Broadcom (www.broadcom.com )(GPU,Graphics Processing Unit) e la RAM.
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -4-
Raspberry Pi 4: (https://www.raspberrypi.org/products/raspberry-pi-4-model-b/)
(https://raw.githubusercontent.com/SeeedDocument/Raspberry-Pi-4/master/img/hardware-overview-1400.jpg )
NOTA Per comandare il Raspberry PI da remoto vi è RaspController. L'app per i dispositivi Android è disponibile sul Google
PlayStore: https://play.google.com/store/apps/details?id=it.Ettore.raspcontroller
Il software Raspberry Pi necessita per funzionare di un sistema operativo. Raspberry Pi è stato progettato e realizzato per
far girare distribuzioni Linux ma, attualmente, è possibile disporre di molte risorse tra cui Windows 10 (https://developer.microsoft.com/it-it/windows/iot).
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -5-
Caratteristiche principali di Raspberry Pi 4 (https://www.raspberrypi.org/products/raspberry-pi-4-model-b/specifications/) ● Broadcom BCM2711, Quad core Cortex-A72 (ARM v8) 64-bit SoC @ 1.5GHz ● 1GB, 2GB or 4GB LPDDR4-3200 SDRAM (depending on model) ● 2.4 GHz and 5.0 GHz IEEE 802.11ac wireless, Bluetooth 5.0, BLE ● Gigabit Ethernet ● 2 USB 3.0 ports; 2 USB 2.0 ports. ● Raspberry Pi standard 40 pin GPIO header (fully backwards compatible with previous boards) ● 2 × micro-HDMI ports (up to 4kp60 supported) ● 2-lane MIPI DSI display port ● 2-lane MIPI CSI camera port ● 4-pole stereo audio and composite video port ● H.265 (4kp60 decode), H264 (1080p60 decode, 1080p30 encode) ● OpenGL ES 3.0 graphics ● Micro-SD card slot for loading operating system and data storage ● 5V DC via USB-C connector (minimum 3A*) ● 5V DC via GPIO header (minimum 3A*) ● Power over Ethernet (PoE) enabled (requires separate PoE HAT) ● Operating temperature: 0 – 50 degrees C ambient
( - Per l’architettura ARM si veda il capitolo ARM con Raspberry in questa stessa dispensa )
Raspberry Foundation raccomanda agli utenti l'utilizzo della distribuzione Raspbian (“Raspbian is a free operating system based on Debian, optimised for the Raspberry Pi hardware” https://www.raspberrypi.org/downloads ).
NOTA DEBIAN (https://www.debian.org) “ Un sistema operativo è l'insieme dei programmi di base e altri vari strumenti che permettono al computer di funzionare. Al centro di un sistema operativo c'è il kernel. Il kernel è il programma fondamentale sul computer ed esegue tutte le operazioni di base e permette di eseguire programmi. I sistemi Debian attuali utilizzano il kernel Linux o quello FreeBSD. Linux è un software scritto inizialmente da Linus Torvalds e che è supportato da migliaia di programmatori nel mondo. FreeBSD è un sistema operativo che comprende un kernel e vari applicativi.”
Numerose sono le applicazioni e linguaggi software che si possono usare, tra cui (https://www.raspberrypi.org/documentation/)
● Scratch is a visual programming tool allowing the user to create animations and games with a drag-and-drop interface
● Python is a general purpose programming language that is easy to pick up and also very powerful ● Sonic Pi Write code to make music with Sonic Pi ● Terminal The Linux terminal is a powerful tool for getting around the filesystem and issuing commands ● GPIO: The General Purpose Input/Output pins allow you to control and interact with the real world from
Python, Scratch or other programming environments ● Minecraft interact with the real world through GPIO ● Python Games ● WordPress Set up a web server on your Raspberry Pi and install Wordpress, a content management and
blogging system ● Mathematica is an industry leading computational platform ● Camera Module is capable of taking full HD 1080p photo and video and can be controlled programmatically.
Using a standard USB webcam instead of the Raspberry Pi camera module ● Kodi media centre software ● Sonic per la musica
Per l’installazione la gestione remota del sistema la rete offre numerosissimi spunti a cominciare dal sito ufficiale.
Per comodità si vedano le schede contenute in APPENDICE1
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -6-
Python
Python (http://www.python.it/ ) nasce in Olanda, ideato da Guido van Rossum negli anni ‘90, ed è disponibile sotto GNU. Il nome deriva dalla serie televisiva Monty Python's Flying Circus basata su sketch divertenti.
Python è un linguaggio multipiattaforma per Linux, MAC OS, Windows. Python è un linguaggio potente e, nel contempo, semplice e versatile. Programmare in Python è spesso un piacere ed è particolarmente
indicato, sia per lo sviluppo client/server sia per il web.
● Python è interpretato ● Python è Interattivo: Python prompt interagisce con l’interprete ● Python è Object-Oriented (classi, istanze, metodi, oggetti,..) ● Python è un linguaggio semplice per iniziare ma è usato per un grandissimo numero di applicazioni in Web ● Python consente a Raspberry Pi di collegarsi al mondo esterno con facilità tramite una una libreria,
chiamata RPi.GPIO, che permette di comandare le uscite e leggere gli ingressi.
NOTA The core philosophy of the language is summarized by the document The Zen of Python: • Beautiful is better than ugly
• Explicit is better than implicit
• Simple is better than complex
• Complex is better than complicated
• Readability counts
NB La versione a cui ci si riferisce è Python3. D’ora in avanti è sottointeso.
(Per le differenze con Python2 cfr. https://www.raspberrypi.org/documentation/usage/python/more.md ).
In questo contesto (https://www.raspberrypi.org/documentation/usage/python/) offriremo solo alcuni cenni di programmazione (vedi nota sotto) e, almeno in un primo momento, ci serviremo massicciamente delle note e dell’emulatore
ESEMPIO
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -7-
(https://developers.google.com/blockly https://blockly-demo.appspot.com/static/demos/code/index.html?lang=en#e9oov4 traduce da Blockly a… Python, JavaScript, PHP ecc: https://blockly-demo.appspot.com/static/demos/code/index.htm l :
esecuzione su Windows10 Python3
1. Costruire il file aa1.py con notepad++:
#!/usr/bin/python3
aa = 123
print(['#ff0000', '#009900', '#330099'])
for count in range(10):
aa = aa + 1
print(aa)
2. lanciare la shell di Python3 (https://www.python.org/downloads/ )
3. Run
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -8-
Note di programmazione in PYTHON Gli esempi, sotto mostrati, racchiudono gli elementi basilari della programmazione in Python anche se non ha alcuna pretesa di insegnare il linguaggio. Il file test1.py contiene semplici esempi relativi a: (variabili, funzioni, cicli , condizioni di scelta, stringhe, input, conversioni di stringhe in int e float
NB Se si fanno delle prove basandosi su programmi prese in rete, attenzione alla differenza di sintassi che può esserci tra Python3 e 2, soprattutto per quanto riguarda le funzioni print e input. Si faccia attenzione anche la fatto che Python, al posto delle parentesi, utilizza un sistema di indentazione (4 spazi) per delimitare i blocchi nidificati di programma.
BLOCKLY https://developers.google.com/blockly
traduce da Blockly a … Python, JavaScript, PHP ecc: https://blockly-demo.appspot.com/static/demos/code/index.html :
https://blockly-demo.appspot.com/static/demos/code/index.html?lang=en#e9oov4
Download Emulatore e Corsi
Consigliato: https://www.w3schools.com/python/
Si veda anche
● On line tutorial : https://docs.python.org/3.6/tutorial/index.html
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -9-
● https://www.tutorialspoint.com/python3/ , segnatamente: https://www.tutorialspoint.com/execute_python3_online.php
● il corso per principianti http://www.python.it/doc/newbie/ e www.programmareinpython.it Utile è anche http://anh.cs.luc.edu/python/hands-on/3.1/handsonHtml/index.html che mostra anche un capitolo dedicato alla creazione di pagine Web e CGI
Download
Interprete per Python3 : py.exe : https://www.python.it/download/
● Per richiamare py.exe in ambiente Windows:
●● Per mandare in esecuzione un file da CMD:
○ C:\aaa>py.exe py0.py Oppure:
○ C:\aaa>py py0.py
Variabili
Non c’è una dichiarazione esplicita. “Una variabile è un contenitore al quale viene associata un'etichetta (il nome) che può essere associata a diversi contenitori anche di tipo diverso durante il suo tempo di vita. Tutte le variabili sono in realtà puntatori ad oggetto (reference). Per esempio a una variabile alla quale è stato assegnato un valore di tipo intero, subito dopo può essere assegnata una stringa o una lista. Gli oggetti sono invece dotati di tipo.
Python mette a disposizione un gran numero di tipi base, essenzialmente tipi numerici e contenitori: interi, floating point, stringhe, anche a tipi più evoluti quali interi a grandezza arbitraria, numeri complessi, liste, insiemi, dizionari. Molti altri tipi sono importabili da librerie standard, e nuovi tipi possono essere creati attraverso le classi.
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -10-
#!/usr/bin/python3 counter = 100 # An integer assignment miles = 1000.0 # A floating point name = "John" # A string print counter print miles print name
NOTA
Camel Case
myVariableName = "John"
Pascal Case
MyVariableName = "John"
Snake Case
my_variable_name = "John"
=====================================================
If … else if expression:
statement(s) else: statement(s)
-------------------------------------------------- -------------------------
#!/usr/bin/python3
var1 = 0 #var1=0
if var1:
print ("TRUE")
print (var1)
else:
print ("FALSE")
print (var1)
x = int(input("Please enter an integer: "))
if x < 0:
x = 0
print('Negative')
elif x == 0:
print('Zero - Positive')
elif x == 1:
print('1-Positive')
else:
print('>1- Positive')
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -11-
input("Press Enter to continue...")
=====================================================
LOOP
While
while expression: statement(s)
---------------------------------------------------------------
#!/usr/bin/python3 count = 0 while (count < 9): print ('The count is:', count) count = count + 1 print ("Good bye!")
-------------------------------------------------------------------------------
FOR
for iterating_var in sequence: statements(s)
Esempio:
for i in range(5):
print(i)
--------------------------------------------
words = ['cat', 'window', 'defenestrate']
for w in words:
print(w, len(w))
--------------------------------------------
for letter in 'Python': # First Example
print ('Current Letter :', letter)
fruits = ['banana', 'apple', 'mango']
for fruit in fruits: # Second Example
print ('Current fruit :', fruit)
=====================================================
Funzioni (def)
#!/usr/bin/python3
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -12-
# Function definition is here
def printme( str ):
"This prints a passed string into this function"
print (str);
return;
# Now you can call printme function
printme("I'm first call to user defined function!");
printme("Again second call to the same function");
----------------------------------
NB Tutti i parametri (argomenti) sono passati by reference con la conseguenza che il valore delle variabili è cambiato.. Ad esempio
# Function definition is here
def changeme( mylist ):
"This changes a passed list into this function"
print ("Values inside the function before change: ", mylist)
mylist[2]=50
print ("Values inside the function after change: ", mylist)
return
# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)
Ma…
#attenzione alle dichiarazioni locali
#!/usr/bin/python3
# Function definition is here
def changemel( mylist ):
"This changes a passed list into this function"
mylist = [1,2,3,4] # This would assi new reference in mylist
print ("l-Values inside the function: ", mylist)
return
# Now you can call changeme function
mylist = [10,20,30]
changemel( mylist )
print ("l-Values outside the function: ", mylist)
------------------------------------------------ PYt2.py completo
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -13-
#!/usr/bin/python3
var1 = 0 #var1=0
if var1:
print ("TRUE")
print (var1)
else:
print ("FALSE")
print (var1)
x = int(input("Please enter an integer: "))
if x < 0:
x = 0
print('Negative')
elif x == 0:
print('Zero - Positive')
elif x == 1:
print('1-Positive')
else:
print('>1- Positive')
count = 0
while (count < 9):
print ('The count is:', count)
count = count + 1
print ("Good bye!")
for i in range(5):
print(i)
words = ['cat', 'window', 'defenestrate']
for w in words:
print(w, len(w))
for letter in 'Python': # First Example
print ('Current Letter :', letter)
fruits = ['banana', 'apple', 'mango']
for fruit in fruits: # Second Example
print ('Current fruit :', fruit)
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -14-
# Function definition is here
def printme( str ):
"This prints a passed string into this function"
print (str);
return;
# Now you can call printme function
printme("I'm first call to user defined function!");
printme("Again second call to the same function");
#!/usr/bin/python3
# Funzione con passaggio dei parametry by reference
# !/usr/bin/python3
# Function definition is here
def changeme( mylist ):
"This changes a passed list into this function"
print ("Values inside the function before change: ", mylist)
mylist[2]=50
print ("Values inside the function after change: ", mylist)
return
# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)
#attenzione alle dichiarazioni locali
#!/usr/bin/python3
# Function definition is here
def changemel( mylist ):
"This changes a passed list into this function"
mylist = [1,2,3,4] # This would assi new reference in mylist
print ("l-Values inside the function: ", mylist)
return
# Now you can call changeme function
mylist = [10,20,30]
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -15-
changemel( mylist )
print ("l-Values outside the function: ", mylist)
#============================================================
input("Press Enter to continue...")
print(test)
========================================================================
Sitografia essenziale Python
On line tutorial : https://docs.python.org/3.6/tutorial/index.html
https://www.tutorialspoint.com/python3/ , segnatamente: https://www.tutorialspoint.com/execute_python3_online.php
corso per principianti http://www.python.it/doc/newbie/ e www.programmareinpython.it
Utile è anche http://anh.cs.luc.edu/python/hands-on/3.1/handsonHtml/index.html che mostra anche un capitolo dedicato alla creazione di pagine Web e CGI
http://www.thirdeyevis.com/pi-page-2.php
Intreprete py.exe (python3) : https://www.python.it/download/
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -16-
Python con Raspbian
Modalità di programmazione (cfr. https://www.raspberrypi.org/documentation/usage/python/ )
In Raspbian ci sono vari modi di lanciare Python:
● Modalità Interattiva di programmazione con terminale ● Modalità Python Shell ● -> Modalità di programmazione Script con la creazione di un file con estensione .py
-------- NOTA -------Desktop
Remoto-----------------------------------------------------------------------------------------------------------
Per accedere direttamente a Raspberry da “Desktop Remoto” di Windows utilizzare l’applicazione “Desktop Remoto” di Microsoft . Si veda il paragrafo “Step 1 - Accesso a Raspberry da “Desktop Remoto” di Windows”
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Modalità Interattiva di programmazione (interprete Python)
In terminal, invocare l'interprete senza passare un file di script come parametro.
L’interprete Python (python3) permette l’esecuzione dei programmi, appare uno specifico prompt, caratterizzato da 3 caratteri di maggiore (>>>) fig p2. Ogni volta che viene invocato il comando python il codice scritto viene trasformato in bytecode (file .pyc o .pyo) eseguiti da un interprete bytecode che è una macchina virtuale Python(PVM).
Fig p2- l’interprete Python3
Modalità Python Shell (IDLE)
Raspbian include un IDE - Integrated Development Environment - chiamato IDLE:
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -17-
https://www.cs.uky.edu/~keen/help/python-tutorial/Lab0.html
Per creare un file Python in IDLE fare clic su File > New Window e verrà dato una finestra vuota che, si tratta di un file vuoto
, non un prompt di Python!
Si scrive un file Python in questa finestra :
n = 0
for i in range(1, 10):
n += i
print("La somma dei numeri da 1 a .. è:")
print(n)
----------------------------------------------------------------
Quindi salvare il file ( File> Save o Ctrl + S , si salva ad esempio in /home/pi/Desktop il file hello.py) e, quindi si esegue (
Run > Run Module, F5) e si vedrà l l'output nella finestra di Python Shell.
-> Modalità di programmazione Script, con la creazione di un file con estensione .py
● In terminal, invocare l'interprete con un parametro di script fa iniziare l'esecuzione dello script che continua fino a quando lo script è terminato. I file Python hanno estensione .py.
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -18-
Aprire un editor di testo (ad esempio l’editor “nano”) e creare il file “hello.py” , quindi effettuare il lancio del programma con l’interprete Python3 come mostrato in figura p4.
● Più semplicemente possiamo premettere nel programma la linea di shebang “#!/usr/bin/python3”. Questa linea di programma (Il termine deriva forse dalla contrazione di SHArp bang e haSH bang, che indica la sequenza di caratteri #!) definisce, in questo caso, la cartella dove si trova l'interprete di python3: “/usr/bin/”. Per eseguire il programma, al posto di digitare “python3 hello.py”, è sufficiente renderlo eseguibile ( Il
comando “chmod +x hello.py” rende eseguibile (+x) il programma hello-py) e digitare semplicemente ./hello.py (fig. p4).
Fig.p4 - Visualizzazione (cat) e lancio del programma con l’interprete Python3. La chiamata del programma (./hello.py) e il file hello.py con la
linea di shebang: “#!/usr/bin/python3”
-------------------------------------------------------------------- Nota Bene
> il prefisso sudo (superutente) non è obbligatorio per lanciare un programma ma, quando si accede a GPIO, potrebbero essere necessarie le autorizzazioni di superutente altrimenti si genera un errore, perciò occorre chiamare il file da eseguire premettendo sudo (fig p5)
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -19-
Fig.p5 -Il file btnled1.py con GPIO va chiamato premettendo “sudo”
----------------------------------------------------------------------------------------------------------------------------------------------
NOTA Per rendere più comoda l’esecuzione è possibile costruirsi una shell (simile a quella mostrata in fig.p5, di nome
“py”) , renderla eseguibile e lanciarla passando come parametro ($1) il nome del file senza estensione alcuna (fig.p5).
Fig p5- la shell py con la chiamata per far girare il programma hello.py
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -20-
ESERCIZI
My first program #my first Python program
username = input("Hello, I'm Raspberry Pi! What is your name? ")
print ('Nice to meet you, ' + username + ' have a nice day!')
----------------------------------------------------------------------------------------------------------------
#!/usr/bin/python3
# Fibonacci numbers module
def fib(n): # return Fibonacci series up to n
result = []
a, b = 0, 1
while b < n:
result.append(b)
a, b = b, a+b
return result
if __name__ == "__main__":
f=fib(100)
print(f)
-------------------------------------------------------------
oppure
f=fib(100)
print(f)
-----------------------------------
Test1.py
#!/usr/bin/python3
#definizione di funzione
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -21-
def poesia():
print("C'era una volta un re che disse alla sua serva: - Raccontami una storia- e la storia cominciò: C'era...")
#stringa
stringa = "ciao"
print (stringa)
var=1
var=var+1
print (var)
#input string
stringa =input("inserisci una stringa: ")
print ("stringa:", stringa)
#if-else
if stringa == "ciao":
print ("la stringa letta è: ", stringa)
else:
print ("stringa non valida")
#conversione da stringa ad int
dato = int(input ("inserisci un numero intero: "))
dato = dato+2
if dato == 3:
print ("il valore intero desiderato è:", dato)
else:
print ("il valore intero è:",dato)
#conversione da stringa ad float
temperatura = float(input(“Inserisci la temperatura di oggi? “)) if temperatura > 25: print(“Metti la maglietta”) else: print(“Metti la camicia”)
#while
print ("\nwhile")
i=1
while i <= 5:
print ("il valore è: ",i, "--",stringa)
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -22-
i=i+1
#for
print ("\nfor")
studenti = ["Andrea", "Carla", "Federica", "Zoe"]
for studente in studenti:
print ("Promosso:", studente)
#elemento array
print ("\neleemnto array")
parola="albero"
for i in range (6): #range genera 6 valori
lettera = parola[i]
print ("elemento:",i, "lettera:",lettera)
#chiamata a funzione
print("raccontami la storia del mago...")
poesia()
------------------------------------------------------------------------------------------------------------------------------------------------------------
CLASS #!/usr/bin/python3
class Employee:
'Common base class for all employees'
empCount = 0
def __init__(self, name, salary,age):
self.name = name
self.salary = salary
self.age= age
Employee.empCount += 1
def displayCount(self):
print ("Total Employee %d" % Employee.empCount)
def displayEmployee(self):
print ("Name : ", self.name, ", Salary: ", self.salary , "Age: ", self.age)
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -23-
#This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
#This would create second object of Employee class"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print ("Total Employee %d" % Employee.empCount)
Librerie per WEB
URLLIB
(https://www.guru99.com/python-tutorials.html) urllib is a Python module that can be used for opening URLs. It
defines functions and classes to help in URL actions.
#
# read the data from the URL and print it
#
import urllib.request
# open a connection to a URL using urllib
webUrl = urllib.request.urlopen('https://www.youtube.com/user/guru99com')
#get the result code and print it
print ("result code: " + str(webUrl.getcode()))
# read the data from the URL and print it
data = webUrl.read()
print (data)
------
Request
http://zetcode.com/web/pythonrequests/ Requests is a simple and elegant Python HTTP library. It provides methods for accessing Web resources via HTTP. Requests is a built-in Python module.
NB Prima di cominciare caricare la libreria
sudo apt-get update
sudo apt-get install python3-requests
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -24-
#!/usr/bin/python3
import requests as req
resp = req.get("http://www.something.com")
print(resp.status_code)
resp = req.get("http://www.something.com/news/")
print(resp.status_code)
---------------------------------------------
Prova con httpbin.org is a freely available HTTP Request & Response Service. #!/usr/bin/python3
import requests as req
payload = {'name': 'Peter', 'age': 23}
resp = req.get("http://httpbin.org/get", params=payload)
print(resp.url)
print(resp.text)
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -25-
JSON
ws4.py
#!/usr/bin/python3
import requests
import json
#https://www.pythonforbeginners.com/requests/using-requests-in-python
r = requests.get('https://github.com/timeline.json')
print ("r.text", r.text)
print ("r.status", r.status_code)
# The Requests library also comes with a built-in JSON decoder,
# just in case you have to deal with JSON data
r = requests.get('https://github.com/timeline.json')
print ("r.jadon1", r.json)
url = 'https://api.github.com/some/endpoint'
payload = {'some': 'data'}
headers = {'content-type': 'application/json'}
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -26-
r = requests.post(url, data=json.dumps(payload), headers=headers)
github_url = "https://api.github.com/user/repos"
data = json.dumps({'name':'test', 'description':'some test repo'})
r = requests.post(github_url, data, auth=('user', '*****'))
print ("r.jsonPOST", r.json)
GPIO-General Purpose Input/Output
Raspberry Pi possiede un’ interfaccia GPIO, di 40 pin, che mette in comunicazione il processore con il mondo esterno. I pin sono raccolti in un pettine presente a lato della scheda (FIG. p7) per facilitare il collegamento con le periferiche di IN/OUT.
Questa interfaccia è una delle caratteristiche rilevanti di Raspberry: ogni pin può essere programmato per inviare o ricevere
segnali digitali (0V-3.3 V) ed è utile per la lettura di sensori, o per comandare attuatori.
Alcuni pin possono essere utilizzati per comunicazioni seriali asincrone e sincrone.
Esistono due modi per identificare i pin.
● Pin fisico - Nel primo caso viene identificato il numero del pin fisico del connettore: il pin 1 è il primo in alto a sinistra, il pin numero 2 corrisponde a quello alla sua destra. Questo vale anche per il pin 3 e 4 della seconda riga, e per tutti i pin successivi.
● Numerazione logica - Il secondo modo, identifica i pin con una numerazione logica: ad esempio il pin GPIO2 corrisponde al pin fisico 3, mentre il GPIO4 corrisponde al pin 7 . Questa seconda modalità (che noi
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -27-
utilizzeremo di preferenza!) permette di sfruttare la libreria (RPi.GPIO) in modo da facilitare la programmazione dei pin di interfaccia (NOTA Ad esempio GPIO24 -> pin fisico 18) . ).
Ogni programma conterrà:
○ le istruzioni per l’importazione della libreria ○ il settaggio dei pin per la loro scrittura o lettura (tab T1).
Tab. T1- In programmazione va importata la libreria RPi.GPIO e attivato il pin numbering, prima di poter usare le istruzioni di input e
output. Quindi TUTTI i programmi dovranno contenere queste istruzioni
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -28-
Import libreria Pi.GPIO Settaggio pin IN/OUT (esempio)
Due modalità:
● import RPi.GPIO as GPIO ## Numerazione logica- Importa GPIO library
● GPIO.setmode(GPIO.BCM) ##Usa numerazone GPIO
● IN ( ## Setup GPIO12 IN e lettura (.input))
GPIO.setup(12, GPIO.IN, pull_up_down=GPIO.PUD_UP)
input_state = GPIO.input(12)
● OUT (## Setup GPIO24 OUT e scrittura (.output))
GPIO.setup(24,GPIO.OUT) ## Set GPIO24 OUT
GPIO.output(24,1) ## Set GPIO24 ON/HIGH/True
Esempio
import RPi.GPIO as GPIO ## Importa libreria GPIO
GPIO.setmode(GPIO.BCM) ## Usa la numerazione GPIO
GPIO.setup(24,GPIO.OUT) ## GPIO24 in OUT
GPIO.output(24,1) ## GPIO24 settato ad 1, ON
fig. P7 l’interfaccia GPIO (cfr. Raspberry Pi Foundation: http:// pi.gadgetoid.com/ pinout/ pin1_3v3_power )- I pin sono sistemati su un pettine di due colonne per 20 righe. Il pin fisico presente sulla prima riga nella colonna più interna corrisponde al numero 1. (https://bloggerbrothers.files.wordpress.com/2017/01/rp2_pinout.png?w=663 cfr. https://drive.doublerobotics.com/ )
Tab. TP - Tabella dei Pin
-----------------------NOTA Trasmissioni seriali sincrone e asincrone con Raspberry
● UART = Universal Asynchronous Receiver Transmitter, a popular serial communication interface which provides full duplex communication between two devices. The term universal means that transmission speed and data format are configurable. As it is asynchronous it doesn’t need to send clock signal along with the data signals. UART uses two data lines for sending (Tx) and receiving (Rx) data. The ground of both devices should be made common.
● SPI = Serial Peripheral Interface is a synchronous serial communication interface specification used for short distance communication. It’s a “synchronous” data bus, which means that it uses separate lines for data and a “clock” that keeps both sides in perfect sync (https://learn.sparkfun.com/tutorials/serial-peripheral-interface-spi ).
● I2C= Inter-integrated Circuit (I2C) Protocol is a protocol intended to allow multiple “slave” digital integrated circuits (“chips”) to communicate with one or more “master” chips. Like the Serial Peripheral Interface (SPI), it is only intended for short distance communications within a single device. Like Asynchronous Serial Interfaces (such as RS-232 or UARTs), it only requires two signal
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -29-
PIN fisici -> Significato
● 1 e 17 -> Alimentazione 3,3V (PWR, Power) ● 2 e 4 -> Alimentazione 5v (PWR, Power) ● 6, 9, 14, 20, 25, 30, 34 e 39 -> Messa a terra (GND, Ground) ● 3, 5, 7, 8, 10, 11, 12, 13, 15, 16, 18, 19, 21, 22, 23, 24, 26, 27, 28, 29, 31, 32, 33, 35, 36, 37, 38 e 40 -> BCM-Broadcom SOC
channel, Pin GPIO (NB Non alimentare i pin BCM con tensioni superiori ai 3.3v!) ● Nota: GPIO 8 e 10 possono essere usati, rispettivamente, come fili di TX e RX per la trasmissione seriale asincrona; altri pin GPIO
possono essere usati per trasmissioni seriali sincrone (SPI, I2C)
wires to exchange information. I2C is a useful bus that allows data exchange between microcontrollers and peripherals with a minimum of wiring (https://learn.sparkfun.com/tutorials/i2c ). Questa interfaccia permette di collegare numerosi circuiti integrati adatti ad interagire col mondo reale: misurare temperature o tensioni, gestire led, LCD e pulsanti, generare tensioni. Usare la libreria wiringPi ( http://wiringpi.com/ ) per interfacciarsi a questi bus.
---------------- fine nota -------------------------------------------------------------------------------------------
OUTPUT La prima prova consiste nel pilotare un output digitale.
NOTA Doc per I/O con Raspberry
http://www.thirdeyevis.com/pi-page-2.php https://www.raspberrypi.org/documentation/usage/gpio/
Anche : http://www.thirdeyevis.com/pi-page-2.php led
http://razzpisampler.oreilly.com/ch07.html button ---> capitoli vari su button motor etc
Esercizio O.0. Accensione di un LED
iniziamo a provare se il nostro LED si accende usando lo schema sottostante che collega il pin di alimentazione a 3,3 V a quello di massa.
Calcolo resistenza per diodo LED
Per alimentare un LED é necessario limitare la corrente di alimentazione. Il limitatore di corrente più semplice é composto da una resistenza.
fig. l1 il led (Light Emitting Diode) è un diodo a semiconduttore che, attraversato dalla corrente, emette luce. Ce ne sono diversi tipi, di
colori diversi.
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -30-
Con la legge degli Ohm: R = (Vcc - Vd) / I
ove: R e' la resistenza , Vcc e' la tensione in continua dell'alimentatore , Vd e' la caduta di tensione del Led e I è la corrente che si vuole far transitare nel Led . Tutte le porte GPIO di Raspberry hanno una tensione di 3.3V. La corrente massima raccomandata per Raspberry, NON dovrebbe mai superare i 16 mA.
Es: Diodo rosso alimentato con alimentazione in CC di 3.3V e corrente di 10mA: R = (3,3V -1,8V) / 10x10^-3 A = 150 Ohm .
(cfr http://www.muzique.com/schem/led.htm per un calcolo automatico)
NOTA a lato
Per la realizzazione dei prototipi ci serviremo di una breadboard (basetta) . Nella figura sottostante viene mostrata la basetta con un esempio di circuiteria ei collegamenti elettrici di una basetta:
Le linee di alimentazione, che sono generalmente poste ai lati e collegate lungo tutto l'asse, e le linee dedicate ai componenti, collegate in posizione perpendicolare alle linee d'alimentazione e più corte
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -31-
Esercizio O.1 led0.py
Il programma permette di accendere il LED posizionato su GPIO24 (pin fisico 18) . Per prima cosa il programma importa la libreria GPIO (import RPi.GPIO as GPIO) e relativa numerazione dei pin ( GPIO.setmode(GPIO.BCM) - Broadcom SOC channel)
Pin utilizzati: GPIO24 (pin 18) in OUTPUT
http://raspi.tv/2013/rpi-gpio-basics-5-setting-up-and-using-outputs-with-rpi-gpio
import RPi.GPIO as GPIO ## Importa libreria GPIO
GPIO.setmode(GPIO.BCM) ## Usa la numerazione GPIO
GPIO.setup(24,GPIO.OUT) ## GPIO24 in OUT
GPIO.output(24,1) ## GPIO24 settato ad 1, ON
Esercizio O.2 led1.py
Il programma permette di accendere e spegnere il LED con un certo ritardo . IL LED è posizionato su GPIO24 (pin fisico 18) . Per prima cosa il programma importa la libreria GPIO (import RPi.GPIO as GPIO) e relativa numerazione dei pin (
GPIO.setmode(GPIO.BCM) - Broadcom SOC channel) , insieme alla funzione sleep
Pin utilizzati: GPIO24 (pin 18) in OUTPUT
-----------------------------------
import RPi.GPIO as GPIO
from time import sleep
GPIO.setmode(GPIO.BCM) ## Use numbering of GPIOx
GPIO.setup(24,GPIO.OUT) ## Setup GPIO24 – pin 18
GPIO.output(24,1)
print ("start")
try:
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -32-
while True:
GPIO.output(24, 1) # set GPIO24 (pin18) to 1/GPIO.HIGH/True
sleep(1) # wait a second
print ("wait 1")
GPIO.output(24, 0) # set GPIO24 (pin 18) to 0/GPIO.LOW/False
sleep(1) # wait a second
print ("wait 0")
except KeyboardInterrupt: # trap a CTRL+C keyboard interrupt
GPIO.cleanup()
INPUT
Esercizio I.1 Input button
Il programma permette di leggere un pulsante presente su GPIO18. Il pulsante è cablato in modo che quando viene premuto, collegherà il GPIO18, configurato come ingresso, a terra (GND). Il pin di ingresso è normalmente mantenuto a 3.3V da pull_up_down = GPIO.PUD_UP in GPIO.setup. Quando si si preme il pulsante, esso viene collegato a massa e il valore che si legge in ingresso (utilizzando GPIO.input), sarà 0 (False).
NOTA
● Pull-up resistors are resistors which are used to ensure that a wire is pulled to a high logical level in the absence of an input signal ● Pull-down resistors work in the same manner as pull-up resistors, except that they pull the pin to a logical low value.
● Raspberry Pi ha tutti i circuiti di cui sopra integrati. Può essere utile immaginare che le due resistenze degli schemi in fig S1, si trovino all'interno del circuito del Raspberry Pi e possono essere abilitate o disabilitate secondo necessità, selezionando un pull up o un pull down nel codice per ogni pin GPIO. Quando si utilizza un pin GPIO come input, è possibile configurare queste resistenze in modo che uno o entrambi o nessuno dei due resistori è attivato. Se questo parametro viene omesso, allora nessuna resistenza verrà attivata. Ciò lascia l'ingresso flottante, il che significa che il suo valore può oscillare tra valore alto e basso a seconda di ciò che raccoglie come rumore elettrico. (se il parametro opzionale per pull_up_down GPIO.setup è impostato su GPIO.PUD_UP, la resistenza di pull-up è abilitato; se è impostato su GPIO.PUD_DOWN, la resistenza di pull-down è abilitato). https://www.critics-corporation.com/RaspberryPi/come-usare-interrupt-pull-up-e-pull-down-con-python-raspberry-pi
(Raspberry Pi is equipped with pull-ups and pull-down resistors that can be activated via software
○ When a Pi is first powered up, the first eight GPIOs have pull-ups enabled, and the rest have pull-downs enabled. After it has finished booting, you can change that if you wish, in your software.
○ The pull-ups don't "supply voltage" - they merely connect a high-value resistor (about 50k) between the 3v3 rail and the GPIO
○ If nothing else is connected to it, that resistor supplies enough electrons - current for a certain time - to the GPIO, such that its voltage rises to 3v3.
○ A pull-down works similarly - electrons are removed so that its voltage reaches 0v (https://www.raspberrypi.org/forums/viewtopic.php?t=202568 )
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -33-
Fig S1
https://github.com/raspberrypilearning/physical-computing-guide/blob/master/pull_up_down.md
Pin utilizzati: GPIO18 (pin 12) in INPUT
http://razzpisampler.oreilly.com/ch07.html
https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/robot/buttons_and_switches/
-INPUT/OUTPUT
Esercizio IO.1 Input button / Output LED
Il programma btnled1.py utilizza :
- GPIO18 (pin 12) in INPUT per button - GPIO24 (pin 18) in OUTPUT per LED
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -34-
Immagine tratta da: “Gateway - Sistemi e Reti NE” - Volume 1 - DE Agostini - pag 137 (https://preview.tinyurl.com/gatewaymacchi )
--------------------------------------------
## btnled1.py
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(24,GPIO.OUT) ## Setup GPIO-24 to OUT -> LED
GPIO.output(24,0) ## LED off
GPIO.setup(18, GPIO.IN, pull_up_down=GPIO.PUD_UP) ## Setup GPIO-18 to IN <- Button
print('Wait for Button Press')
while True:
input_state = GPIO.input(18)
if input_state == False:
GPIO.output(24, 1) ## LED on
print('Button Pressed')
time.sleep(0.5)
GPIO.output(24, 0) ## LED off
----------------------------------------------------------------
chiamata: pi@raspberrypi ~ $ sudo python3 btnled1.py
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -35-
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -36-
Scheda FT1060M
FT1060M scheda: https://www.futurashop.it/Allegato_PDF_IT/7100-FT1060M.pdf
Scheda di sperimentazione analogico/digitale:
● Convertitore AD/DA a 8 bit PCF8591 ● sensore di temperatura (NTC) ● Fotoresistenza ● 6 LED ● 2 pulsanti ● 1 interruttore
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -37-
Btnled2.py (realizzata su scheda FT1060M)
Il programma btnled2.py utilizza :
- GPIO22 in INPUT per button - GPIO24 in OUTPUT per LED
#!/usr/bin/python3
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(24,GPIO.OUT) ## Setup GPIO 24 to OUT
GPIO.output(24,0) ## LED off
GPIO.setup(22, GPIO.IN, pull_up_down=GPIO.PUD_UP)
print('Wait for Button Press')
while True:
try:
input_state = GPIO.input(22)
if input_state == False:
GPIO.output(24, 1) ## LED on
print('Button Pressed')
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -38-
time.sleep(0.5)
GPIO.output(24, 0) ## LED off
except KeyboardInterrupt:
GPIO.cleanup() #pulisce e resetta GPIO
Segnalazioni con Led ● Far lampeggiare i LED, ON-OFF, con un tempo diverso ogni volta che premo il pulsante. ● Inseguimento LED: ON-OFF dei led uno dopo l’altro con rotazione ● Codifica binaria su 4 LED (0000,0001,..1111) ogni volta che si preme il pulsante
GIOCO RIFLESSI PRONTI-(rifle3.py su scheda FT1060M)
Il gioco dei riflessi pronti permette a due giocatori di confrontarsi con la prontezza dei propri riflessi: il primo che preme il pulsante vince!!!
La logica è la seguente:
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -39-
● Nello stato READY viene acceso il LED L5 (ON) (PRONTI)
● Viene fatto partire un tempo casuale al cui scadere L5 si spegne (OFF) indicando lo START GAME (VIA!)
● Ogni giocatore deve premere il proprio pulsante (P1-B1,P2- B2): il primo a premere fa accendere il led corrispondente e vince:
○ per P1 il LED L3=ON,
○ per P2 il LED L4=ON
● Dopo la vittoria si passa nello
Pin GPIO utilizzati:
L’inizializzazione…
# linea di shebang ( indica la cartella dove si trova l'interprete di python3):
#!/usr/bin/python3
#librerie
import RPi.GPIO as GPIO
import time
from time import sleep
import random
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -40-
stato di RESET (segnalato dall’accensione del LED L1 (ON).
● Dopo un tempo definito (ad esempio 3 secondi) i LED si spengono e il gioco riprende dallo stato READY
# OUT -> LED
GPIO.setmode(GPIO.BCM)
GPIO.setup(24,GPIO.OUT) ## Setup GPIO24to OUT
GPIO.output(24,0) ## L3, LED off
GPIO.setup(25,GPIO.OUT) ## Setup GPIO25 to OUT
GPIO.output(25,0) ## L4, LED off
GPIO.setup(4,GPIO.OUT) ## Setup GPIO4 to OUT
GPIO.output(4,0) ## L5 LED5 off
GPIO.setup(18,GPIO.OUT) ## Setup GPIO18 to OUT
GPIO.output(18,0) ## L1 (RESET) LED1 off
# IN -> PULSANTI
GPIO.setup(22, GPIO.IN, pull_up_down=GPIO.PUD_UP) #B1, button 1
GPIO.setup(27, GPIO.IN, pull_up_down=GPIO.PUD_UP) #B23, button 2
#START
def start( state):
print('START: Wait for Button Press--------------------')
….
while True:
if(GPIO.input(22)==False): ## 1 WINNER
...
return state
elif(GPIO.input(27)==False): ## 2 WINNER
...
return state
#MAIN
state=0 #set init state=0
#--- polling forever
while True:
# print("INITstate= ", state)
try:
if(state==0):
…. ## L1 OFF (fine reset state)
... ## L5 ON
randt=random.randint(1,3)
sleep(randt)
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -41-
print ("READY randt State",randt, state)
state=start(state)
elif(state==1):
….
except KeyboardInterrupt:
GPIO.cleanup() # pulisce e ed esce quando premi CTRL+C
Esempio semplice completo
#!/usr/bin/env python3 import random import RPi.GPIO as GPIO from time import sleep GPIO.setmode(GPIO.BCM) GPIO.setup(23, GPIO.OUT)# GPIO 23 LED GIOCATORE 1 GPIO.setup(24, GPIO.OUT)# GPIO 25 LED GIOCATORE 2 GPIO.setup(25, GPIO.OUT)# GPIO 24 LED START GPIO.setup(22, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)# GPIO 22 BOTTONE GIOCATORE 1 14 GPIO.setup(27, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)# GPIO 27 BOTTONE GIOCATORE 2 18 GPIO.setup(17, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)# GPIO 17 SWitch RESET 15 GPIO.output(23,GPIO.LOW) #SPENGO TUTTI I LED GPIO.output(24,GPIO.LOW) GPIO.output(25,GPIO.LOW) def stop(): while True:
print("STOP") if(GPIO.input(17)): print("RESET") GPIO.output(23,GPIO.LOW) GPIO.output(25,GPIO.LOW) GPIO.output(24,GPIO.LOW) via() def start(): sleep(random.randint(1,3)) GPIO.output(25,GPIO.HIGH) #START!! print("START!") def via(): print("Nuovo Gioco") start() print("Partita in corso") while True: if(GPIO.input(22)):
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -42-
print("Vince giocatore 1") GPIO.output(23,GPIO.HIGH) GPIO.output(25,GPIO.LOW) stop() if(GPIO.input(27)): print("Vince Giocatore 2") GPIO.output(24,GPIO.HIGH) GPIO.output(25,GPIO.LOW) stop() if(GPIO.input(17)): print("RESET") via() while True: try: via() except KeyboardInterrupt: GPIO.cleanup() # pulisce e ed esce quando premi CTRL+C
aggiungere il nome del giocatore e un buzzer
Non sarebbe meglio se il programma ti dicesse chi ha vinto invece di quale pulsante è stato premuto? Per questo, è necessario scoprire i nomi dei giocatori. In Python, puoi usare l'input per questo.
Ad es.
left_name = input('left player name is ') right_name = input('right player name is ')
…
print(left_name + ' won the game') ...
Esercizio IO.2 Input button / Output LED: riflessi pronti con Gpiozero
Gpiozero è una libreria Python (“a simple interface to everyday GPIO components used with Raspberry Pi”. ) per la gestione semplificata degli GPIO del Raspberry che contiene codice che va dalla gestione dei led e pulsanti agli oggetti per case intelligenti.
In https://gpiozero.readthedocs.io/en/v1.2.0/recipes.html trovate numerosi esempi, tra cui: gestione motori, semafori, robot, e il gioco dei riflessi pronti: https://www.raspberrypi.org/learning/python-quick-reaction-game/worksheet/ :
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -43-
from gpiozero import LED, Button ##Gpiozero library
from time import sleep
from random import uniform
led = LED(4)
right_button = Button(15)
left_button = Button(14)
led.on()
sleep(uniform(5, 10))
led.off()
def pressed(button):
print(button.pin.number + ' won the game')
right_button.when_pressed = pressed
left_button.when_pressed = pressed
----------------------------------------------
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -44-
OUT Analogico PWM (“Pulse-Width Modulation”)
Esercitazione 4 PWM - (Output analogico)
(da Arduino-primi calci) Approfondimento Digitale vs Analogico
Se realizziamo blink di un LED agendo sul tempo e se il tempo diminuisse molto (dell’ordine dei 10ms)
non ci accorgeremmo quasi più del blink del LED e la sua luminosità risulterebbe leggermente diminuita.
In pratica la velocità con cui il LED si accende e spegne darebbe al nostro occhio l’illusione che lo stiamo pilotando con un segnale analogico!
Il motivo sta nel fatto che abbiamo fatto lampeggiare un LED ad una frequenza elevata, cambiando il rapporto tra il tempo in cui sta acceso ed il tempo in cui sta spento.
In questo modo abbiamo applicato la tecnica PWM (“Pulse-Width Modulation”): l’uscita digitale viene utilizzata per creare un'onda quadra, un segnale commutato tra gli stati di ON e OFF, in cui il rapporto tra la durata del segnale quando è a ON varia rispetto al periodo totale (duty cycle). In altre parole, trucchiamo un’uscita digitale facendola apparire analogica!
L’utilizzo della funzione di ritardo non è però una scelta premiante perchè ritarderebbe l’intero ciclo di
polling impedendo la lettura immediata di altri sensori o dispositivi.
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -45-
DIGITALE ANALOGICO
● I calcolatori lavorano con sistemi digitali basati sui valori 0 e 1
● I fenomeni naturali (suoni, pressioni, temperature) sono tipicamente analogici
● I segnali analogici vanno necessariamente convertiti in digitale. Si tratta, sostanzialmente, di metodi che permettono di tradurre un fenomeno analogico in una sequenza di due soli elementi: 1 e 0, on e off, acceso e spento
● Un segnale analogico è fatto di infinite variazioni
● La ricchezza di un suono viene convertita in una stringa di bit applicando semplici funzioni matematiche che permettono di approssimare numericamente la curva che rappresenta, istante per istante, la pressione dell’aria
● Un suono ha infinite variazioni. La sola pressione dell’aria è in grado di trasmettere una stupenda sinfonia, gli infiniti timbri della voce o il rumore di una cascata
● Un’immagine viene convertita in pixel, cioè in una serie di punti di cui si memorizza il valore numerico del colore e della quantità di luce
● Un’immagine possiede infinite variazioni di intensità di colore
Per questo è possibile ottenere un duty cycle variabile in funzione del valore passato come parametro, da 0 (0%, sempre OFF) a 255 (100%, sempre ON).
La fig. PW1 mostra i due valori corrispondenti a un duty cycle del 25% (64) e del 50% (127).
fig. PW1- “Duty Cycle” (ciclo di lavoro) - La modulazione della larghezza di impulsi, o PWM, permette di variare il tempo dello stato ON del segnale rispetto al periodo totale. https://www.mbtechworks.com/projects/raspberry-pi-pwm.html
(http://www.toptechboy.com/raspberry-pi/raspberry-pi-lesson-27-analog-voltages-using-gpio-pwm-in-python/ https://sourceforge.net/p/raspberry-gpio-python/wiki/PWM/ http://www.engeene.it/la-porta-gpio-della-raspberry-pi/
PWM : LED a intensità variabile o buzzer (cicalino) (https://projects.raspberrypi.org/en/projects/physical-computing/10 https://www.raspberrypi.org/forums/viewtopic.php?t=98140 https://sourceforge.net/p/raspberry-gpio-python/wiki/PWM/ ) # pwm11.py - PWM -> Illumina e attenua la luce di un LED
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -46-
p = GPIO.PWM(pin, freq) pin – pin number/GPIO number freq – frequency of the PWM
Creates an PWM instance and assigns it to variable p
p.start(dutyCycle) dutyCycle – Starting duty cycle Values from 0.0 to 100.0
Starts the PWM
p.ChangeFrequency(freq) freq – new Frequency in Hertz Changes the frequency of the PWM
p.ChangeDutyCycle(dutyCycle) dutyCycle – new duty cycle Values from 0.0 to 100.0
Changes the duty cycle of the PWM
p.stop() Stops the PWM
import time
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(24, GPIO.OUT) # GPIO24 (pin 18)
pw = GPIO.PWM(24, 100) # GPIO24, frequenza=100Hz
pw.start(0)
print ("start")
try:
while 1:
for dutyc in range(0, 101, 5):
pw.ChangeDutyCycle(dutyc) # illumina
time.sleep(0.2)
for dutyc in range(100, 0, -5):
pw.ChangeDutyCycle(dutyc) # attenua
time.sleep(0.2)
except KeyboardInterrupt:
print ("stop")
pw.stop
GPIO.cleanup()
NOTA I buzzer possono essere di due tipi: attivi e passivi ● I buzzer attivi hanno al loro interno un’oscillatore che emetterà suono se vengono alimentati ● quelli passivi non posseggono un oscillatore interno e quindi per emettere suono è indispensabile fornire al
buzzer un segnale ad onda quadra tra i 2Khz e i 5 Khz. Realizzazione (come linea e punto nel codice Morse): ● In caso di vittoria : segnale sonoro di durata maggiore di 1 secondo ● In caso di sconfitta: suono breve di 0,3 secondi
Es.6 UART
Legge 10 characters dalla porta seriale e ne fa l’eco
import serial
ser = serial.Serial ("/dev/ttyAMA0") #Open named port
ser.baudrate = 9600 #Set baud rate to 9600
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -47-
data = ser.read(10) #Read ten characters from serial port to data
ser.write(data) #Send back the received data
ser.close()
Raspbian SHELL
Es.S1 01_LED_Blink.sh
#!/bin/bash
# sudo sh LED_Blink.sh
# Pin setting: 3=LED(out)
echo 3 > /sys/class/gpio/export
echo out > /sys/class/gpio/gpio3/direction
for i in $(seq 1 10);
Do
echo 1 > /sys/class/gpio/gpio3/value
sleep 1
echo 0 > /sys/class/gpio/gpio3/value
sleep 1
echo $i
done
echo 3 > /sys/class/gpio/unexport
es.S2 02_PushButton_OnOff.sh
(a cura di Serena Arena)
#!/bin/bash
# sudo sh PushButton_OnOff.sh
# Pin setting: 4=PushButton(in)
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -48-
echo 4 > /sys/class/gpio/export
echo in > /sys/class/gpio/gpio4/direction
for i in $(seq 1 10);
Do
PB=`cat /sys/class/gpio/gpio4/value`
echo $PB
sleep 1
done
echo 4 > /sys/class/gpio/unexport
-----------------------------------------------------------------------
Es.S3 03_LED-PushButton.sh
(a cura di Serena Arena)
#!/bin/bash
# sudo sh PushButton_OnOff.sh
# Pin setting: 3=LED(out) 4=PushButton(in)
echo 3 > /sys/class/gpio/export
echo out > /sys/class/gpio/gpio3/direction
echo 4 > /sys/class/gpio/export
echo in > /sys/class/gpio/gpio4/direction
# Variable settings:
DELAY=0.1
DELTAT=50
# PB=0: pulsante premuto; PB=1: pulsante non premuto
for i in $(seq 1 $DELTAT);
Do
PB=`cat /sys/class/gpio/gpio4/value`
echo $PB
sleep $DELAY
if [ $PB -eq 0 ]
then
echo 1 > /sys/class/gpio/gpio3/value
else
echo 0 > /sys/class/gpio/gpio3/value
fi
done
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -49-
echo 3 > /sys/class/gpio/unexport
echo 4 > /sys/class/gpio/unexport
---------------------------
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -50-
LABORATORIO - IOTlab
Gestione remota del Raspberry (con la collaborazione tecnica del sig. Marco Nascimben, e logistica del sig. Nino Amadore)
In un laboratorio didattico è spesso utile, per motivi pratici, gestire remotamente Raspberry. Il sistema permette di gestire, da una postazione remota (in cui risiede lo studente) della stessa rete locale(Laboratorio Sistemi), un controller Raspberry .
Il PC dello studente è dotato, ad esempio, di sistema operativo Windows e accede al Raspberry remoto di sua competenza. La figura sottostante mostra lo schema logico della rete.
Sulla destra è rappresentato IOT-lab ( l’insieme dei Raspberry rappresentati sottoforma di sistemi intelligenti: Appliance, Door, Monitor,..) che sono collegati allo switch2 che, a sua volta, si collega a switch4 e che, tramite il router R1, accede a Internet e al server remoto (server1). Nell’immagine sottostante è mostrato il tavolo di impiego reale.
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -51-
Per operare dalle postazioni remote del laboratorio (ad esempio da Sistemi-PC1) è necessario attuare una serie di passi per la configurazione del sistema complessivo.
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -52-
Progetti
Semaforo
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -53-
/* by Nasci 5IA con stati*/
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Importiamo le librerie necessarie
# Per GPIO
import RPi.GPIO as GPIO
# Per sleep
from time import sleep
# Flag per conoscere lo stato
# False = Ciclo normale
# True = In prenotazione
premuto=False
# Set delle GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(14, GPIO.OUT)
GPIO.setup(15, GPIO.OUT)
GPIO.setup(18, GPIO.OUT)
GPIO.setup(23, GPIO.IN)
# Definizione delle funzioni
# Ritorna lo stato corrente
def getStato():
if(GPIO.input(14)):
return "rosso"
elif(GPIO.input(15)):
return "giallo"
elif(GPIO.input(18)):
return "verde"
# Lascia acceso solo led rosso
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -54-
def vaiRosso():
print ("Rosso")
GPIO.output(14,1)
GPIO.output(15,0)
GPIO.output(18,0)
# Lascia acceso solo led giallo
def vaiGiallo():
print ("Giallo")
GPIO.output(14,0)
GPIO.output(15,1)
GPIO.output(18,0)
# Lascia acceso solo led verde
def vaiVerde():
print ("Verde")
GPIO.output(14,0)
GPIO.output(15,0)
GPIO.output(18,1)
# Quando viene premuto il bottone
def bottonePremuto(evento):
# Imposto flag in true (quindi avviso che il bottone è premuto)
premuto=True
# Prevengo doppia pressione
sleep(0.05)
print("Bottone premuto")
# Se il semaforo è verde, lo porto prima in giallo, poi in rosso
if(getStato()=="verde"):
print ("Semaforo in verde - vado in giallo e poi in rosso")
vaiGiallo()
sleep(1)
premuto=False
# Altrimenti, non faccio nulla, il semaforo o è già rosso o è in giallo
# (ovvero sta per diventare rosso)
else:
print ("Semaforo in giallo o rosso - lascio andare")
premuto=False
# Funzione per il normale funzionamento del semaforo
# Controllo se sono a bottone premuto, fermo tutto
def cicloNormale():
print "Ciclo normale"
while True:
if(premuto==False):
vaiVerde()
Un altro esempio (senza stati):
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -55-
sleep(5)
if(premuto==False):
vaiGiallo()
sleep(1)
if(premuto==False):
vaiRosso()
sleep(5)
# Mi metto in ascolto del bottone, se premuto chiamo la funzione
GPIO.add_event_detect(23, GPIO.RISING, callback=bottonePremuto)
# Faccio partire il ciclo normale
cicloNormale()
## Berto Mastro
#!/usr/bin/python3
import random
from random import randint
from time import sleep
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(18,GPIO.IN,pull_up_down=GPIO.PUD_UP) ##p1
GPIO.setup(17,GPIO.IN,pull_up_down=GPIO.PUD_UP) ##p2
GPIO.setup(23,GPIO.IN,pull_up_down=GPIO.PUD_UP) ##pR
GPIO.setup(16,GPIO.OUT) ##ledP1
GPIO.setup(21,GPIO.OUT) ##ledP2
GPIO.setup(20,GPIO.OUT) ##centrale
win1=0
win2=0
print("WAIT")
try:
while True:
timeR=random.randint(2,5) ##genero n random
print ("ssss")
print(timeR)
input_p1=GPIO.input(18)
input_p2=GPIO.input(17)
input_R=GPIO.input(23)
if((timeR<=5)and(timeR>=2)):
if((win1==0)and(win2==0)):
if(input_p1==False):
print("bottone premuto: player 1 win")
GPIO.output(20,0)
GPIO.output(16,1)
GPIO.output(21,0)
win1=1
win2=0
elif(input_p2==False):
print("bottone premuto: player 2 win")
GPIO.output(20,0)
GPIO.output(16,0)
GPIO.output(21,1)
win2=1
win1=0
elif(input_R==False):
print("button reset premuto")
SIMPHY - CLIENT-SERVER application Cfr. http://moodle.isisfacchinetti.it/mod/data/view.php?d=21&rid=747
(AS16-17\5IA\sistemi\IOT 2016\Symphy)
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -56-
GPIO.output(16,0)
GPIO.output(21,0)
sleep(timeR)
GPIO.output(20,1)
win1=0
win2=0
except KeyboardInterrupt:
GPIO.cleanup()
##CLIENT
#!usr/bin/python3
import vlc
import socket
import RPi.GPIO as GPIO
from datetime import datetime,date,time,timedelta
##GPIO.setmode(GPIO.BCM)
##GPIO.setup(4,GPIO.OUT) ##led
##GPIO.output(4,0)
print "[CLIENT] Lettura configurazione"
file=open("conf","r")
testo = file.read()
file.close()
aTesto=testo.split( )
for a in aTesto:
confSplit=a.split('=')
if(confSplit[0]=="server"):
server=confSplit[1]
elif(confSplit[0]=="port"):
port=int(confSplit[1])
print "[CLIENT] Connessione al server "+server+":"+str(port)+" in corso"
try:
cs=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cs.connect((server,port))
except socket.error, ex:
print "[CLIENT] ERRORE - eccezione del socket: "+str(ex)
quit()
print "[CLIENT] Connesso al server"
##GPIO.output(4,1)
msgC=raw_input()
cs.sendto(msgC.encode(),(server,port))
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -57-
msgS=cs.recv(1024)
print "[CLIENT] Ricevuto messaggio: "+msgS
if(msgS=="201"):
msgC=raw_input()
cs.sendto(msgC.encode(),(server,port))
msgS2=cs.recv(1024)
print "[CLIENT] Ricevuto messaggio: "+msgS2
if(msgS2=="202"):
print "[CLIENT] preparo song1"
p=vlc.MediaPlayer("song1.mp3")
print "[CLIENT] Vuoi far partire la song? 103=SI"
msgC=0
while(msgC!="199"):
##print "Sono dentro"
msgC=raw_input()
cs.sendto(msgC.encode(),(server,port))
msgS3=cs.recv(1024)
print "[CLIENT] Ricevuto messaggio: "+msgS3
if(msgS3.split('/')[0]=="203"):
cs.close();
d=datetime.strptime(msgS3.split('/')[1],'%Y-%m-%d %H:%M:%S');
print d;
while (d-datetime.now()).total_seconds()>0:
print datetime.now()
print (d-datetime.now())
p.play()
print "play"
cs=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cs.connect((server,port))
if(msgS3=="204"):
p.pause()
print "Pausa"
if(msgS3=="205"):
p.stop()
print "Stop"
-----------------------------------------------------------------------------------------------------------------------------------
##SERVER
import socket
from datetime import datetime,date,time
print "[SERVER] Avvio del server in corso"
ss=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print "Il tuo IP: "+socket.gethostbyname(socket.gethostname())
ss.bind(("192.168.101.13",15150))
ss.listen(5)
while True:
print "[SERVER] In ascolto"
-Python Quick Reaction Game
-- https://projects.raspberrypi.org/en/projects/python-quick-reaction-game
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -58-
try:
cs, serverAddress=ss.accept()
print "[SERVER] Nuova connessione da "+cs.getpeername()[0]+":"+str(cs.getpeername()[1])
serverLogString="[SERVER-"+cs.getpeername()[0]+":"+str(cs.getpeername()[1])+"] "
chiusura=True
while chiusura:
print serverLogString+"In attesa di messaggio"
dati=cs.recv(1024)
print serverLogString+"Ricevuto messaggio: "+dati
msg="404"
if(dati=="101"):
msg="201"
elif(dati=="199"):
msg="299"
elif(dati=="102"):
msg="202"
elif(dati=="103"):
msg="203/"+str(datetime(2017,06,7,13,39,00));
elif(dati=="104"):
msg="204"
elif(dati=="105"):
msg="205"
print serverLogString+"Invio messaggio: "+msg
cs.sendto(msg,(cs.getpeername()[0], cs.getpeername()[1]))
if(dati=="199"):
print serverLogString+"Chiusura della connessione"
chiusura=False
cs.close()
except socket.error, ex:
print "[CLIENT] ERRORE - eccezione del socket: "+str(ex)
APPENDICE 1 - Installazione e gestione remota
Documentazione ufficiale: https://www.raspberrypi.org/documentation/
Installazione NOTA: Per l’installazione https://www.raspberrypi.org/downloads/ http://www.engeene.it/la-porta-gpio-della-raspberry-pi-1/
https://www.raspberrypi.org/learning/getting-started-with-raspberry-pi-lesson/
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -59-
https://www.raspberrypi.org/help/
Le procedure di seguito descritte sono relative alla versione ufficiale di Raspbian disponibile dal maggio 2016, ma non dovrebbero esserci differenze significative con altre versioni.
Per installare in modo semplice e “pronto all’uso” il sistema operativo usaremo NOOBS, un pacchetto di installazione che, automaticamente, crea una partizione autoavviante, di Raspbian, una versione di Linux, ritagliata per Raspberry Pi.
Quando si inserisce l’alimentazione il sistema parte
● allo start cliccare su NOOBS ● Dal menu cliccare su: Raspbian -> Install-> Yes …. Si attende il tempo di caricamento in cui è presentata
una panoramica dei servizi offerti da Raspbian (oppure Boot (rasi-config) -> Enable boot -> OK ; Desktop log -> invio; FINISH (tab) ; YES) e ...
Login: pi
Pass: raspberry
● Per GUI: startx
….. Sperimentare, esplorare e divertirsi
Provare
lsusb per verificare le periferiche USB
dmesg | tail per verificare le funzionalità del sistema
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -60-
NOTA E’ possibile acquistare diverse schede SD, in maniera tale da avere diversi sistemi operativi funzionanti all’occorrenza. Con un solo Raspberry Pi, possiamo utilizzare diverse distribuzioni di Linux. ESiste anche RASPBMC che trasforma Raspberry Pi, in un media center (http:// www.raspbmc.com).
Configurazione di Raspberry
STEP 1 - Impostazione IP statico
Può essere comodo configurare Raspberry con un indirizzo IP statico (se possiede un indirizzo assegnato da DHCP della rete locale) per poterlo raggiungere più facilmente in occasione dei successivi collegamenti.
In realtà per fare questo occorre sapere l’indirizzo IP del Raspberry che gli viene assegnato dal server DHCP della propria rete.
Abbiamo due possibilità per scoprire l‘indirizzo IP:
● entrare nelle impostazioni del router della rete e verificare gli indirizzi IP della rete, individuando la scheda ● Utilizzare un software per la scansione degli indirizzi IP come, ad esempio, NMAP (http:// nmap.org/
download.html). Dopo aver avviato NMAP inseriamo l’indirizzo di rete, ad esempio 192.168.1.0/24, ed avviamo la scansione. Otterremo una lista delle macchine connesse in rete, compreso il Raspberry, identificate dall’indirizzo IP e MAC (vedi fig.x1).
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -61-
Fig. x1- L’individuazione di Raspberry PI tramite Zenmap (https://nmap.org/zenmap/ ), un visualizzatore dei risultati di NMAP in formato testuale e grafico.
Per esercitazioni si veda http://www.fastweb.it/internet/come-effettuare-il-port-scanning-e-come-difendersi/
NOTA Per installare NMAP In Linux -> “Terminale”:
sudo apt-get update && sudo apt-get upgrade && sudo apt-get install nmap sudo nmap 192.168.1.0/ 24
Una volta determinato l’indirizzo dinamico della macchina, dobbiamo configurare l’IP statico.
Modalità grafica (consigliata)
Da Desktop con il tasto di destro cliccare sull’icona che rappresenta il collegamento in rete (fig. r3)
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -62-
Impostare l’indirizzo statico, Router (Gateway), DNS, scegliendo la configurazione per la rete Ethernet (eth0) oppure Wi-Fi (wlan0) come in fig. r3:
Frae il reboot (shutdown)
Modalità testuale (alternativo alla modalità grafica)
Gli indirizzi IP con la password e le impostazioni di assegnazione automatica degli indirizzi, sono contenuti nel file interfaces. Useremo Putty per connetterci tramite il protocollo SSH da macchine Windows e modificare il file con “nano” .
Putty (porta 22, SSH) per accesso a Raspberry
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -63-
fig. 1 – putty con SSH su porta 22
● Raspberry risponde al prompt:
Login pi
Password raspberry
● abilitare l’interfaccia Ethernet aprendo il file “interfaces”
Per attivare l’interfaccia Ethernet, eth0, e quella Wi-Fi, wlan0, inserire gli indirizzi IP del proprio Raspberry, del gateway di interfaccia (tipicamente il router) e della subnet mask, della propria rete locale. Ad esempio:
Sia per Raspbian wheezy (la versione più vecchia) che per i sistemi jessie, dal terminale collegato al raspberry (o via collegamento ssh, con PuTTY), aprire il file: /etc/network/interfaces.
● Richiamiamo l’editor nano
○ sudo nano /etc/network/interfaces ● Modifichiamo il file in modo tale da disabilitare il DHCP ed impostare un indirizzo manuale. Quindi la riga di testo:
iface eth0 inet dhcp dovrà sparire e sarà necessario digitare:
auto lo
iface lo inet loopback
allow-hotplug wlan0
iface wlan0 inet manual
wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
auto wlan0
iface wlan0 inet static
address 192.168.101.x
gateway 192.168.101.126
netmask 255.255.255.128
auto eth0
iface eth0 inet static
address 192.168.101.x
netmask 255.255.255.128
gateway 192.168.101.126
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -64-
NOTA Per quanto riguarda i sistemi jessie (ad es. Raspberry Pi 4) bisognerà (anche) modificare il file: /etc/dhcpcd.conf (cfr. L’assegnazione dellindirizzo statico “static ip_address=192.168.101.x “)
● sudo nano /etc/dhcpcd.conf
interface eth0
static ip_address=192.168.101.x
static routers=192.168.101.126
static domain_name_servers=192.168.101.126
interface wlan0
static ip_address=192.168.101.x
static routers=192.168.101.126
static domain_name_servers=192.168.101.126
In questo file non si imposta la subnet mask ma domain_name_servers con l’indirizzo del router.
NOTA Un’alternativa per togliere l’assegnazione dinamica degli indirizzi è quella di lanciare il comando:
sudo update-rc.d -f dhcpcd remove
CAMBIO NOME
● cambio nome raspberry
sudo nano /etc/hosts
.. raspsisx
save and exit
VERIFICA
sudo nano etc/hostname
.. raspsisx
● reboot
(sudo reboot) oppure sudo shutdown -r now
(per spegnerlo: sudo shutdown -h now , per scollegarsi : logout )
(per aggiornamento e reboot: sudo aptitude update && sudo aptitude upgrade && sudo shutdown -r now )
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -65-
STEP 2 - Installazione XRDP-Remote Desktop Protocol su Raspberry
Per accedere a Raspberry Pi da un terminale (client) remoto, in modo sicuro, è necessario abilitare il server SSH che, nelle ultime versioni risulta disabilitato come impostazione predefinita .
Dal desktop (fig. r2):
Preferences -> Raspberry Pi Configuration -> Interfaces -> navigare per abilitare SSH enable
● Abilitazione SSH
●
Fig. r2 menu per l’abilitazione di SSH
● Aggiornamento delle dipendenze (facoltativo)
Accedere con Putty a Raspberry e aggiornare il sistema (consigliato)
sudo apt-get update
Attendere la fine .entro qualche minuto.
● installazione del desktop remoto xrdp
sudo apt-get install xrdp
….
Attendere la fine entro qualche minuto
STEP 3 - Accesso a Raspberry da “Desktop Remoto” di Windows
Accesso a Raspberry da “Desktop Remoto” di Windows
Per accedere da remoto (da un PC con sistema operativo Windows) utilizzare l’applicazione “Desktop Remoto” di Microsoft (fig.2) .
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -66-
Ora si presenta la pagina di Raspberry mostrata in fig.3 ed è possibile lavorare da remoto (come in locale!)
Fig 3 controllo del raspberry da remoto
(nota Per un desktop remoto completo, vedere VNC https://www.raspberrypi.org/documentation/remote-access/vnc/README.md .)
Server Web e installazione LAMP (a cura di Marco Nascimben)
In questa sezione forniamo una GUIDA BASE all’Installazione per LAMP – Linux Apache MySQL PHP
Apache è un server web che è possibile installare sul Raspberry Pi . Di per sé, Apache può gestire i file HTML su protocollo HTTP e, con moduli aggiuntivi, può gestire pagine web dinamiche utilizzando linguaggi di scripting come PHP.
(SETTING UP AN APACHE WEB SERVER ON A RASPBERRY PI:
https://www.raspberrypi.org/documentation/remote-access/web-server/apache.md , https://www.glgprograms.it/?p=tricks/raspberrypi-4 )
STEP 1 – PREPARAZIONE
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -67-
fig 2- l’applicazione Desktop Remoto su sistema operativo Windows
192.168.1.3
Login pi
Password raspberry
-Per connettersi a un computer remoto WINDOWS, è necessario che tale computer sia acceso, che abbia una connessione di rete, che Desktop remoto sia abilitato e che tu abbia accesso in rete al computer remoto, ad esempio tramite Internet, e dell'autorizzazione a connetterti. Per essere autorizzato alla connessione, devi essere incluso nell'elenco di
utenti.https://support.microsoft.com/it-it/help/17463/wi
ndows-7-connect-to-another-computer-remote-desktop-connection
Diventiamo amministratori
sudo -i
Aggiorniamo i repository, in modo da scaricare tutti i pacchetti necessari
apt-get update
STEP 2 – APACHE, il server web Installiamo Apache, il server web
apt-get install apache2
…
Una volta terminato il processo di installazione, possiamo provare il nostro web server visitando l'IP della macchina su cui esso gira.
Se tutto funziona, visualizzeremo la pagina di default.
- Gli indirizzi IP sono quelli della macchina su cui è stato installato il server Web
Per utilizzare un nostro sito, basta creare la sottocartella html :
/var/www/html
e creare il nuovo file prova.html
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Nota: I file nella cartella /var/www/html hanno come proprietario l’utente di root. È necessario avere i privilegi di amministratore per
poterli creare o modificare.
Ricordiamo che al primo accesso al sistema si può effettuare con le credenziali fornite:
L'utente pi è anche sudoers e può diventare amministratore digitando sulla riga di comando semplicemente
$ sudo su
( Per Impostare la password di root effettuiamo l'accesso come utente pi, dopodichè digitiamo:
$ sudo su
# passwd
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -68-
Utente: pi
Password: raspberry
)
Oppure come in figura sottostante con il comando sudo chmod -R 777 /var/www
----------------------------------------------------------------------------------------------------------------------------------------
Chiamiamo ora il server web:
……………………………………………………………………………………...
STEP 3 – PHP, il linguaggio di scripting Ora installiamo PHP (con le credenziali di root!), con il seguente comando
apt-get install php5 libapache2-mod-php5
Per sicurezza, riavviamo il servizio di Apache, in modo da caricare il modulo di PHP
service apache2 restart
-----------------------------------------------------------------------
Attenzione: per rendere effettiva ogni modifica ai file di configurazione di Apache e PHP, è indispensabile riavviare il webserver (o, al
limite, ricaricare la sua configurazione), attraverso uno dei seguenti comandi
# service apache2 restart # riavvia il webserver
# service apache2 reload # ricarica la configurazione
# service apache2 stop # spegne il webserver
# service apache2 start # avvia il webserver
oppure riavviando completamente il Raspberry Pi.
----------------------------------------------------------------------------------------------------------------------------
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -69-
Possiamo ora testare se l'installazione è avvenuta con successo.
Creiamo in /var/www/html un file PHP e verifichiamo che il browser visualizzi correttamente la sua elaborazione.
Nota: Apache come usa prima pagina principale index.html . Se non esiste usa index.php .
Se hai creato una pagina con nome index.php, ricorda di rimuovere o rinominare index.html
STEP 4 – MySQL, il database E per finire, installiamo MySQL, uno dei principali database in circolazione.
apt-get install mysql-server php5-mysql
Durante l'installazione verrà richiesta una password da assegnare all'account root del database, che permette l'accesso al database.
In un ambiente di prova può essere lasciata vuota, ma se un giorno dovessimo pubblicare il nostro server sul web, è importante che essa sia complicata.
Anche dopo il termine di questa installazione, riavviamo Apache in modo da caricare i moduli necessari.
service apache2 restart
Per prova, possiamo dare il comando
mysql
E verificare che ci venga aperta la console dei comandi di MySQL.
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -70-
STEP OPZIONALE – PHPMYADMIN, il gestore di database Per semplificarsi la vita con la gestione del database, è una scelta molto diffusa quella di installare assieme a
MySQL un’applicazione web, phpMyAdmin che consente di amministrare il database tramite browser anziché tramite riga di comando.
Installiamolo usando
apt-get install phpmyadmin
Nelle schermate successive, ci verrà chiesto:
● Il server web da configurare, nel nostro caso “apache2” ● Se avviare la configurazione automatica o manuale. In caso mysql sia appena stato installato, è meglio
usare quella automatica, altrimenti se esiste già un database, è necessaria la configurazione manuale. ● La password di MySQL, in modo da potervi accedere ● La password per accedere alla configurazione di phpMyAdmin
Nota: è consigliato non lasciare questo campo vuoto. Genererebbe una password casuale.
Ora basterà andare su <IP>/phpmyadmin per poter eseguire il login e gestire il database da browser.
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -71-
Nota: in caso in MySQL la password sia vuota, phpMyAdmin impedisce il login, per motivi di sicurezza. Per permettere ciò, bisogna modificare il file /etc/phpmyadmin/config.inc.php e togliere il commento dalla riga
$cfg['Servers'][$i]['AllowNoPassword'] = TRUE;
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -72-
FTP E’ possibile accedere a Raspberry remoto anche tramite FTP
La gestione via FTP si ottiene ad esempio con Filezilla
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -73-
Scarti
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(12, GPIO.IN, pull_up_down=GPIO.PUD_UP)
while True:
input_state = GPIO.input(12)
if input_state == False:
print('Button Pressed')
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -74-
time.sleep(0.2)
-------------------------------------------------------------------------
chiamata:
pi@raspberrypi ~ $ sudo python switch.py
Idee e progetti
RASPBERRY PI LOCATION TRACKER
http://www.instructables.com/id/Raspberry-Pi-Location-Tracker/
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -75-
4G + GPS Shield for Arduino and Raspberry Pi Tutorial (LTE
/ WCDMA / HSPA+ / 3G / GPRS) https://www.cooking-hacks.com/documentation/tutorials/4g-gps-lte-wcdma-hspa-3g-gprs-shield-arduino-raspberry-pi-waspmote-tutoria
l/
Morse http://www.engeene.it/la-porta-gpio-della-raspberry-pi-1/
Vediamo un esempio minimo di programma, che faccia solo output su di un LED, traducendo in codice Morse ciò che gli passiamo come argomento. Il programma è commentato:
#!/usr/bin/python #Librerie import sys import RPi.GPIO as GPIO import time #################### #Configurazione # #################### #Pin del led ledPin=22 #Durata dell'accensione per il punto e della linea (in secondi) durPunto=0.2 durLinea=0.5 #Modalita' di indicazione del led (numerazione GPIO) GPIO.setmode(GPIO.BCM) #################### #Dati utili #
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -76-
#################### #Codice Morse MORSE = {"'": '.----.','(': '-.--.-',')': '-.--.-',',': '--..--','-': '-....-','.': '.-.-.-','/': '-..-.','0': '-----','1': '.----','2': '..---','3': '...--','4': '....-','5': '.....','6': '-....','7': '--...','8': '---..','9': '----.',':': '---...',';': '-.-.-.','?': '..--..','A': '.-','B': '-...','C': '-.-.','D': '-..','E': '.','F': '..-.','G': '--.','H': '....','I': '..','J': '.---','K': '-.-','L': '.-..','M': '--','N': '-.','O': '---','P': '.--.','Q': '--.-','R': '.-.','S': '...','T': '-','U': '..-','V': '...-','W': '.--','X': '-..-','Y': '-.--','Z': '--..','_': '..--.-'} #################### #Funzioni # #################### #Accende e spegne rapidamente il led per il punto def punto(): GPIO.output(ledPin, 1) time.sleep(durPunto) GPIO.output(ledPin,0) time.sleep(durPunto) #Accende e spegne lentamente il led per la linea def linea(): GPIO.output(ledPin, 1) time.sleep(durLinea) GPIO.output(ledPin,0) time.sleep(durPunto) #################### #Programma # #################### def main(argv): GPIO.setup(ledPin, GPIO.OUT) #Per ogni parola passata come comando for arg in argv: #Per ogni lettera della parola for lettera in arg: #Per ogni segno del Morse corrispondente for segno in MORSE[lettera.upper()]: if segno == '-': linea(); else: punto(); time.sleep(durLinea) GPIO.cleanup() #elimino il primo argomento main(sys.argv[1:])
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -77-
Paolo Macchi - Serena Arena RasPython – rel. 21.02.06 -78-
![[XLS] · Web viewComuni che NON utilizzano gestionali propri e per i quali il centro di riferimento per la raccolta dati è la sede regionale Istat Comuni che utilizzano gestionali](https://img.pdfslide.tips/doc/110x75/5b0404d07f8b9a89208cffa0/xls-viewcomuni-che-non-utilizzano-gestionali-propri-e-per-i-quali-il-centro-di.jpg)
