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.

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.

Tutte le schede Raspberry sono state progettate per eseguire un sistema operativo. Un microcomputer dalle dimensioni ridotte e dal costo contenuto permette di creare diverse tipologie di software, da quelli didattici a quelli più complessi che un microcontrollore non potrebbe probabilmente gestire. D’altro canto non è possibile acquisire direttamente dei segnali analogici, le linee GPIO hanno una latenza importante e i consumi energetici, anche in sleep mode, sono molto elevati (rispetto a un microcontrollore).

Probabilmente questo ha portato alla progettazione di un chip ad alte prestazioni, dotato di un buon numero di linee IO, di diversi tipi di bus di comunicazione e dal costo davvero contenuto (circa 4,5€).

Le caratteristiche del chip RP2040 sono elencate di seguito

Caratteristiche davvero molto interessanti che permettono di realizzare schede adatte a svariati tipi di progetti.

Software e Hardware

Raspberry ha quindi avviato anche una collaborazione con diverse aziende, tra cui Arduino, per lo sviluppo e la produzione di schede basate sul chip RP2040.

Per quanto riguarda il software di programmazione sono stati sviluppati due sdk uno per programmare in C/C++ e l’altro per programmare in MicroPython. Anche in questo caso la programmazione avviene utilizzando diverse piattaforme e ambienti come Visual Studio Code su Windows o l’editor Thonny su Raspberry OS.

Raspberry Pi Pico è già disponibile all’acquisto come alcune schede costruite da Adafruit e SparkFun, mentre per la scheda realizzata da Arduino si dovrà attendere ancora qualche settimana.

Ulteriori informazioni possono essere trovate sul sito ufficiale e seguendo questi indirizzi

Sito ufficiale Raspberry Pi Pico

Raspberry Pi Pico and RP2040 SparkFun

RP2040 and Adafruit family

Blog Arduino

The post Pi Pico, Raspberry crea il suo microcontrollore RP2040 appeared first on Esperimenti con logiche programmabili.

In un precedente articolo abbiamo introdotto la scheda FLIP and click di Mikroelecktronika, una particolare versione della Arduino DUE che comprende 4 connettori mikroBUS che possiamo utilizzare per sperimentare con la vasta gamma di click Boards.

Tra le tante click Boards una delle più utili, a mio avviso è il modulo ethernet (ETH WIZ click). Per poterlo utilizzare basta semplicemente inserirlo in un connettore mikroBUS della scheda FLIP & click. I connettori sono contrassegnati dalle lettere A, B, C e D.

Il modulo ETH WIZ può essere utilizzato con la libreria Ethernet di Arduino. Il protocollo di comunicazione tra FLIP-n-clich e click Boards è lo SPI. Avendo 4 bus dobbiamo specificare nelle istruzioni di inizializzazione della libreria il pin CS adeguato

Nella tabella seguente ho inserito i corrispettivi pin CS in funzione dello slot mikroBUS dove ho collegato la ETH WIZ.

Lanciamo l’Arduino IDE  e dal menu File->Esempi->Ethernet carichiamo lo sketch LinkStatus. Modifichiamo il metodo init() secondo le nostre esigenze.

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

void setup() {
  // Per utilizzare la scheda ETH WIZ dobbiamo selezionare il pin CS corretto
  //in funzione del connettore della FLIP-n-click 
  //Per la porta A utilizzare il pin 77
  //Per la porta B utilizzare il pin 87
  //Per la porta C utilizzare il pin 86
  //Per la porta D utilizzare il pin 78

  Ethernet.init(77); //modulo ETH WIZ collegato sulla porta A della FLIP & click

  Serial.begin(9600);
}

void loop() {
  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);
}

Carichiamo il codice sulla scheda e colleghiamo un cavo lan tra il nostro pc e la ETH WIZ.

Se tutto è andato a buon fine, aprendo il serial monitor dell’IDE dovremmo visualizzare la scritta Link status: ON 

The post FLIP & click, come collegare la ETH WIZ click appeared first on Esperimenti con logiche programmabili.

Nello scorso articolo abbiamo capito come attivare la Arduino sim e come configurare l’Arduino MKR GSM 1400. Inoltre abbiamo visto come sia possibile inviare dati alla scheda utilizzando il Network Monitor.

In questo articolo andremmo a creare un elemento Thing utilizzando l’Arduino Cloud e a scrivere il codice per la MKR GSM 1400 in modo da poter inviare dei dati sul cloud.

Seguiamo questo indirizzo https://create.arduino.cc/iot/. Nella home dell’Arduino Cloud (al momento ancora in versione beta) possiamo creare un nuovo Thing, ovvero un contenitore di oggetti grafici che hanno il compito di visualizzare dati provenienti dalla scheda oppure di inviarli.

Cliccando sul bottone Add New Thing verrà caricata una pagina in cui inserire il nome del Thing e la scheda da associare nostro progetto IoT.

Nel combobox Select Board selezioneremmo la scheda GSM 1400 che abbiamo configurato nel precedente articolo. Clicchiamo ora sul pulsante CREATE.

Ci ritroveremo nella pagina principale del Thing che abbiamo appena creato.

Attualmente sono disponibili 4 Tab. Nel tab Properties verranno elencate tutte le variabili del Thing. Queste variabili potranno essere richiamate nello sketch. Nal tab Dashboard verranno rappresentate le variabili sotto forma di oggetti grafici, pulsanti e indicatori. Nel tab Webhooks possiamo scambiare dati con altri servizi. Nel tab Board sarà possibile associare una scheda al Thing, questa associazione è molto importante perchè va a mettere in relazione la scheda selezionata con la chiave memorizzata nel crypto chip della GSM 1400. Se la chiave del crypto chip non coincide con la chiave della scheda che abbiamo caricato nel Device Manager, la comunicazione non potrà avvenire.

Creare delle proprietà

Torniamo nel tab Properties e clicchiamo sul bottone ADD PROPERTY. Verrà caricata una nuova pagina contenente un form come quello in figura:

Nel campo Name inseriamo un nome identificativo per la proprietà, questo nome sarà copiato anche sul campo Variable Name. Se lo riteniamo opportuno possiamo cambiare il Variable Name. Il nome inserito nel campo Variable Name, sarà utilizzato all‘interno del codice dello sketch.

Inseriamo per esempio il nome “temperatura”.

Nella combobox Type selezioniamo la voce Temperature sensor (Celsius). Vengono visualizzati due nuovi campi dove inserire il valore minimo e massimo che la variabile temperatura dovrà avere. Inseriamo come valore minimo 0°C e come valore massimo 100°C.

Compiliamo anche la sezione Permission, Update  e History.

Nella sezione Permission possiamo scegliere Read Only se il dato viene inviato dal dispositivo al cloud Arduino, mentre sceglieremo Read & Write se abbiamo la necessita di aggiornare la variabile temperature dall’Arduino cloud.

La sezione Update ci permette di ricevere i dati a tempi prestabiliti (utilizzando la textbox per indicare un tempo) oppure riceverli quando il dato ha una variazione rispetto al dato precedentemente inviato.

La sezione history crea un grafico utilizzando uno storico dei dati inviati dalla scheda.

Ora non ci resta che cliccare sul bottone ADD PROPERTY per confermare la nostra proprietà.

Andiamo nel tab Dashboard è osserviamo la presenza di un elemento che visualizzerà il dato proveniente dalla scheda.

Per il momento non aggiungiamo nessun’altra proprietà e dedichiamoci alla scrittura del codice.

Installazione delle librerie

Apriamo l’Arduino IDE e creiamo un nuovo sketch. Importiamo tutte le librerie per lavorare con l’Arduino cloud. Da Gestore Librerie (combinazione di tasti Ctrl+Maiusc+i) cerchiamo la libreria ArduinoIotCloud:

procediamo con l’installazione cliccando sul pulsante Installa. Il gestore delle librerie indicherà che sono indispensabili delle librerie aggiuntive:

Installiamole tutte come richiesto.

Scrivere il codice per la scheda MKR GSM 1400

Il codice seguente mostra come collegarsi all’Arduino Cloud e come aggiornare la variabile temperatura definita precedentemente nel Thing:

//Includo le librerie seguenti
#include <ArduinoIoTCloud.h>
#include <Arduino_ConnectionHandler.h>

//creo una costante dove contenere il think_id
//questo dato possiamo ottenerlo andando nel pannello di controllo
//dell'arduino cloud
const char THING_ID[]      = "a42be6ce-3158-4843-a29b-a36e1c90256f";

//in queste costanti inserisco i dati relativi alla sim arduino
const char GPRS_APN[]      = "prepay.pelion";
const char PINNUMBER[]     = "0000";
const char GPRS_LOGIN[]    = "arduino";
const char GPRS_PASSWORD[] = "arduino";

//questa è la variabile temperatura che abbiamo definito nelle proprietà del Thing
CloudTemperature temperatura;

//creo la connessione all'arduino cloud usando la rete gsm
GSMConnectionHandler ArduinoIoTPreferredConnection(PINNUMBER, GPRS_APN, GPRS_LOGIN, GPRS_PASSWORD);

void setup() {
  // inizializzo la seriale
  Serial.begin(9600);
  //attendo che tutto sia pronto
  delay(1500);
  
  //inizializzo con l'id del clous
  ArduinoCloud.setThingId(THING_ID);
  //specifico la variabile che ho inserito nel thing e le sue caratteristiche
  ArduinoCloud.addProperty(temperatura, READ, ON_CHANGE, NULL);

  //inizializzo la connessione con la'rduino cloud
  //specificando il canale di comunicazione
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);
  
  //attivo i messaggi di debug
  setDebugMessageLevel(2);
  ArduinoCloud.printDebugInfo();
}

void loop() {
  //trigghero l'arduino cloud
  ArduinoCloud.update();

  //genero dei valori casuali per la variabile temperatura
  temperatura = random(0, 100);
  //visualiazzo sul serial monitor il valore della variabile
  Serial.print("send data ");
  Serial.println(temperatura);
  attendo 10 s tra gli aggiornamenti
  delay(10000);

}

I commenti che ho inserito nel codice descrivono il lavoro svolto dalle istruzioni.

Compiliamo e carichiamo il codice sulla Arduino GSM 1400. Terminato il caricamento apriamo il Serial monitor e osserviamo le fasi che portano a stabilire la connessione con l’Arduino Cloud.

Sul serial monitor osserviamo la stringa Device ID, questo valore deve essere identico a quello riportato nel tab Board. La stringa Thing ID invece deve essere identica a quella che viene indicata sulla pagina del Thing che abbiamo creato.

Apriamo una finestra del browser e colleghiamoci all’Arduino Cloud andando sulla dashboard del Thing. Osservando l’elemento grafico temperatura, dovremmo riscontrare gli stessi valori che la scheda sta trasmettendo.

In questo articolo abbiamo visto come configurare l’Arduino cloud e come trasmettere dei dati usando la MKR GSM 1400. Vedremo prossimamente anche come inviare dati dall’Arduino cloud alla scheda.

The post Configura con successo l’Arduino cloud appeared first on Esperimenti con logiche programmabili.

Un dispositivo IoT, tipicamente, ha bisogno di avere un circuito elettronico in grado di acquisire ed elabora dati (provenienti da sensori o da comandi esterni), un mezzo di trasmissione (molto spesso basato su un segnale  a radio frequenza) e un sistema remoto capace di memorizzare, elaborare e gestire i dati.

Le caratteristiche del microcontrollore sono scelte in base alla potenza di calcolo e alla sua capacità di risparmiare energia. Molte applicazioni IoT sono spesso installate in luoghi remoti dove non è possibile avere una alimentazione stabile e duratura, quindi l’unica fonte di energia è demandata all’uso di una batteria.

I mezzi di comunicazione più diffusi che vengono utilizzati in ambito IoT sono, LoRa, Sigfox, NB e rete cellulare(2G/3G/4G). La scelta tra questi sistemi avviene principalmente in base alla copertura, alla posizione geografica del dispositivo IoT e ai costi di gestione.

Questo articolo si basa sull’utilizzo di una Arduino Sim e una scheda Arduino MKR GSM 1400.

La Arduino SIM può essere utilizzata solamente con Arduino Cloud.

Come attivare la Sim Arduino

Quando riceviamo la sim Arduino, prima di poterla utilizzare, dobbiamo procedere alla sua attivazione. Sulla custodia della sim viene riportato un link (https://store.arduino.cc/digital/sim/activation) che porta ad una pagina web in cui è possibile inserire il codice ICCID presente sulla sim:

Dopo aver inserito il codice clicchiamo sul pulsante NEXT. Nella pagina successiva, andremmo a leggere e accettare i termini di utilizzo (ARDUINO SIM TERMS AND CONDITIONS). Clicchiamo nuovamente sul pulsante NEXT per confermare.

Nella pagina successiva ci sarà un riepilogo sulle informazioni del nostro account e sul costo del servizio. Continuiamo cliccando sul pulsante NEXT. Nella pagina successiva dovremmo inserire i dati di pagamento per poi procedere cliccando sul pulsante Complete Payment.

La sim a questo punto è in fase di attivazione e prima di utilizzarla dovremmo attendere una mail di conferma.

Come gestire la Arduino SIM

Per verificare le impostazioni e il traffico dati della nostra Arduino SIM dobbiamo andare sul device manager (https://create.arduino.cc/devices/). Scorrendo e arrivando in fondo alla pagina, vedremmo la nostra sim e il suo stato.

Per i dettagli è sufficiente cliccare sull’icona della sim attiva:

In questa pagina troviamo anche delle informazioni che dovranno essere inserite nel codice dello sketch che andremmo a scrivere:

Aggiungere una scheda al Device Manager

Dopo aver attivato la Arduino SIM dobbiamo associare nel Device Manager (https://create.arduino.cc/devices/) una scheda Arduino che potrà interagire con il cloud Arduino. Le schede abilitate all’uso del cloud Arduino sono le seguenti:

• MKR 1000
• MKR WiFi 1010
• MKR GSM 1400
• MKR NB 1500
• Nano 33 IoT
• MKR WAN 1300
• MKR WAN 1310

Nel mio caso utilizzerò una MKR GSM 1400.

Clicchiamo sull’icona ADD NEW BOARD. Verrà caricata una pagina con una procedura guidata che permetterà di associare la nostra scheda al Device Manager.

Nella prima pagina della procedura guidata, selezioniamo la scheda da utilizzare:

clicchiamo sull’icona Arduino MKT GSM 1400. Nella schermata successiva, vengono indicate le fasi per configurare la MKR GSM 1400:

Clicchiamo sul pulsante START per andare avanti. La prima fase della procedura guidata indica che dobbiamo scaricare il plugin Arduino Create Agent, il cui compito è quello di mettere in comunicazione la scheda collegata al pc con la procedura di configurazione on line.

Clicchiamo sul pulsante DOWNLOAD:

Una volta cliccato sul pulsante, la procedura mostra che dopo aver terminato il download del file, dobbiamo eseguire un doppio click su di esso e seguire le istruzioni:

Dopo l’installazione dell’Arduino Create Agent, la procedura guidata indicherà che la comunicazione con il plugin è avvenuta con successo:

Andiamo avanti cliccando sul pulsante NEXT. Nella schermata successiva viene richiesto di collegare la scheda al pc. Quindi procediamo collegando, tramite cavo usb, la scheda MKR GSM 1400 al nostro computer:

Dopo qualche istante il plug Arduino Create Agent, aggiornerà la procedura guidata on line che la scheda MKR 1400 è stata collegata al computer.

A questo punto otterremo la seguente schermata dove assoceremmo un nome alla nostra scheda:

Inseriamo un nome identificativo, ad esempio gsm_1400 e andiamo avanti cliccando sul pulsante NEXT.

Ora la procedura indica se vogliamo configurare il Crypto Chip presente nella MKR GSM 1400. Questa procedura è importante perché aumenta il livello di sicurezza della comunicazione tra la scheda e l’Arduino Cloud.

Clicchiamo su CONFIGURE e attendiamo la fine della configurazione del Crypto Chip.

Nella schermata successiva ci viene chiesto di inserire la scheda SIM. Io in questa fase ho scollegato la scheda dalla porta usb, ho inserito la sim e ricollegato la scheda alla porta usb.

Quindi clicchiamo nuovamente sul pulsante NEXT.

Nella schermata successiva viene visualizzato uno sketch di esempio. Lasciamo questo codice invariato e clicchiamo sul pulsante ENTER GSM DATA:

Ora viene richiesta la compilazione dei campi relativi ai parametri della Arduino SIM. Questi parametri gli abbiamo già incontrati quando abbiamo configurato la Arduino SIM.

Inseriamoli nei relativi campi e clicchiamo sul pulsante UPLOAD

Terminato l’upload dello sketch sulla Arduino GSM 1400, la procedura guidata prova a stabilire una connessione con la scheda utilizzando la rete gsm:

Se tutto funziona correttamente otterremo la schermata del Network Monitor:

In questa schermata possiamo accendere o spegnere il led on board della MKR GSM 1400. Scrivendo sulla textbox la stringa ON e cliccando sul bottone SEND potremo osservare che sulla scheda il led viene effettivamente acceso.
Per spegnerlo sarà sufficiente inserire la stringa OFF e premere nuovamente sul bottone SEND.

Terminiamo la procedura guidata cliccando sul pulsante PLAY.

Nel prossimo articolo andremmo a creare una THING utilizzando l’Arduino cloud e a scrivere del codice per spedire o ricevere dei dati.

The post Scopri come configurare Arduino sim e MKR 1400 appeared first on Esperimenti con logiche programmabili.

La maggior parte dei dispositivi elettronici che ci circondano, dal piccolo elettrodomestico alla smartphone, hanno circuiti elettronici che vengono gestiti da un software. Anche se non ci accorgiamo, ogni giorno, direttamente o indirettamente, abbiamo a che fare con dei programmi che ci permettono di utilizzare in modo semplice, diversi dispositivi.

E’ prevedibile che nel prossimo futuro i software saranno presenti in maniera ancora più massiccia, andando a governare ogni tipo dispositivo elettronico. Se consideriamo solo il mercato IoT, stimato in miliardi di dispositivi installati, capiamo quale sia l’importanza dello sviluppo software.

Di conseguenza, imparare a programmare, ci mette nelle condizioni di capire meglio il funzionamento dei dispositivi elettronici. Questo produce inoltre altri vantaggi, infatti queste competenze potranno essere impiegate anche in altri numerosi campi, dallo sviluppo di applicazioni per pc a quelle per dispositivi mobili o per il web.

Attualmente ci sono decine di linguaggi di programmazione consigliati a chi volesse iniziare a programmare. Non esiste un linguaggio migliore di un altro, tutti hanno dei pro e dei contro e la scelta ricade dal tipo di software che vogliamo sviluppare e dalle risorse che abbiamo a disposizione.

Il linguaggio più apprezzato per le persone che vogliono iniziare a programmare, ma che non hanno nessuna esperienza, è certamente Python. I vantaggi di questo linguaggio sono riassunti in questi pochi punti:

• semplice da imparare
  • (la sua sintassi è molto semplice da imparare e la scrittura del codice permette di capire subito la struttura del codice)
• multi piattaforma
  • (il software può essere scritto utilizzando diversi sistemi operativi e può girare in tantissimi dispositivi, dai microcontrollori ai pc più potenti)
• open source
• vasta community
  • (la community Python ci permette di imparare dall’esperienza fatta da altri utenti)

Installare Python (su Windows)

La prima cosa da fare è installare Python sul proprio pc. La procedura risulta molto semplice, è sufficiente andare sul sito ufficiale Python.org, cliccare sul link download e cliccare sul pulsante Download Python. Il pacchetto di installazione deve essere effettuato in base al proprio sistema operativo.

Una volta scaricato il file eseguibile, basta eseguirlo con un doppio clic e seguire le istruzioni del wizard.

Se tutto è andato a buon fine nel menu Start di Windows dovremmo avere una cartella con nome Python 3.8 (Il numero si riferisce alla versione installata e potrebbe differire a seconda della vostra installazione).
All’interno di questa cartella ci sono due icone che si riferiscono alla documentazione Python e due icone che lanciano due programmi la REPL e l’Idle.

Il programma REPL è un ambiente a linea di comando che permette di eseguire i comandi Python. Questo è utile per provare dei comandi immediatamente per capirne il funzionamento.

Idle invece è un editor che ci permette di scrivere i programmi Python, di poterli salvare ed eseguire.

The post Programmare usando Python appeared first on Esperimenti con logiche programmabili.

Arduino UNO dispone di 6 canali ADC che permettono di acquisire segnali analogici con una risoluzione di 10 bit. Questo significa che il dato analogico può essere espresso con un valore digitale compreso tra 0 e 1024 ( 2^10=1024). Nella maggior parte dei tutorial che ho scritto la risoluzione di 10 bit è stata più che sufficiente per acquisire i segnali proveniente dai sensore analogici che usai.

Capita però che in particolari casi abbiamo bisogno di avere una risoluzione maggiore e piuttosto che cambiare scheda, è possibile utilizzare un convertitore analogico digitale esterno, impiegando un integrato apposito.

Gli ADC possono avere uno o più canali, risoluzioni e velocità di campionamento differenti. Quale scegliere dipende sostanzialmente dalle specifiche di progetto.
In uno degli articoli precedenti ho utilizzato l’integrato PCF8591. Questo integrato ha 4 porte ADC a 8 bit e 1 porta DAC.

In questo articolo invece andremmo ad utilizzare l’integrato MCP3201 che ha un canale con risoluzione di 12 bit.

Il convertitore A/D MCP3201

Questo convertitore a singolo canale di tipo sample & hold, viene interfacciato con il microcontrollore tramite bus SPI. Nella figura seguente viene illustrato lo schema a blocchi.

L’integrato MCP3201 ha un range di tensioni di lavoro che vanno da 2.7 V a 5.5 Vdc, la corrente di lavoro è di circa 300uA mentre in standby assorbe circa 500nA, quindi si presta in molte applicazioni dove il risparmio energetico è fondamentale.

Nella figura seguente viene proposto lo schema elettrico del circuito di prova.

La prima cosa da notare è che la linea MOSI (pin 11 di Arduino UNO) del bus SPI non viene utilizzata. Questo perchè per ricevere i dati dall’MCP3201 viene utilizzata la line CS e il segnale di clock del bus SPI. Nella figura seguente viene mostrato il grafico dei timing delle linee CS, CLK e Dout:

Il microcontrollore pone a livello basso la linea CS per avviare la comunicazione con l’integrato MCP3201. A questo punto il segnale di clock generato dal microcontrollore viene utilizzato per avviare la conversione analogico digitale. Nella figura seguente viene illustrato dettagliatamente il ciclo di conversione e di trasferimento dei dati.

Osserviamo il segnale di clock, dopo il terzo impulso è disponibile sulla linea Dout il bit più significativo (MSB) del dato analogico. Gli impulsi seguenti del segnale di clock permettono di avere i restanti bit del dato digitale. Da notare che il bit B1 viene ripetuto al sedicesimo clock e deve essere rimosso quando andiamo a ricostruire il dato digitale del segnale analogico. Questo può essere fatto shiftando a destra tutti i bit di una posizione.

Terminata la lettura dei due bute il microcontrollore mette al livello alto la line CS.

Il codice di esempio

Il seguente codice permette di leggere il valore della conversione analogico digitale dell’integrato MCP3201

#define ADC_SELECT 10

int PrimoByte = 0;
int SecondoByte = 0;
int Lettura = 0;

void setup() {

pinMode (ADC_SELECT, OUTPUT);

//init del MCP3201
digitalWrite(ADC_SELECT, 0);
delay(100);
digitalWrite(ADC_SELECT, 1);

//init seriale
Serial.begin(9600);
delay(100);

// init SPI
SPI.begin();
delay(100);
}

void loop() {

digitalWrite(ADC_SELECT, 0);
PrimoByte = SPI.transfer(0);
SecondoByte = SPI.transfer(0);
digitalWrite(ADC_SELECT, 1);

SPI.endTransaction();

Lettura = ((PrimoByte & 0x1F) << 8) | SecondoByte;

//elimino il bit di ridondanza
Lettura = Lettura >> 1;

Serial.print("Dato analogico= ");
Serial.println(Lettura);

delay(500);

}

Il costo dell’integrato mcp3201 è di circa 2.5€.

The post Convertitore A/D MCP3201 appeared first on Esperimenti con logiche programmabili.