paolo macchi - serena arena
RasPython RaspberryPi+Python |
RasPython: Raspberry+Python 2016-2021 |
Introduzione a RasPython = Raspberry+Python
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 paolo.macchi@libero.it , 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
RasPython |
Convenzioni usate nel testo: rappresenta una curiosità o un approfondimento |
INDICE
Note di programmazione in PYTHON
Modalità Interattiva di programmazione (interprete Python)
GPIO-General Purpose Input/Output
Esercizio O.0. Accensione di un LED
Pin utilizzati: GPIO24 (pin 18) in OUTPUT
Esercizio IO.1 Input button / Output LED
Btnled2.py (realizzata su scheda FT1060M)
GIOCO RIFLESSI PRONTI-(rifle3.py su scheda FT1060M)
Esercitazione 4 PWM - (Output analogico)
SIMPHY - CLIENT-SERVER application
APPENDICE 1 - Installazione e gestione remota
STEP 1 - Impostazione IP statico
Modalità grafica (consigliata)
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 2 – APACHE, il server web
STEP 3 – PHP, il linguaggio di scripting
STEP OPZIONALE – PHPMYADMIN, il gestore di database
4G + GPS Shield for Arduino and Raspberry Pi Tutorial (LTE / WCDMA / HSPA+ / 3G / GPRS)
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?
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.
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 )
Caratteristiche principali di Raspberry Pi 4 (https://www.raspberrypi.org/products/raspberry-pi-4-model-b/specifications/)
( - Per l’architettura ARM si veda il capitolo ARM con Raspberry in questa stessa dispensa ) |
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
Raspberry Pi necessita per funzionare di un sistema operativo. Raspberry Pi è stato progettato e realizzato per far girare distribuzioni Linux (cfr server e corso NDG Linux Unhatched https://moodle.isisfacchinetti.it/mod/data/view.php?d=21&rid=799 )ma, attualmente, è possibile disporre di molte risorse tra cui Windows 10 (https://developer.microsoft.com/it-it/windows/iot).
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/)
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
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.
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
(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
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
Consigliato: https://www.w3schools.com/python/
Si veda anche
Interprete per Python3 : py.exe : https://www.python.it/download/
NOTA if __name__ == "__main__":
main()
Some modules contain code that is intended for script use only, like parsing command-line arguments or fetching data from standard input. When a module like this were to be imported from a different module, for example to unit test it, the script code would unintentionally execute as well.
Si utilizza if __name__ == "__main__" in tutti quei casi in cui vogliamo che il codice sia chiamato sia come programma che come modulo.
· Pyton e CISCO
https://www.packettracernetwork.com/internet-of-things/
https://developer.cisco.com/learning/modules/fundamentals/fileMedia
http://wpage.unina.it/rcanonic/didattica/rc/rc1_2018.html
https://docs.python.org/3/library/__main__.html
https://www.programmareinpython.it/video-corso-python-intermedio/03-if-name-main/
Esempio STRuttURA DI UN PROGRAMMA Python in PT:
#importa librerie
from time import *
from gpio import *
…
#inizializzazione variabile e I/O
def setup ():
pinMode(0, INPUT) #Wind Detector
..
var1=0
..
customWrite(2, var1) #Window open
…
#funzioni e main
def funtion1():
global switchValue
….
def main():
setup()
print ("GO!")
#ciclo infinito
while True:
funtion1()
print("LED1 ON")
delay(1000)
#chiamata a main
if __name__ == "__main__":
main()
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.
#!/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')
input("Press Enter to continue...")
=====================================================
while expression:
statement(s)
---------------------------------------------------------------
#!/usr/bin/python3
count = 0
while (count < 9):
print ('The count is:', count)
count = count + 1
print ("Good bye!")
-------------------------------------------------------------------------------
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)
=====================================================
#!/usr/bin/python3
# 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
#!/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)
# 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]
changemel( mylist )
print ("l-Values outside the function: ", mylist)
#============================================================
input("Press Enter to continue...")
print(test)
========================================================================
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/
(cfr. https://www.raspberrypi.org/documentation/usage/python/ )
In Raspbian ci sono vari modi di lanciare Python:
-------- 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”
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
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
Raspbian include un IDE - Integrated Development Environment - chiamato IDLE:
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
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.
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)
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
#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)
-----------------------------------
#!/usr/bin/python3
#definizione di funzione
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)
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()
------------------------------------------------------------------------------------------------------------------------------------------------------------
#!/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)
#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)
(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)
------
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
#!/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)
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'}
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)
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.
Ogni programma conterrà:
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
Import libreria Pi.GPIO | Settaggio pin IN/OUT (esempio) |
Due modalità:
|
GPIO.setup(12, GPIO.IN, pull_up_down=GPIO.PUD_UP) input_state = GPIO.input(12)
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
PIN fisici -> Significato |
|
-----------------------NOTA Trasmissioni seriali sincrone e asincrone con Raspberry
---------------- fine nota -------------------------------------------------------------------------------------------
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
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.
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
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
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:
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()
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
(Raspberry Pi is equipped with pull-ups and pull-down resistors that can be activated via software
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
Il programma btnled1.py utilizza :
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
FT1060M scheda: https://www.futurashop.it/Allegato_PDF_IT/7100-FT1060M.pdf
Scheda di sperimentazione analogico/digitale:
Il programma btnled2.py utilizza :
#!/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')
time.sleep(0.5)
GPIO.output(24, 0) ## LED off
except KeyboardInterrupt:
GPIO.cleanup() #pulisce e resetta GPIO
Segnalazioni con Led
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:
|
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
# 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)
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)):
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/ :
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
----------------------------------------------
OUT Analogico PWM (“Pulse-Width Modulation”)
(da Arduino-primi calci) Approfondimento Digitale vs Analogico
DIGITALE | 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.
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/
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 |
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
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
Realizzazione (come linea e punto nel codice Morse):
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
data = ser.read(10) #Read ten characters from serial port to data
ser.write(data) #Send back the received data
ser.close()
#!/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
(a cura di Serena Arena)
#!/bin/bash
# sudo sh PushButton_OnOff.sh
# Pin setting: 4=PushButton(in)
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
-----------------------------------------------------------------------
(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
echo 3 > /sys/class/gpio/unexport
echo 4 > /sys/class/gpio/unexport
---------------------------
(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.
Per operare dalle postazioni remote del laboratorio (ad esempio da Sistemi-PC1) è necessario attuare una serie di passi per la configurazione del sistema complessivo.
| /* 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 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() 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() |
Un altro esempio (senza stati):
| ## 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") GPIO.output(16,0) GPIO.output(21,0) sleep(timeR) GPIO.output(20,1) win1=0 win2=0
except KeyboardInterrupt: GPIO.cleanup() |
Cfr. http://moodle.isisfacchinetti.it/mod/data/view.php?d=21&rid=747
(AS16-17\5IA\sistemi\IOT 2016\Symphy)
| ##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)) 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" 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) |
-Python Quick Reaction Game
-- https://projects.raspberrypi.org/en/projects/python-quick-reaction-game
Documentazione ufficiale: https://www.raspberrypi.org/documentation/
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/
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
Login: pi
Pass: raspberry
….. Sperimentare, esplorare e divertirsi
Provare
lsusb per verificare le periferiche USB
dmesg | tail per verificare le funzionalità del sistema
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).
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:
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.
Da Desktop con il tasto di destro cliccare sull’icona che rappresenta il collegamento in rete (fig. r3)
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
fig. 1 – putty con SSH su porta 22
Login pi
Password raspberry
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.
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
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 “)
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
sudo nano /etc/hosts
.. raspsisx
save and exit
sudo nano etc/hostname
.. raspsisx
(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 )
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
Fig. r2 menu per l’abilitazione di SSH
Accedere con Putty a Raspberry e aggiornare il sistema (consigliato)
sudo apt-get update
Attendere la fine .entro qualche minuto.
sudo apt-get install xrdp
….
Attendere la fine entro qualche minuto
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) .
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/windows-7-connect-to-another-computer-remote-desktop-connection |
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 .)
(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 )
Diventiamo amministratori
sudo -i
Aggiorniamo i repository, in modo da scaricare tutti i pacchetti necessari
apt-get update
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.
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:
Utente: | pi |
Password: | raspberry |
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
)
Oppure come in figura sottostante con il comando sudo chmod -R 777 /var/www
----------------------------------------------------------------------------------------------------------------------------------------
Chiamiamo ora il server web:
……………………………………………………………………………………...
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.
----------------------------------------------------------------------------------------------------------------------------
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
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.
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:
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.
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;
E’ possibile accedere a Raspberry remoto anche tramite FTP
La gestione via FTP si ottiene ad esempio con Filezilla
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')
time.sleep(0.2)
-------------------------------------------------------------------------
chiamata:
pi@raspberrypi ~ $ sudo python switch.py
http://www.instructables.com/id/Raspberry-Pi-Location-Tracker/
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 #
####################
#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.10.24 --