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

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.

Data e ora del nostro Raspberry vengono sincronizzate all’avvio del sistema operativo tramite server NTP. In tutte le altre applicazioni dove non avete un accesso ad internet la data e l’ora sono impostate di default ma non corrisponderanno a valori corretti. In questi casi una soluzione è utilizzare un rtc che in caso di spegnimento della scheda tenga sempre aggiornato il dato di data e tempo.

Vediamo come fare.

La prima cosa è procurarci un modulo rtc pronto all’uso oppure realizzarne uno partendo dai singoli componenti. Nel mio caso visto il costo e la praticità di installazione ho scelto un rtc già assemblato. Il modello si basa sul chip DS3231 è ha un pratico connettore che permette l’installazione connettendolo direttamente sui pin header del raspberry;

DS3231 ad Alta precisione modulo di Memoria Orologio RTC per Arduino Raspberry Pi

Nell’immagine seguente potete osservare come deve essere installato il modulo rtc ds3231. 

Configurazione del dispositivo

La comunicazione tra il DS3231 e il Raspberry avviene utilizzando il bus I2C. Procediamo alla sua attivazione eseguendo il comando:

sudo raspi-config

Viene avviata la schermata del Raspberry PI Software Configuration Tool.  Portiamoci sulla voce Interface Options e premiamo invio, nella schermata successiva selezioniamo la voce I2C. Confermiamo rispondendo affermativamente e attendiamo l’attivazione del bus I2C:

Dopo aver terminato l’attivazione del bus, riavviamo il sistema operativo con il comando seguente:

sudo reboot

Dopo il riavviamo apriamo una nuova finestra terminale e utilizzando programma i2cdetect possiamo verificare che il modulo rtc e il bus I2C stiano funzionando:

i2cdetect -y 1

dovremmo avere una schermata simile alla seguente:

il programma i2cdetect non fa altro che scansionare il bus I2C alla ricerca di dispositivi collegati. Nel nostro caso ha trovato un dispositivo all’indirizzo 0x68 che corrisponde all’unico dispositivo collegato al raspberry, ovvero il modulo DS3231.

Per sicurezza possiamo verificare sul datasheet dell’rtc l’indirizzo del dispositivo.

A questo punto possiamo caricare sul kernel linux il modulo rtc ds3232 (compatibile con il DS3231) eseguendo il seguente commando:

sudo modprobe rtc-ds3232

premiamo invio per eseguire il commando:

a questo punto dobbiamo creare un nuovo device con indirizzo 0x68 ed inserirlo nel bus I2C. Per eseguire questa serie di commandi dobbiamo loggarci come utente root digitando il comando seguente:

su

inseriamo la password per l’utente root.

Nel caso in cui non si disponga di una pssword per l’utente root è necessario crearla digitando il comando:

sudo passwd root

Digitiamo una nuova password per l’utente root e confermiamo ripetendola nuovamente.

Ora che abbiamo i privilegi del superuser digitiamo il seguente commando:

echo ds3232 0x68 > /sys/class/i2c-adapter/i2c-1/new_device

premiamo invio. Digitiamo il comando exit per ritornare all’utente pi:

Impostare data e ora dell’RTC

Dopo le precedenti istruzioni il sistema carica automaticamente i dati correnti di data e ora sull’RTC. Se questi dati corrispondono ai valori corretti non dobbiamo far altro che leggere i dati con il seguente comando:

sudo hwclock -r

in alternativa possiamo settare i valori come desideriamo eseguendo questo comando:

sudo hwclock --set --date "Fri Jan 1 15:00:00 CET 2021"

Tutte queste impostazioni non rimangono memorizzate al successivo riavvio del sistema operativo e quindi necessario inserire queste istruzioni su un file che viene lanciato durante le fasi di boot come ad esempio il file rc.local, quindi procediamo ad eseguire le seguenti istruzioni:

Modifichiamo il files modules per caricare sul kernel il modulo rtc-ds3232

sudo nano /etc/modules

inseriamo alla fine del file la seguente stringa:

rtc-ds3232

salviamo il file con la combinazione di tasti crtl+o  e usciamo con ctrl+x

Ora apriamo il file rc.local:

sudo nano /etc/rc.local

portiamoci con puntatore prima dell’istruzione exit 0 e aggiungiamo le seguenti istruzioni:

echo ds3232 0x68 > /sys/class/i2c-adapter/i2c-1/new_device

inseriamo subito dopo anche l’istruzione seguente:

sudo hwclock -s

in modo da sincronizzare la data e l’ora del sistema operativo con quella del modulo RTC.

disconnettiamo il Raspberry dalla rete cablata o WiFi, riavviamo e verifichiamo con il comando date che le impostazioni del sistema siano coerenti con quelle impostate precedentemente nell’rtc.

The post Aggiungere un RTC al Raspberry PI appeared first on Esperimenti con logiche programmabili.

MQTT (Message Queue Telemetry Transport) è un protocollo di comunicazione progettato per trasferire messaggi occupando una banda molto ridotta. Per questo viene spesso impiegato in ambito IoT. Il metodo di trasmissione e ricezione dei messaggi è asincrono e si basa su una architettura publish/subscribe (mittente/destinatario).

Il mittente ed il destinatario non possono però scambiarsi messaggi direttamente tra loro ma necessitano di un intermediario chiamato dispatcher o broker.

Lo scambio di dati avviene in questo modo: il mittente (publisher) invia un messaggio al dispatcher. I destinatari, a loro volta, scelgono quali messaggi ricevere comunicandolo al dispatcher. Il dispatcher quindi invia il messaggio solo ai dispositivi che si nono iscritti (subscribe) per la ricezione dei messaggi.

Se al dispatcher sono collegati diversi mittenti e destinatari come è possibile scegliere a chi mandare il messaggio o da chi riceverlo?

MQTT utilizza i Topics

Il meccanismo di scambio dati si basa utilizzando i topics, una struttura gerarchica simile a quella per la gestione delle directory in un files system.

Quindi il mittente decide un topic sul quale pubblica un messaggio, ad esempio

/sensore1

il destinatario può leggere il messaggio abbonandosi al topics:

/sensore1

La figura illustra quanto detto:

Riepiloghiamo i concetti in questi pochi punti:

• I messaggi non sono inviati direttamente ai destinatari;
• Viene utilizzato un dispatcher o broker che permette lo scambio dei messaggi tra mittenti(publisher) e destinatari(subscriber)
• Il dispatcher organizza i messaggi in topics e gli ridistribuisce ai destinatari che si sono abbonati al topic.
• Tutti i dispositivi collegati al dispatcher possono inviare o ricevere messaggi.
• Solitamente il dispatcher non memorizza i messaggi.

Installare MOSQUITTO

L’elemento fondamentale in una architettura MQTT è il dispatcher o broker. Se i nostri dispositivi sono collegati ad internet possiamo utilizzare un servizio web oppure nei casi di un sistema stand alone, utilizziamo un nostro broker da installare su una scheda Raspberry PI.

Un software open source che potrebbe essere utilizzato per i nostri lavori è Eclipse Mosquitto, un broker molto leggero installabile su single board computer come il Raspberry PI.

Apriamo un terminale sul nostro Raspberry, o colleghiamoci con un client ssh, digitiamo il seguente commando:

sudo apt-get install mosquitto

premiamo invio e attendiamo il download e l’installazione del software.

Testiamo l’installazione verificando che il broker MQTT sia in esecuzione:

sudo service mosquitto status

in particolare bisogna notare la presenza della stringa Active: active (running).

Per fermare il servizio utilizziamo il seguente comando:

sudo service mosquitto stop

mentre per avviarlo digitiamo:

sudo service mosquitto start

oppure stoppare e riavviare il servizio con un singolo comando:

sudo service mosquitto restart

Installare client MQTT

Una volta installato il broker sul Raspberry PI eseguiamo delle prove utilizzando un programma per pubblicare un topic e un programma per abbonarsi.

Digitando il seguente comando installeremo quanto richiesto:

sudo apt-get install mosquitto-clients

Attendiamo il completamento dell’installazione e se non si sono verificati errori dovremmo avere disponibili i seguenti programmi

mosquitto_sub
mosquitto_pub

come si intuisce dal nome il primo è il programma che funge da subscriber mentre il secondo è il programma che funge da publisher.

Per poter eseguire un semplice test apriamo due finestre terminale o, se ci colleghiamo al Raspberry da un altro host, due sessioni ssh.

Sul primo terminale abboniamoci a un topic eseguendo questo commando:

mosquitto_sub -h localhost -t "mio_topic"

(ci stiamo abbonando al topic denominato mio_topic che viene gestito dal broker che gira sulla macchina localhost)

Nella seconda finestra terminale lanciamo il publisher per inviare un messaggio al broker sul topic mio_topic:

mosquitto_pub -h localhost -t "mio_topic" -m "ciamo mondo"

Nelle immagini seguenti potete osservare lo scambio dei messaggi

Nel primo terminale mi metto in ascolto sul topic chiamato mio_topic

sul secondo terminale invio il messaggio “ciao mondo” al topic mio_topic

Nel primo terminale osservo la ricezione del messaggio “ciao mondo”.

Questi due programmi sono molto utili per esercitarci e capire meglio come funziona il protocollo MQTT.

The post MQTT, installare Mosquitto sul Raspberry PI appeared first on Esperimenti con logiche programmabili.

In quei progetti dove diverse schede interagiscono tra loro, scambiandosi e memorizzando dati, potrebbe risultare utile avere un mini server (LAMP) per la memorizzazione e l’elaborazione dei dati. In questo caso niente di più flessibile di un computer embedded come una Raspberry PI.

Nel mio caso mi sono trovato a realizzare un sistema composto da diverse schede Arduino MKRZero + MKR ETH che acquisiscono dati da dei sensori analogici. Questi dati invece di essere memorizzati su scheda SD ho deciso di inviarli ad un database locale, dato che le schede sono collegate alla stessa lan. Per limitare i costi ho inserito un Raspberry PI configurato come server LAMP (Linux + Apache + Mysql + Php).

In questo articolo vediamo come installare tutto il necessario per creare un server LAMP con Raspberry PI seguendo questi 5 passi:

1. Installare server web apache
2. Installare motore PHP
3. Installare database relazionale Mysql (MAriaDB)
4. Installare software di gestione PhpMyAdmin
5. Configurare utenti e privilegi

1. Installare Apache

Il server Apache permette di avere un server HTTP locale capace di elaborare le richieste dei client collegati alla stessa rete. Per l’installazione si utilizza il commando seguente :

sudo apt-get install apache2

Premiamo invio e alla richiesta di continuare digitiamo S e nuovamente invio

Terminata l’installazione digitiamo il seguente comando per leggere l’indirizzo ip della scheda Raspberry PI

hostname -I

premendo invio verrà visualizzato l’ip assegnato alla scheda.

apriamo il browser su un pc della stessa rete e digitiamo nella barra degli indirizzi l’ip della scheda. Se il server apache è stato installato correttamente dovreste visualizzare una schermata come la seguente:

2. Installare PHP

Il passo successivo è quello di installare il motore PHP che permetterà di eseguire tutti gli script php contenuti nelle pagine web. Digitiamo il seguente comando:

sudo apt-get install php

premiamo invio, confermiamo l’installazione digitando S e nuovamente invio.

Terminata l’installazione procediamo a verificare che il motore php sia stato installato correttamente. Portiamoci sulla directory seguente:

cd /var/www/html/

elenchiamo ora i file presenti nella cartella con il comando:

ls -l

dovrebbe esserci un solo file, index.html. rimuoviamolo con il seguente comando

sudo rm index.html

Ora utilizzando un editor di testo creiamo una nuova pagina , index.php, eseguendo questo comando

sudo nano index.php

Premiamo invio e digitiamo nel’editor di testo nano la seguente istruzione

<?php echo(phpinfo()) ?>

Per salvare il file index.php premiamo sulla tastiera i tasti CTRL+O e per uscire i tasti CRTL+X

nuovamente eseguiamo un elenco dei files contenuti nella cartella html con il comando:

ls -l

dovremmo avere un solo file, index.php:

dal browser precedentemente aperto ricarichiamo la pagina (oppure digitiamo nuovamente l’ip della scheda Raspberry) e se tutto sta girando correttamente dovremmo visualizzare le informazioni relative al motore php, come di seguito:

Se il server web non risponde potremmo provare a riavviarlo digitando questo comando:

sudo service apache2 restart

3. Installare MySQL

Mysql è un RDBMS molto diffuso in ambiente web. Sviluppato come progetto open source è poi stato acquisito da Oracle. Attualmente è disponibile sotto licenza GNU e anche commerciale. Nel nostro Raspberry installeremo mariaDB un progetto totalmente open che si basa sul codice sorgente di MySql. Per eseguire l’installazione digitiamo il seguente comadndo:

sudo apt-get install mariadb-server

confermiamo digitando S e premendo invio

4. Installate PhpMyAdmin (opzionale)

Se siete arrivati fin qui la parte server è stata installata correttamente. Ora possiamo installare un software scritto in php che permette di interagire con il server MySql, tramite una comoda interfaccia web. Eseguiamo quindi il seguente comando per avviare l’installazione e la configurazione di PhpMyAdmin:

sudo apt-get install phpmyadmin

Confermiamo digitando S e premendo invio per avviare il download del software e la sua installazione.

Dopo qualche istante ci viene richiesto di selezionare il server web installato sul Raspberry in modo tale che phpmyadmin esegua le sue configurazioni. Selezioniamo con la barra spaziatrice la voce apache2, con il tasto tab ci spostiamo sul pulsante <ok>. Premiamo invio per continuare:

Successivamente viene mostrata una nuova finestra per poter configurare il database mysql. Selezioniamo il pulsante <Sì> e premiamo invio:

Ora digitiamo una password per l’utente phpmyadmin e premiamo invio:

ripetiamo digitando e confermando la password, continuiamo premendo invio:

dopo qualche istante l’installazione terminerà.

Proviamo ora a verificare se l’installazione del software phpmyadmin è avvenuta con successo. Portiamoci nuovamente sul browser e digitiamo nella barra degli indirizzi il seguente link

[ip raspberry]/phpmyadmin

dovremmo visualizzare la schermata di login come segue:

digitiamo come nome utente phpmyadmin e come password quella inserita nella procedura guidata per eseguire l’accesso all’interfaccia web.

l’utente phpmyadmin non ha privilegi che permettano la gestione dei databases. Nel prossimo passo provvederemo a creare un utente che possieda tutti i privilegi.

5. Creare un utente per gestire il database

I comandi seguenti servono a creare un utente con tutti i privilegi di amministrazione del database. In questo modo protremmo accedere tramite phpmyadmin per creare e gestire i nostri databases.

Il comando seguente permette di avviare la console mysql in modo tale da poter inviare comandi sql all’ RDBMS:

sudo mariadb

e premiamo invio:

ora creiamo un utente, nel mio caso con nome marco, tra apici inseriamo anche una password:

CREATE USER marco@localhost IDENTIFIED BY 'inserisci la tua password';

ricordati di terminate la stringa sql con il simbolo di punto e virgola. Premiamo invio per per eseguire la query:

ora l’utente marco è stato creato ma come l’utente phpmyadmin non ha nessun privilegio e non puo effettuare nessuna operazione. Assegniamo quindi a questo utente tutti i privilegi eseguendo questa query:

GRANT ALL PRIVILEGES ON *.* TO marco@localhost;

premiamo invio per eseguire la query:

usciamo dal dal database eseguendo il seguente comando:

exit;

riavviamo il servizio mysql eseguendo il seguente comando

sudo service mysql restart

Conclusioni

Utilizzando un Raspberry PI dal costo contenuto è possibile creare un hub di rete capace di eseguire un server LAMP con adeguate prestazioni. In questo modo è possibile integrare un sistema di schede che piuttosto che memorizzare i dati in una propria memoria può invece inviare i dati su un database relazionale con tutti i vantaggi che ne derivano.

The post 5 passi per installare un webserver LAMP sul 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.