• Codice Python sul Raspberry SQLite
• Codice sull’Arduino MKR Zero

Il progetto che ho realizzato riguarda il monitoraggio di temperatura e umidità all’interno di un locale tecnico. I dati rilevati da un sensore DHT22 vengono acquisti da una Arduino MKR Zero e tramite una shield MKR ETH inviati a un computer Raspberry PI 4 che dopo averli acquisiti li memorizza all’interno di una tabella SQLite.

Il protocollo utilizzato per l’invio dei dati si basa su UDP come abbiamo visto in questo articolo.

I dati sarebbero potuti essere memorizzati in un semplice file di testo ma ho preferito usare un database in modo tale da estrarli in modo rapido utilizzando semplici query. Il database contiene per ora una tabella contenente i seguenti campi:

Il codice seguente gira sul Raspberry Pi 4; ho inserito diversi commenti che spiegano le varie istruzioni contenute nel programma:

import sqlite3
import socket
import threading
import time

#IP computer locale
UDP_IP_ADDR = "192.168.178.50"
#Porta computer locale
UDP_PORT_NUMBER = 20002

ip_port_Data = (UDP_IP_ADDR, UDP_PORT_NUMBER)
   
def client_Receive_Data():
    print("Avvio THREAD Receive Data...")
    serversocket1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    serversocket1.bind(("192.168.178.30", 20001))
    msgToSend = str.encode("DB_OK")
    
    #crea connessione al database
    connection = sqlite3.connect('lopro.db')
    cursor = connection.cursor()
        
    try:            
        while True:            
            data, address = serversocket1.recvfrom(1024)
            strData = bytes.decode(data).split(":")
         
            sql = """ INSERT INTO tbl_log(Temperatura, Umidita) VALUES ('{}', '{}');""".format(strData[0], strData[1])
            
            print(sql)
            
            cursor.execute(sql)
            connection.commit()

            #invia al device una risposta
            serversocket1.sendto(msgToSend, ip_port_Data)
            time.sleep(1)
    except:
        print("errore")
        msgToSend = str.encode("ERRORE")
        serversocket1.sendto(msgToSend, ip_port_Data)
        connection.close()

def crea_tabella():
    #una volta creata la tabella possiamo evitare di chiamare
    #questa funzione ad ogni esecuzione del programma
    #crea connessione al database
    connection = sqlite3.connect('lopro.db')
    cursor = connection.cursor()
 
    #Se esiste la tabella cancellala
    #cursor.execute("DROP TABLE IF EXISTS tbl_log")
 
    # Crea la tabella se non esiste
    table = """ CREATE TABLE IF NOT EXISTS tbl_log (
            ID INTEGER PRIMARY KEY AUTOINCREMENT,
            Data TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
            Temperatura VARCHAR(50) NOT NULL,
            Umidita VARCHAR(50) NOT NULL      
        ); """
 
    cursor.execute(table)
    cursor.close()
    connection.close()

 
def list_rows():
    print("list rows..")
    #crea connessione al database
    connection = sqlite3.connect('lopro.db')

    sql = """ SELECT * FROM tbl_log;"""

    cursor = connection.cursor()
    cursor.execute(sql)
    rows = cursor.fetchall()

    for row in rows:
        print(row)

    # Close the connection
    connection.close()

if __name__=="__main__":
    #Rimuovere il commento per creare la tabella
    #crea_tabella()
    #list_rows()
    #Avvio un thred
    print("Start program")
    t1 = threading.Thread(target=client_Receive_Data)
    t1.start()

Questo è invece il codice che gira sulla Arduino MKR Zero; ho inserito diversi commenti che spiegano le varie istruzioni contenute nel programma:

#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
#include <DHT.h>

#define DHTPIN 6
#define DHTTYPE DHT22

// creo un MAC address e un IP address per la scheda Arduino
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 178, 50);

//creo un ip address per il raspberry
IPAddress ip_remote(192, 168, 178, 30);
//creo una porta per la scheda Arduino
unsigned int localPort = 20002; 

//creo degli array di char per la ricezione e l'invio dei
//dati via udp
char packetBuffer[UDP_TX_PACKET_MAX_SIZE];
char chrBuffer[11];

//altre variabili 
String strTempUmid = "";
byte ciclo = 0;

// Creo degli oggetti per l'utilizzo di udp e del 
//sensore dht
EthernetUDP Udp;
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  //inizializzo lo shield mkr eth
  Ethernet.init(5);

  //inizializzo la scheda di rete
  Ethernet.begin(mac, ip);

  //inizializzo la seriale
  Serial.begin(9600);
  
  // verifico la ethernet shield
  if (Ethernet.hardwareStatus() == EthernetNoHardware) {
    Serial.println("MKR ETH non presente o configurata in modo errato!");
    while (true) {
      delay(1);
    }
  }

  //inizializzo l'oggetto udp
  Udp.begin(localPort);
  //inizializzo l'oggetto dht
  dht.begin();
}

void loop() {

  //verifico presenza pacchetti udp in arrivo
  int packetSize = Udp.parsePacket();
  
  //se coi sono pacchetti
  if (packetSize) {
    //Serial.println(packetSize);
    //leggo i pacchetti e gli inserisco nell'array di char
    Udp.read(packetBuffer, UDP_TX_PACKET_MAX_SIZE);
    //printo i dati ricevuti
    Serial.println(packetBuffer);
  }

  //leggo umidità e temperatura dal sensore dht
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  //creo una stringa del tipo temp:umid
  strTempUmid = "";
  strTempUmid.concat(t);
  strTempUmid.concat(":");
  strTempUmid.concat(h);
  //printo la stringa sul ser mon
  Serial.println(strTempUmid);
  //converto la stringa in un array di char
  strTempUmid.toCharArray(chrBuffer, strTempUmid.length());

  //inizializzo la connessione con ip e porta del Raspberry
  Udp.beginPacket(ip_remote, 20001);
  //Scrivo i dati nel buffer
  Udp.write(chrBuffer);
  //invio i dati
  Udp.endPacket();

  //attendo un minuto prima del prossimo invio
  for (ciclo = 0; ciclo < 60; ciclo++)
    delay(1000);

}

Ogni minuto viene inviata una unica stringa contenente i dati di temperatura e umidita che il codice python provvederà a separate in due dati distinti per essere caricati sul database.

Memorizzare solo le variazioni significative su Raspberry SQLite

Possiamo ottimizzare lo spazio sulla tabella (e di conseguenza sul filesystem del Raspberry) memorizzando solo i dati che hanno una variazione significativa. In questo modo il monitoraggio rimane costante perché comunque l’Arduino legge e invia i dati ogni minuto ma posso risparmiare spazio sul database salvando solo le variazioni significative. Sulla tabella memorizzo anche il timestamp e quindi posso ricostruire l’andamento di temperatura e umidità interpolando i dati.

Il codice seguente mostra la modifica alla funzione client_Receive_Data() in modo tale da memorizzare solo i dati che hanno una variazione di 0.5 rispetto ai dati della lettura precedente rilevata dalla scheda Arduino:

def client_Receive_Data():
    print("Avvio THREAD Receive Data...")
    serversocket1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    serversocket1.bind(("192.168.178.30", 20001))
        
    # crea connessione al database
    connection = sqlite3.connect('lopro.db')
    cursor = connection.cursor()
    #creo due variabili per memorizzare i dati delle 
    #letture di temp e umid
    temp_prec = 0
    umid_prec = 0
    
    try:
        while True:
            data, address = serversocket1.recvfrom(1024)
            strData = bytes.decode(data).split(":")

            #verifico se i dati appena letti differiscono di 0.5 dai valori della lettuare precedente
            if (abs(temp_prec - float(strData[0])) > 0.5) or (abs(umid_prec - float(strData[1])) > 0.5) :
                print("Variazione di Temp e Hum")  
                sql = """ INSERT INTO tbl_log(Temperatura, Umidita) VALUES ('{}', '{}');""".format(strData[0], strData[1])

                #memorizzo i dati per poterli confrontare con quelli
                #che arrivano dalla scheda arduino
                temp_prec = float(strData[0])
                umid_prec = float(strData[1])
                #visualizzo la stringa sql
                print(sql)
                #eseguo la stringa sql insert avviando una transazione
                cursor.execute(sql)
                #confermo la transazione
                connection.commit()
                
                # invia al device una risposta
                msgToSend = str.encode("DB_OK")
                serversocket1.sendto(msgToSend, ip_port_Data)
            else:
                print("Nessuna variazione di Temp e Hum")  
                # invia al device una risposta
                msgToSend = str.encode("DB_NOK")
                serversocket1.sendto(msgToSend, ip_port_Data)
            
            time.sleep(1)
    except:
        print("errore")
        msgToSend = str.encode("ERRORE")
        serversocket1.sendto(msgToSend, ip_port_Data)
        connection.close()

L’utilizzo congiunto di Raspberry e Arduino ci permette di realizzare progetti che superano i limiti dati dalle singole schede.

The post Datalogger con Raspberry SQLite e Arduino appeared first on Esperimenti con logiche programmabili.

I progetti timelapse basati su schede Raspberry Pi sono numerosi, ben documentati e replicabili. Perchè quindi creare l’ennesimo progetto camera timelapse?

La mia esigenza è quella di creare un sistema che scatta delle fotografia ad intervalli regolari, ma con la possibilità di registrarle in modo circolare. Cosa significa registrazione circolare?
Il classico timelapse esegue un numero continuo di scatti. Il timelapse circolare invece, dopo aver raggiunto un numero massimo di scatti continua la sequenza di registrazione sovrascrivendo le foto meno recenti.

Questo sistema ha il vantaggio di non andare mai a saturare la memoria e quindi si adatta in tutte quelle situazioni in cui non possiamo andare spesso a scaricare le fotografie.

Infatti questo sistema è utile quando viene installato in zone remote e quando non abbiamo la certezza di andare a scaricare le foro in maniera regolare avendo la certezza che la registrazione saturerà la memoria del Raspberry.

Nel dispositivo che ho realizzato ho inserito anche una serie di pulsanti in modo da avere un sistema gestire il software senza usare l’interfaccia grafica.

Lo scarico dei dati avviene utilizzando dei pulsanti che permettono di stoppare il timelapse, trasferire i files sulla pen drive e riprendere il ciclo di funzionamento.

Nella figura seguente è possibile osservare lo schema elettrico.

I quattro ingressi del Raspberry sono normalmente bassi (resistenze da 10k collegate a massa), premendo un pulsante porteremmo la 3.3Vdc sul pin di ingresso. I due led invece servono per avere delle indicazioni luminose sull’operazione che il software sta eseguendo.

Il codice scritto in Python permette di acquisisce e memorizzare le foto, gestisce i pulsanti i led e scaricare le foto sulla pen drive.

from picamera import PiCamera
from os import system
import shutil
import time
import RPi.GPIO as GPIO
import os.path
import os

src_folder = "/home/pi/PythonProject/tl_pics/"
dest_folder = "/media/pi/logicapro/foto"

StartTL = True
AutoStart = True

i = 0
loop = False
newloop = False

GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)

GPIO.setup(19, GPIO.IN)
GPIO.setup(26, GPIO.IN)
GPIO.setup(4, GPIO.IN)
GPIO.setup(17, GPIO.IN)

GPIO.setup(27, GPIO.OUT)
GPIO.setup(22, GPIO.OUT)

#led rosso on giallo off
GPIO.output(27, GPIO.HIGH)
GPIO.output(22, GPIO.LOW)

camera = PiCamera()
camera.resolution= (1024,768)

pics_id = open('/home/pi/PythonProject/PicsIndex.dat')
i = int(pics_id.read())
pics_id.close()

if (i>0):
    loop=True

def StopTL(channel):
    global StartTL
    global AutoStart
        
    print("STOP TL")
    
    if StartTL == True:
        StartTL = False
        AutoStart = False
        print ("StartTL =", StartTL)
        print ("AutoStart =", AutoStart)
        GPIO.output(27, GPIO.HIGH)        
        time.sleep(1)    
        
            
def RunTL(channel):
    global StartTL
    global AutoStart
    
    print("START TL")
    
    if StartTL == False:
        StartTL = True
        AutoStart = True
        print ("StartTL =", StartTL)
        print ("AutoStart =", AutoStart)
        pics_id = open('/home/pi/PythonProject/PicsIndex.dat')
        i = int(pics_id.read())
        print ("RunTL i =", i)
        pics_id.close()
        GPIO.output(27, GPIO.LOW)
        GPIO.output(22, GPIO.LOW)        
        time.sleep(1)

GPIO.add_event_detect(17, GPIO.RISING, callback=StopTL, bouncetime=500)
GPIO.add_event_detect(4, GPIO.RISING, callback=RunTL, bouncetime=500)

while True:
    
    #primo pulsante
    if AutoStart == True:
        #start timelapse       
        while (StartTL):
            i += 1
            #print (i)
            if loop==True:
                #print ("i=", i)
                
                try:
                    t = time.localtime()
                    anno = str(t[0])
                    mese = str(t[1])
                    giorno = str(t[3])
                    #print(giorno + "-" + mese + "-" + anno)
                    #se esiste il file lo cancello
                    if (os.path.isfile('/home/pi/PythonProject/tl_pics/image{0:05d}.jpg'.format(i)) == True):
                        print("elimino file esistente ".format(i))
                        os.remove('/home/pi/PythonProject/tl_pics/image{0:05d}.jpg'.format(i))
                    
                    print("Eseguo shot " + str(i))
                    camera.capture('/home/pi/PythonProject/tl_pics/image{0:05d}.jpg'.format(i))
                    time.sleep(0.7)
                    GPIO.output(27, GPIO.HIGH)
                    time.sleep(0.3)
                    GPIO.output(27, GPIO.LOW)
                    #time.sleep(60)
                    pics_id = open('/home/pi/PythonProject/PicsIndex.dat', 'w')
                    pics_id.write(str(i))
                    pics_id.close()
                    print("pic_shot = " + str(i))
                except (e):
                    print("Errore shot " + str(i))
                    f = open('/home/pi/PythonProject/Error.txt', 'a')
                    f.write("Errore shot file " + str(e) + " ")
                    f.write(str(i) + "\n")
                    f.close()
                except:
                    print("Errore generico shot " + str(i))
                    f = open('/home/pi/PythonProject/Error.txt', 'a')
                    f.write("Errore shot file " + str(i) + " \n")
                    f.close()
            
                fc = open('/home/pi/PythonProject/CopyLog.txt', 'a')
                fc.write("Current shot ")
                fc.write(str(i) + "\n")
                fc.close()
            
                #attendi 2 minuti 60x2sec
                for tempo in range (60): #range(60):
                    GPIO.output(22, GPIO.HIGH)
                    time.sleep(0.1)
                    GPIO.output(22, GPIO.LOW)
                    time.sleep(1.9)
                    
                    if StartTL == False:
                        break
            
            #10080 5040
            if i >= 4320:
                i=0                
                loop=True                
                print("NEW LOOP")
                time.sleep(1)
            
            if GPIO.input(17):
                break
            
        print ("Exit loop")    
    
    #terzo pulsante
    if GPIO.input(19):
        #crea un video dai file del timelapse
        print("Terzo Pulsante")
        GPIO.output(22, GPIO.HIGH)
        time.sleep(0.5)
        GPIO.output(22, GPIO.LOW)
        time.sleep(0.5)
        GPIO.output(22, GPIO.HIGH)
        time.sleep(0.5)
        GPIO.output(22, GPIO.LOW)
        time.sleep(0.5)
        GPIO.output(22, GPIO.HIGH)
        time.sleep(0.5)
        GPIO.output(22, GPIO.LOW)
        time.sleep(0.5)
        os.system("sudo reboot")
        
    #quarto pulsante
    #copia le foto nella cartella della pen drive
    if GPIO.input(26):
        GPIO.output(27, GPIO.HIGH)
        GPIO.output(22, GPIO.HIGH)
        time.sleep(1)
        try:
            print("Copia file in corso")
            time.sleep(1)

            src = os.listdir(src_folder)

            for files in src:
                GPIO.output(22, GPIO.HIGH)
                time.sleep(0.1)

                if (files.endswith(".jpg")):
                    shutil.copy("/home/pi/PythonProject/tl_pics/" + files, dest_folder + "/" + files)
                    print(files)
                    
                GPIO.output(22, GPIO.LOW)
                time.sleep(0.1)
            
            #fine copia files
            GPIO.output(27, GPIO.LOW)
            GPIO.output(22, GPIO.LOW)
            
            os.system("sudo umount /media/pi/logicapro")
            time.sleep(3)
            
            print("Copia file terminata")
            AutoStart=True
            StartTL = True
            
        except (IndexError):
            print("Errore copia file")
            AutoStart=False
            GPIO.output(22, GPIO.HIGH)
            GPIO.output(27, GPIO.HIGH)
            time.sleep(3)
            GPIO.output(22, GPIO.LOW)
            GPIO.output(27, GPIO.LOW)
            f = open('/home/pi/PythonProject/Error.txt', 'a')
            f.write("Errore copia file ")
            f.write(str(files) + "\n")
            f.close()
        except  (Exception, e):
            print("Errore generico")
            f = open('/home/pi/PythonProject/Error.txt', 'a')
            f.write("Errore generico " + str(e))
            f.write(str(files) + "\n")
            f.close()
            AutoStart=True
            StartTL = True
        

GPIO.cleanup()

I commenti nel codice illustrano come lavorano le istruzione Python.

Per la realizzazione ho scelto di utilizzare una Raspberry Pi ZERO, principalmente per il basso costo e le dimensioni contenute. La Pi camera può essere sostituita con la versione ir.

Per quanto riguarda l’alimentazione della scheda in zone remote è necessario un pannello solare, un regolatore di carica e una batteria dimensionati opportunamente per fornire la corrente per alimentare la Pi Zero e la Pi Camera.

The post Il miglior progetto timelapse camera con Raspberry Pi Zero appeared first on Esperimenti con logiche programmabili.

Nello scorso articolo abbiamo visto come configurare la Raspberry Pi Pico per poter essere programmata utilizzando il linguaggio MicroPython. In particolare abbiamo installato e configurato Thonny e caricato l’interprete MicroPython sulla scheda Pico.

In questo articolo vediamo come scrivere il nostro primo programma MicroPython e come caricarlo sulla Pico.

Colleghiamo la Pi Pico alla porta usb del computer e lanciamo l’ide Thonny. Dopo qualche istante sulla finestra shell dovremmo vedere la finestra interattiva di Python (REPL):

Utilizzando la finestra Shell è possibile eseguire direttamente dei semplici comandi. In questo modo è possibile testare delle funzioni o piccole parti di codice in modo molto veloce.

Ad esempio digitiamo sulla Shell il seguente codice e premiamo invio

print("Ciao Mondo!! Questa è la mia prima istruzione in MicroPython")

otterremo la risposta della Pico:

niente di entusiasmante! Ma comunque un semplice test per verificare che la scheda stia eseguendo il codice Python.

Scrivere un semplice programma

Nell’editor dei Thonny andiamo a scrivere delle istruzioni un po più utili. Sappiamo che il chip RP2040 è dotato di un sensore di temperature collegato all’ingresso analogico ADC4, quindi con il codice seguente andiamo a prelevare la tensione sulla linea ADC4 per poi convertirla in un valore espresso in gradi centigradi:

import machine
import utime

sensor_temp = machine.ADC(4)
conversion_factor = 3.3 / (65535)

while True:
    reading = sensor_temp.read_u16() * conversion_factor
    temperature = 27 - (reading - 0.706)/0.001721
        
    print(temperature)
    
    utime.sleep(2)

Il codice è stato copiato dal libro Get started with MicroPython.

Premiamo il pulsante Esegui lo script corrente (F5) per eseguire il programma. Thonny ci chiede dove vogliamo salvare il programma, salviamo sulla Raspberry Pi Pico:

Diamo un nome al nostro programma e premiamo sul pulsante OK:

Non appena premiamo il pulsante OK la Raspberry Pi Pico inizierà ad eseguire il programma. Sulla finestra Shell potremmo osservare il valore della temperatura rilevata dal microprocessore.

The post Caricare un programma MicroPython sulla Pi Pico appeared first on Esperimenti con logiche programmabili.

Dopo l’annuncio della produzione della Raspberry Pi Pico ho acquistato alcuni moduli per poterli testare e capire se questo nuovo microcontrollore potrà ritagliarsi una fetta importante nel mondo dei makers.

A prima vista sono rimasto molto contento del form factor della PI Pico data la flessibilità di poterlo inserire in un proprio custom pcb,  della mancanza del power led (non capisco perchè nelle schede Arduino MKR sia presente questo led che non può essere disabilitato a meno che non si proceda a dissaldarlo!) utile nei progetti a basso consumo. Inoltre un pin del microcontrollore (GPIO23) va a gestire il Power Saving del convertitore DC/DC.

Il led sulla scheda è furbamente collegato ad un pin del microcontrollore, dando la possibilità al programmatore di tenerlo acceso o meno. Non è presente un pulsante di reset integrato certamente escluso per tenere basso il costo del prodotto (per resettare la scheda è sufficiente collegare un pulsante esterno).

Un altro punto di forza della Pi Pico è la possibilità di essere programmata con due linguaggi, Python (MicroPython) o C/C++.

Con MicroPython abbiamo una curva di apprendimento rapida, subito pronti a programmare la PI Pico con ambienti di sviluppo semplici come Thonny (disponibile per diversi sistemi operativi e preinstallato su Raspberry OS).

Con C/C++ e con un completo SDK, possiamo spingerci a sviluppare programmi con performance elevate, di sfruttare tutta la potenza del microcontrollore RP2040 e di avere ambienti più sviluppo professionali come Visual Studio Code o Eclipse.

Utilizzare Thonny su Windows 10

Thonny è un ambiente di sviluppo integrato per principianti, preinstallato su Raspberry OS e disponibile anche per Windows, Mac e Linux. Dal sito thonny.org procediamo al download del software (versione 3.3.3 al momento in cui scrivo), versione per Windows. Terminato il download avviamo l’installazione lanciando l’eseguibile thonny-3.3.3.exe. Seguiamo le semplici istruzioni della procedura guidata:

Terminata l’installazione avviamo Thonny eseguendo un doppio clic sull’icona nel desktop.

Al primo avvio verrà richiesta la scelta della lingua da utilizzare nell’interfaccia grafica, selezioniamo quella che preferiamo e andiamo avanti premendo il pulsante Let’s go!:

Dopo qualche istante vi ritroverete davanti l’interfaccia grafica di Thonny:

Caricare MycroPython sulla Pi Pico

Per programmare la Pi Pico con Thonny è necessario caricare l’interprete MicroPython. Questa procedura è stata eseguita utilizzando Windows 10 versione 20H2. Colleghiamo la PI Pico alla porta usb del computer. La scheda viene riconosciuta dal sistema e viene avviata una procedura automatica di configurazione.

Clicchiamo, col pulsante destro del mouse, sul pulsante Start, dal menu contestuale scegliamo la voce Gestione Dispositivi. Sotto la voce Altri dispositivi dovrà essere presente l’elemento con nome RP2 Boot.

In caso contrario rimuoviamo la scheda dalla porta usb, teniamo premuto il pulsante BOOTSEL della Pico e contemporaneamente ricolleghiamo la scheda alla porta usb.

Rilasciate il pulsante BOOTSEL.

In Esplora risorse dovremmo anche avere una nuova unita disco chiamata RPI-RP2.

Portiamoci sul sito raspberrypi.org, nella sezione dedicata alla Pico scarichiamo Micropython cliccando sul pulsante Download UF2 File:

Ora copiamo il file pico_micropython_20210121.uf2 sul disco RPI-RP2. Attendiamo la copia del file e il riavvio della scheda Pi Pico.

Controllando in gestione dispositivi dovremmo avere che la voce Altri Dispositivi-> RP2 Boot viene eliminata e sostituita da una nuova periferica COM, nel mio caso la COM22

Configurazione dell’ambiente di sviluppo

La versione 3.3.3 di Thonny ha già preinstallato il plug-in per comunicare con la Raspberry Pi Pico. E’ sufficiente selezionare l’interprete dal menu posizionato in basso a destra della finestra principale:

Selezionando la voce MicroPython (Raspberry Pi Pico) permetterà a Thonny di collegarsi alla Pico attivando la comunicazione seriale con la Pico e mostrando l’interfaccia interattiva REPL.

Per selezionare la scheda e la porta COM manualmente è possibile farlo dal menu Esegui->Seleziona Interprete:

Nel tab Interprete possiamo selezionare l’interprete e la porta COM della scheda Pi Pico:

Nel prossimo articolo vedremmo come caricare il primo programma sulla Pi Pico

The post Programmare la Raspberry Pi Pico con MicroPython appeared first on Esperimenti con logiche programmabili.

The post Leggi subito il manuale della nuova Raspberry Pi Camera appeared first on Esperimenti con logiche programmabili.

Sul sito Raspberry Pi è stato da poco annunciato il nuovo modulo camera da ben 12,3 mega pixel, con la possibilità di utilizzare lenti intercambiabili. Questo nuovo dispositivo permette di migliorare la qualità di tutti i progetti esistenti e di ampliarne le caratteristiche e le funzionalità.
Oltre ad aver incrementato la risoluzione è ora possibile avere la regolazione del fuoco utilizzando le lenti intercambiabili.

Le caratteristiche del nuovo modulo camera sono le seguenti:

• sensore Sony IMX477 da 12.3 Mpixel
• dimensione dei pixel 1.55um x 1.55um
• diagonale del sensore 7.9mm
• retroilluminazione del sensore per una maggiore sensibilità
• supporta lenti CS-mount e C-mount
• adattatore integrato per montaggio su cavalletto

Sicuramente il consiglio è quello di abbinare questa nuova camera con il Raspberry Pi 4 (versione con almeno 2GB di ram). 

Solo il modulo camera si attesta a circa 55€, mentre la lente da 6mm (wide lens) costa intorno ai 30€ e la lente da 16mm (telephoto lens) si attesta intorno ai 58€.

Per il momento non è prevista una versione ir, ma credo che sarà possibile aggiungere dei filtri.

The post Finalmente una camera hq per Raspberry Pi appeared first on Esperimenti con logiche programmabili.

E’ da diverso tempo che uso un Raspberry Pi come computer per navigare su internet e per imparare a programmare in Python. Con poche decine di euro è possibile creare il proprio desktop replacement.

Anche se le prestazioni non sono entusiasmanti possiamo utilizzare questa scheda come piccolo laboratorio di sviluppo. Nonostante la presenza di diverse linee gpio potremmo avere comunque l’esigenza di continuare ad utilizzare le schede Arduino, quindi perchè non utilizzare il Raspberry Pi per programmarle?

Installare l’Arduino IDE

La prima cosa da effettuare è quella di scaricare dal sito ufficiale Arduino il software dell’ide per piattaforma linux arm. Una volta ottenuto il pacchetto in formato compresso dobbiamo scompattarlo eseguendo il commando seguente

tar Jxvf arduino-1.8.8-linuxarm.tar.xz

Verrà creata automaticamente la cartella arduino-1.8.8 nella stessa directory dove abbiamo salvato il file arduino-1.8.8-linuxarm.tar.xz

[the_ad id=”6199″]

Ora dentro la cartella arduino-1.8.8 ci sarà il file di installazione install.sh. per eseguirlo dovremmo digitare quanto segue:

./arduino-linux-setup.sh pi

Attendiamo qualche istante finché il pacchetto software non viene installato correttamente sul nostro Raspberry Pi.

Ultimata l’installazione viene richiesto il riavvio del sistema operativo.

Durante l’installazione viene creata una voce di menu come potete osservare dalla figura seguente.

Collaudo

Ora che tutto è stato installato possiamo esegure subito una prova per  verificare se le nostre schede Arduino possano essere programmata attraverso il Raspberry pi.

Colleghiamo alla porta usb del Raspberry Pi una Arduino UNO. Avviamo ora l’Arduino IDE.
Se tutto funziona correttamente nella voce di menu Strumenti->Porta dovremmo osservare la presenza della scheda Arduino UNO e della relativa porta di comunicazione, come nella figura seguente:

Dal menu file->esempi->01 Basics carichiamo il classico sckecth Blink, ora dal menu Sketch clicchiamo sulla voce Carica. Se tutto è andato a buon fine lo sketch verrà caricato correttamente sulla scheda UNO.

The post Installare Arduino sul Raspberry PI appeared first on Esperimenti con logiche programmabili.

Oggi, a gran richiesta degli utenti, viene annunciata la Raspberry Pi 3 model A+. A quanto pare questa sarà l’ultima scheda che verrà progettata dalla Raspberry Pi Foundation in quanto, nel futuro prossimo, l’architettura di questi dispositivi dovrebbe cambiare sensibilmente rispetto a quanto utilizzato oggi.

La Raspberry Pi 3 model A+ si pone a metà strada tra la Pi Zero e la Pi 3 Model B+ infatti cerca di mantenere un form factor ridotto, (eliminando alcune porte usb e la porta ethernet) ma mantenendo lo stesso SoC del fratello maggiore. Forse l’unico peccato è la quantità di ram pari a 512MB.

Nella tabella seguente riassumo le caratteristiche delle ultime schede prodotte

La scheda è certificata FCC, permettendo di avere un significativo risparmio nella certificazione dei propri prodotti basati su questa scheda.

La scheda è già disponibile all’acquisto presso i maggiori distributori. A dicembre sarà messo in vendita anche il case ufficiale come già fatto in precedenza con le schede Model B, B+ e Zero.

The post Ecco la nuova Raspberry Pi 3 model A+ 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.

Recentemente è stata presentata la versione 3 della Compute Module ispirata all’architettura della Raspberry PI 3. Questa scheda è pensata principalmente per un utilizzo industriale e per essere installata in sistemi embedeed. Questa soluzione basata sul processore Broadcom BCM2837 (1.2GHz, 64bit, quad-core, 1GB Ram) permette di avere un modulo molto più performante del precedente (presentato nel 2014 e basato sul processore BCM2835) mantenendo, in gran parte, la retro compatibilità col Compute Module 1. La versione standard del CM3 è dotata di un modulo di memoria eMMC da 4GB che permette di ospitare il sistema operativo mentre la versione Lite è sprovvista di tale memoria e quindi sarà necessaria una memoria SD esterna come avviene per la Raspberry PI 3.

Per sviluppare il proprio prototipo è stata realizzata la carrier board Compute Module IO Board V3 (CMIO3) che agevola la rapida prototipazione del progetto e di eseguire quindi i relativi test di funzionamento prima di spostare il Computer Module 3 sul prodotto finale.

Probabilmente la fondazione vuole ampliare la propria presenza sia in ambito industriale sia nel settore IoT, mercato in forte espansione dove tutte le grandi aziende stanno investendo le proprie risorse.
Il Compute Module 3 è molto compatto, le sue dimensioni sono quelle di una classica memoria DDR2 SoDIMM. Questo form factor permette l’installazione del modulo tramite un socket SoDIMM montato sul proprio pcb.

Per risparmiare spazio e per avere un costo molto inferiore alla Raspberry PI 3, nel modulo non sono stati implementati i circuiti wireless, ethernet e i vari connettori come HDMI, camera e DSI. Molti pin del SoC BCM2837 sono collegati direttamente ai pin del modulo SoDIMM. E’ necessaria una certa accortezza nell’interfacciamento del modulo alla circuiteria esterna e nell’implementazione delle funzionalità wifi e ethernet.

Penso che il lavoro più arduo per la fondazione sia sicuramente garantire il massimo supporto verso questo prodotto e di rendere Raspbian sempre più stabile e performante con caratteristiche che si adattino alle esigenze del mercato industriale e IoT.

Il prezzo per la versione Standard sarà intorno ai 30€ mentre la versione Lite avrà un prezzo sui 25€.

The post Raspberry PI Compute module 3 CM3 appeared first on Esperimenti con logiche programmabili.