Home
Accesso / Registrazione
 di 

Domotica interfacciata all'antifurto Bentel con microcontrollore PIC16F876

Immagine del circuito montato

A quanti di voi non piacerebbe uscire di casa senza dover pensare alla chiusura delle tapparelle? Con questo circuito è possibile, si può interfacciare l’antifurto della Bentel ma penso anche altri antifurti alle finestre e alle tapparelle, automatizzando e proteggendo la casa. Il circuito oltre che ad automatizzare le tapparelle chiudendole quando si vuole uscire di casa, protegge la casa anche se l’antifurto è spento, infatti quando le tapparelle sono abbassate il circuito rileva attraverso un contaimpulsi il sollevamento della tapparella non attivata tramite il pulsante dell’automazione e fa scattare l’antifurto nella modalità sabotaggio.

Il circuito è molto semplice, il cuore del sistema è il nostro microcontrollore PIC16F876, il quale viene interfacciato all’antifurto della Bentel tramite 2 uscite che vanno agli ingressi dell’antifurto nella modalità sabotaggio, infatti la Bentel ha una modalità di funzionamento antisabotaggio che consiste nel controllare i valori di resistenza degli ingressi, se la resistenza è del valore di 5KOhm l’ingresso è nella condizione di riposo, se è di 10KOhm è nella condizione di allarme, e se è completamente aperto è nella condizione di sabotaggio, in questa condizione l’antifurto suona anche se non è attivato. Questo vuol dire che l’antifurto è attivato 24 ore su 24. Sfruttando le resistenze da 10KOhm in parallelo e i transistor si può gestire questa modalità. Le tapparelle possono essere aperte o chiuse anche con dei pulsanti in due modi, premendo una volta la tapparella in automatico sale o scende completamente, tenendo premuto la tapparella funziona in manuale e si ferma quando viene rilasciato il pulsante. Quando dobbiamo uscire di casa possiamo premere il pulsante sull’antifurto e in automatico le tapparelle scendono tutte, se vogliamo sollevarle premiamo lo stesso pulsante e saliranno tutte in automatico. La scheda ha un buzzer per segnalare la salita e la discesa automatica della tapparella, il buzzer si attiva anche quando rileva un sollevamento della tapparella non autorizzato, questo può essere utile se ad esempio in qualche modo riescono a disattivare la sirena comunque il circuito avvisa che sta succedendo qualcosa che non va. Il circuito ha la possibilità di inserire un ricevitore radio fantastico che ho acquistato su futura elettronica, l’RX-4MHCS, questo modulo radio si presta benissimo la dove non è possibile inserire i pulsanti nel muro, infatti io l’ho messo in bagno (non mi andava di rovinare le piastrelle), il modulo ha già una codifica interna e può memorizzare i telecomandi attraverso il pulsante che ho inserito nella scheda.

Passiamo alla spiegazione del circuito, l'alimentazione del circuito viene presa dal 12V dell'antifurto e poi viene convertita a 5V attraverso un semplice 7805.

Sistema Domotico interfacciato all'antifurto

Il cuore del sistema è il PIC 16F876 al quale viene dato un clock attraverso il quarzo da 4 MHz. I pulsanti di comando della singola tapparella vengono collegati ai morsetti "PULS" uno per muovere la tapparella verso l'alto uno per muovere la tapparella in basso. I morsetti "ANTI-IN" uno è collegato all'antifurto per la modalità automazione e l'altro non è utilizzato. Ai morsetti tapparella viene collegato il contaimpulsi con una fune collegata alla tapparella, come questo:

la cordicella viene collegata alla fine della tapparella e vengono generati una serie di impulsi che vanno all'ingresso del nostro microcontrollore, se il circuito "sente" degli impulsi quando non viene azionato il motore fa scattare l'allarme. I morsetti "FINESTRA" sono collegati ad un contatto magnetico della finestra, quando la finestra è aperta la tapparella per sicurezza non scende in automatico ma solo in manuale. Il modulo radio ha 4 uscite di cui 2 si collegano in parallelo ai pulsanti che comandano la tapparella, gli altri 2 si collegano ad altri 2 ingressi del microcontrollore, per ora non sono utilizzati. I morsetti denominati "ANTI-OUT" sono le uscite che si collegano alle zone dell'antifurto, ed attraverso 4 transistor possono generare i 3 stati di funzionamento: riposo,allarme e sabotaggio sulle 2 uscite (tapparella e finestra). I 2 relè collegati alle uscite RC0 ed RC1 sono collegate al motore della tapparella e permettono l'automazione. Al pin RA5 è collegato un buzzer che suona quando l tapparella funziona in modalità automatica per avvisare che si chiude o che si apre.I pin RA3 e RA2 sono collegate la sirena e un led di segnalazione per lo spostamento della tapparella, per ora non ho collegato nulla.

i

Il programma l’ho scritto attraverso il compilatore della MikroC, gratuito con la limitazione di non superare i 2 Kwords, più che sufficienti per questo programma, lo riporto qui sotto:

//*************************************************
// ANTIFURTO CASA BASE 1.1
// Firmware: ACB1.1
// Scheda: DVD-0006-03
// modulo: main.c
// Autore: Davide Stecco
// Data: 09/05/2011
// Descrizione: Automazione tapparelle e antifurto
// picmicro: PIC16F876A
// clock: 4MHz
//*************************************************
 
unsigned char ScattiMax;                //Variabile Scatti tapparella massimi
unsigned char RitChius;                 //Variabile Ritardo alla chiusura quando l'antifurto è attivato
unsigned char RitApert;                 //Variabile Ritardo apertura quando l'antifurto è disattivato
unsigned char ScattiMem;                //Variabile Memorizzazione degli scatti
unsigned char cnt;                      //Variabile di conteggio
unsigned char OldState;
unsigned char CntAll;
unsigned int CntReset;
 
#define ANTI1 Button(&PORTB,0,1,1)          //Ingresso RB0 antifurto abilitazione antifurto
#define ANTI2 RB1_bit                       //Ingresso RB1 antifurto (da vedere)
#define PULSSU Button(&PORTB,2,10,0)         //Ingresso RB2 pulsante su
#define PULSGIU Button(&PORTB,3,10,0)        //Ingresso RB3 pulsante giu
#define TAPPA RB4_bit                       //Ingresso RB4 contatto tapparella
#define FINES RB5_bit                       //Ingresso RB5 contatto finestra
#define RAD1 Button(&PORTB,6,1,1)           //Ingresso RB6 contatto radio 1
#define RAD2 Button(&PORTB,7,1,1)           //Ingresso RB7 contatto radio 2
 
#define OUTSU PORTC.B0                      //Uscita Motore SU
#define OUTGIU PORTC.B1                     //Uscita Motore GIU
 
#define AntNormTap PORTC.B2                 //Uscita antifurto 1 sezione 1
#define AntSabotTap PORTC.B3                //Uscita antifurto 1 sezione 2
#define AntNormFin PORTC.B4                 //Uscita antifurto 2 sezione 1
#define AntSabotFin PORTC.B5                //Uscita antifurto 2 sezione 2
 
#define BUZZER PORTA.B5                     //Uscita buzzer
#define SEGNALA PORTA.B2                    //Uscita Segnalazione LED
#define SIRENA PORTA.B3                     //Uscita Sirena (opzionale)
 
#define TapAlla 1
#define TapFerm 0
 
// Definizione delle funzioni :
void Salita (void);
void Discesa (void);
void AntOn (void);
void AntOff (void);
void Allarme (void);
 
 
 
void main (void){
        // ********************************
        // Inizializzazione PIC
        // ********************************
 
        // Imposto PORTA come uscite
        TRISA = 0;
        PORTA = 0;
 
        // Imposto PORTB come ingressi
        TRISB        = 0xFF;
 
        // Imposto PORTC come uscite
        TRISC = 0;
        PORTC = 0;
 
        // Imposto gli interrupt
         INTCON = 0x00;
         OPTION_REG = 0x00;
        //resetto le uscite d'allarme per non avere problemi sull'antifurto.         
        AntNormTap = 1;
        AntSabotTap = 1;
        AntNormFin = 1;
        AntSabotFin = 1;
        // Leggo la EEPROM e li memorizzo nelle variabili
        //        da fare più avanti
        ScattiMax = Eeprom_Read(0);
        Delay_ms(500);
        RitChius = Eeprom_Read(1);
        Delay_ms(500);
        RitApert = Eeprom_Read(2);
        Delay_ms(500);
        ScattiMem = Eeprom_Read(3);
 
 
         
        ScattiMax  = 250;
        RitChius = 60;
        RitApert = 60;
        //SIRENA = 1;
        //Delay_ms(1000);
        //SIRENA = 0;
        //SEGNALA = 1;
        //Delay_ms(1000);
        //SEGNALA = 0;
        //BUZZER = 1;
        //Delay_ms(1000);
        //BUZZER = 0;
         
        if(ANTI2 == 1){
                 OldState = 0;
             }
        if(ANTI2 == 0 && OldState == 0){
                  OldState = 1;
             }
          while(1) {
          // Controllo il pulsante di salita
          if(PULSSU) {
                     Salita();
          }
          // Controllo il pulsante di discesa
          if(PULSGIU) {
                      Discesa();
          }
          if(ANTI2 == 1 && OldState == 1){
                         OldState = 0;
                         AntOff();
          }
          if(ANTI2 == 0 && OldState == 0){
                         OldState = 1;
                         AntOn();
          }
          if(FINES == 0) {
                    AntNormFin = 1;
          }
          if(FINES == 1) {
                  AntNormFin = 0;
          }
          if (TAPPA == TapAlla) {
              while(TAPPA == TapAlla){
              }
           CntAll++;
          }
          if (CntAll > 3) {
               Allarme();
               Delay_ms(1000);
               CntAll = 0;
          }
          CntReset++;
          if (CntReset > 65000) {
                   CntReset = 0;
                   CntAll = 0;
          }
          }
}
 
void Salita (void){
     Delay_ms(100);
        OUTGIU = 0;                      //spengo per sicurezza il motore GIU
        cnt = 0;                         //Azzero la variabile
        OUTSU = 1;                       //Accendo il motore SU
        Delay_ms(1000);
        if(PULSSU){
          while(PULSSU){
                  OUTSU = 1;
                  Delay_ms(10);
                  }
        }else{
            for(cnt = 0; cnt < ScattiMax; cnt++){  //Ciclo di pausa
                Delay_ms(100);
                if (PULSSU) {
                  goto FermaSalita;
                }
                if (PULSGIU) {
                  goto FermaSalita;
                }
            }
        }
        OUTSU = 0;                       //Spengo il motore SU
        FermaSalita:
        Delay_ms(200);
}
 
void Discesa (void){
        if (FINES == 0){
        Delay_ms(100);
        OUTSU = 0;                        //spengo per sicurezza il motore SU
        cnt = 0;                          //Azzero la variabile
        OUTGIU = 1;                       //Accendo il motore GIU
        Delay_ms(1000);
        if(PULSGIU){
          while(PULSGIU){
                  OUTGIU = 1;
                  Delay_ms(10);
          }
        }else{
 
            for(cnt = 0; cnt < ScattiMax; cnt++){  //Ciclo di pausa
                Delay_ms(100);
                if (PULSSU) {
                   goto FermaDiscesa;
                }
                if (PULSGIU) {
                   goto FermaDiscesa;
                }
                if (FINES == 1) {
                   goto FermaDiscesa;
                    }
                }
            }
        }else{
                  while(PULSGIU){
                  OUTGIU = 1;
                  Delay_ms(10);
                  }
          }
        OUTGIU = 0;                      //spengo il motore GIU
        FermaDiscesa:
        Delay_ms(200);
}
 
void Allarme (void){
 
for(cnt = 0; cnt < 20; cnt++){
     SEGNALA = 1;
     BUZZER = 1;
     if (TAPPA == TapAlla) {
          AntNormTap = 0;
     }
     Delay_ms(200);
     SEGNALA = 0;
     BUZZER = 0;
     Delay_ms(200);
}
for(cnt = 0; cnt < 255; cnt++){
     if (TAPPA == TapAlla) {
          AntNormTap = 0;
     }
     Delay_ms(100);
}
BUZZER = 0;
SEGNALA = 0;
Delay_ms(5000);
AntNormTap = 1;
}
 
void AntOff (void){
  cnt = 0;
  OUTGIU = 0;
  OUTSU = 0;
  for(cnt = 0; cnt < RitApert; cnt++){   //Ciclo di pausa
          Delay_ms(1000);
        }
  if(ANTI2 == 1){
            Salita();
     }
}
 
void AntOn (void){
  cnt = 0;
  OUTSU = 0;
  OUTGIU = 0;
  for(cnt = 0; cnt < RitApert; cnt++){   //Ciclo di pausa
          Delay_ms(1000);
        }
   if(ANTI2 == 0){
            Discesa();
     }
}

Il codice è molto semplice e tutto commentato, se avete dubbi potrete tranquillamente contattarmi. In allegato ho inserito tutti i file PCB Eagle , il programma della MikroC con l’assembler creato dalla MikroC e il codice sorgente.

AllegatoDimensione
File.zip285.61 KB

 

 

Scrivi un commento all'articolo esprimendo la tua opinione sul tema, chiedendo eventuali spiegazioni e/o approfondimenti e contribuendo allo sviluppo dell'argomento proposto. Verranno accettati solo commenti a tema con l'argomento dell'articolo stesso. Commenti NON a tema dovranno essere necessariamente inseriti nel Forum creando un "nuovo argomento di discussione". Per commentare devi accedere al Blog
ritratto di Bazinga

Sembra una naturale

Sembra una naturale espansione della centrale antifurto, ottimo lavoro.

ritratto di Emanuele

Antifurto Bentel e Domotica

Avendo progettato per anni nel settore della sicurezza antifurto attiva, mi ha molto interessato questo progetto, sia dal lato applicativo e da quello puramente tecnico.

Personalmente non mi è mai piaciuto il sistema di gestione linee di ingresso con l'antisabotaggio sulla stessa linea dell'allarme, ho sempre preferito la linea tamper separata dall'antifurto normale. Anche perche le linee le ho spesso realizzate con l'autoapprendimento, quindi la resistenza di carico poteva variare in un range, quindi anche linee molto lunghe e cavi maldimensionati, potevano essere sufficientemente rilevati, autoapprendendo anche la resistenza del cavo.
Questione di punti di vista :)

Anche il contaimpulsi per tapparella mi apre ai ricordi, appena possibile (e se lo ritrovo ancora :) posterò la schedina di controllo impulsi con il mitico contatore Johnson!

Complimenti per il progetto!

ritratto di Alex87ai

innanzitutto complimenti a

innanzitutto complimenti a Davidessss per il progetto...tuttavia Emanuele rispondo al tuo commento perché vorrei avere maggiori delucidazioni sulla tecnica dell'autoapprendimento delle linee, che se non ho capito male si basa sulla misura della resistenza dei cavi che portano alla centralina d'allarme...

ritratto di Emanuele

Autoapprendimento linee.

Ciao Alex,
si l'autoapprendimento si basa proprio sulla misura della resistenza.

A livello hardware si realizza una interfaccia di ingresso linea con un partitore resistivo che poi entra nel micro in un ingresso analogico (con ad converter).
Ovviamente se abbiamo centrali con molte linee si inserisce un 4051 in modo che si utilizzi un canale solo adconverter ogni 8 ingressi.

A livello firmware si memorizza la condizione di riposo (valore dell'ad converter) per poi generare allarme quando la variazione supera una certa soglia.
Si potrebbe anche includere la gestione antimanomissione all'interno dei valori dell'ad converter. Ma ho sempre preferito farla esternamente, con una linea dedicata (decisioni nate dopo riunioni con installatori di antifurto ed il commerciale)

ritratto di davidessss

hai ragione

ma ho fatto questa scheda per il mio appartamento e non volevo tirare troppi cavi per l'antifurto, anche perchè avevo intenzione in un prossimo futuro di collegare tutte le schede con l'rs485 e di inserire come master arduino. volevo poi collegarlo ad internet attraverso la ethernet arduino e creare una casa domotica con pagina web, avevo gia fatto le prove con la wii che visualizza perfettamente la pagina web di arduino, cosi dal divano potevo alzare o abbassare qualsiasi tapparella o accendere l'antifurto. Magari nel prossimo concorso parteciperò con questa idea.

 

 

Login   
 Twitter Facebook LinkedIn Youtube Google RSS

Chi è online

Ci sono attualmente 2 utenti e 57 visitatori collegati.

Utenti online

Ultimi Commenti