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.

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.

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.

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

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

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

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

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

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

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

La fondazione Raspberry PI (www.raspberrypi.org) ci stupisce nuovamente introducendo la piccola PI ZERO, una nuova scheda dalle dimensioni disarmanti e dal costo di appena 5 dollari. Un piccolo computer (o meglio una piccola scheda madre) che permetterà di realizzare una miriade di progetti investendo una cifra irrisoria, ala portata di tutti.
Se qualche anno fa eravamo abituati ad avere in allegato alle riviste di tecnologia un dvd in omaggio piuttosto che piccoli gadget elettronici, oggi sembra incredibile vedere la PI Zero allegata alla rivista MagPI! Un computer in omaggio allegato alla rivista!

Nonostante il prezzo di lancio di 5 dollari, il SoC utilizzato (Broadcom BCM2835) è identico a quella della Raspberry PI Model A+ ma con una frequenza da 1GHz e una Ram da 512MB.

Per capire meglio la famiglia di schede, ho realizzato una tabella comparativa che mostra quali siano le differenze principali tra i vari modelli, allo scopo di avere un riferimento quando vorremo acquistarne una:

Raspberry PI	PI ZERO	Model A+	Model B	Model B+	2 Model B
Tipo SoC	Broadcom BCM2835	Broadcom BCM2835	Broadcom BCM2835	Broadcom BCM2835	Broadcom BCM2836
Processore	ARMv11 single core	ARMv6 single core	ARMv6 single core	ARMv6 single core	ARMv7 Quad Core
Frequenza CPU	1GHz	700MHz	700MHz	700MHz	900MHz
Ram	512MB SDRAM	256MB SDRAM	256MB SDRAM	512MB SDRAM	1GB SDRAM
Numero Porte USB	1	1	2	4	4
Porta Ethernet	NO	NO	SI	SI	SI
Numero porte GPIO	40	40	26	40	40

Questa nuova scheda a mio parere si candida per essere impiegata principalmente nei progetti elettronici del segmento domotica e IoT poiché il suo basso assorbimento di energia e le dimensioni contenute (lunghezza 65mm, altezza 30mm, Spessore 5mm) sono certamente una caratteristica peculiare.

La tabella seguente compara i vari assorbimenti tra le schede PI

La ZERO ha assorbimenti in linea con la A+, nonostante abbia il processore overcloccato a 1GHz. Per progetti dove l’alimentazione è un punto critico (circuiti alimentati a batteria) si potrebbe agire sui file di configurazione, della distribuzione Raspbian, per diminuire la velocità di clock (test che personalmente  non ho provato).

In conclusione credo che questa scheda sia un ottima opportunità per chi ha intenzione di arricchire il proprio bagaglio tecnico in ambiente Linux e per realizzare progetti con un investimento davvero irrisorio.

The post Pi ZERO il primo Raspberry PI a 5 dollari appeared first on Esperimenti con logiche programmabili.

Sentire parlare di progetti IoT è quasi diventata una moda e nonostante la realizzazione di progetti più o meno interessanti, possiamo confermare che il mercato è in forte espansione e l’industria sta investendo ingenti capitali. Uno degli aspetti chiave dell’internet delle cose è sicuramente la remotizzazione dei dispositivi. Vengono perciò progettate reti dedicate, come la rete Sigfox oppure il sistema LoRa caratterizzate da lunghe distanze operative e bassi consumi.
Un altro canale di comunicazione che sta ritornando in uso è la rete gsm, forte della sua alta percentuale di copertura del territorio nazionale e un uso ormai semplificato grazie a libreria pronte all’uso.
Nonostante i moduli GSM abbiano un consumo energetico maggiore rispetto a quelli SigFox e LoRa, rimane comunque un sistema molto valido soprattutto in attesa che anche nel nostro paese vengano realizzate reti IoT dedicate.

Esistono diverse shield gsm o moduli stand alone che permettono di costruire circuiti capaci di dialogare tra loro a grandi distanze. La shield ufficiale Arduino è da tempo indisponibile, nonostante esiste una seconda versione, viste le diatribe tra le due società Arduino, ho preferito usare un altro prodotto ed in particolare quello sviluppato da Mikroelektronica che si basa sul modulo M95A perché  ha un costo contenuto ed è compatibile con la libreria ufficiale disponibile nell’ide sviluppato da Arduino.cc.

Di seguito potete vedere il modulo e la sua pin function

Mikroelektronica, oltre ha produrre diversi tipi di compilatori, ha un suo sistema di sviluppo hardware composto da delle schede chiamate Click Boards che si collegano tra loro utilizzando il Mikro Bus.

La comunicazione tra la GSM2click ed Arduino avviene tramite UART. Esiste anche la Arduino UNO click shield ma purtroppo non possiamo utilizzarla perché la libreria gsm utilizza la SoftwareSerial sui pin 2 e 3 mentre nella Arduino UNO click shield la seriale è collegata ai pin 0 e 1.
Quindi dovremmo adattare i collegamenti Arduino UNO e la GSM2click seguendo questo semplice schema:

Il modulo GSM2Click utilizza sia l’alimentazione a 3.3Vdc sia quella a 5Vdc. I pin TX e RX del modulo vanno rispettivamente collegati al pin 2 e pin 3 di Arduino (quelli utilizzati dalla SoftwareSerial della libraria GSM). Il pin7 di Arduino va collegato al pin RST che in pratica corrisponde al PowerKey del modulo M95.

Codice di esempio

Prima di caricare il codice dobbiamo inserire nel modulo GSM2Click una SIM attiva con relativo credito telefonico. Nonostante il modulo possa funzionare senza l’ausilio di un’antenna consiglio assolutamente il suo impiego per aumentare il segnale ricevuto e soprattutto evitare disadattamenti di impedenza del trasmettitore RF.

Il codice seguente inizializza il modem del modulo M95 e ne ricava il codice IMEI:

// libraria GSM
#include <GSM.h>

//creo un oggetto modem
GSMModem modem;

String IMEI = "";
float tempo_prec, tempo =0;

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

Serial.println("Avvio modem...");

//memorizzo il tempo corrente
tempo_prec = millis();

//inizializzo il modem e verifico il suo stato
if (modem.begin())
{
//memorizzo il tempo corrente
tempo= millis();

//calcolo il tempo di avvio del modem
Serial.print("Modem avviato in ");
Serial.print((tempo - tempo_prec)/1000);
Serial.println(" secondi.");

}
else
//avvisami in caso di errore
Serial.println("ERRORE, nussuna risposta dal modem.");

Serial.println("Leggo il codice IMEI");

//ottengo il codice imei
IMEI = modem.getIMEI();

//verifico il codice e lo visualizzo
if (IMEI != NULL)
{
Serial.print("Codice IMEI= " + IMEI);
}
else
{
Serial.println("ERRORE: lettura codice IMEI fallita!");
}
}

void loop()
{

}

La classe GSM permette di semplificare la comunicazione col modulo utilizzando una sintassi molto elementare. Abbiamo comunque la possibilità di scendere nel dettaglio utilizzando i comandi AT. La Quectel fornisce dettagliate documentazioni relative a tutti i sui moduli, in questo modo possiamo ottimizzare il nostro codice accedendo solo alle funzioni specifiche del modulo.

Per provare ad utilizzare i comandi AT, ho modificato il circuito elettrico prelevando il segnale sul pin STA del modulo GSM2Click, questo perchè prima di inviare un comando devo assicurarmi che il modulo sia attivo e funzionante.

Questo il codice che testa la comunicazione tramite comandi AT:

#include <SoftwareSerial.h>

#define rxPin 2
#define txPin 3

SoftwareSerial mySerial =  SoftwareSerial(rxPin, txPin);

String risp_at = "";
char message[50];

void setup() {
// put your setup code here, to run once:
mySerial.begin(9600);
Serial.begin(9600);

pinMode(6, INPUT);
pinMode(7, OUTPUT);

//verifico se il modulo è attivo
if(digitalRead(6) == LOW)
{
//attivo il moduloinviando un livello
//logico alto al pin PWK (Power Key)
digitalWrite(7, HIGH);
delay(1000);
digitalWrite(7, LOW);
}

//attendi l'avvio del modulo
while(digitalRead(6) == LOW)
{
delay(100);
Serial.print(".");
}

//Invio il comando 'AT' per verificare la
//risposta del modulo
mySerial.write("AT");
mySerial.write(10);
mySerial.write(13);

delay(500);

//attendo finchè non ricevo dati dal modulo
while(mySerial.available())
{
risp_at += (char)mySerial.read();
}

if(risp_at.length() > 0)
{
risp_at.toCharArray(message, risp_at.length());
Serial.println(risp_at);
}
}

void loop()
{
delay(10);
}

Volendo possiamo utilizzare direttamente il Serial Monitor per inviare comandi AT al modulo. In pratica invio il comando ad Arduino UNO che lo rigira al modulo M95 e viceversa, i dati inviati dal modulo M95 vengono spediti al serial monitor tramite Arduino UNO. Questo è un ottimo metodo per testare comandi At e capirne il funzionamento.

#include <SoftwareSerial.h>

#define rxPin 2
#define txPin 3

SoftwareSerial mySerial(rxPin,txPin); // RX, TX

void setup(){

Serial.begin(9600);
Serial.println("Arduino serial initialized!");
delay(10);

mySerial.begin(9600);
Serial.println("Software serial initialized!");
delay(10);

pinMode(6, INPUT);
pinMode(7, OUTPUT);

//verifico se il modulo è attivo
if(digitalRead(6) == LOW)
{
//attivo il moduloinviando un livello
//logico alto al pin PWK (Power Key)
digitalWrite(7, HIGH);
delay(1000);
digitalWrite(7, LOW);
}

}

void loop()
{
if(Serial.available())
{
mySerial.write(Serial.read());
}

if(mySerial.available())
{
Serial.write(mySerial.read());
}
}

Ora possiamo usare il Serial Monitor come se fosse collegato direttamente al modulo M95.
Lanciamo il Serial Monitor ed assicuriamoci di avere impostata la velocità di comunicazione a 9600bps e di selezionare il ritorno carrello e la nuova linea (NL & CR).

Proviamo a scrivere sul serial monitor il comando AT e clicchiamo sul pulsante invia. Il modulo risponderà con questa stringa:

OK //comando eseguito correttamente

La risposta OK informa che il comando AT è stato eseguito correttamente.
Possiamo verificare ed esempio quale sia il livello del segnale della rete GSM inviando al modulo questi caratteri AT+CSQ
il risultato, nel mio caso è il seguente:

+CSQ: 26,0

OK

il comando CSQ è riconosciuto valido e il suo valore è 26,0. Questi dati possono essere interpretati utilizzando il manuale del modulo M95.

Le istruzioni AT sono molto semplici e permettono di eseguire sia comandi sia settaggi di impostazioni. Per ulteriori esempi non dovete fare altro che leggerli dal manuale!

The post Arduino. Utilizzare la rete GSM per progetti IoT appeared first on Esperimenti con logiche programmabili.

Il termine ‘internet delle cose‘ sta diventando sempre più popolare per due motivi fondamentali, il primo riguarda la grande diffusione dei dispositivi programmabili come Arduino e Netduino (senza tralasciare  il sistema OpenPicus e il RaspberryPI) con la loro relativa semplicità di utilizzo, mentre il secondo motivo è dovuto alla necessità di conoscere in tempo reale cosa questo dispositivo sta facendo e come sia possibile controllarne le funzionalità, anche a distanza.
Tutto questo è strettamente legato alla diffusione della rete 3G e degli smartphone che permettono di avere una connessione ad internet pressoché ovunque.

Questo scenario rende interessante lo sviluppo di nuove tipologie di applicazioni legate appunto al controllo e allo scambio dati tra dispositivi hardware collegati ad internet.

Esistono numerosi prototipi ma anche esempi reali che dimostrano come l’utilizzo di sistemi embedded+internet creino infrastrutture, anche complesse, controllabili. Il classico esempio riguarda la gestione del traffico che nelle nostre città viene gestito da semplici semafori che regolano il traffico in modo statico. Utilizzando dispositivi smart è possibile ottimizzare questo sistema migliorando la viabilità, evitando ingorghi e facendo risparmiare energia e carburante. Ma le applicazioni sono davvero notevoli e sono tutte orientate al risparmio energetico e al migliorare il nostro modo di vivere.

Di seguito sono elencate le categorie dove maggiormente verranno sviluppati dispositivi riconducibili all’internet delle cose

• Domotica
• Controllo inquinamento ambientale cittadino
• Monitoraggio Ambientale
• Energie rinnovabili, Smart Grid
• Illuminazione pubblica intelligente
• Sistemi per il rilevamento tempestivo degli incendi
• Controllo delle acque, tra cui livello degli argini.
• Controllo e gestione degli accessi con tecnologia RFID
• Agricoltura, irrigazione intelligente.
• Sorveglianza di pazienti e anziani in abitazioni isolate.
• Miglioramento processi industriali, gestione magazzino.

Gartner ha identificato l’IOT come una delle 10 tecnologiche trainanti per il 2013.

Per quello che ci riguarda dobbiamo dotarci di un dispositivo capace di connettersi ad internet, nel mio caso utilizzerò l’Arduino Ethernet, di una connessione internet e di un server web capace di elaborare le richieste inviate dall’Arduino.

Il progetto di questo tutorial permette di acquisire un segnale analogico, di inviarne il valore al server remoto che lo memorizzerà in una tabella del database MySql.
L’invio dei dati avviene tramite architettura REST. Praticamente i valori acquisiti da Arduino verranno inviati utilizzando l’URL.
Lato server, uno script PHP recupererà i valori dall’url e li memorizzerà sul database.

se non disponete di un server web remoto potete installarne uno nella vostra macchina locale utilizzando XAMPP. Il pacchetto installa automaticamente il server web Apache, l’interprete PHP ed il server MySql.

Iniziamo subito con il codice che ho caricato sull’Arduino:

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

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
//indirizzo server web (locale)
IPAddress server(192, 168, 0, 140);

//indirizzo ip dell'Arduino
IPAddress ip(192, 168, 0, 200);

EthernetClient client;

String strURL = "";
float temp = 0;

void setup()
{
Serial.begin(9600);

if (Ethernet.begin(mac) == 0)
{
Serial.println("Configurazione DHCP fallita!");
Ethernet.begin(mac, ip);
}

delay(1000);

}

void loop()
{
UpdateTemp();

while(client.available())
{
char c = client.read();
Serial.print(c);
}

if (!client.connected())
{
Serial.println();
Serial.println("Disconnesso.");
client.stop();
}

//esegui la richiesta ogni 10 secondi
delay(10000);
}

void UpdateTemp()
{
Serial.println("Connessione...");

if (client.connect(server, 80))
{
Serial.println("Connesso");
//acquisisco il valore analogico dal sensore MCP9700
//vedi questo articolo
//logicaprogrammabile.it/mcp9700a-netduino-sensore-temperatura-analogico
temp = analogRead(0);

//creo l'url utilizzanso una stringa
strURL = "GET /arduino/index.php?valore=";
strURL += (int)temp;
strURL += "&localita=Sardegna HTTP/1.1";

//invio la richiesta al server
client.println(strURL);
client.println("Host: localhost");
client.println("Connection: close");
client.println();
//chiudo la connessione
client.stop();
}
else
{
Serial.println("Errore Connessione");
}
}

Il codice esegue una connessione al server locale e, dopo aver acquisito il segnale proveniente dal sensore analogico, costruisce l’indirizzo URL inserendo due parametri, il valore analogico acquisito e la località:

/arduino/index.php?valore=120&localita=Sardegna

La pagina index.php ha il compito di recuperare i parametri e di caricarli sul database. Questo è il codice PHP:

<?php
//controllo se sono presenti i parametri valore e localita
if(isset($_GET['valore']) && isset($_GET['localita']))
{
//Recupero il valore del parametro "valore"
$valore = $_GET['valore'];

//Recupero il valore del parametro "localita"
$localita = $_GET['localita'];

//eseguo la connessione al database sul server locale
//inserendo nome utente e password
$link = mysql_connect('localhost', 'root', 'root');

//gestione degli errori
if (!$link) {die('Impossibile connettersi: ' . mysql_error());}

//seleziono il databse di nome arduino
mysql_select_db("arduino") or die( "Impossibile selezionare il database.");

//creo una stringa sql di inserimento con i valori
//recuperati dall'url
$sql = "INSERT INTO `arduino`.`tbl_temperature`
(
`ID` ,
`Tempo_Server` ,
`Tempo_Locale` ,
`Valore` ,
`Localita`
)
VALUES
(
NULL , CURRENT_TIMESTAMP , NULL , '" . $valore . "', '" . $localita . "'
);";

//eseguo la query
$retval = mysql_query( $sql, $link );

//gestione degli errori
if(! $retval ){die('Impossibile eseguire la query: ' . mysql_error());}

//chiudo la connessione al db
mysql_close($link);
}
?>

Tramite phpMyAdmin ho creato un database di nome Arduino e una tabella di nome tbl_Temperature. Il codice sql per creare la tabella è il seguente:

CREATE TABLE `tbl_temperature` (
`ID` int(11) NOT NULL AUTO_INCREMENT,
`Tempo_Server` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
`Tempo_Locale` datetime DEFAULT NULL,
`Valore` int(11) NOT NULL,
`Localita` varchar(50) NOT NULL,
PRIMARY KEY (`ID`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1;

Utilizzando Arduino, PHP e Mysql siamo riusciti a realizzare un piccolo sistema IOT. Certamente bisogna imparare ad utilizzare anche le tecnologie lato server per far interagire Arduino, ma con un po di impegno è possibile realizzare applicazione molto interessanti.

In questo tutorial non ho approfondito l’installazione e la configurazione di XAMPP, ne l’uso di PHP e MySql perché sarebbe stato necessario un tutorial dedicato, molto più lungo e forse dispersivo.

The post Memorizzare dati su un sito web con PHP e Mysql appeared first on Esperimenti con logiche programmabili.