Processing - Presentazione

Internet è un calderone di conoscenza all'interno del quale si può trovare qualsiasi cosa; fonte di conoscenza dalla quale ci si può informare e imparare una miriade di cose. Navigando su internet tra siti e video su YouTube sono venuto a conoscenza di metodi per l'interfaccia tra Arduino e il PC. Il primo metodo che ho trovato è stato quello di utilizzare LabWiew, programma di National Intruments, l'ho trovato molto interessante guardando video di progetti e tutorial. C'è solamente un unico inconveniente, il programma è a pagamento, per questo ho continuato la ricerca di un'altra possibilità.Continuando la ricerca ho trovato PROCESSING (sito http://processing.org). Mi ha subito intrigato la possibilità di creare interfacce grafiche e animazioni senza avere una conoscenza approfondita nel codice, cosa che richiedono altri linguaggi di programmazione ( es. C, C++, Java); altro aspetto che mi ha colpito e che cercavo è la possibilità di creare programmi che permetto di interfacciarsi, dal nostro PC, con Arduino. Insomma, quello che cercavo! Tutto ciò mi ha spinto ad informarmi sempre di più su forum, siti dedicati a progetti e video tutorial fino ad arrivare al punto di scaricare l'ambiente di programmazione e iniziare a lavorarci un po’.



Ma prima un pochino di storia...Processing è stato creato da Casey Reas e Ben Fry, sviluppato con il precisoscopo di rendere molto semplice l'interazione con elementi grafici (realizzazioni diimmagini, animazioni ed interazioni) che con altri linguaggi di programmazione, come C++ e Java, diventa tutto molto complesso richiedendo al programmatore un alto livello di conoscenza dell'ambiente di sviluppo. Altro obbiettivo che Casey e Ben si erano prefissati era quello di creare un linguaggio per insegnare agli studenti di arte e di design come programmare e fornire agli studenti di scuole tecniche un modo semplice per lavorare con la grafica.Il software in fase alpha è stato rilasciato nell'agosto del 2002 fino all'aprile del 2005, e poi in beta pubblico fino al novembre del 2008. Durante questo lasso di tempo Prosessing è stato utilizzato in classi di studenti e da migliaia di persone nel mondo. I due creatori hanno sviluppato anche un sistema di estensione del software chiamato LIBRERIE (proprio come per Arduino) permettendo così alle persone di espandere questo novo linguaggio di programmazione. Il 29 novembre 2008 uscì la versione 1.0 del software.

Se conoscete già Arduino e come si programma troverete molte famigliarità tra l'ambiente di programmazione di Processing e di quello della più famosa scheda di prototipazione rapida. Per chi invece non avesse dimestichezza o non sapesse neanche cosa sia Arduino, non vi preoccupate, il linguaggio di programmazione di Processing è molto semplice ed intuitivo.

Pagina successiva>>

Nuovo progetto - Autovelox

E' da un po di tempo che nella mia testa si aggira l'idea di un nuovo progetto da realizzare con Arduino, la scheda elettronica open surce più famosa al mondo. L'idea mi è venuta per puro caso proprio quando la mia mente vagava, avevo la mente tra le nuvole in quel preciso momento quando è arrivata il flash per il mio futuro progetto, mi era venuto in mente l'idea di un "autovelox" o per lo meno un misuratore di velocità.

Tempo addietro mi ero informato su come funzionassero gli autovelox e avevo imparato non erano nient'altro che due raggi ad infrarossi posti ad una determinata distanza tra loro, non appena l'oggetto intercettava il primo raggio il sistema faceva partire un contatore che lo fermava non appena lo stesso oggetto avesse intercettato il secondo raggio ad infrarossi, per definire la velocità dell'oggetto al sistema bastava fare il rapporto tra la distanza fissa tra i due raggi e il tempo impiegato dall'oggetto ad attraversarli. Assieme alla comprensione del funzionamento degli autovelox, avevo visto un video su youtube nella quale un ragazzo spiegava come funzionasse un circuito utilizzando un led ad infrarossi e un fototransistor; non appena si interrompeva il flusso di raggi ad infrarossi tra il led e il fototransistor il circuito azionava un led per segnalarlo (ecco QUI il video in questione). la mia mente è riuscita ad unire queste due cose e così mi è venuta l'idea di costruire un "autovelox". Oltre a questo si è aggiunta un'altra cosa, un'altra idea, la possibilità di variare la posizione fissa tra i due sensori ad infrarossi posizionandoli su una morsa. Tenendo fisso uno dei due l'altro avrà la possibilità di muoversi, avvicinandosi o allontanandosi. Magari aggiungeremo anche un tastierino con la possibilità di immettere la nuova distanza tra i due raggi ad infrarossi in modo da non cambiare tutto il programma caricato su Arduino ma solamente una variabile. Assieme a tutto questo sarà presente anche un dislay che permetterà la visione della velocità rilevata.      

Domotica - Sistema anti intrusione

La casa è protetta da un antifurto perimetrale composto da reed (contatti magnetici) applicati a ogni

finestra. I contatti magnetici sono particolari interruttori che permettono il passaggio della corrente

a seconda che un magnete sia allontanato o avvicinato al dispositivo, in questo caso esso è posto su un oggetto mobile (porta o finestra). Mentre il sistema è abilitato, non appena una finestra o

porta viene aperta, l’allarme si attiva con una segnalazione acustica, ottenuta tramite un campanello, e da una segnalazione visiva data da una luce lampeggiante. Il sistema anti intrusione è attivabile e disattivabile tramite tastierino numerico, digitando una password. Il programma visualizza lo stato dell’allarme sul display della centralina.

Programma Arduino

#include <Keypad.h>

#define sirena 24

#define LEDA 17

#define mg1 4

#define mg2 3

#define mg3 2

#define mg4 44

#define mg5 45

#define mg6 14

#define mg7 15

#define mg8 16

int x = 0;

int y = 0;

int m = 0;

const byte ROWS = 4;

const byte COLS = 3;

char keys[ROWS][COLS] = {

  {'1','2','3'},

  {'4','5','6'},

  {'7','8','9'},

  {'*','0','#'}

};

byte rowPins[ROWS] = {34, 35, 36, 37};

byte colPins[COLS] = {38, 39, 40};

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup() {

pinMode(LEDA, OUTPUT);

pinMode (sirena, OUTPUT);

pinMode (mg1, INPUT);

pinMode (mg2, INPUT);

pinMode (mg3, INPUT);

pinMode (mg4, INPUT);

pinMode (mg5, INPUT);

pinMode (mg6, INPUT);

pinMode (mg7, INPUT);

pinMode (mg8, INPUT);

keypad.addEventListener(keypadEvent);

}

void loop() {

char key = keypad.getKey();

  pinMode ( x == 0) {

    lcd.setCursor(0, 0);

    lcd.print("CASA DOMOTICA   ");

    lcd.setCursor(0, 1);

    lcd.print("allarme off     ");

  }

  else {

    lcd.setCursor(0, 0);

    lcd.print("CASA DOMOTICA   ");

    lcd.setCursor(0, 1);

    lcd.print("allarme on      ");

  }

  if ( (digitalRead(mg1) == LOW) || (digitalRead (mg2) == LOW) || (digitalRead (mg3) == LOW) || (digitalRead (mg4) == LOW) || (digitalRead (mg5) == LOW) || (digitalRead (mg6) == LOW) || (digitalRead (mg7) == LOW) || (digitalRead (mg8) == LOW)) {

    y = 1;

  }

  else {

    y = 0;

  }

  if (( y == 1) && ( x == 1)) {

    do {

      digitalWrite(sirena, HIGH);

      do {

        digitalWrite(LEDA, HIGH);

        delay(100);

        digitalWrite(LEDA, LOW);

        delay(100);

        m = m + 1;

      }

      while (m < 1);

      m = 0;

      char key = keypad.getKey();

    }

    while (x == 1);

    digitalWrite(sirena, LOW);

    digitalWrite(LEDA, LOW);

  }

}

void keypadEvent(KeypadEvent key) {

  switch (keypad.getState()) {

    case PRESSED:

      if (key == '#') {

        x = !x;

      }

      break;

  }

}

Domotica - Applicazioni reali

Abbiamo pensato (e realizzato) il nostro progetto in modo tale che sia facilmente applicabile in una situazione reale. Tutti gli INPUT e OUTPUT della scheda Arduino possono essere dati da relè posti in un quadro centrale. Tutti i pulsanti dislocati all'interno dell'abitazione, quando premuti, danno una tensione necessaria ai relè per commutare, i quali daranno in ingresso alla scheda i necessari 5 V in corrente continua. Per quanto riguarda le uscite la scheda relè compatibile con Arduino può essere utilizzata per pilotare altri relè che lavorano alla tensione di rete di 230 V in corrente alternata. L'idea è di utilizzare relè a 12 Vca oppure 24 Vca, una tensione molto più bassa di quella di rete ottenendo così una maggior sicurezza dell'impianto e ottenendo anche un isolamento per quanto riguarda i vari comandi digitali da quelli di potenza a 230 V.
Sotto potete trovare un semplice schema che rappresenta l'idea descritta sopra

Per quanto riguarda i segnali di tipo analogici, come il sensore di temperatura, la fotoresistenza del vialetto ed altri sensori aggiuntivi, per evitare interferenze o perdita di segnale dovute a grandi distanze è preferibile utilizzare più schede Arduino collocate in prossimità di questi, così che il segnale arrivi al suo controllore, venga letto e che il programma esegua le relative istruzioni in base ai valori elaborati.

Fotoresistenza

La fotoresistenza è un componente elettrico la cui resistenza è inversamente proporzionale alla quantità di luce che la colpisce. Si comporta come una tradizionale resistenza, ma il suo valore diminuisce man mano che aumenta l'intensità luminosa. Questo funzionamento fa della fotoresistenza una vera e propria resistenza variabile, il cui valore non dipende dal nostro intervento (come per un potenziometro), ma a causa della luce. Qui a sinistra possiamo vedere l'immagine di un resistore dipendente dalla luce (fotoresistenza).
Ma come facciamo a trovare il valore del resistore e quindi l'illuminazione a cui è sottoposta?
Prima di tutto consideriamo il grafico del trasduttore con la resistenza in funzione dell'illuminazione, il grafico è riportato qui sotto.

Bene, adesso possiamo trovare la luminosità in base alla resistenza che assume il trasduttore. Ma c'è un altro problema. Come facciamo a determinare la resistenza del sensore se Arduino in ingresso analogico legge solo la tensione? Semplice, creiamo un partitore di tensione in modo tale da ricavare il valore della resistenza che ci interessa, che in questo caso riguarda quello della fotoresistenza.

La regola del partitore di tensione dice che la tensione su un qualsiasi resistore di una serie di resistori è pari alla tensione totale moltiplicata per il rapporto tra la resistenza considerata e quella equivalente.

Vediamo il collegamento del partitore.

  

R1 : fotoresistenza

R2 : resistenza nota (10 kohm)

Vcc : tensione di alimentazione

V : c.d.t. sulla fotoresistenza, da collegare in ingresso ad un pin analogico

Adesso, invece, vediamo come ricavare la resistenza del sensore dalla formula del partitore di tensione:

R2 è nota perchè è un valore scelto da noi, Vcc vale 5V mentre V la misurerà Arduino. Inserendo questa equazione nel nostro programma potremmo determinare il valore della nostra fotoresistenza. In base ai valori calcolati durante l'esecuzione delle istruzioni e in base ai valori scelti, corrispondenti alla luminosità (ricavati dal grafico sopra riportato), potremmo, ad esempio, se rilevato buio o una determinata luminosità, far accendere un LED oppure accendere una lampadina tramite relè comandato da Arduino, a voi la scelta.

Domotica - Modellino Casa

Per illustrare il nostro progetto, la realizzazione di un impianto domotico con Arduino, alla commissione d'esame abbiamo deciso di realizzare il modellino di una casa. Con questo modello illustreremo l'accensione delle luci di ogni singola stanza e del vialetto tramite la fotoresistenza, il sistema anti intrusione, il controllo di una tenda su porta finestra e faremo vedere anche il relativo controllo remoto.

Tutto ebbe inizio con la decisione delle varie grandezze del modellino, tutte scritte sul pianale in legno su cui erge la nostra "casa"

Misure cucina

Dimensioni camera e corridoio

Posizione della porta d'ingresso (destra) e della porta finestra della cucina (in basso) 

Posizione delle finestre del salotto

Dimensioni bagno e corridoio

Dopo aver deciso tutte le varie misure ci siamo procurati il compensato, disegnato su di esso le varie pareti con porte e finestre, lo abbiamo fatto tagliare e questo è il risultato

Modellino con pareti montate

Procurati anche i contatti magnetici ad incasso c'è venuta la bella idea di "incassarli" nelle pareti del modellino, e così abbiamo fatto. L'alloggiamento dei contatti lo abbiamo fatto grazie ad una piccola fresa per modellismo, il risultato ottenuto non è niente male 

Prove per l'incasso dei contatti

Contatto magnetico inserito nel suo alloggiamento

Contatti inseriti sia sulla finestra che sotto

Contatti stuccati al legno

Risultato ottenuto una volta asciugato lo stucco

Vista vialetto e contatti magnetici inseriti nel pavimento

Vista interna della cucina

Vista del resto delle stanze

Cassone aperto

Abbiamo voluto dare un tocco di classe al modellino, perchè non farlo mettendo un bel parquet in mogano?

Pavimento e LED

Preparazione del fondo per l'erba 

Pulsanti e tastierino numerico posizionati

Posizionamento delle canaline che andranno a contenere i vari cavi di collegamento

Anemometro, pluviostato e foto resistenza

Prova dei LED del vialetto

Sensore di temperatura e ventola per la simulazione del condizionamento

Tenda della cucina come dovrebbe apparire totalmente abbassata

Tenda della cucina come dovrebbe apparire totalmente alzata

Il modellino terminato

Schema di collegamento degli ingressi

Ecco riportato lo schema di collegamento dei pulsanti con la scheda Arduino.

(schema realizzato in CAD)

(schema realizzato con Fritzing, la scelta dei pin è solamente a puro scopo illustrativo)

P1, P2, P3, P4, P5: pulsanti 

1, 2, 3, 4, 5: questi andranno poi collegati  alla scheda Arduino ai relativi pin scelti

R: resistenza dal valore di 10 kohm da 1/4 W; queste resistenze sono necessarie per creare un partitore di tensione che permette di rilevare lo stato dei pulsanti, se premuto ai pin relativi si realizza una differenza di potenziale di 5 volts (stato alto, HIGH). La resistenza da 10 kohm presenta i colori (da sinistra a destra) marrone, nero, arancio e oro, quest'ultimo indica la tolleranza della resistenza. 

(resistenze da 10 kohm da 1/4W)

Utilizzo di pulsanti come interruttori (Autoritenuta)

Può capitare che per dare in entrata un ingresso digitale e andare così a comandare una uscita del nostro Arduino, potremmo avere sotto mano solamente pulsanti.  Come facciamo, dando in ingresso un impulso di valore alto (HIGH), a mantenere un valore costante in uscita? In questo post capirete come farlo, andremo a creare un programma che soddisfi le nostre esigenze. Vediamo come fare.

Iniziamo con le dichiarazioni delle variabili:

const int btPin = __; (numero pin non specificato) 

pin dedicato all'input del pulsante

const int Pin = __; (numero pin non specificato)

pin dedicato all'output che andrà a comandare il relè per accendere/spegnere il punto luce

int btSt = 0;

variabile che corrisponde allo stato in tempo reale del pulsante, le attribuisco valore zero

int lastBtnSt = LOW;

variabile che corrisponde all'ultimo valore dello stato del pulsante, lo pongo a valore basso (low)

int State = LOW;

variabile che corrisponde al valore dello stato dell'uscita, la pongo a valore basso (low)

Dichiarazione di programma che gira solamente una volta, qui si definiscono i vari ingressi e uscite:

void setup() {

pinMode(Pin, OUTPUT); dichiaro la variabile come segnale di comando (output)

pinMode(btPin, INPUT); dichiaro la variabile come segnale d'ingresso (input)

}

Programma che verrà ripetuto in continuazione dopo aver eseguito la parte di setup:

 btSt = digitalRead(btPin); 

  if (btSt != lastBtnSt && btSt == HIGH){

   State = !State;

  if (State == HIGH){

  digitalWrite(Pin, HIGH);

 }

else{ 

digitalWrite(Pin, LOW);

}

}

lastBtnSt = btSt;

delay(50);

quando vado a premere il pulsante la scheda Arduino rileva il valore in ingresso, che al momento della pressione è HIGH, ed attribuisce tale valore alla variabile corrispondente allo stato del pulsante (btSt varrà così HIGH) a questo punto il programma arriva al primo "if"; se lo stato del pulsante è diverso dall'ultimo stato (LOW, definito nella dichiarazione delle variabili) e se tale valore (btSt) è alto (HIGH) fai cambiare il valore dello stato dell'uscita nel suo opposto (se LOW cambialo in HIGH, se HIGH cambia in LOW). La prima istruzione del primo "if" è terminata il programma passerà quindi al secondo "if". Se lo stato dell'uscita è HIGH  (cosa che sarà perchè nella dichiarazione delle variabili lo abbiamo posto a LOW valore cambiato nel suo opposto dovuto all'istruzione dopo il primo "if") dai in uscita un valore alto. Il programma termina ponendo il valore dell'ultimo stato del pulsante uguale all'attuale stato, cioè LOW (stato dopo la sua premuta). Così abbiamo visto come il programma da in uscita un valore HIGH costante anche se il pulsante non è più premuto (dovuto al fatto che lo stato del pulsante è uguale al suo ultimo stato, LOW, quindi la condizione del primo "if" non è rispettata e il programma non continuerà). Per ritornare a dare in uscita un valore basso (LOW) il programma vede che le condizioni del primo blocco sono rispettate e passa all'istruzione seguente. Dato che abbiamo in uscita un valore alto lo stato dell'uscita passa da HIGH, valore attribuito alla variabile in seguito alla prima pressione, ad uno stato basso. Si arriva alla seconda condizione ("if"). La seconda condizione non sarà rispettata (State = LOW) quindi il programma andrà ad eseguire le istruzioni alternative (istruzioni comprese nell'"else"), dando così in uscita un stato basso in modo costante. Il programma attribuisce alla variabile dell'ultimo stato del pulsante (LastBtnSt) il valore attuale del pulsante, il programma è pronto ad essere ripetuto.

Il ritardo della ripetizione del programma è inserito per evitare l'effetto bounce (rimbalzo).

Schemi di collegamento - Domotica

Ecco i link riguardanti i vari schemi di collegamento del progetto Domotica.

Collegamento display LCD 16X2

Collegamento dei pulsanti con la scheda Arduino

Schema di collegamento schermo LCD 16X2

Vediamo come collegare lo schermo LCD 16X2 (2 righe e 16 colonne) che ci permetterà di visualizzare valori o messaggi in base alle nostre esigenze e necessità. Andremo ad utilizzare la versione 4 bit, la stessa modalità utilizzata per i programmi d'esempio di Arduino, ciò comporta l'utilizzo di 6 pin digitali sulla nostra scheda. Nella tabella allegata trovate le funzioni di ogni pin dello schermo LCD (la piedinatura di questi display è per la maggior parte comune, nel caso non lo fosse controllate il retro del vostro LCD per vedere se i pin corrispondono alla tabella sotto riportata oppure ricercate i datasheet relativi al vostro display)

Ecco lo schema di collegamento:

Qui sono riportati i pin del display LCD (sinistra) e quelli della scheda Arduino (destra):

pin 1 - GND

pin 2 - alimentazione (Vcc)

pin 3 - pin centrale del  potenziometro (100 kohm), serve per la regolazione della luminosità del display, se              questo è retroilluminato

pin 4 - piedino 12 (digitale)

pin 5 - GND

pin 6 - piedino 11 (digitale)

pin 11 - piedino 5 (digitale)

pin 12 - piedino 4 (digitale)

pin 13 - piedino 3 (digitale)

pin 14 - piedino 2 (digitale)

pin 15 - alimentazione (Vcc) tramite una resistenza dal valore di 220 ohm, serve per alimentare il led della                  retroilluminazione

pin 16 - GND

Domotica - Materiale Utilizzato

In questa pagina elencheremo il materiale utilizzato per la realizzazione del progetto di un impianto domotico con la scheda elettronica Arduino. Sono stati utilizzati:

- Scheda Arduino Mega 2560 (utilizzata come centralina di comando)

-Scheda Ethernet Shield (per il controllo remoto della casa)

-Schede  8 relè e 2 relè compatibili con Arduino (controllo di luci interne e esterne ed il controllo della tenda)

-Modulo con foto resistenza (per l'accensione delle luci del vialetto in base all'intensità luminosa)

-Modulo con sensore di temperatura 18B20 (per la lettura della temperatura all'interno dell'edificio)

-Contatti magnetici (per l'impianto anti intrusione) 

-Tastierino numerico (per l'attivazione e disattivazione dell'allarme)

-Schermo LCD 16X2 (per la visione dello stato allarme, della temperatura e varie ed eventuali)

-Pulsanti

-Ventola per PC (simulazione impianto di condizionamento)

-n°20 LED bianchi

-Pluviostato compatibile con Arduino

-Anemometro

Ritorna alla pagina relativa al progetto