controllo - Massari Electronics

  • MassaBus Controller

    {jcomments on}VERSIONE: 2.1.0.1 | 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 è l’interfaccia software progettata tra il programma di gestione e il sistema domotico MassaBusEsso è diviso in due modalità operative: comando manuale e comando automatico.


    Nella modalità a comando manuale è possibile controllare direttamente dal programma MassaBus ogni singola caratteristica di ogni scheda presente nel sistema. In questa modalità è disponibile una comoda ricerca automatica che effettua una scansione degli indirizzi utilizzati dalle varie schede e li restituisce in ordine su una lista.

    Nella modalità a comando automatico, invece, MassaBus controller apre un porta TCP/IP da cui sarà possibile inviare i comandi direttamente da un programma di gestione realizzato ad hoc per l’utente finale in grado di eseguire le attività del bus domotico, garantendo la massima praticità. Il software MassaBus controller provvederà poi a girare le risposte al programma sempre via TCP/IP.

    ...in aggiornamento...

    Sono disponibili i sorgenti del programma utilizzabili con Visual Basic .NET (gratuito) e il programma eseguibile.


    DOWNLOAD 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!

  • 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)