casa - Massari Electronics

  • MassaBus Application Example

     VERSIONE: 1.0 | SISTEMA OPERATIVO: WINDOWS (32/64bit) 2000, XP, Vista e 7 | RILASCIO: OPEN SOURCE

     

    I DISPOSITIVI MASSABUS SONO ORA IN VENDITA COMPLETI E AGGIORNATI QUI!

    Il software MassaBus Controller da solo non è in grado di controllare le funzioni affidate al sistema domotico MassaBus, per questo motivo esso dispone di una modalità automatica che permette ad un software esterno di controllare le varie unità del bus domotico attraverso un porta TCP/IP. Tale software può essere adattato al massimo per soddisfare le esigenze dell’utente finale. In questa parte si analizza un software di esempio per comprendere alcuni aspetti della domotica: il monitoraggio e la mutazione immediata delle funzioni.


    Il software di esempio progettato si occupa di visualizzare a video la temperatura di due sensori di temperatura (schede Temperature sensor) presenti nel bus e monitorare l’attivazione di un sensore di movimento piroelettrico PIR attraverso l’ingresso 1 di una scheda Multi I/O Device. Quando il sensore PIR rivelerà un movimento il software a seconda della modalità impostata via software può intraprendere due azioni: accendere una luce o attivare un allarme. Queste due funzioni vengono svolte in maniera immediata e senza alcuna modifica alla circuiteria del sistema, rappresentando quindi la praticità di utilizzo di un sistema domotico.

    La circuitazione di esempio utilizzata con il software di controllo e il sistema MassaBus è visibile in figura sotto, dove è anche possibile vedere un esempio di assegnazione degli indirizzi delle schede nel bus. 

     

    In tale circuito si nota la presenza di un campanello di allarme, di una luce e del sensore PIR per il rilevamento dei movimenti. Il campanello richiede una tensione di 12Vac, mentre la luce a led viene alimentata con 16Vdc eppure non vie è alcun problema di pilotaggio essendo il relè considerabile come un normale deviatore meccanico. Il sensore PIR invece provvede a fornire al primo ingresso una tensione di 16Vdc (che è supportabile dalla scheda nonostante l’ingresso sia progettato per una tensione di 12V) che si occupa di attivare il fotoaccoppiatore di ingresso e il led di segnalazione.

    Questa applicazione ovviamente ha una dubbia utilità, permette però di capire come un sistema domotico possa “interagire” con l’ambiente circostante. Ad esempio se nel computer master viene installato un cellulare GSM con opportuno software di controllo comunicante via TCP/IP con il software MassaBus Controller, sarà possibile controllare a distanza l’ambiente in cui il sistema MassaBus è installato. Tutto questo tramite normali SMS o chiamate dati.

    Il circuito descritto montato fisicamente è visibile in figura sotto dove si possono notare in centro la campana di allarme, il sensore PIR e introno le schede MassaBus utilizzate. 

    ALTRE IMMAGINI

    Sono disponibili i sorgenti per Visual Basic .NET (gratuito) o Visual Studio 2010 e l'eseguibile compilato per avviare direttamente l'applicazione.

    DOWNLOAD FILE SORGENTI

    DOWNLOAD ESEGUIBILE

  • MassaBUS incontra Arduino

     

    I DISPOSITIVI MASSABUS SONO ORA IN VENDITA COMPLETI E AGGIORNATI QUI!

    Molte persone oggi conoscono Arduino, una piattaforma di sviluppo che in pochi anni è diventato un vero e proprio ecosistema composto da schede, librerie e moduli aggiuntivi detti "shields". I vantaggi dell'utilizzo di arduino sono derivanti da tanti fattori, primo fra tutti il fatto che sia compeltamente open source. Un altro vantaggio non indifferente è la possibilità di disporre di un microcontrollore programmabile al volo direttamente tramite usb attraverso un IDE di sviluppo multipiattaforma.

    Non è quindi un mistero la volontà di far incontrare il sistema per domotica MassaBUS con Arduino. Partiamo da un presupposto, la caratteristica principale di MassaBUS è di essere un sistema flessibile: le schede sono dei semplici servi di un cervello centrale che può mutare indipendemente dalla struttura del sistema. Il cervello centrale fino ad ora (come mostrato nei miei articoli su MassaBUS) era un PC avente in esecuzione un programma di gestione. Per quelli a cui piace modificare ed evolvere i progetti di continuo il PC è un ottima soluzione in quanto unisce praticità e velocità di cambiamento (basta aggiornare il software), però spesso questa soluzione è esagerata per la maggior parte degli utilizzi dove magari si vuole aggiornare l'impianto di tanto in tanto (o anche mai!!). In questo caso Arduino può sostituire efficacemente il PC centrale, meantenedo la praticità di riprogrammazione con il vantaggio di rappresentare una soluzione meno onerosa garantendo bassisimi consumi senza utilizzare sistemi embedded avanzati.

    Le schede del sistema MassaBUS si vanno quindi a collegare tramite bus RS485 a un nodo centrale costituito da una scheda Arduino avente in esecuzione il programma di gestione del sistema (con incluse eventuali shield ethernet o wifi...).

    In questa pagina vi mostrero le funzioni necessarie per implementare in Arduino il protocollo MassaBUS, un programma di esempio e uno schema per realizzare la shield RS485 necessaria per interfacciare Arduino UNO (o Leonardo, PRO) con il bus RS485 utilizzato da MassaBUS. Puoi acquistare la scheda già montata e collaudata per Arduino direttamente qui.

    INTERFACCIA ARDUINO RS485

    Per utilizzare il bus RS485 con Arduino è necessario disporre di una shield di interfaccia RS485. Qui ne vedremo un tipo realizzato appositamente per utilizzare tutte le caratteristiche del MassaBUS. Infatti la scheda oltre ad avere i componenti indispensabili all'uso dell'RS485 dispone anche delle funzioni di terminazione linea e polarizzazione linea attivabili tramite dip-switch. Inoltre dispone di un led per segnalare la trasmissione di un pacchetto (o altre funzioni a piacimento) ed infine un pulsante che può essere utilizzato ad esempio per prove, ripristini o altre funzioni.

    Ecco lo schema elettrico dell'interfaccia:

    Come visibile nello schema sopra il componente principale della shield è l'integrato MAX485 che si occupa di trasformare il bus RS485 in segnali 0-5V adatti per l'utilizzo con microcontrollore a 5V come quello della scheda Arduino UNO. L'integrato utilizza il pin RX e TX dell'UART di Arduino nonchè un pin di output (2) che controlla l'abilitazione della trasmissione nel bus (essendo half-duplex). L'abilitazione della ricezione (cioè i dati sul bus vengono portati nel pin RX di Arduino) può essere eseguita con 2 modalità selezionabili tramite ponticello TX ECHO: la prima prevede l'attivazione della ricezione solo quando la trasmissione è disattivata, mentre la seconda mantiene la ricezione sempre attiva pertanto sul pin RX di arduino avremo anche l'ECO del pin TX. La modalità per l'uso con MassaBUS è quella in cui la ricezione è disattivata durante la trasmissione.

    Le uscite del BUS RS485 sono collegate ad un dip switch che tramite il selettore 1 permette di attivare la terminazione della linea (solo se la scheda è all'inizio o alla fine del bus) e tramite il selettore 2 e 3 permette l'attivazione della polarizzazione della linea (attivazione di entrambi necessaria in una sola scheda del BUS).

    In seguito possiamo trovare delle piccole aggiunte che fanno da contorno alla scheda: un led al pin 3 di Arduino e un pulsante al pin 5 di Arduino. Il led può essere utile per indicare la trasmissione di un pacchetto, mentre il pulsante (attivo con ingresso alto su Arduino) può essere utile per ripristinare in particolari condizioni i valori di default del sistema (ipotizzando l'uso della ethernet shield insieme a questa shield, esattamente come avviene nei dispositivi di rete). La resistenza da 470 all'ingresso di Arduino dove è collegato il pulsante serve come protezione per Arduino in caso che tale pin di ingresso venga erroneamente impostato come uscita. Ovviamente sia il led che il pulsante sono utilizzabili a vostra discrezione!

    Puoi acquistare la scheda già montata e collaudata per Arduino direttamente qui.

    IL CODICE PER ARDUINO

    Essendo Arduino il nodo centrale, esso si occupa anche di far partire la comunicazione e una volta fatto si aspetta una risposta. Ecco quindi che il codice per arduino si divide in due parti: una si occupa della trasmissione del pacchetto (tramite una funzione chiamata "code_data_to_send") e di una funzione di ricezione chiamata dalla funzione di decodifica ("decode_ric_data") che a sua volta è chiamata da una routine di cattura dei dati seriali ("serialEvent") che si verifica ogni volta che il primo byte del pacchetto arriva nella seriale di Arduino. Di seguito trovate tutte le funzioni con le rispettive chiamate.

    Le funzioni sono state inserite in un programma di esempio che si occupa di scrivere ogni 5 secondi due valori alternati in output. Per provare subito il programma ed effettuare i primi esperimenti di utilizzo è necessario collegare ad Arduino + RS485 una scheda Multi I/O Device o Mini I/O Device con indirizzo pre programmato 2. Nei relè di uscita, una volta caricato il programma, vedrete variare l'output ogni 5 secondi.

    //-----------------------------------------------------------------
    // Esempio applicativo del protocollo MassaBus con Arduino
    // Il programma per la prova di funzionamento richiede una scheda
    // di output (Multi I/O o Mini I/O con indirizzo pre impostato a 2)
    // Durante la prova ogni circa 5 secondi l'output sulla scheda cambierà
    // di stato
    //------------------------------------------------------------------
    //Definisco numero byte bus
    #define SIZE_BUS_DATA 11
    //Definisco il timeout massimo per la seriale
    #define MAX_MILLIS_TIMEOUT 50
    //Inizializzazioni
    int led_act = 13;//Pin di arduino con il LED incluso
    int bus_dir = 2;//Pin di selezione della direzione
    int count;//Variabile conteggio generica
    long mil_mem = 0;//Variabile memorizzazione millisecondi
    byte my_adr = 1;//Mio indirizzo nel bus
    byte send_compose[SIZE_BUS_DATA];//Array invio pacchetto
    //Variabili procedure ricezione (riguardano l'ultimo pacchetto decodificato)
    byte recived_data[SIZE_BUS_DATA];//Array del pacchetto ricevuto
    boolean correct_data;//True se il pacchetto era corretto
    byte adress_reciver_ric;//L'indirizzo destinatario
    byte adress_sender_ric;//Indirizzo mittente
    byte type_ric;//Tipologia pacchetto
    byte data1_ric;//Campo dato 1
    byte data2_ric;//Campo dato 2
    //Procedura creazione trama da inviare su BUS
    //Campi: indirizzo destinatario,tipologia pacchetto, dato 1, dato 2)
    void code_data_to_send(byte adress_reciver,byte type_s,byte data1_s,byte data2_s)
    {
     //Variabili utilizzate nella procedura
    byte checksum_send;//checksum completo
    byte checksum_send_low;//checksum diviso (parte bassa)
    byte checksum_send_hi;//checksum diviso (parte alta)
    byte type_to_send;//Tipologia pacchetto
    byte data_send_1;//Primo campo dati da inviare
    byte data_send_2;//Secondo campo dati da inviare
    byte adress_sender;//Indirizzo mittente
    //Inizio procedura
    type_to_send = type_s << 2; //shift di due bit per spazio riservato zero flag
    //se l'indirizzo è in modalità normale (destinatario diverso da 255)
    if(adress_reciver != 255){
      adress_sender = my_adr; //Metto come mittente il mio indirizzo
     } else {
      adress_sender = 255; //Altrimenti anche il mittente a 255
     } 
    if(data1_s == 0){//se data1 è pari a 0
      data_send_1 = 48; //lo sostituisco con il codice ASCII 48
      type_to_send = type_to_send | 1; //Imposto a 1 il rispettivo zero flag
     } else {
      data_send_1 = data1_s; //altrimenti mantengo il dato
     }
    if(data2_s == 0){//se data2 è pari a 0
      data_send_2 = 48; //lo sostituisco con il codice ASCII 48
      type_to_send = type_to_send | 2; //Imposto a 1 il rispettivo zero flag
     } else {
      data_send_2 = data2_s; //altrimenti mantengo il dato
     }
    //Calcolo e assegnazione bit checksum
    //Effettuo XOR con tutti i campi necessari
    checksum_send = adress_reciver ^ adress_sender ^ type_to_send ^ data_send_1 ^ data_send_2;
    //Suddivido il checksum in due parti (alta e bassa) a 4 bit ciascuna
    //Imposto di ogni parte il bit più significativo a 1 come previsto da protocollo
    checksum_send_low = (checksum_send & 15) | 128;
    checksum_send_hi = (checksum_send >> 4) | 128;
    // Composizione array stringa seriale
    //Ad ogni rispettivo byte del pacchetto assegno il rispettivo dato
    send_compose[0] = 'S';
    send_compose[1] = adress_reciver;
    send_compose[2] = adress_sender;
    send_compose[3] = type_to_send;
    send_compose[4] = data_send_1;
    send_compose[5] = data_send_2;
    send_compose[6] = checksum_send_low;
    send_compose[7] = checksum_send_hi;
    send_compose[8] = 3; //Terminazione
    send_compose[9] = 3;
    send_compose[10] = 3;
    //Invio il pacchetto
    send_data();
    }
    //Procedura invio dati su bus tramite seriale
    void send_data(){
     // setto il flag di trasmissione
     UCSR0A=UCSR0A |(1 << TXC0);
     Serial.flush();
     // abilito led
     digitalWrite(led_act,HIGH);
     //attivo il MAX485 in trasmissione
     digitalWrite(bus_dir,HIGH);
     //Mando l'array di byte
     Serial.write(send_compose, SIZE_BUS_DATA);
     //Attendo la fine della trasmissione
     Serial.flush();
     while (!(UCSR0A & (1 << TXC0)));
     //Disabilito led e max485
     digitalWrite(bus_dir,LOW);
     digitalWrite(led_act,LOW);
    }
    //Procedura decodifica dati
    void decode_ric_data(){
    //Variabili checksum separati
    byte chk_low;
    byte chk_hi;
    //Composizione complessiva del checksum
    byte checksum;
    //Variabile checksum ricalcolato
    byte calcolated_checksum;
    //imposto a default la variaible pacchetto corretto
    correct_data = false;
    //Verifico che il primo pacchetto sia S e ci sia la terminazione (come da protocollo MassaBUS)
    if((recived_data[0] =='S')&&(recived_data[8] == 3)){//Controllo start byte e terminazione
     //Ricostruzione byte checksum
     //Separo la parte bassa dal pacchetto
     chk_low = recived_data[6] & 15;
     //Separo la parte alta dal pacchetto
     chk_hi = recived_data[7] & 15;
     //Mette insieme i due byte per ricostrire checksum (con shift del più alto)
     checksum = (chk_hi << 4) | chk_low; 
     //controllo il dato ricevuto con il checksum (lo ricostruisco con i byte ricevuti)
     calcolated_checksum = recived_data[1] ^ recived_data[2] ^ recived_data[3] ^ recived_data[4] ^ recived_data[5];
     //Verifico che il checksum sia uguale (calcolato e ricevuto) e verifico che i due byte dei
     //pacchetti dei checksum abbiano il bit più significativo alto (come da protocollo)
     if((calcolated_checksum == checksum) && ((recived_data[6] & 128) == 128) && ((recived_data[7] & 128) == 128)){
       //se il checksum è corretto
       //Setto nella variabile condivisa l'indirizzo del destinatario (forse questa scheda!!!)
       adress_reciver_ric = recived_data[1];
       //Setto nella variabile condivisa l'indirizzo del mittente
       adress_sender_ric =recived_data[2];
       //preleva il pacchetto di tipologia (saltando gli zero flag)
       type_ric = recived_data[3] >> 2; 
       //Verifica degli zero flag (sia primo che secondo campo dati)
       //Se dato 48 e rispettivo zero flag a 1 setto data a 0
       //altrimenti setto il valore ricevuto
       if((recived_data[4]==48)&&((recived_data[3] & 1)==1)){
         //se data1 = 0 (controllo zero flag a 1)
         data1_ric=0;
       } else {
         data1_ric=recived_data[4];
       }
       //Verifica degli zero flag
       //Se dato 48 e rispettivo zero flag a 1 setto data a 0
       //altrimenti setto il valore ricevuto
       if((recived_data[5]==48)&&((recived_data[3] & 2)==2)){
         //se data2 = 0 (controllo zero flag a 1)
         data2_ric=0;
       } else {
         data2_ric=recived_data[5];
       }
       //Indico che il pacchetto è stato decodificato correttamente
       correct_data = true;
     }
    }
     //Se il pacchetto è decodificato correttamente
     if(correct_data){
       //Chiamo la procedura che gestisce il pacchetto decodificato
       packet_data_elaboration();
     }
    }
    // the setup routine runs once when you press reset:
    void setup() {
      // inizializzo led indicazione invio pacchetto e led selezione direzione
      pinMode(led_act,OUTPUT);
      pinMode(bus_dir,OUTPUT);
      Serial.begin(9600);
    }
    //evento lanciato durante la ricezione di dati seriali
    void serialEvent() {
      byte index_buffer_rx = 0;
      boolean get_byte_continue =true;
      //Prendo i millisecondi attuali
      long last_millis =millis();
      long mem_millis;
      //Inizializzo conteggio millisecondi di timeout
      int count_millis = 0;
      //Inizializzo varibile indicante dati corretti
      boolean bus_data_avaible =false;
      //Verifico disponibilità dati
      if(Serial.available()){
        //Prelevo primo dato
        recived_data[index_buffer_rx++] = Serial.read();
        //Attivo loop di ricezione pacchetti
        while(get_byte_continue){
          //Parte gestione byte ricevuti
          if(Serial.available()){
            recived_data[index_buffer_rx++] = Serial.read();
            //Verifico se il buffer ha un pacchetto completo
            // (-2 per riconosere il pacchetto conteggiando da 0)
            if(index_buffer_rx > (SIZE_BUS_DATA - 2)){
              //Fermo la ricezione di byte (dopo uscirà dal ciclo)
              get_byte_continue = false;
              //Indico mettendo in true che il pacchetto è stato ricevuto correttamente
              bus_data_avaible = true;
            }
          }
          //Seconda parte (conteggia i milliscondi del ciclo while)
          //Se supera timeout esco (evitando stalli del software!)
          //Parte gestione timeout
          //Prelevo i millisecondi attuali dall'accensione di arduino
          mem_millis = millis();
          //Se diversi da quelli memorizzati precedentemente
          if(mem_millis != last_millis){
            //Salvo in memoria gli attuali
            last_millis = mem_millis;
            //Incremento il conteggio dei millisecondi
            count_millis++;
            //Se supera soglia di millisecondi impostati (costante)
            if(count_millis > (MAX_MILLIS_TIMEOUT - 1)){
              //Esco dal ciclo mettendo in flase la variabile
              get_byte_continue = false;
              //bus_data_avaible rimane in false (pacchetto non corretto!!)
            }
          }
         }
      }
      //Se all'uscita del while i dati sono corretti
      if(bus_data_avaible){
        //Chiamo la procedura di decodifica pacchetto
        //Nell'array recived_data ho tutti i byte del pacchetto
        //Pronti da analizzae...
        decode_ric_data();  
      }
    }
    void loop() {
      //Attendo 5 secondi (non uso delay per permettere ricezione seriale)
     if (millis() != mil_mem){
       mil_mem = millis();
     if(count++ > 5000){
       count = 0;
       //Invio in output 5 (tipologia 12 output, indirizzo 2)
     code_data_to_send(2, 12, 5, 0);
     }
    }
    }
     
    void packet_data_elaboration() {
    //Se il pacchetto è indirizzato qui e arriva dal dispositivo 2 con tipologia 12
    if ((adress_reciver_ric == 1) && (adress_sender_ric == 2) && (type_ric == 12)){
      if(data1_ric = 5){
        delay(5000);//attendo 5 sec
        code_data_to_send(2, 12, 10, 0);
        //Invio in output 10 (tipologia 12 output, indirizzo 2)
      }   
     }
    }

    Di seguito trovate il sorgente per Arduino.

    DOWNLOAD SORGENTE ARDUINO

    Buon lavoro!

  • Sensore di pioggia e allagamenti

    Ti interessa acquistare questo sensore di pioggia e allagamenti già pronto all'uso? Clicca qui!

    Questo circuito permette di rilevare la presenza di liquidi conduttivi (es. acqua impura) tra i propri terminali. Il circuito si compone di due parti: il sensore vero e proprio ed un trasduttore in grado di fornire un segnale digitale indicate la presenza o meno di liquido.

    Il sensore può essere utilizzato sia come sensore di pioggia per evitare danni a tende, oggetti e chiudere finestre o per informare i sistemi domotici delle case della presenza di pioggia. Un altro utilizzo è quello di sensore di allagamento che come dice la parola stessa permette di rilevare la presenza di liquidi a terra come nel caso di un allagamento, infatti oltre che a segnalare l’eventuale presenza con un allarme, esso può essere usato per informare un eventuale sistema domotico come MassaBus della presenza di acqua e se previsto in fase realizzava esso potrà in automatico chiudere l’erogazione di acqua per evitare che possano avvenire danni ingenti. E ancora possiamo usarlo come rilevatore di umidità per il terreno delle piante, permettendo ad un inaffiatoio automatico o a un sistema di controllo di sapere quando la terra è secca. Inoltre, prendendo i terminali di rilevazione e lasciandoli scoperti può essere anche usato come sensore sensibile al tocco di un dito!

    Il principio che sta alla base del funzionamento di questo tipo di sensori è il fatto che l’acqua con cui abbiamo a che fare sempre non è pura ma contiene al suo interno alcuni minerali disciolti che la rendono più o meno conduttiva, infatti l’acqua pura di per se è un isolante. La rilevazione del liquido quindi può essere fatta attraverso due conduttori che in assenza di acqua siano isolati, mentre in presenza di acqua, quest’ultima, chiuda un qualsivoglia circuito in grado di attivare un'uscita ad esempio digitale.

    Detta così la questione è semplice però per realizzare un apparato funzionante è necessario considerare alcuni aspetti critici:

    • L’acqua ha una conduttività variabile a seconda dei sali disciolti, inoltre la sezione di liquido che conduce può variare. Questo fa si che il liquido abbia una resistenza equiavelente molto variabile.
    • I conduttori quasi sicuramente sono metallici. Come è risaputo la presenza di corrente elettrica contiuna tra due conduttori immersi in un liquido provoca un effetto chiamato elettrolisi: ciò comporta una reazione chimica in grado di cambiare le proprietà dei materiali rendendoli inutilizzabili dopo un certo tempo. Per evitare che l’elettrolisi avvenga è necessario invertire continuamente la polarità elettrica a cui i puntali sono sottoposti.

    Di seguito, nella descrizione dello schema elettrico, verranno illustrate le varie metodologie per eliminare gli aspetti critici.

    SCHEMA ELETTRICO

    Il tutto è incentrato sull’integrato CMOS 40106 (struttura interna nella figura a fianco) che al suo interno contiene 6 porte NOT a trigger di Smith. La peculiarità di queste porte è quella di avere i livelli di tensione a cui la porta commuta di stato logico ben definiti e quindi garantiscono prestazioni migliori soprattutto in applicazioni dove è richiesto che la commutazione avvenga dopo che si è superata una ben definita soglia.

    Tutto il funzionamento parte dall’oscillatore a porta NOT visibile in alto a sinistra dello schema. Come è noto uno porta logica di tipo NOT inverte lo stato logico all’ ingresso e questa caratteristica viene usata proprio per generare un onda quadra attraverso il multivibratore astabile costituito da R1 e C1. Questo elemento genera l’onda quadra sfruttando una sola porta NOT, il suo funzionamento è molto semplice: consideriamo la tensione ai capi del condensatore C1 e consideriamola inizialmente a 0V. In questa condizione la porta logica avendo in ingresso una tensione inferiore alla soglia minima porta la sua uscita a livello alto essendo invertente, questo fa si che il condensatore si inizi a caricare attraversola resistenza R1 e ciò avverrà fino a quando la tensione ai suoi capi sarà inferiore alla soglia superiore della porta logica. Quando la soglia viene superata la porta logica ha in ingresso un livello logico alto e pertanto la sua uscita lo avrà basso, così il condensatore attraverso R1 inizierà a scaricarsi, questo solo attraverso R1  e non tramite l’ingresso della porta logica che avendo un alta impedenza non rappresenta un carico rilevante per il condensatore. Questo ciclo continua all’infinito e dall’uscita della porta logica si otterrà un onda quadra di frequenza dipendente dai valori di R1 e C1. In dettaglio sotto è visibile la sezione circuitale del multivibratore.

    Con R1 pari a 10K e C1 pari a 100nF la frequenza dell’onda quadra è di circa 1 kHz. Tale frequenza può essere modificata variando i valori di R1 e C1, la frequenza dipende (circa) dall’inverso della constante di tempo R * C cioè 1/(R * C). Il circuito continua utilizzando un'altra porta NOT dell’integrato utilizzata come buffer invertente: il suo scopo è quello di non caricare il multivibratore precedente permettendo così di variare il carico in uscita (verso R2) della seconda porta logica senza andare a modificare i tempi di caricamento e scaricamento di C1, avendo come già detto anche la seconda porta logica un ingresso con impedenza molto alta e un uscita a bassa impedenza. L’inversione logica del segnale effettuata dalla porta non incide sul funzionamento del circuito.

    Seguono la resistenza R2 che garantisce protezione all’uscita della porta logica da eventuali corto circuiti e C2 che ha un compito particolare e fondamentale nel funzionamento del sensore: il suo scopo è quello di eliminare il valore medio dell’onda quadra appena generata. Infatti come è noto il condensatore rappresenta un circuito aperto per le correnti continue e una resistenza (o meglio impedenza) per le correnti alternate. Questo fa si che il condensatore porti a questo effetto: 

    Come si nota Vin è l’andamento della tensione nel tempo in uscita dalla porta logica. Essa è un onda quadra avente valor medio pari a Vin/2 e un andamento da0 a Vin, pertanto l’elettrolisi avviene comunque in quanto i terminali del sensore sono posti, sebbene per metà del tempo, alla stessa polarità. Il condensatore C2 invece fa si che l’elettrolisi non possa avvenire in quanto il condensatore annullando il valore medio dell’onda quadra provoca un continuo cambio di segno (Vout) nella polarità alla quale i terminali del sensore sono sottoposti. Quindi Vout ha un valor medio pari a 0 e una tensione (riferita sempre a Vin) pari a +Vin/2 e –Vin/2 questo fa si che la polarità dei terminali del sensore cambi continuamente e questo fa si che l’elettrolisi non possa avvenire. Quando il sensore è in contatto con l’acqua tra i due terminali si instaura praticamente un corto circuito che permette all’onda quadra di passare negli stadi successivi del circuito. Successivamente C3,R3 proteggono l’ingresso della successiva porta logica da eventuali correnti provocate da tensioni parassite (in arrivo dall’acqua) e R4 in particolare assicura che l’ingresso non sia ad uno stato logico flottante, portando ad un malfunzionamento del circuito.

    Il diodo D4 ha lo scopo di far passare all’ingresso della porta logica solo le parti dell’onda quadra avente tensione maggiore di 0. Questo è necessario per far si che all’ingresso della porta logica non vi siano mai tensioni  negative. Infatti come è possibile notare  quando la tensione è maggiore di 0 il diodo può essere considerato come un circuito aperto e la tensione viene posta all’ingresso della successiva porta logica. Quando invece la tensione è minore di 0 il diodo conduce e ha ai sui capi una tensione massima di 0,7V che dalla porta logica vengono visti come -0,7V che è un valore sopportabile dalla porta logica. In realtà volendo è possibile anche omettere il diodo D4 in quanto la porta logica per via dell’architettura CMOS è già dotata internamente di tale diodo come ricorda il datasheet (parte visibile sotto), comunque D4 rimane utile per eventuali casi imprevisti che possono portare il diodo della porta logica alla rottura (esempio dispersioni della tensione di rete) in quanto il diodo D4 supporta correnti fino a 200mA.

     

    La corrente che scorre nel diodo e nel sensore è comunque in casi normali limitatissima dato i valori alti delle resistenze coinvolte prima e dopo il circuito e dal fatto che la porta logica ha un ingresso ad alta impedenza. Questo porta ad avere un circuito molto sensibile in grado di rilevare anche la minima presenza di liquido tra i sui terminali. Le due porte logiche successive risultano funzionare da semplice buffer in quanto effettuano la negazione due volte: questo permette di avere un ingresso ad alta impedenza (lato sensore) e un uscita a bassa impedenza per gli stadi del circuito successivi. 

    Lo stadio successivo si occupa di trasformare l’onda quadra (oramai mezza, visto che la parte negativa è stata eliminata in precedenza) in un segnale continuo, inoltre si occupa di ritardare di alcuni secondi la disattivazione quando finisce la rilevazione di acqua, evitando così eventuali  segnali instabili che potrebbero portare problemi agli stadi successivi. Questo stadio è composto innanzitutto dal diodo D2 il cui scopo è quello di fare da canale di non ritorno: se la porta logica ha in uscita un livello alto nel diodo scorrerà la corrente che porterà alla carica di C4, se però la porta logica si porta a livello basso e il condensatore è carico il diodo essendo in polarizzazione inversa impedisce che il condensatore si scarichi attraverso di esso. Quando il diodo D2 è in conduzione la resistenza R5 si occuperà di caricare velocemente il condensatore scarico senza sovraccaricare l’uscita della porta logica (infatti è di soli 100 ohm). Essendo l’ingresso della porta logica successiva ad alta impedenza per scaricare il condensatore in un tempo ragionevole è stata inserita la resistenza R6 che oltre a mantenere un livello logico definito quando il condensatore è scarico si occupa di scaricarlo. Con questi valori di R6 e C4 una volta ripristinato l’isolamento tra i contatti del sensore l’uscita si disattiverà nel giro di 1-2 secondi. Se si vuole modificare questo tempo è possibile agire aumentando R o C per aumentare il tempo o diminuire R o C per diminuire tale tempo. E’ possibile calcolare (circa)  il tempo di ritardo moltiplicando i valori di R e C (trovando la costante di tempo).

    Le altre due porte logiche successive hanno anche loro la funzione di buffer infatti forniscono a partire da un ingresso ad alta impedenza un’uscita a bassa impedenza. Con queste due ultime porte logiche si utilizzano nel dispositivo tutte le 6 porte logiche dell’integrato 40106. Successivamentela resistenza R7 limita la corrente alla base del transistor TR1 di uscita. Il transistor a seconda dello stato logico dell’uscita dall’ultima porta logica va in saturazione attivando il carico o in interdizione. Tra il + del circuito e il collettore del transistor TR1 è possibile collegare il carico che si deve attivare in caso di presenza di liquidi: può essere un relè, un led, un ingesso di una scheda di I/O come nel caso del sistema domotico MassaBus oppure un qualsiasi carico che assorba massimo 100 mA (con TR1 BC547 e R7 da 4,7Kohm) e supporti una tensione pari a quella di alimentazione del circuito. Nel caso in cui si usi un relè o un carico induttivo è necessario montare anche il diodo D3 che protegge il transistor dalle extratensioni di commutazione provocate dal relè, altrimenti D3 è possibile ometterlo. Anche LD1 e R8 sono opzionali e servono unicamente da indicazione di attivazione. Il circuito così composto (escludendo il relè o il carico applicato) consuma pochi mA sia a riposo che in presenza di liquidi, quindi l'assorbimento maggiore da considerare per scegliere l'alimentatore giusto è quello del carico sull'uscita del sensore (max 100mA). Infine D1 si occupa di proteggere il circuito e il carico in uscita dalle inversioni di polarità, mentre C5 e C6 si occupano di filtrare la tensione in ingresso da eventuali disturbi o auto-oscillazioni.

     

    COLLEGAMENTI SCHEDA TRASDUTTORE

    Ecco di seguito lo schema di collegamento della scheda. In particolare è presente il connettore di alimentazione che deve essere in corrente continua con una tensione tra i 9V e i 18V, l’uscita che permette di collegare relè o altro funzionate alla stessa tensione di alimentazione e il connettore a cui collegare il sensore utilizzato. 

     

    TIPI DI SENSORE

    In questo articolo vengono descritti due tipi di sensore: uno è adatto a rilevare gli allagamenti, mentre l’altro è adatto come sensore di pioggia. Entrambi possono essere collegati ai contatti sensore del circuito allo stesso modo e senza alcuna polarità.

    • Sensore allagamenti

    Per utilizzare il dispositivo come sensore allagamenti è necessario predisporre due puntali metallici collegati ad una scatola di plastica, meglio se stagna. I puntali dovranno arrivare a filo del pavimento o al livello in coi vorrete che l’acqua faccia scattare il sensore. I puntali possono essere distanziati a piacere senza però metterli troppo distanti (non oltre30 cm) o in cortocircuito.

    Questa configurazione può anche essere usata per rilevare l'umidità del terreno di una pianta o di un giardino, permettendo ai sistemi di controllo e irrigazione di sapere quando la terra è secca e necessità di acqua.

    • Sensore di pioggia 
    Per utilizzare il dispositivo come sensore di pioggia è necessario utilizzare una piastrina di rilevazione come quella mostrata sotto. Per realizzarla è sufficiente cerare un circuito stampato partendo dal master fornito e da li stagnare tutte le piste fino a creare una unica traccia di stagno.Il sensore a posto attaccato ad una parete e inclinato di circa 45° con la parte delle piste posta verso l’alto. Potete modificare lo stampato da me preparato allargando o restringendo la distanza tra le piste per aumentare o diminuire la sensibilità alla pioggia.
     
     
    CIRCUITI STAMPATI

    Attenzione! Queste sono soltanto immagini indicative. Per la realizzazione fate riferimento ai file allegati.

    • Trasduttore

    Nello stampato mancano i componenti LD1, R8 e RL1 in quanto montati esternamente.

    • Sensore di pioggia (da realizzare solo se utilizzato in questa maniera)
    I fili vanno saldati nei terminali quadrati.
    ALCUNE IMMAGINI
     

     

    Di seguito è disponibile il link per scaricare l'archivio zip contenente i file per la realizzazione. I file originali dei circuiti stampati e degli schemi sono in formato FidoCad, mentre i master da stampare per realizzare le schede sono in formato PDF.
    BUON LAVORO!

     

  • Sistema domotico MassaBus

    I DISPOSITIVI MASSABUS SONO ORA IN VENDITA COMPLETI E AGGIORNATI QUI!

    Domotica fai da te. Il sistema MassaBusèun sistema domotico adatto per controllare ed automatizzare ambienti domestici ed aziendali. Esso si basa sullo standard di comunicazione RS485, molto usato a livello industriale per la sua elevata resistenza ai disturbi induttivi e capacitivi. L’interfacciamento del sistema al computer centrale avviene tramite una porta seriale standard RS232 mentre la comunicazione nel bus viene gestita in modalità MASTER – SLAVE con una rete RS485 di tipo half-duplex che permette di estendere il sistema fino ad una distanza di 1200 metri.

    Il sistema può essere usato per automatizzare i vari dispositivi presenti in una abitazione o in una azienda e per monitorare degli ambienti interni o esterni. Attualmente il sistema permette di collegare fino a 32 dispositivi (limite dettato dalla rete RS485 ma espandibile fino  a 254 attraverso opportune schede di rigenerazione del segnale) comprendenti un dispositivo MASTER composto da un PC e dei dispositivi SLAVE che permettono di gestire uscite digitali e monitorare ingressi digitali, tensioni,  temperature e altro.

    Caratteristiche principali:

    • Interfacciamento al computer tramite seriale RS232;
    • bus di comunicazione RS485 avente alta resistenza ai disturbi;
    • interfaccia RS232 isolata elettricamente dal bus di comunicazione RS485;
    • sistema estendibile senza rigeneratori fino a 1200m e 31 dispositivi slave, oppure oltre 1200m e fino a  253 dispositivi slave attraverso l’uso di rigeneratori di segnale;
    • Alimentazione centralizzata;
    • Flessibilità, possibilità di ampliamento ed adattamento agli ambienti in cui è predisposto;
    • Controllo centralizzato tramite PC predisposto con software di gestione;
    • I/O isolati dal sistema;
    • Utilizzo componenti di facile reperibilità;
    • Massima libertà nella programmazione degli indirizzi: ogni unità indirizzabile può avere da 1 a 254 come indirizzo e l’indirizzo può essere programmato direttamente via software;
    • Le schede slave dispongono di alcune caratteristiche comuni quali: un led di segnalazione attività, un interruttore che consente di attivare la programmazione degli indirizzi e un pulsante di reset per applicare i nuovi indirizzi o per effettuare il reset della scheda;
    • Tutte le schede interfacciate al bus RS485 dispongono di dip switch per adattare la scheda alle caratteristiche del bus.

    Il sistema MassaBus prevede come mezzo fisico trasmissivo un doppino twistato non schermato (UTP) per il trasporto dei segnali differenziali A e B ed un terzo conduttore che si occupa di interconnettere la massa in comune ai vari dispositivi. Il doppino twistato può anche essere di tipo schermato (FTP o SFTP) che permette di avere una maggiore resistenza ai rumori esterni, utile soprattutto in ambienti particolarmente rumorosi dal punto di vista elettromagnetico. Oltre ai segnali è necessario prevedere anche 2 fili conduttori che collegheranno l’alimentatore del sistema con i singoli dispositivi del bus. Questi fili andranno scelti di opportuna sezione in accordo con la dimensione e la struttura del sistema adottata.

    Il sistema MassaBus strutturalmente è composto dagli elementi visibili in figura.

    Comunicazione logica del sistema

    Il sistema MassaBus per poter gestire la propria architettura a bus non ha bisogno solo degli accorgimenti illustrati nel capitolo precedente, ma deve anche prevedere un ben preciso protocollo di comunicazione che permetta, oltre al trasferimento dati, anche l’indirizzamento dei dispositivi presenti nel bus. Questo tipo di protocollo viene detto “protocollo di linea”. Esso è stato ideato da me e si rifà ai protocolli di linea adottati a livello 2 ISO OSI nelle reti, adattati all’utilizzo specifico nel sistema MassaBus.

    Tale protocollo ha le seguenti caratteristiche:

    • E’ un protocollo di linea a pacchetti organizzati in trama.
    • Indirizza fino a 254 dispositivi (da1 a 254).
    • Permette 63 tipi di comando ai dispositivi (da1 a 63).
    • Consente l’invio di 2 campi dati ad 8 bit per pacchetto.
    • Utilizza una rivelazione (ma non di correzione) degli errori attraverso operazioni di XOR, detta “Checksum”.
    • Ha una trama avente 11 byte.

    Il protocollo di linea applicato nel sistema prevede per la comunicazione una forma a pacchetto avente una trama (figura 2.12) composta da 11 byte, aventi ognuno una funzione specifica.

    I byte hanno le seguenti funzioni nella trama:

    • Start byte (0): questo byte indica l’inizio della trama.
    • Indirizzo destinatario(1): è un indirizzo ad 8 bit che indica il destinatario del pacchetto.
    • Indirizzo mittente (2): è un indirizzo ad 8 bit che indica il mittente del pacchetto.
    • Type e zero flag (3): questo byte è composto da 2 parti: i primi due bit meno significativi rappresentano gli “zero flag”, mentre gli altri bit indicano il tipo di comando a cui si riferisce il pacchetto. Gli zero flag sono bit posti a 1 quando il campo data 1 o data2 ha valore zero (il meno significativo indica uno zero, in data 1, quando ha valore 1, il secondo bit indica uno zero, in data 2, quando ha valore 1). Questo accorgimento è necessario poiché il master utilizza linguaggi di alto livello aventi spesso problemi nel trattare dati aventi in mezzo alla trama valori nulli (pari a 0).
    • Data 1 e data 2 (4 e 5): rappresentano i 2 byte inviati dal pacchetto
    • Checksum low (6): contiene come bit più significativo un 1 fisso e come 4 bit meno significativi i 4 bit meno significativi del Checksum calcolato prima della trasmissione.
    • Checksum high (7): contiene come bit più significativo un 1 fisso e come 4 bit meno significativi i 4 bit più significativi del Checksum calcolato prima della trasmissione. I bit posti ad 1 fisso dei due byte di Checksum low e high consentono di evitare il formarsi di byte aventi valore 0 e di sequenze simili agli end byte.
    • End byte (8,9 e 10): sono una sequenza di 3 byte aventi valore 3, che non può presentarsi in altri campi altri della trama, indicanti la fine del pacchetto.

    Indirizzamento dispositivi

    L’indirizzamento dei dispositivi MassaBus avviene tramite un codice binario ad 8 bit, permettendo di indirizzare fino a 254 dispositivi. Tale numero massimo è dovuto alle limitazioni sull’utilizzo degli indirizzi, in particolare:

    • L’indirizzo 0 non può essere utilizzato
    • L’indirizzo 255 è riservato al master per comunicazioni di broadcast ( a tutti i dispositivi slave, in contemporanea) e per la programmazione iniziale degli indirizzi.

    Il master deve essere unico nella rete e deve disporre di un unico indirizzo tra 1 e 254, assegnatogli prima dell’ assegnazione degli indirizzi agli slave. I dispositivi slave possono essere al massimo 253 con indirizzi da1 a 254. Questo protocollo non si interessa del mezzo fisico utilizzato, pertanto per poter usare 254 dispositivi è necessario prevedere unità di rigenerazione del segnale essendo la rete RS485 limitata, nei transceiver utilizzati, a 32 dispositivi interconnessi senza rigenerazione.

    Di seguito trovate una tabella che indica le vari funzioni dei campi presenti nel pacchetto. Solitamente la comunicazione di base avviene con una chiamata del master al slave e lo slave subito risponde al master. L'unica eccezione è appunto in caso di broadcast in cui gli slave comandati non rispondono. Nelle comunicazioni normali la tipologia pacchetto tra domanda master e risposta slave, salvo errori, non cambia. A cambiare è solo il campo dati che cambia significato di volta in volta. Di seguito la tabella permette di capire l'associazione tipologia pacchetto e significato campo dati in domanda e risposta al master.

    Hardware & Software attuale del sistema MassaBus, cliccare sui link per i dettagli (tutte le parti sono in fase di pubblicazione)

    La parte hardware del sistema MassaBus si articola attualmente su queste tipologie di dispositivi:

    • Scheda alimentazione provvede ad alimentare l’intero sistema
    • Scheda di interfaccia bus provvede a convertire i segnali dell’interfaccia PC RS232 in segnali adatti al bus RS485 del sistema
    • Scheda Multi I/O device permette di controllare 8 uscite a relè, 8 ingressi optoisolati e dispone di un ingresso analogico 0-5V per collegare sensori o dispositivi aventi in uscita un segnale analogico
    • Scheda Mini I/O device permette di controllare 4 uscite a relè e 4 ingressi optoisolati
    • Scheda Temperature sensor permette il controllo della temperatura presente in un ambiente o in un oggetto
    • Scheda PAN camera control permette di controllare la rotazione di una telecamera a 360°

    Inoltre è possibile arricchire la dotazione sensoriale e di interazione del sistema con appositi dispositivi accessori da collegare agli input/output del sistema:

    • Termostato elettronico permette di attivare un ingresso del sistema MassaBus quando la temperatura misurata tramite un sensore NTC supera la soglia impostata tramite trimmer
    • Sensore di pioggia e allagamenti permette di attivare un ingresso del sistema MassaBus quando un sensore apposito rileva la presenza di liquidi come in caso di pioggia o allagamenti

    Mentre la parte software del PC si articola su questi programmi:

    • MassaBus Controller Il programma di gestione della comunicazione e di tutte le schede del bus, supporta una modalità manuale dove i comandi al bus vengono dati tramite l'intefaccia del software e una modalità automatica in cui un programma esterno (es. MassaBus Application Example) tramite una connessione TCP può invocare i comandi sul bus ed automatizzare tutto il sistema.
    • MassaBus Application Example è un software dimostrativo che lavora in simbiosi con il programma MassaBus Controller e permette di dare "intelligenza" al sistema domotico. Questo programma può essere sostituito con uno creato appositamente per soddisfare le proprie esigenze.

    Questo progetto è stato presentato per la mia tesina di maturità, nel link qui sotto è possibile visualizzare il pdf con la tesina completa di spiegazioni dettagliate sul funzionamento di ogni scheda. Infatti troverete tutto quello che è pubblicato sul sito (e che deve essere ancora pubblicato) con alcune spiegazioni in più ed una dettagliata analisi dei software coinvolti.


    TESINA MASSABUS (PDF)