Python per Raspberry Introduzione Introduzione Python un linguaggio
Python per Raspberry Introduzione
Introduzione • • Python è un linguaggio interpetato La traduzione in linguaggio macchina viene eseguita riga per riga di comando. Per questo motivo, un programma in python può essere scritto anche in una shell riga per riga. Ciò però non permette di salvare il programma Se il programma viene salvato in un file di estensione. py, una volta salvato e tradotto i bytecode, viene eseguito sempre quel bytecode. Se invece, al file vengono apportate delle modifiche e processato con lo stesso nome, anche il bytecode cambia. Un file python può essere editato in due modi: – – • Dalla shell del sistema opeativo Dalla finestra grafica Se il sistema operativo è ubuntu, un file python viene editato in uno dei seguenti modi: – – Dalla shell si scrive sudo nano nomfile. py; si apre la schermata nera dove scrivere il codice ; per chiudere il file e salvare bisogna pigiare i tasti ctrl^x Dalla finestra grafica di ubuntu, se è installato python; compare la schermata di python; basta poi scegliere new file. Nella schermata di python, dalla riga di comando, si possono digitare i vari comandi ma ciò non è comodo perché i comandi non vengono salvati Per fare eseguire un programma python si può scrivere • • Sul propt dei programmi: python nomefile. py Dal menù a tendine: run
Un po’ di sintassi • Python è un linguaggio case sensitive • I commenti iniziano con il simbolo # • Come in ogni linguaggio, anche in python ci sono i tipi di variabili che però non vanno dichiarati. I tipi base sono: interi, float, caratteri • Per far comparire una scritta sul monitor basta scrivere il seguente comando: print(“commento”)
Lampeggio di un led
Python e Raspberry: lampeggio di un led 1) import RPi. GPIO as gpio 2) import time 3) gpio. setwarnings(False) 4) gpio. setmode(gpio. BCM) 5) gpio. setup(7, gpio. OUT) 6) while True: 7) gpio. output(7, True) 8) time. sleep(1) 9) gpio. output(7, False) 10) time. sleep(1)
Lampeggio di un led Il programma precedente gestisce il lampeggio di un led fino a che il microprocessore è acceso. 1. import Rpi. GPIO as gpio importa la libreria e crea una istanza 2. import time importa la libreria per gestire il tempo 4. setmode imposta in quale modo si fa riferimento ai pin. – – 5. 3. gpio. setmode(gpio. BOARD) indica che si vuole accedere ai pin attraverso il loro numero gpio. setmode(gpio. BCM) indica che si utilizzerà il numero di porta GPIO gpio. setup(7, gpio. OUT) imposta la GPIO 7 come output gpio. setwarnings(False) disabilita tutte le porte gpio se erano impegnate in processi precedenti. Questo comando è opzionale. Se non viene utilizzatocomparire il messaggio di canale occupato. 4. while True: inizio del blocco di programma attivo fino a che c’è alimentaxione al microprocessore 5. gpio. output(7, True) il livello logico sul pin 7 è alto e il led è acceso 6. time. sleep(1) si attende un secondo 7. gpio. output(7, False) il livello logico sul pin 7 è basso e il led è spento 8. time. sleep(1) si attende un secondo Se si vuole far comparire sul monitor lo stato del led basta aggiungere dopo la settima riga di comando, il seguente codice: print(“led acceso”) e, dopo la nona riga di comando, il codice: print(“led spento”)
Lampeggio di un led per 10 volte import RPi. GPIO as GPIO import time GPIO. setmode(GPIO. BCM) GPIO. setup(7, GPIO. OUT) for i in range(0, 10): GPIO. output(7, GPIO. HIGH) time. sleep(2) GPIO. output(7, GPIO. LOW) time. sleep(1) GPIO. cleanup()
Lampeggio di un led per 10 volte • Nel programma precedente sono state inserite due nuove righe colorate in giallo: – for i in range(0 10): inizia il blocco che fa ripetere 10 volte un insieme di comandi che vengono racchiusi in una indentazione – GPIO. cleanup() questo comado è opzionale; è fuori dalla indentazione del for e disabilita tutte le GPIO quando termina il for, libera il pin
Accensione di un led con un pulsante import RPi. GPIO as gpio import time gpio. setmode(gpio. BCM) gpio. setup(18, gpio. OUT) gpio. setup(7, gpio. IN) while True: inva=gpio. input(7) if inva==False: gpio. output(18, False) time. sleep(1) if inva==True: gpio. output(18, True)
Led pilotato da un pulsante
Accensione di un led con un pulsante • Per pilotare l’accensione di un led con un pulsante, sono state aggiunte le righe di programma colorate in giallo • Bisogna prima settare il pin sul quale è posizionato il pulsante, come input tramite il comando gpio. setup(7, gpio. IN) • Nel blocco di comando while True: , compare una riga di programma altri due blocchi di programma: 1. 2. inva=gpio. input(7) if inva==False: 3. if inva==True: gpio. output(12, False) time. sleep(1) gpio. output(12, True) La 1. legge il valore sul pin 7 e lo chiama inva Il blocco 2 verifica che il pulsante non è premuto e allora, il led resta spento Il blocco 3 verifica che il pulsante è premuto e allora, il led si accende
PWM import RPi. GPIO as GPIO import time GPIO. setmode(GPIO. BOARD) GPIO. setup(12, GPIO. OUT) p=GPIO. PWM(12, 70) p. start(0) p. Change. Duty. Cycle(30) time. sleep(2) p. Change. Duty. Cycle(0) p. stop() GPIO. cleanup()
Pwm • Diamo per scontato che si conosca la pwm • In azzurro è stato colorato un comando nuovo che non centra con la pwm, GPIO. setmode(GPIO. BOARD); questo comando indica che si terrà conto della numerazione dei pin secondo il pettine e non secondo il nome dato. Il pin PWM è il 12 secondo la numerazione BOARD che coincide con il 18 secondo la numerazione BCM. Si può però generare un segnale PWM sui pin 12, 33, 35 ONBOARD di Raspberry, che corrispondono come BCM a GPIO 18, GPIO 12, GPIO 13, GPIO 19 • In giallo sono colorati i comandi tipici della PWM – p=GPIO. PWM(12, 70) si da un nome alla inizializzazione della PWM sul pin 12 a 70 Hz, si crea una istanza – p. start(0) il duty cycle di partenza è zero – p. Change. Duty. Cycle(30) porta il duty cycle al 30% – p. stop() termina la pwm • Il programma successivo cambia solo dei parametri
Pin PWM
PWM import RPi. GPIO as GPIO. setmode(GPIO. BCM) GPIO. setup(18, GPIO. OUT) p = GPIO. PWM(18, 50) p. start(50) p. Change. Duty. Cycle(90) p. Change. Frequency(100) p. stop() GPIO. cleanup()
Frequenza PWM La frequenza di PWM varia a seconda del programma utilizzato
PWM, cambiare il duty cycle dalla tastiera import RPi. GPIO as GPIO. setmode(GPIO. BCM) GPIO. setup(18, GPIO. OUT) lum= GPIO. PWM(18, 500) lum. start(100) while True: duty_s = raw_input(“Inserisci la luminosità (0 duty = int(duty_s) lum. Change. Duty. Cycle(duty) to 100): ")
PWM, cambiare il duty cycle dalla tastiera • Nel programma precedente il duty cycle viene scelto da tastiera • Anche in questo caso i nuovi comandi vengono colorati di giallo – raw_input() acquisisce un dato da tastiera e lo chiama duty_s – int(duty_s) trasforma un dato che viene visto come carattere, in intero e lo chiama duty • Per poter inserire il dato da tastiera, bisogna eseguire il programma dalla shell di ubuntu con il codice nomefile. py; il programma attende un comando e poi esegue le istruzioni
PWM, cambiare il duty cycle dalla tastiera
Luminosità variabile import RPi. GPIO as GPIO import sleep ledpin = 12 GPIO. setwarnings(False) GPIO. setmode(GPIO. BOARD) GPIO. setup(ledpin, GPIO. OUT) pi_pwm = GPIO. PWM(ledpin, 1000) pi_pwm. start(0) while True: for duty in range(0, 101, 1): #il led si accende piano da 0% a 100% pi_pwm. Change. Duty. Cycle(duty) sleep(0. 01) sleep(0. 5) for duty in range(100, -1): #il led si spegne piano da 100% a 0% pi_pwm. Change. Duty. Cycle(duty) sleep(0. 01) sleep(0. 5)
PWM, cambiare il duty cycle da tastiera su più canali import RPi. GPIO as GPIO. setmode(GPIO. BCM) GPIO. setup(18, GPIO. OUT) lum= GPIO. PWM(18, 500) GPIO. setup(25, GPIO. OUT) lum 1= GPIO. PWM(25, 500) GPIO. setup(8, GPIO. OUT) lum 2= GPIO. PWM(8, 500) lum. start(100) lum 1. start(100) lum 2. start(100) while True: duty_s = raw_input(“Inserisci la luminosità (0 duty = int(duty_s) lum. Change. Duty. Cycle(duty) lum 1. Change. Duty. Cycle(duty) lum 2. Change. Duty. Cycle(duty) to 100): ")
PWM, cambiare il duty cycle da tastiera su più canali con valori differenti import RPi. GPIO as GPIO. setmode(GPIO. BCM) GPIO. setup(18, GPIO. OUT) lum= GPIO. PWM(18, 500) GPIO. setup(25, GPIO. OUT) lum 1= GPIO. PWM(25, 500) GPIO. setup(8, GPIO. OUT) lum 2= GPIO. PWM(8, 500) lum. start(100) lum 1. start(100) lum 2. start(100) while True: duty_s = raw_input(“Inserisci la luminosità del led giallo (0 to 100): ") #si creano tre variabili differenti duty = int(duty_s) duty_s 1 = raw_input(“Inserisci la luminosità del led rosso (0 to 100): ") duty 1 = int(duty_s 1) duty_s 2 = raw_input(“Inserisci la luminosità del led blu (0 to 100): ") duty 2 = int(duty_s 2) lum. Change. Duty. Cycle(duty) lum 1. Change. Duty. Cycle(duty 1) lum 2. Change. Duty. Cycle(duty 2)
Frequenza di pwm Frequenza richiesta Frequenza misurata 50 Hz 100 Hz 98. 7 Hz 200 Hz 195 Hz 500 Hz 470 Hz 1 k. Hz 980 Hz 10 k. Hz 4. 4 Hz Importante notare che all’aumentare della frequenza, diminuisce la stabilità
- Slides: 23