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.

STAMPA

6 Comments

  1. Bazinga 16 aprile 2012
  2. Emanuele 23 aprile 2012
  3. schat 8 ottobre 2014
  4. Alex87ai 23 aprile 2012
  5. davidessss 24 aprile 2012
  6. Emanuele 26 aprile 2012

Leave a Reply