Gestire linee IO della Pico

La Pi Pico possiede 26 linee GPIO. Per poterle utilizzarle dobbiamo definirle come linee di ingresso o come linee di uscita, come avviene con Arduino con l’istruzione pinMode().

Realizziamo un semplice circuito come il seguente:

In questo caso le istruzioni da utilizzare fanno parte del modulo machine, quindi la prima istruzione da usare e l’importazione del modulo:

import machine

per definire un pin come uscita digitale utilizzeremo questa istruzione:

led = machine.Pin(15, machine.Pin.OUT)

L’oggetto led possiede il metodo value che permette di portare a livello alto o basso lo stato del pin:

led.value(1) # mette alto il pin 15
led.value(0) # mette basso il pin 15

Il classico blink del led si esegue con il seguente codice:

import machine
import utime

#definisco il pin gpio 15 come uscita
led = machine.Pin(15, machine.Pin.OUT)

while(1):
    led.value(1) # uscita a livello logico alto
    utime.sleep(1) # pausa di 1 secondo
    led.value(0) # uscita a livello logico basso
    utime.sleep(1) # pausa di 1 secondo
    

GPIO Speed Test

Dal codice precedente, eliminando l’istruzione sleep() possiamo misurare la velocita massima di commutazione del pin

import machine
import utime

#definisco il pin gpio 15 come uscita
led = machine.Pin(15, machine.Pin.OUT)

while(1):
    led.toggle() # mette l'uscita alta e poi bassa 

ottenendo una frequenza di commutazione di circa 60,5 KHz ma che presenta una continua variazione del livello alto dell’onda di circa  +- 1.3uS

Questo fenomeno e tipico in tutti i microcontrollori che eseguono codice interpretato, queste latenze sono intrinseche e tipicamente tollerate in questi sistemi. Per avere tempistiche certe nell’esecuzione dei programmi dobbiamo usare codici compilati e ottimizzati per l’architettura del microcontrollore.

Configurare un ingresso digitale

allo stesso modo delle istruzioni viste in precedenza possiamo definire un pin in ingresso con il seguente codice:

import machine
import utime

#definisco il pin gpio 15 come uscita
led = machine.Pin(15, machine.Pin.OUT)
#definisco il pin gpio 16 come ingresso
pulsante = machine.Pin(16, machine.Pin.IN)

while(1):
    if pulsante.value() == 0:
        print("pulsante premuto!")

        utime.sleep(0.2)
    
    # continuo a commutare il pin 15
    #la frequenza ora è di circa 26KHz
    led.toggle()

Utilizzare un thread

Lo svantaggio di avere delle latenze dovute alla presenza dell’interprete MicroPython può essere in parte compensato da un linguaggio ad alto livello che permette di scrivere il codice con un approccio moderno come quello dell’uso dei Thread.

Un thread è un processo che può essere eseguito in contemporanea (o quasi) con l’esecuzione di altro codice. Nell’esempio seguente il codice del thread controllerà quando premiamo il pulsante. Mentre il resto del programma continuerà a eseguirà le altre istruzioni.

import machine
import utime
import _thread

#creo una variabile globale che verrà usata in tutte le funzioni
global stato_pulsante
stato_pulsante = False

#definisco il pin gpio 15 come uscita
led = machine.Pin(15, machine.Pin.OUT)
#definisco il pin gpio 16 come ingresso
pulsante = machine.Pin(16, machine.Pin.IN)

#creo una funzione che verrà gestita dal thread
def leggi_stato_pulsante():
    global stato_pulsante
    while True:
        # se premo il pulsante cambio il valore della 
        # variabile globale
        if pulsante.value() == 0:
            stato_pulsante = True
            utime.sleep(0.2)

#creo un thread e lo associo alla funzione precedentemente creata
_thread.start_new_thread(leggi_stato_pulsante, ())

#questo è il codice del thread principale
while True:
    #controllo il valore della variabile globale
    if (stato_pulsante == True):
        print("pulsante premuto!")
        #reimposto la variabile globale a False
        global stato_pulsante
        stato_pulsante = False
    
    #continuo a eseguire la commutazione del pin 15
    led.toggle()

L’effetto di questo codice è uguale al precedente ma la scrittura del codice rimane qualitativamente migliore.

The post Come usare pin IO digitali della Pico appeared first on Esperimenti con logiche programmabili.

Nonostante la presenza di alcune schede della serie MKR che hanno a bordo il modulo WiFi è da qualche tempo disponibile la scheda UNO WiFi r2. Questa nuova scheda ha numerose funzionalità rispetto alla UNO (basata sul micro ATMEGA328) e personalmente credo che la caratteristica maggiore sia la presenza del microcontrollore ATMEGA4809. Nonostante la maggior parte dei progetti basati su Arduino impieghi il micro ATMEGA328 probabilmente è ora il momento di guardare avanti utilizzando un nuovo microcontrollore.

ATMEGA4809 Arduino UNO WiFi r2Per capire cosa c’è di nuovo nell’ATMEGA4809, di seguito una tabella comparativa tra i vari micro delle schede Arduino UNO, Leonardo e UNO WiFi

Si può notare subito una maggiore quantità di memoria programma, una maggiore quantità di memoria SRAM e la presenza di ben 4 seriali UART.
Il package  può essere un limite, sono disponibili infatti il TQFP48 e il UQFN, e questo significa che per utilizzarlo in progetti custom è necessario utilizzare un pcb o un supporto adattatore (TQFP to DIP).

Probabilmente avrebbe più senso avere una versione delle schede serie MKR con questo microcontrollore. In questo modo verrebbe semplificata la prototipazione di schede custom.

Sulla carta l’ATMEGA4809 ha molte caratteristiche che potrebbero permettere una evoluzione della piattaforma Arduino basata sui microcontrollori a 8 bit. La presenza di 5 timers, il gran numero di line GPIO (41), 11 linee PWM e altre funzionalità, che potete leggere sul datasheet, lo candidano (forse) ad essere il dispositivo ideale per essere utilizzato nelle future schede.

ATMEGA4809 Speed Test

Come negli articoli precedenti ho eseguito una commutazione continua di una linea GPIO per misurare la frequenza di commutazione. Eseguendo il codice sottostante e misurando e misurando con un oscilloscopio la frequenza di commutazione presente sulla linea GPIO 0 ho ottenuto un valore di circa 138.3KHz.

void setup()
{
  //pin0 in uscita
  pinMode(0, OUTPUT);
}
 
void loop()
{
  //ciclo infinito
  while(true)
  {
    //metto il pin0 alto
    digitalWrite(0, HIGH);
    //metto il pin0 basso
    digitalWrite(0, LOW);
  }
}

Di seguito la tabella riepilogativa aggiornata:

Le voci dove è presente l’asterisco (*) sono i nuovi valori ottenuti utilizzando gli ultimi aggiornamenti (Arduino avr Boards versione 1.6.23)

The post Arduino Uno WiFi Rev2 GPIO speed test appeared first on Esperimenti con logiche programmabili.

Sapiamo che le schede Raspberry Pi offrono un panorama di impiego molto ampio, grazie anche alla presenza di un connettore maschio a 40 pin (Raspberry Pi 1, 2, 3, Zero) che interfaccia la scheda a diverse tipologie di circuiti elettronici. Questa possibilità è data da una serie di linee GPIO che possono essere programmate anche con Python.

Cosa sono le linee GPIO

Le linee GPIO (general purpose input output) sono dei collegamenti tra il processore e i pin del connettore della scheda. Queste linee possono essere programmate sia per funzionare come porte di ingresso sia come porte di uscita. Alcune di queste linee hanno delle funzionalità aggiuntive infatti possono essere configurate come linee UART, SPI o I2C.

Pin function

Per conoscere la posizione e la denominazione delle linee GPIO nel connettore a 40 pin del Raspberry Pi utilizzo il comando pinout. Apriamo il terminale LxTerminal e digitiamo il seguente comando:

$ pinout

premiamo invio e dopo qualche istante avremo sul terminale la rappresentazione delle periferiche della scheda ed in particolare del connettore a 40 pin:

In verde sono elencate le linee GPIO, in grigio i pin collegati a GND, in rosso le linee di alimentazione a 5Vdc ed in celeste le linee di alimentazione a 3,3V

La programmazione delle porte IO può avvenire utilizzando diversi linguaggi di programmazione, ma naturalmente andremo ad utilizzare il linguaggio Python perché è quello che viene maggiormente usato su questa piattaforma (almeno credo!).

Gestire le linee GPIO con Python

Configurare pin Gpio in uscita

Per utilizzare le porte IO abbiamo a disposizione l’attributo GPIO del modulo RPi. Questo attributo mette a disposizione i metodi per definire una linea come ingresso o come uscita e ne permette di controllarne lo stato. Se è una linea di uscita è possibile porla a livello logico alto oppure basso, se è una linea di ingresso è possibile leggere il valore logico disponibile sul pin.

Per scrivere il programma Python usiamo Thonny, disponibile come software preinstallato nelle ultime versioni di Raspbian.

scriviamo la prima istruzione che definisce l’attributo GPIO

from RPi import GPIO

L’istruzione seguente, invece, è necessaria per definire il modo di riferimento del pin. In pratica possiamo riferirci ad un pin tramite la numerazione del connettore (da 1 a 40) o tramite la numerazione del processore (ad esempio gpioxx). Usando l’istruzione seguente utilizzeremo la numerazione gpio del processore

GPIO.setmode(GPIO.BCM)

quindi per definire il pin 40 (gpio21) come linea di uscita dovremmo scrivere la seguente istruzione:

GPIO.setup(21, GPIO.OUT)

il metodo setup accetta come primo argomento il numero della linea gpio, in questo caso la 21, che corrisponde al pin 40. Se avessi usato questa istruzione per definire il riferimento ai pin:

GPIO.setmode(GPIO.BOARD)

nel metodo setup avrei dovuto scrivere:

GPIO.setup(40, GPIO.OUT)

le due istruzioni precedenti producono lo stesso risultato, ovvero definire il pin 40 (gpio21) come una uscita.

Una volta definito il pin come linea digitale di output possiamo gestirne lo stato con la seguente istruzione:

#uscita a livello logico alto
GPIO.output(21, GPIO.HIGH)
#uscita a livello logico basso
GPIO.output(21, GPIO.LOW)

di seguito il codice completo:

from RPi import GPIO
import time

#tipo di riferimento, numerazione della cpu
GPIO.setmode(GPIO.BCM)

#imposto linea 21, pin 40, come uscita
GPIO.setup(21, GPIO.OUT)

#ciclo infinito
while (True):
    #metto la linea 21 alta
    GPIO.output(21, GPIO.HIGH)
    #attendo 1 secondo
    time.sleep(1)
    #metto la linea 21 bassa
    GPIO.output(21, GPIO.LOW)
    #attendo 1 secondo
    time.sleep(1)

Di seguito il circuito uttizzato per verificare la corretta esecuzione del codice

Configurare pin Gpio in ingresso

Allo stesso modo di come abbiamo configurato un pin in uscita possiamo utilizzare alcune semplici istruzioni per impostare un pin in ingresso. L’istruzione seguente configura la linea Gpio 20 (pin 38) come ingresso:

GPIO.setup(20, GPIO.IN)

Per leggere il livello logico presente sul pin dobbiamo utilizzare la seguente istruzione

GPIO.input(20)

Il seguente circuito permette di avere sul pin 38 (gpio20) un livello logico alto (+3.3Vdc) e premendo il pulsante un livello logico basso (0Vdc).

Il codice per verificare lo stato del pin è il seguente:

from RPi import GPIO
GPIO.setmode(GPIO.BCM)

GPIO.setup(20, GPIO.IN)

while (True):
    if GPIO.input(20)== False:
        print ("Pulsante premuto")

Ogni volta che premeremmo il pulsante verrà printata la stringa “Pulsante premuto”.

Queste che abbiamo visto sono le istruzioni basilari che ci permettono di interfacciare il Raspberry Pi al mondo esterno utilizzando le linee GPIO come ingressi e uscite digitali.

The post Raspberry Pi come usare linee GPIO appeared first on Esperimenti con logiche programmabili.

Anche per il modulo Flyporyt Ethernet ho realizzato lo speed test come quello per le schede Netduino, Arduino e GHI. Il test consiste nella commutazione continua di un singolo pin digitale, misurando con un oscilloscopio, la frequenza risultante.

Il circuito elettrico dei collegamenti è il seguente:

mentre questo è il risultato della misura:

Come si può osservare la frequenza e di ben 134.5KHz, un risultato che reputo molto soddisfacente, paragonato ai precedenti speed test.

La tabella seguente riepiloga i risultati misurati con le varie schede

Lo speed test è indicativo e non stabilisce certamente la scheda migliore. Ogni dispositivo possiede pro e contro a prescindere dal risultato dello speed test.

The post Flyport Ethernet Speed Test appeared first on Esperimenti con logiche programmabili.

L’utilizzo dei pin digitali rientra tra le nozioni basilari da comprendere per poter iniziare ad interagire con  i dispositivi ed i componenti esterni che permettono al modulo Flyport Ethernet di far parte di un sistema complesso.
Il modulo Flyport Ethernet è composto da due connettori, J1 e J2; essi sono collegati direttamente ai pin del microcontrollore Pic24F ed al controller Ethernet ENC424J600.

Tramite questi connettori possiamo collegarlo al modulo NEST Proto o ad un nostro circuito host dedicato.
Nel mio caso utilizzerò il Nest Proto per motivi di semplicità e di uniformità dei tutorial.

Nel Nest Proto è presente un connettore femmina collegato direttamente al connettore J1 del Flyport Ethernet, che permette di utilizzare dei fili elettrici pint-to-pin per realizzare velocemente prototipi ed esperimenti. Tralasciamo, per ora, il connettore J2 che viene impiegato per la comunicazione ethernet (tramite una porta RJ45 da saldare sul NEST Proto), e per offrire altri 8 pin IO.

Il connettore J1 è composto da 26 pin, ad ognuno è associata una funzione specifica. La tabella seguente mostra la pin-function del connettore:

Configurare pin GPIO come uscita

I pin contrassegnati come GPIO possono funzionare sia come ingressi sia come uscite digitali. La colonna Remappable indica invece se al pin può essere associata una funzione speciale, ad esempio i pin p1 e p3 NON sono rimappabili e quindi possono essere configurati o come GPIO o come bus I2C. Un pin rimappabile può funzionare sia come GPIO ed è possibile associarli anche una funzionalità aggiuntiva come PWM, UART o SPI. Questa peculiarità permette di avere un sistema molto flessibile, configurabile per ogni esigenza progettuale.
La colonna, 5V Tollerant, indica se il pin può sopportare tensioni di 5 Volt (Logica TTL), ad esempio il pin p17 non è 5V tollerant e quindi dobbiamo stare molto attenti a non collegare tensioni superiori ai 3.3V, causa possibile danneggiamento del microcontrollore.

Utilizziamo il circuito in figura per scrivere un piccolo programma che utilizzerà le istruzioni per definire il pin p2 come uscita digitale:

al pin p2, ho collegato una resistenza da 330 ohm ed un diodo led. Da notare che i numeri dei pin sono disposti utilizzando la prima riga, del connettore J1, per i numeri dispari e la seconda riga per i numeri pari.

Il codice seguente accende e spegne il led ogni 500ms:

[c]
#include "taskFlyport.h"

void FlyportTask()
{
//il pin p2 viene configurato
//come uscita digitale
IOInit(p2, out);

//ciclo infinito
while(1)
{
//commuto il pin p2 a livello
//logico alto
IOPut(p2, on);
//creo un ritardo di 500ms
DelayMs(500);
//commuto il pin p2 a livello
//logico basso
IOPut(p2, off);
//creo un ritardo di 500ms
DelayMs(500);
}
}
[/c]

L’istruzione che permette di definire un pin come uscita o come ingresso è la IOInit(). I parametri da passare sono il numero del pin, espresso nella forma px (dove x è il numero del pin) ed il flag per specificare un uscita out o un ingresso in.
In questo caso il pin p2 viene usato come uscita (out). Per poter commutare il suo stato logico utilizziamo la funzione IOPut(). Questa funzione accetta due parametri, il primo è il numero del pin, definito nella IOInit, e il secondo specifica se metterlo a livello logico alto (on) o al livello basso(off).

Configurare pin GPIO come ingresso

Il pin p2 viene ora impiegato come ingresso digitale. Lo schema elettrico è il seguente:

la resistenza R1 serve per avere un livello logico basso sul pin p2 quando il pulsante è aperto. Sul pin p4 ho collegato un diodo led in modo da poterlo accendere quando premo sul pulsante.
Questo è il codice del firmware da caricare sul Flyport:

[c]
#include "taskFlyport.h"

void FlyportTask()
{
//il pin p2 viene configurato
//come Ingresso digitale
IOInit(p2, in);

//il pin p4 viene configurato
//come Uscita digitale
IOInit(p4, out);

//ciclo infinito
while(1)
{
//verifico lo stato del pin p2
//Alto o basso
if(IOGet(p2) == 1)
//sel il pin è a livello
//logico alto, accendo il led
IOPut(p4, on);
else
//altrimenti
//spegni il led
IOPut(p4, off);

DelayMs(20);
}
}
[/c]

Ho usato due istruzioni IOInit per definire il pin p2 come ingresso e il pin p4 come uscita. Nel blocco while, controllo, con l’istruzione IOGet, se il livello logico sul pin p2 è alto. In caso affermativo, utilizzo il pin p4, per accendere o spegnere il diodo led.

Nei prossimi tutorial vedremo come attivare la resistenza interna di pull-up e di pull-down per gli ingressi digitali del Flyport Ethernet.

The post Flyport Ethernet, conoscere i pin digitali appeared first on Esperimenti con logiche programmabili.

Per eseguire una comparazione con Netduino ho eseguito lo stesso esperimento (Netduino speed test) anche per Arduino Uno. Il gpio speed test è molto semplice, basta definire un pin in uscita ed eseguire in modo ciclico un’istruzione che lo ponga a livello logico alto e poi basso.
Questa commutazione continua genera un segnale ad onda quadra misurabile con un oscilloscopio.

Il codice seguente mostra come effettuare questo test:

void setup()
{
  pinMode(0, OUTPUT); //Definisce il Pin0 come Uscita
}

void loop()
{
  while(true)
  {
    digitalWrite(0, HIGH); //Commuta l'uscita alta
    digitalWrite(0, LOW); //Commuta l'uscita bassa
  }
}

La frequenza ottenuta sul pin 0 è di ben 125 KHz decisamente superiore a quella ottenuta dal Netduino (8.4KHz) nonostante i suoi 48 Mhz di clock contro i 16Mhz dell’Arduino.

L’istruzione digitalWrite() impiega circa 4uS contro i 53uS della Write() eseguita dal Netduino.

Netduino impiega delle risorse per far girare il .Net micro framework ecco perché nello speed test contro Arduino esce perdente.
Arduino nonostante i sui 16Mhz di clock è capace di essere più veloce, perché il suo codice, accede direttamente alle funzioni a basso livello del microprocessore ATMEGA328.

The post Arduino Uno gpio Speed Test appeared first on Esperimenti con logiche programmabili.