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.

Quando iniziamo a sperimentare con una scheda elettronica spesso e volentieri ci ritroviamo, involontariamente, a freezzare la scheda o a eliminare file necessari al corretto funzionamento della stessa.
Per esempio se andate a cancellare i file contenuti nella flash (PyBFlash)della scheda PyBoard, questi file potranno essere ripristinati solamente eseguendo un Factory Reset. Fortunatamente con la scheda PyBoard basata su Micropython è impossibile commettere errori software che potrebbero comprometterne permanentemente la funzionalità.

Per testare questa procedura andremmo a cancellare tutti i file presenti nella PyBFlash della scheda, ovvero:

• pybcdc.inf
• README.txt
• boot.py
• main.py

Cancellati questi file se eseguiamo il reset della scheda, l’unico file che verrà automaticamente rigenerato sarà il file boot.py

Come eseguire il factory reset

Per poter ripristinare la nostra scheda PyBoard è necessario eseguire una semplice procedura utilizzando i pulsanti onboard.

1. Alimentare la scheda utilizzando la porta usb.
2. Tenere premuto il pulsante USR.
3. Tenendo sempre premuto il pulsante USR, premiamo e rilasciamo il pulsante di Reset.
4. Il led Verde e Arancio inizieranno a lampeggiare, alternativamente e contemporaneamente.
5. Nell’istante in cui entrambi i led risultano accesi dobbiamo rilasciare il pulsante USR.
6. Il led Verde e Arancio lampeggeranno in contemporanea per alcuni istanti, in maniera molto veloce.
7. Il Led Verde e Arancio resteranno accesi e in contemporanea verrà acceso anche il led Rosso.
8. Questi tre led resteranno accesi per 4 secondi e successivamente si spegneranno.
9. La scheda è ora ripristinata alle condizioni iniziali.

Verifica della PyBoard

Se la procedura è andata a buon fine dovremmo ritrovare nella PyBFlash i file originali che abbiamo precedentemente cancellato.

Verifichiamo che collegandoci via seriale otterremo una risposta dalla scheda.
Avviamo Putty e inseriamo i parametri corretti per il collegamento seriale alla PyBoard

Cliccando sul pulsante Open potremmo osservare il caricamento della sessione seriale e l’avvio del prompt REPL, come mostrato in figura:

Con queste istruzioni abbiamo imparato ad eseguire il factory restore utile in tutti quei casi in cui abbiamo bisogno di ripristinare alle impostazioni di fabbrica la nostra PyBoard.

The post Micropython come ripristinare la PyBoard appeared first on Esperimenti con logiche programmabili.

Arduino con la sua scheda UNO ha rivoluzionato il mondo dei makers dando la possibilità di realizzare numerosi progetti sia in ambito hobbistico che professionale. La diffusione delle schede Arduino ha influenzato numerosi produttori che hanno messo in campo risorse per la realizzazione di nuovi dispositivi facili da programmare (il modulo G30 TH è un esempio), dal costo contenuto e open.

Oggi sono disponibili molte tipologie di schede che possono essere utilizzate in sostituzione della UNO o comunque essere impiegate in concomitanza. Tra le schede che personalmente reputo molto valide ci sono quelle basate sul .Net Micro framework ed in particolare quelle prodotte da GHI Electronics.

E’ chiaro che non esiste una scheda migliore o peggiore poiché ognuna possiede pregi e difetti. La scelta principale dipende sicuramente dalla tipologia di progetto che intendiamo realizzare e soprattutto dalla propria esperienza in campo elettronico ed informatico.

E’ difficile fare una comparazione diretta tra due schede con una architettura completamente differente ma è anche vero che quando andiamo ad acquistare un dispositivo effettuiamo delle scelte mettendo a confronto alcuni parametri.

Tuttavia non è sempre vero che una comparazione tra grandezze dello stesso tipo porti a valutare quale sia la scheda migliore, ad esempio il modulo G30 TH ha una cpu a 32bit con frequenza di 84MHz mentre la UNO una cpu a 8bit e frequenza di 16MHz, ma questo non significa assolutamente che la G30 TH sia più veloce e performante.

Tenterò di fare questa comparativa soprattutto per farvi conoscere la scheda G30 TH (sfortunatamente GHI Electonics non mi paga per fargli pubblicità!!)

La scelta del confronto tra la G30 TH e la UNO è dipesa principalmente per il fatto che sono posizionate nella stessa fascia di prezzo, infatti la UNO ha un costo di circa 24€ e la G30 TH un costo di circa 23€.

La tabella seguente mette in evidenza quali siano le differenze hardware tra i due prodotti:

Analizzando la tabella sembrerebbe che la G30 TH esca vincitrice nel confronto delle singole voci. Ma è davvero cosi?

Realizziamo una prima semplice prova pratica per testare quale delle due schede ha una velocità di commutazione di un pin IO più elevata. Di seguito il codice caricato sulla UNO e sulla G30 TH

//codice eseguito dalla Genuino UNO
void setup()
{
    pinMode(2, OUTPUT);
}

void loop()
{
    while()
    {
      digitalWrite(2, HIGH);
      digitalWrite(2, LOW);
    }
}

//codice eseguito dal modulo G30 TH
public class Program
    {

        static OutputPort dLED = new OutputPort(GHI.Pins.G30.Gpio.PA1, false);

        public static void Main()
        {
            while (true)
            {
                dLED.Write(true);
                dLED.Write(false);
            }
        }
    }

Stando alle informazioni della tabella precedente sembra scontato che il modulo G30 TH possa garantire una velocità superiore ma invece otteniamo dati controversi, infatti la UNO ha un toggle di 114KHz mentre la G30TH di soli 29.48KHz.

Ora proviamo a eseguire il GPIO speed test impiegando questa volta tre pin digitali, il codice sulla UNO è il seguente:

void setup()
{
    //definisco i pin 2, 3 e 4 in uscita
    pinMode(2, OUTPUT);
    pinMode(3, OUTPUT);
    pinMode(4, OUTPUT);
}

void loop()
{
    //eseguo un ciclo infinito 
    while(true)
    {
      //commuto continuamente le uscite 2, 3 e 4
      digitalWrite(2, HIGH);
      digitalWrite(3, HIGH);
      digitalWrite(4, HIGH);
      digitalWrite(2, LOW);
      digitalWrite(3, LOW);
      digitalWrite(4, LOW);
    }
}

Misurando la frequenza di commutazione dei pin della UNO otteniamo un valore di circa 29,5KHz, questo perché viene impiegato un certo tempo per eseguire le istruzioni:

Di seguito il listato di codice caricato sul modulo G30 TH:

using System;
using System.Text;
using System.IO.Ports;
using System.Threading;
using Microsoft.SPOT.Hardware;
using GHI.Processor;

namespace MFConsoleApplication2
{
    public class Program
    {
        static OutputPort dLED2 = new OutputPort(GHI.Pins.G30.Gpio.PA2, false);
        static OutputPort dLED3 = new OutputPort(GHI.Pins.G30.Gpio.PA3, false);
        static OutputPort dLED4 = new OutputPort(GHI.Pins.G30.Gpio.PA4, false);

        private static void test()
        {
            while (true)
            {
                dLED2.Write(true);
                dLED2.Write(false);
            }
        }

        private static void test1()
        {
            while (true)
            {
                dLED3.Write(true);
                dLED3.Write(false);
            }
        }

        private static void test2()
        {
            while (true)
            {
                dLED4.Write(true);
                dLED4.Write(false);
            }
        }

        public static void Main()
        {
            Thread th = new Thread(test);
            th.Start();

            Thread th1 = new Thread(test1);
            th1.Start();

            Thread th2 = new Thread(test2);
            th2.Start();
        }
    }
}

Il codice esegue la commutazione da livello logico alto a quello basso utilizzando tre thread. Misurando con un oscilloscopio il valore di frequenza sui pin del modulo G30 TH osserviamo che la frequenza di commutazione è rimasta invariata sui 29.48KHz:

Quindi sulla scheda UNO, inserendo più istruzioni,  otteniamo un rallentamento dovuto all’uso contemporaneo di più risorse. Nel modulo G30 TH questo non si è verificato infatti utilizzando dei thread il dispositivo ha prodotto la stessa frequenza di commutazione sui tre pin.

Gli esempi precedenti mostrano che le schede possono avere performance differenti e quindi alla domanda “quale è la scheda più veloce?” non possiamo dare una risposta assoluta ma probabilmente convincerci che la domanda più corretta sia “quale è la scheda più adatta al mio progetto?”.

Differenze principali tra G30 TH e UNO

La differenza sostanziale tra la UNO e la G30TH è che in quest’ultima il programma viene gestito da un piccolo framework (TinyCLR) che ha il compito di gestire le istruzioni per poi farle eseguire al microprocessore. Questa soluzione ha lo svantaggio di una leggera latenza poiché il codice deve essere interpretato e gestito dal micro framework prima di poter essere eseguito dalla cpu, questa soluzione avvantaggia lo sviluppatore che non si deve preoccupare di cosa avviene al livello hardware (gestione timer e registri gestione della memoria e puntatori) ma deve solo preoccuparsi di scrivere ed ottimizzare il suo programma.

La UNO invece esegue immediatamente le istruzioni del programma, abbiamo accesso diretto ai registri e ai timers del microcontrollore permettendo di manipolarli a nostro piacimento (se sapiamo dove mettere le mani!).
Il microcontrollore della UNO, l’ATMEGA328, può essere impiegato in progetti stand alone senza grosse difficoltà visto che è in formato THT dip28, mentre il SoC G30 è in package tfq99, rendendo la progettazione homemade più difficoltosa.

Ambiente di sviluppo:

La UNO può essere programmata con l’Arduino IDE, un software molto spartano ma che mette a disposizione tutto il necessario per programmare e caricare i programmi sul microcontrollore. L’IDE è multi piattaforma è può essere utilizzato con sistemi Windows, Mac e Linux.

Per scrivere i programmi per il modulo G30 TH abbiamo bisogno di Microsoft Visual Studio, un eccellente ambiente di sviluppo che ci permette di scrivere, caricare e debbuggare in tempo reale i programmi che girano sul dispositivo. Visual Studio è disponibile solo per Windows.

Supporto e community

Quando acquisto un dispositivo verifico quale siano le risorse di supporto del produttore o di eventuali community. Per quanto riguarda Arduino possiamo far affidamento all’ottimo forum che solitamente assolve a qualsiasi tipologia di richiesta, inoltre potete trovare numerosissimi tutorial su blog e siti web.

Anche GHI Electronics ha un forum, molto meno frequentato di quello Arduino, ma che vi permetterà comunque di mettervi in contato con persone esperte che potranno darvi una risposta. Inoltre GHI offre un supporto ufficiale per la realizzazione di hardware specifico che impiega i suoi moduli.

Conclusione:

Penso che definire una scheda migliore di un’altra sia difficile se non si specifica il campo di impiego della scheda stessa. In generale quando devo scegliere il dispositivo ideale per la realizzare un progetto valuto il rapporto prezzo/prestazioni e la quantità di tempo necessario a scrivere il codice (questo dipende anche dalla disponibilità di supporto on line).

Penso anche che sia importante non fossilizzarsi solamente su una piattaforma ma provare a sperimentare usando nuovi dispositivi aumentando cosi il nostro bagaglio tecnico dandoci una visione più ampia nella scelta del dispositivo ideale al proprio progetto.

The post Arduino UNO vs GHI G30 TH appeared first on Esperimenti con logiche programmabili.

La libreria Webduino implementa una semplice autenticazione basata sul protocollo http. Certamente non offre un livello di sicurezza impenetrabile ma può comunque essere utile utilizzare questa funzione per le nostre applicazioni.

Nell’esempio, viene caricata la pagina index.htm dove è presente un link che punta a una pagina protetta. per poter visualizzarne il contenuto è necessario inserire nome utente e password.

La based authentication si basa sulla codifica Base64. Il nume utente e la password, nella forma numeutente:password, vengono convertiti in un unica stringa  di caratteri.  Per la conversione, potete utilizzare diversi servizi online oppure scaricare la mia app ConvertBase64.

Il codice seguente è pronto all’uso, dovete cambiare solamente l’indirizzo ip, adattando lo alla vostra rete locale.

[c]
#include "SPI.h"
#include "Ethernet.h"
#include "WebServer.h"

//definisco mac address e indirizzo ip
static uint8_t mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
static uint8_t ip[] = { 192, 168, 1, 10};

//creo un oggetto webduino
WebServer webserver("", 80);

//funzione che crea la pagina principale del sito
void defaultCmd(WebServer &server, WebServer::ConnectionType type, char *, bool)
{
server.httpSuccess();
if (type != WebServer::HEAD)
{
//invio al browser la pagina principale
P(helloMsg) = "<h4>Accedi:</h4><a href=\"private.html\">Pagina Privata</a>";
server.printP(helloMsg);
}
}

//questa funzione permette di verificare il nome utente e la password
//e in caso di successo di visualizzare la pagina privata
void privateCmd(WebServer &server, WebServer::ConnectionType type, char *, bool)
{
//user= admin
//password= admin

//verifico nome utente e password
if (server.checkCredentials("YWRtaW46YWRtaW4="))
{
//in caso affermativo…
server.httpSuccess();
if (type != WebServer::HEAD)
{
//invio al browser la pagina privata
P(helloMsg) = "<h3>Buongiorno Admin!</h3>";
server.printP(helloMsg);
}
}
else
{
//creo una risposta http
//nel caso in cui si tenta un accesso
//no autorizzato
server.httpUnauthorized();
}
}

void setup()
{
//inizializzo la ethernet shield
Ethernet.begin(mac, ip);
//definisco funzione che gestisce
//la pagina principale del sito
webserver.setDefaultCommand(&defaultCmd);
webserver.addCommand("index.html", &defaultCmd);
//definisco la funzione che gestisce la pagina privata
webserver.addCommand("private.html", &privateCmd);

//inizializzo la libreria webduino
webserver.begin();
}

void loop()
{
char buff[64];
int len = 64;

webserver.processConnection(buff, &len);
}
[/c]

La libreria Webduino è molto flessibile e permette di realizzare applicazioni interessanti in modo molto veloce.

The post Webduino Based Authentication. Accedere ad una pagina privata appeared first on Esperimenti con logiche programmabili.

Un progetto che ha sempre attirato molta attenzione è il circuito VU meter sincronizzato con il ritmo della musica (il mitico luci psichedeliche ). Anche io quando ero alle superiori mi sono cimentato costruendone uno. Il circuito era formato da tre filtri analogici, uno passa basso uno passa banda e uno passa alto, che lavoravano rispettivamente alle frequenze 0-500Hz, 500Hz 4000Hz e 4000Hz-16000Hz. All’uscita dei filtri c’era un rilevatore di picco costruito con un operazionale che andava a pilotare dei driver che accendevano delle lampadine colorate.

Oggi la tecnologia offre prodotti integrati a basso costo, specializzati in una vasta gamma di compiti che rendono più semplice la realizzazione dei nostri circuiti. Per quanto riguarda le nostre luci psichedeliche possiamo fa affidamento allo Spectrum shield per Arduino. Lo shield è molto semplice ed è composto principalmente da due integrati MSGEQ7 (Equalizzatore grafico a 7 bande). Lo schema a blocchi dell’integrato è il seguente:

si osserva che in effetti il principio di funzionamento è molto simile a quello che si usava nei primi circuiti a luci psichedeliche, ma i filtri a disposizione sono ben 7 e le uscite dei filtri vengono multiplexate, in questo modo invece di avere 7 pin di output ne abbiamo solamente uno.
Inviando un primo impulso positivo al pin strobe avremmo in uscita il valore analogico proveniente dal filtro a 63Hz, inviandone un altro impulso avremmo in uscita il valore analogico del filtro a 160Hz e così via fino a tornare dopo 8 impulsi al filtro a 63Hz.

I due integrati MSGEQ7 presenti nello spectrum shield analizzano il segnale audio proveniente dal canale destro e dal canale sinistro. Per brevità utilizzerò un solo integrato (canale) visto che il codice è interscambiabile.
Le uscite analogiche dei due integrati sono collegate ai pin A0 e A1 mentre i pin Strobe e Reset sono collegati ai pin digitali D4 e D5.

Questo è il codice:

[c]
//Specifica i pin Reset, Strobe
int spectrumReset=5;
int spectrumStrobe=4;

//Specifico il canale di ingresso
//pin A0 per canale destro
//pin A1 per canale sinistro
int spectrumAnalog = 1; //canale sinistro

//creo un vettore per contenere i valori analogici
//delle 7 bande
int Spectrum[7];

void setup()
{
//pin reset e strobe in output
pinMode(spectrumReset, OUTPUT);
pinMode(spectrumStrobe, OUTPUT);

//inizializzo lo spectrum shield
//Strobe
digitalWrite(spectrumStrobe,HIGH);
delay(1);
digitalWrite(spectrumStrobe,LOW);
delay(1)

//Reset dei due chip
digitalWrite(spectrumReset,HIGH);
delay(1);
digitalWrite(spectrumReset,LOW);
delay(5);

//definisco 7 uscite digitali per pilotare altrettanti led
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);

}

void loop()
{
//esegui la lettura ogni 10mS
readSpectrum();
delay(10);
}

void readSpectrum()
{
//Questa funzione legge il valore analogico per ogni banda
//e ne rappresenta il valore tramite dei led

byte Band;
//questo ciclo for viene eseguito 7 volte
for(Band = 0; Band < 7; Band++)
{
//eseguo due letture per poi dividerle per due tramite
//spostamento di bit. Il valore ottenuto viene memorizzato
//nel vettore
Spectrum[Band] = (analogRead(spectrumAnalog) + analogRead(spectrumAnalog) ) >>1;

//invio un impulso al pin strobe per passare al filtro successivo
digitalWrite(spectrumStrobe,HIGH);
digitalWrite(spectrumStrobe,LOW);
}

//una volta effettuata la memorizzazione dei dati
//nel vettore, creo un altro ciclo for
//per rappresentare gli stessi tramite led
for (byte Ciclo = 0; Ciclo < 7; Ciclo++)
{
//recupero il valore memorizzato nel vettore
//traslo il valore intero in un byte
byte x = map(Spectrum[Ciclo], 0, 1023, 1, 254);

//se il valore supera una soglia accendi il led
//altrimenti spegnilo
if( x > 120)
digitalWrite(Ciclo + 6 , HIGH);
else
digitalWrite(Ciclo + 6, LOW);
}
}
[/c]

Mentre questo è il circuito elettrico

Per poter collegare delle lampade a 220Vac è necessario usare dei triac con relativo stadio pilota fotoisolato.

The post Utilizzare lo Spectrum Shield con Arduino appeared first on Esperimenti con logiche programmabili.

Utilizzare un display risulta utile per una miriade di applicazioni dove è necessario una maggiore interazione con l’utente. Effettuare i collegamenti tra display e Arduino ed utilizzare la libreria LiquidCrystal per gestire il display è una operazione tutto sommato semplice ma nonostante molti utenti alle prime armi trovano alcune difficoltà.

I display a matrice di punti, utilizzano un protocollo comune basato sul chip HD44780 prodotto dalla Hitachi. Sono formati da diverse colonne e righe ed i valori tipici vengono espresso nella forma ColonnexRighe, nel nostro caso il display è un 20×4, quindi composto da 20 colonne per ognuna delle 4 righe (altri tipi possono essere 16×1, 16×2, 128×64, ecc…).

L’interfaccia per poter inviare i comandi ed i dati è di tipo parallelo, composta da 16 pin. Nella tabella seguente viene illustrata la pin function:

I pin Data servono per inviare un byte al chip del display. Il valore inviato può essere interpretato sia come un comando (ad esempio per spostare il cursore, per posizionarsi su una riga specifica, per pulire il display) sia un valore ASCII da scrivere sulla matrice. La scelta tra comando e carattere ASCII viene gestita dal livello logico posto sul pin RS.
Il pin E abilita l’esecuzione del comando o la scrittura sulla matrice.

Il circuito seguente è quello che ho realizzato per il tutorial:

Nello schema potete notare che i Data Pin non sono collegati completamente ma vengono utilizzati solo i bit più significativi (bit 4, 5, 6, 7). Questa peculiarità è possibile poichè il display supporta la modalità a 4-bit, che essendo implementata anche dalla libreria LiquidCrystal, fa in modo di usare solo 4 file piuttosto che 8.

Il pin6 di Arduino è collegato al pin4 del display per gestire la funzione di RS (Comando/Dato) mentre il pin7 è collegato al pin6 del display E, per far processare al chip del display il Comando o il Dato.

Una volta effettuati i collegamenti, possiamo iniziare con un piccolo sketch di esempio:

[c]
//inserisco la libreria per
//gestire i display a matrice di punti
#include <LiquidCrystal.h>

//creo un oggetto specificando i pin RS il pin E e
//i 4-bit di dati (bit 4, 5, 6, 7)
//collegati rispettivamente ai pin 6, 7, 4, 3, 2
//di arduino come da schema
LiquidCrystal Display20x4(6, 7, 5, 4, 3, 2);

void setup()
{
//il metodo begin permette di impostare il numero di
//colonne e di righe che compongono il display
//nel mio caso il modello è un 20×4
Display20x4.begin(20, 4);

//pulisci il display e posiziona il cursore sulla prima
//riga e sulla prima colonna
Display20x4.clear();

//visualizza il cursore sul display
//per verificare la posizione iniziale
Display20x4.cursor();

//attendi 2 secondi
delay(2000);

//disattivo il cursore
Display20x4.noCursor();

}

void loop()
{
//sposta il cursore alla prima riga e prima colonna
//questa operazione è necessaria se vogliamo
//scrivere il testo sempre nella stessa posizione
//omettendo questa istruzione il testo verrà scritto continuamente
//sul display andando a coprire tutte le righe
Display20x4.home();
//scrivi nella prima riga un testo
Display20x4.print("Logicaprogrammabile");

//ritardo
delay(500);
}

[/c]

La scrittura deve essere composta da una istruzione che gestisce la posizione del cursore e una successiva che effettua la scrittura del testo sul display.

Per scrivere su ogni riga dobbiamo quindi comporre le istruzioni in questo modo:

[c]
void loop()
{
//posiziono il cursore all’inizio della prima riga
Display20x4.setCursor(0,0);
//scrivi nella prima riga un testo
Display20x4.print("ABCDEFGHILMNOPQRSTUV");

Display20x4.setCursor(0,1);
//scrivi nella seconda riga un testo
Display20x4.print("ABCDEFGHILMNOPQRSTUV");

Display20x4.setCursor(0,2);
//scrivi nella terza riga un testo
Display20x4.print("ABCDEFGHILMNOPQRSTUV");

Display20x4.setCursor(0,3);
//scrivi nella quarta riga un testo
Display20x4.print("ABCDEFGHILMNOPQRSTUV");

//ritardo
delay(500);
}
[/c]

Se il testo che printiamo sul display supera i 20 caratteri avremmo una situazione di riscrittura del testo sulla stessa riga, in pratica se abbiamo un testo di 25 caratteri, verranno prima printati 20 caratteri e i rimanenti 5, saranno riscritti nella stessa riga occupando le prime 5 colonne,compromettendo il testo scritto precedentemente.

Se ad esempio scrivessi questo teso (25 caratteri)

ABCDEFGHILMNOPQRSTUV12345

otterrei sul display questa visualizzazione (20 caratteri)

12345FGHILMNOPQRSTUV

L’uso del display risulta quindi molto semplice, la libreria è composta da altri metodi che permettono di effettuare altre operazioni. Nel link seguente potete trovare ulteriori informazioni a riguardo.

Riferimento libreria LyquidCrystal su Arduino.cc

The post Arduino gestire display a matrice 20×4 appeared first on Esperimenti con logiche programmabili.

Mi piace realizzare progetti che impiegano dispositivi esistenti che, magari messi da parte per lungo tempo, si rivelano ottimi per costruire nuovi dispositivi.
La lampada led a batteria è un oggetto molto comune che si compra a basso costo nelle bancarelle delle fiere di elettronica. Date le sue dimensioni ridotte è possibile utilizzarla per illuminare tutte quelle piccole aree dove non abbiamo previsto una fonte di illuminazione fissa e dove non abbiamo la possibilità di portare dei cavi elettrici se non tramite opere murarie.

Non potendo tenere accesa la lampada per ore, causa scaricamento repentino della batteria, ho realizzato un piccolo circuito che tramite un sensore PIR e un relè permetta l’accensione della lampada solo al passaggio di una persona (o comunque qualsiasi cosa che si muove![tranne mosche e zanzare!]). Adoperando anche una fotoresistenza riesco a gestire l’accensione solo nelle ore notturne.
Tutto il sistemino è gestito da un parsimonioso ATtiny85.

Lo schema del circuito è il seguente:

Le batterie della lampada (che forniscono nel mio caso circa 7Vdc) hanno anche il compito di alimentare il circuito. Il regolatore di tensione 7805 stabilizza e fornisce alimentazione al circuito. L’ATtiny85 acquisisce il segnale analogico proveniente dalla fotoresistenza e il segnale digitale proveniente dal sensore PIR. Tramite il transistor comando un micro relè che cortocircuita l’interruttore meccanico posto sulla lampada, provocandone l’accensione.

Il codice che governa l’ATtiny85 è il seguente:

void setup()
{
  //uscita per comandare il rele
  pinMode(0, OUTPUT);
  //ingresso per sensore pir
  pinMode(4, INPUT);
}

void loop()
{
  //leggo il valore analogico proveniente dalla fotoresistenza
  int FotoR = analogRead(3);
  //leggo lo stato del segnale pir
  byte inp = digitalRead(4);

  //se il sensore pi rileva un movimento...
  if (inp == HIGH)
  {
    //controlla se la luce ambiente è insufficiente
    if (FotoR <= 150)
    {
      //attiva il relè pe accendere la lampada led
      digitalWrite(0, HIGH);
      //tieni la lampada accesa per 30 secondi
      Ritardo();
    }
  }
else
  //altrimenti tieni il relè disattivato
  digitalWrite(0, LOW);
}

void Ritardo()
{
  //ritardo di 30 secondi

  for(byte Ciclo = 0; Ciclo <= 30; Ciclo++)
  {
    delay(1000);
  }
}

Per programmare l’ATtiny85 potete usare un Arduino UNO come spiegato in questo tutorial. Per chi possiede un programmatore dedicato come quello descritto nel precedente articolo potete usare lo schema seguente per caricare lo sketch nel microcontrollore.

Attenzione il connettore da utilizzare dellUSBasp è il J5

La lampada del led è costata circa 15€ mentre per i componenti del circuito o speso circa 10-12€.

Per usare il circuito all’esterno consiglio di utilizzare un buon contenitore, per evitare che umidità o pioggia possano causare rotture o cortocircuiti.

The post Lampada di cortesia a batteria con ATtiny85 appeared first on Esperimenti con logiche programmabili.

Tra le applicazioni che trovo molto richieste è la scheda relè da gestire tramite smartphone. Utilizzando la libreria Webduino riusciamo a realizzare un dispositivo semplice e funzionale basato su pochi componenti quali Arduino Ethernet, dei classici relè, un router wifi (presente ormai nelle nostre abitazioni) e uno smartphone.

La figura seguente illustra il progetto di questo articolo:

Arduino Ethernet è collegato tramite cavo lan al router e permette di gestire i relè collegati ai pin digitali tramite una applicazione web basata sulla libreria Webduino. Tramite lo smarthphone o un pc collegato alla rete locale possiamo gestire i relè semplicemente usando un browser web.

Per la parte software ho deciso di usare la libreria webduino perché fornisce tutto il necessario per la gestione delle richieste http.

Lo schema elettrico del prototipo che ho realizzato è il seguente:

Il codice caricato sul dispositivo è disponibile nel seguente listato:

[c]

#include <Ethernet.h>
#include <SPI.h>
#include <WebServer.h> //libreria webduino

//variabili statiche per il mac address e lìip address
static byte mac_Add[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
//cambiare l’ip in funzione della propria rete
static byte ip_Add[] = {
192, 168, 0, 220 };
//creazione oggetto Webduino
WebServer webserver("", 80);

//Variabili booleane che memorizzano
//lo stato delle uscite collegate ai relè
boolean Rele1 = false;
boolean Rele2 = false;
boolean Rele3 = false;

//=============================================================================
//funzione pagina Start
void Start(WebServer &server, WebServer::ConnectionType type,
char *url_param, bool param_complete)
{
//restituisce al browser l’intestazione http 200 OK
server.httpSuccess();

//gestisco il tipo di richiesta HEAD
if (type != WebServer::HEAD)
{
String s = "";

if (param_complete == true)
{
s = url_param;

if ( s == "R1=ON")
{
Rele1 = true;
digitalWrite(2, HIGH);
}
else if ( s == "R1=OFF")
{
Rele1 = false;
digitalWrite(2, LOW);
}

if ( s == "R2=ON")
{
Rele2 = true;
digitalWrite(3, HIGH);
}
else if ( s == "R2=OFF")
{
Rele2 = false;
digitalWrite(3, LOW);
}

if ( s == "R3=ON")
{
Rele3 = true;
digitalWrite(4, HIGH);
}
else if ( s == "R3=OFF")
{
Rele3 = false;
digitalWrite(4, LOW);
}
}

//gestisco la pagina html in base allo stato delle uscite di Arduino
P(htmlHead) =
"<html>"
"<head>"
"<title>Arduino Scheda Rele</title>"
"</head>"
"<body>";

server.printP(htmlHead);

server.print("<table border=\"1\">");
server.print("<tr><td>Stato Rele</td><td>Comandi</td></tr>");

if(Rele1 == true)
server.print("<tr><td style=\"color: red;\">RELE 1 ON</td><td>");
else
server.print("<tr><td style=\"color: black;\">RELE 1 OFF</td><td>");

if(Rele1 == false)
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R1=ON’\">");
else
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R1=OFF’\">");

server.print("</td></tr>");

if(Rele2 == true)
server.print("<tr><td style=\"color: red;\">RELE 2 ON</td><td>");
else
server.print("<tr><td style=\"color: black;\">RELE 2 OFF</td><td>");

if(Rele2 == false)
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R2=ON’\">");
else
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R2=OFF’\">");

server.print("</td></tr>");

if(Rele3 == true)
server.print("<tr><td style=\"color: red;\">RELE 3 ON</td><td>");
else
server.print("<tr><td style=\"color: black;\">RELE 3 OFF</td><td>");

if(Rele3 == false)
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R3=ON’\">");
else
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R3=OFF’\">");

server.print("</td></tr>");

server.print("</table></body></html>");

}
}
//=============================================================================

void setup()
{
//inizializzo l’ethernet shield con il mac e il address
Ethernet.begin(mac_Add, ip_Add);

//definisci l’azione di default che verrà eseguita quando l’utente
//naviga nella root del sito
webserver.setDefaultCommand(&Start);
webserver.addCommand("index.htm", &Start);

//avvia il web server
webserver.begin();

delay(100);

//definisci i pin 2 3 4 in uscita
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);

//inizializza i le uscite
digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, LOW);

}

void loop()
{
//elabora costantemente tutte le richieste provenienti dal browser
webserver.processConnection();
}

[/c]

Nonostante le numerose righe di codice potete capirne il funzionamento semplicemente leggendo i commenti che lo accompagnano.
L’interfaccia web per gestire i relè è la seguente:

Cliccando il bottone con la label “clicca qui” si ottiene una commutazione dello stato dei pin di uscita di Arduino e l’aggiornamento della label Stato Rele.

Anche in questo caso con poco si ottengono dispositivi interessanti e utili.

The post Scheda relè remota con Arduino e Webduino appeared first on Esperimenti con logiche programmabili.

Una caratteristica che reputo molto interessante è la possibilità di espandere Arduino tramite l’uso di shield. La maggior parte di queste schede aggiuntive sono però progettate per compiere una funzione specifica, non programmabile.
Esistono alcuni metodi che permettono di comunicare con altri dispositivi utilizzando come canale di trasmissione dati i protocolli seriali (I2C, SPI o RS232). Questo rende possibile demandare ad una scheda slave funzioni di elaborazione gravose, che non vogliamo far eseguire alla scheda master. Ho realizzato questo piccolo tutorial usando il bus I2C per creare uno scambio dati tra un Arduino ed un chip ATmega328 standalone.

Il bus I2C, basandosi su due fili, non permette la comunicazione contemporanea tra Master e Slave. Lo scambio dati deve essere gestito dal Master tramite gli indirizzi (univoci) degli slave. Il flusso può essere sintetizzato in questo modo

1. Il Master invia sul bus un bit di start
2. Il Master invia sul bus l’indirizzo dello slave con cui vuole comunicare
3. Il Master decide se scrivere o leggere dal dispositivo
4. Lo Slave legge o scrive in base alla richiesta del Master

La libreria Wire dispone di tutte le funzioni necessarie alla realizzazione Master-Slave tra due schede Arduino. Lo schema del circuito che ho realizzato è visibile nella figura seguente.

Come detto precedentemente lo schema si basa su Arduino Uno impiegato come Master e con un ATmega328 impiegato come slave.

Il codice permette di inviare un dato numerico allo slave, che provvederà ad incrementarlo per poi rispedirlo al Master.

[c]
//MASTER
#include <Wire.h>

byte x = 0;
byte num = 0;

void setup()
{
//inizializzo la libreria Wire come Master
Wire.begin();

//init seiale
Serial.begin(9600);
//avviso che il programma è avviato
Serial.println("START");

}

void loop()
{
//invio sul bus I2C un byte al device
//che ha come indirizzo il valore 0x04
//start trasmissione
Wire.beginTransmission(0x04);
//invio un byte
Wire.write(x);
//fine trasmissione
Wire.endTransmission();

delayMicroseconds(500);

//richiedo un byte allo slave che ha indirizzo 0x04
Wire.requestFrom(0x04, 1);

//attendo la disponibilità di dati sul bus i2c
while(Wire.available())
{
//quando è presente un dato avvia
//la lettura
num = Wire.read();
}

//incrementa il valore del byte
x++;

//verifico che il byte letto dallo slave sia stato
//incrementato
if(num != x)
Serial.println("ERRORE");

delay(5);

}

[/c]

Il codice seguente è relativo allo Slave

[c]
//SLAVE
#include <Wire.h>

byte x = 0;

void setup()
{
//inizializzo la libreria
//imposto l’indirizzo dello slave
Wire.begin(0x04);

//eventi per la ricezione del dato
//e per la richiesta del dato
Wire.onReceive(receiveEvent);
Wire.onRequest(requestEvent);
}

void loop()
{
//esegui qualcosa
delay(1000);
}

void receiveEvent(int data)
{
//questo evento viene generato quando sul bus
//è presente un dato da leggere

//eseguo la lettura
x = Wire.read();

//elaboro il dato letto
x++;
}

void requestEvent()
{
//questo evento viene generato quando il master
//richiede ad uno specifico slave
//una richiesta di dati

//spedisco il dato al Master
Wire.write(x);

}

[/c]

I commenti presenti nel codice permettono di capire ciò che avviene tra i due dispositivi.

Di seguito uno screenshot dei dati scambiati sul bus

Di seguito invece la trasmissione del Master

The post Comunicazione tra Arduino tramite I2C appeared first on Esperimenti con logiche programmabili.

Ho acquistato un semplice programmatore AVR dal costo molto contenuto per poter programmare gli ATMega328 senza passare per una scheda Arduino. Questo metodo risulta interessante quando si creano dei propri dispositivi stand alone senza perdere la semplicità di programmazione tipica dei dispositivi Arduino.
Il modello in questione è l’AVR Programmer prodotto da JYE Tech (http://www.jyetech.com) che ho comprato da Cooking Hacks (http://www.cooking-hacks.com/index.php/avr-usb-programmer.html) per poco più di 10€.

Il programmatore è basato sul chip Atmega48 ed è programmato per essere compatibile con l’USBasp.

La prima operazione è installare i driver del programmatore. Scaricate l’ultima versione dei driver dal sito fischl.de (attualmente usbasp.2011-05-28.tar.gz) e scompatateli in una cartella sul vostro pc. Ora collegate il programmatore tramite cavo mini usb e annullate la ricerca automatica dei driver. Da gestione dispositivi selezionate la voce USBasp e avviate la procedura per aggiornare i driver selezionando la ricerca automatica e specificando come percorso la cartella che avete scompatato precedentemente. Attendete la fine della procedura che porterà all’installazione del programmatore sul vostro computer.

Passiamo ai collegamenti seguendo lo schema elettrico seguente:

la tabella riepiloga i collegamenti da effettuare:

(Ricordiamoci anche di collegare il quarzo da 16MHz ed i due condensatori ceramici da 18pF ai pin 9 e pin 10 come da schema).

Ora tutto è pronto per provare a caricare il nostro sketch tramite il programmatore utilizzando semplicemente il classico Arduino IDE. Una volta aperto l’IDE (nel mio caso versione  1.0.1) andiamo a settare il tipo di programmatore da utilizzare per il deployment. Clicchiamo sul seguente percorso Strumenti->Programmatore e  selezioniamo la voce USBasp.

Carichiamo il classico sketch di esempio Blink (File->Esempi->01.Basics->Blink) avviamo la programmazione tramite il menu File->Carica con un programmatore

Penso che i vantaggi di questo metodo siano notevoli perché oltre alla possibilità di creare sistemi stand alone con un costo contenuto abbiamo anche il vantaggio di non dover caricare il bootloader e quindi avere un po più di spazio per i nostri programmi.

The post Caricare sketch su AtMega328 tramite programmatore esterno appeared first on Esperimenti con logiche programmabili.