Arduino dispone di diverse shield che permettono di collegarci a una rete lan cablata come ad esempio la MKR ETH. Esistono sul mercato altri dispositivi che svolgono la stessa funzione con costi contenuti e form factor molto piccoli. Uno di questi e la scheda WIZ850io prodotta da WIZnet, dotata di chip wiznet w5500 lo stesso utilizzato per la MKR ETH.

Questa scheda ha una dimensione del pcb di 25mm X 23mm e un costo di circa 20 euro. Di seguito la pin function della scheda:

Come possiamo vedere l’alimentazione della scheda richiede una tensione di 3.3V, è quindi consigliato utilizzare schede con tensione di funzionano di 3.3v, questo per avere i livelli logici con questa tensione. Il bus di comunicazione è affidato all’interfaccia SPI. La figura seguente mostra i collegamenti tra una Arduino MKR Zero e la scheda WIZ850io:

in dettaglio i collegamenti descritti nella tabella seguente:

Per verificare se tutti i collegamenti sono stati eseguiti correttamente possiamo utilizzare il codice seguente (esempio linkstatus della libreria Arduino ethernet):

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

void setup() {
  //inizializzo la wiz850io
  //il pin chip select è stato collegato al pin 7
  //della scheda arduino. se lo collegate in un altro pin dovete
  //modificare il numero del pin all'interno del metodo init()
  Ethernet.init(7);
  
  //inizializzazione seriale
  Serial.begin(9600);
}

void loop() {
  //verifico se il cavo lan è collegato e se esiste un link
  //con una periferica ethernet
  auto link = Ethernet.linkStatus();
  Serial.print("Link status: ");
  switch (link) {
    case Unknown:
      Serial.println("Unknown");
      break;
    case LinkON:
      Serial.println("ON");
      break;
    case LinkOFF:
      Serial.println("OFF");
      break;
  }
  delay(1000);
}

Questa scheda permette di implementare una interfaccia di rete cablata in tutte le schede Arduino dotate di porta SPI.

The post Arduino MKR Zero e WIZ850io appeared first on Esperimenti con logiche programmabili.

• 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.

(informazioni aggiuntive seguendo questo link Python UDP)

• Codice Python Raspberry
• Codice Python Computer

Ho la necessità di scambiare dati tra una scheda Raspberry e un computer che fanno parte di una rete locale. Il metodo più veloce è quello di utilizzare il protocollo UDP perchè è molto semplice da implementare, veloce e funzionale. In particolare il codice che gira sul Raspberry deve inviare una stringa contenente le informazioni sullo stato di attivazione di otto relay. Questa stringa è composta da otto etichette separate da un carattere di due punti (:). L’etichetta varia in funzione dello stato del relay, La parte di gestione dei relay e della modifica della stringa è stata ommessa per semplificare il codice.

Il programma Python che gira sul Raspberry crea un thread che ogni tre secondi  invia la stringa verso il computer locale. Ho inserito dei commenti per descrivere le varie istruzioni del programma:

codice python raspberry:

#python udp raspberry
import socket
import threading
import time

#IP computer locale
UDP_IP_ADDR = "192.168.178.24"
#Porta computer locale
UDP_PORT_NUMBER = 20001

#Creo una tupla
ip_port_Data = (UDP_IP_ADDR, UDP_PORT_NUMBER)

#Stringa contenente lo stato dei relay
relay_status = "RL01_OFF:RL02_OFF:RL03_OFF:RL04_OFF:RL05_OFF:RL06_OFF:RL07_OFF:RL08_OFF"

#funzione per invio dei dati via UDP viene eseguita dal thread
def client_Send_Data():
    print("Avvio THREAD Send Data...")
    #Crea un socket udp per l'invio e la ricezione di dati
    serversocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)    
    
    while True:
        #converto la stringa in byte
        msgToSend = str.encode(relay_status)
        #invio i dati specificando ip e porta
        serversocket.sendto(msgToSend, ip_port_Data)
        #attendo 3 secondi
        time.sleep(3)

if __name__=="__main__":
    #Avvio un thred 
    print("Start program")
    t1 = threading.Thread(target=client_Send_Data)
    t1.start()  

Il codice che invece gira sul computer locale deve mettersi in ascolto sulla porta utilizzata per l’invio dei dati, attendere la ricezione dei dati e poi mostrarli sulla console. Anche in questo codice ho inserito diversi commenti che spiegano le varie istruzioni:

codice python computer

#python udp computer
import socket
import threading
import time

#IP computer locale
UDP_IP_LISTENER = "192.168.178.24"
#Porta computer locale
UDP_PORT_LISTENER = 20001

#creo una tupla
ip_port_Listener = (UDP_IP_LISTENER, UDP_PORT_LISTENER)

def client_Receive_Data():
    print("Avvio THREAD Receive Data...")
    #creo un socket udp
    serversocket1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    #assoccio il socket a ip e porta
    serversocket1.bind((UDP_IP_LISTENER, UDP_PORT_LISTENER))
    
    while True:
        #leggo i dati ricevuti dal socket
        data, address = serversocket1.recvfrom(100)
        #converto i byte in stringa
        cmd = bytes.decode(data)
        #printo i dati sul terminale o console
        print(cmd)
        #metto in pausa il thread per 1 secondo
        time.sleep(1)


if __name__=="__main__":    
    print("Start program")
    t1 = threading.Thread(target=client_Receive_Data)
    #Avvio thread
    t1.start()

Osservando il codice (Python udp Raspberry e Python udp computer) si nota che sono presenti gli stessi indirizzi ip. Questo perché il codice che riceve i dati si mette in ascolto sull’indirizzo ip della macchina e su una determinata porta. Il codice sul Raspberry invierà i dati sull’ip della macchina e sulla porta di ascolto.

The post Python UDP inviare dati da Raspberry a computer appeared first on Esperimenti con logiche programmabili.

Se hai intenzione di imparare a programmare Arduino e non hai tante nozioni di elettronica puoi acquistare l’Arduino Sensor Kit.

Questo kit permette i dedicarsi totalmente alla stesura del codice senza preoccuparsi di conoscere il modo corretto per collegare i componenti e i sensori alla Arduino UNO.

Un vantaggio enorme che permette di abbassare la curva di apprendimento.

Molte persone hanno il desiderio di programmare una scheda Arduino, ma dopo aver comprato l’hardware necessario, iniziano ben presto a trovare difficoltà nella realizzazione dei collegamenti, per poi finire di abbandonare tutto nel cassetto della propria scrivania.

Con l’Arduino Sensor Kit invece, devi dedicarti solamente ad acquisire esperienza nella programmazione e questo permette di avere delle piccole soddisfazioni che non fanno spegnere la voglia di imparare a utilizzare una scheda Arduino.

Il kit sviluppato in collaborazione con Seed Studio viene venduto in versione base al costo di circa 28€ e in versione bundle con una  scheda Arduino UNO per una spesa di poco inferiore ai 50€. 

La Sensor Kit è compatibile con i sistema Grove ideato da Seed Studio, rendendola quindi espandibile con centinaia di moduli pre-assemblati pronti all’uso dandoti così la possibilità di provare ad utilizzare nuovi sensori o attuatori.

Per semplificare ulteriormente l’uso è stata sviluppata una libreria che con poche righe di codice puoi scrivere subito i primi programmi e se ancora non bastasse puoi trovare tutte le risorse sul sito dedicato (Sensor Kit arduino.cc) con tutti gli esempi di codice da utilizzare immediatamente!

Buon divertimento e buon codice!!

The post Il miglior modo per iniziare a programmare Arduino appeared first on Esperimenti con logiche programmabili.

In un precedente articolo, utilizzando Arduino UNO avevamo parlato degli interrupt, spiegando cosa sono e come gestirli. Anche la Raspberry Pi Pico, come la maggior parte dei microcontrollori è in grado di gestire gli interrupt. Utilizzando il linguaggio Micropython questa operazione diventa molto semplice.

Questo meccanismo è molto utile perché sostituisce il meccanismo di polling che in un microcontrollore può essere molto svantaggioso. Ad esempio se devo controllare ciclicamente lo stato di un ingresso non posso mettere il microcontrollore in sleep mode perchè andrei a fermare il controllo del pin mentre un interrupt viene gestito dall’hardware e quindi è possibile superare questo limite.

Nel caso della Pico, programmata usando Micropython non sono sicuro se questa funzione sia disponibile anche quando il microcontrollore è in sleep mode.

Gestire le interruzioni

Come accade per Arduino dobbiamo definire una funzione (che verrà richiamata quando avviene l’evento di interrupt) e definire un pin capace di gestire l’interrupt.

Nello schema seguente viene mostrato come ho eseguito i collegamenti di un circuito di test.

Mentre il codice seguente descrive le istruzioni necessarie a gestire l’interrupt:

import machine
import utime

#definisco il pin 0 come ingresso
#su questo pin è collegato un pulsante con una
#resistenza di pull down
button = machine.Pin(0, machine.Pin.IN, machine.Pin.PULL_DOWN)
#definisco il pin 1 come uscita
#su questo pin collego un led e una resistenza da 330 ohm
led = machine.Pin(1, machine.Pin.OUT)

#definisco una funzione che verrà richiamata quando
#viene scatenato l'interrupt
def ev_handler(pin):
    print("bottone premuto")
    
#associo al pin in ingresso la funzione di interrupt
#l'evento videne generato usando il parametro RISING
button.irq(trigger=machine.Pin.IRQ_RISING, handler=ev_handler)

#loop che fa blinkare il led
while True:
    led.toggle()
    utime.sleep(1)

Dopo le dichiarazione dei pi e della funzione il codice entra nel ciclo while ed esegue continuamente la commutazione del pin 1. Non appena premiamo il pulsante collegato al pin 0 viene generato un evento che interrompe il ciclo e richiamata la funzione ev_handler(). Terminata l’esecuzione del codice nella funzione ev_handler() viene ripresa l’esecuzione del codice del ciclo while().

Da notare che l’interruzione non è asincrona quindi il codice nella funzione ev_handler() deve essere il più rapido possibile per non impattare sul codice del ciclo while().

The post Pi Pico usare gli interrupt 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.

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.

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.

Irrigare una pianta può diventare molto noioso! L’irrigazione è una pratica che richiede costanza e attenzione, caratteristiche che non si sposano bene se abbiamo altri impegni e interessi. Fortunatamente possiamo automatizzarne il processo.

Esistono diversi circuiti pronti all’uso che eseguono molto bene questo compito, ma se siete appassionati del fai da te probabilmente vorrete realizzare qualcosa con le vostre mani.

Quello che ho realizzato io è un semplice circuito che utilizza una pompa peristaltica. Il circuito elettrico è molto semplice e si riduce a un componente programmabile, come una scheda Arduino e un circuito di potenza per pilotare la pompa peristaltica.

Il software deve eseguire l’attivazione della pompa ad intervalli regolari. Da qui le possibilità di gestione sono davvero tante, possiamo creare un sistema on off, un sistema che utilizza un rtc o un sistema complesso che monitorizza l’umidità del terreno e temperatura ambiente per decidere la giusta quantità di acqua da fornire alla pianta.

In questo esempio utilizzo la libreria Time per creare un ciclo di irrigazione che si attiva ogni giorno. Il codice seguente mostra come fare:

#include <TimeAlarms.h>
#include <Time.h>

void avviaIrrigazionePianta()
{
  Serial.println("Avvio irrigazione pianta");
  digitalWrite(3, HIGH);
}

void fermaIrrigazionePianta()
{
  Serial.println("Fermo irrigazione pianta");
  digitalWrite(3, LOW);
}


void setup() {
  //init Seriale
  Serial.begin(9600);
  delay(100);

  pinMode(3, OUTPUT);
  digitalWrite(3, LOW);

  //imposto l'ora e la data
  setTime(8, 29, 45, 24, 01, 2021);

  //queste funzioni vengono eseguite ogni giorno
  //imposto orario di avvio irrigazione
  Alarm.alarmRepeat(8, 30, 0, avviaIrrigazionePianta);
  //imposto interruzione orario di irrigazione
  Alarm.alarmRepeat(8, 32, 0, fermaIrrigazionePianta);
  //l'irrigazione dura 2 minuti
}

void loop() {

  //visualizzo data e ora correnti
  Serial.print("Tempo= ");
  Serial.print(hour());
  Serial.print(":");
  Serial.print(minute());
  Serial.print(":");
  Serial.print(second());
  Serial.println("");

  Serial.print("Data= ");
  Serial.print(day());
  Serial.print("/");
  Serial.print(month());
  Serial.print("/");
  Serial.print(year());
  Serial.println("");
  
  //aggiorno l'allarme ogni secondo
  //senza questa istruzione non è possibile far scattare
  //gli allarmi preimpostati
  Alarm.delay(1000);

}

Con pochi componenti e una manciata di istruzioni abbiamo realizzato un semplice irrigatore automatico. Questo semplice circuito può essere ampliato utilizzando un sensore di umidità, un rtc e un datalogger per monitorare tutti i parametri.

The post Pilotare pompa peristaltica appeared first on Esperimenti con logiche programmabili.