Projet Alarme intrusion à boucle équilibrée

Bonsoir, Le projet n’a rien d’innovant mais je débute en arduino. Dans ma jeunesse j'ai fais de l'assembleur (dérivé de C/C++) et il me reste encore quelques notions.

Je réalise donc une alarme intrusion sur la base d' arduino méga (pour la carte mère) et de digicode sur la base du nano avec un bus I2C?

Il y aura 6 Zones: Périmétrique Volumétrique incendie

Cabane Garage Piscine

Il y aura plusieurs niveau d'utilisateurs: Maitre: Tous les droits de zone, ajout d'utilisateur... Utilisateur: Droits d'usage Utilisateur lite: Droit restreint (avec RFID)

Les élément terminaux, les BJ et le coffret de la centrale sont aux normes NFA2P.

Le câblage ainsi que le code pour les boucles sont ok.

Le digicode est en cours. Pour le moment, c'est lui qui détiens l'intelligence, mais je vais surement la migrer dans la centrale pour que plusieurs digicode puissent interroger une base unique.

Pour le moment, il me manque des éléments en commande afin d'avancer. Il va falloir également que je me penche sérieusement sur l'I2C et le RFID.

Quelques Photo du matériel:

Boite de raccordement

Radar:

Boitier pour la centrale (Alim, Mega, sortie relais)

Essai pour le digicode avec un uno:

Bonjour Zarb94,

Perso j'ai réalisé mon système d'alarme pour mon habitation a partir d'un arduino nano,

j'ai 3 zones en détection par détecteur double technologie et 1 zone via un read sur la porte d’entrée. Une sirène extérieur commandée via une sortie de l'arduino. Le verrouillage et déverrouillage du système ce fait via un petit logiciel installé sur mon gsm androide en wifi. j'avais commence un système avec un clavier codeur mais le programme commençais a être trop lourd donc la solution du gsm me paraissait plus simple a réaliser. L'application du gsm a été écrit a l'aide de App inventor. Le tous foctionne acuellement mais reste encore a améliorée.

Ton système est bien plus complexe et complet ;) Je suivrai ton poste avec interet et si je peut t'aider se sera avec plaisir.

Joel

Le système d'aplpli, c'est une bonne idée. Je n'y avais pas pansé. Il me fallait quelque chose de simple à utiliser et l'idée de coder un digicode me plaie. Un challenge. En tous cas, merci pour l’intérêt qu tu porte, je viendrai sans doute te demander des info sur ton appli en temps voulu.

J'ai reçu une partie du matériel qui constituera le digicode (il me manque le nano). Les choses sérieuses vont commencer!

J'ai vu un poste plus haut avec le résultat d'un teste du nextion écran tactile connexion série.

Sa me donne une idée d'interface utilisateur pour le système !!!.

Je connais ses système d'écran c'est très facile d'usage et ne consomme rien en mémoire du nano ;)

A voir !

Bonjour à tous

J'ai réalisé ce genre de montage qui fonctionne depuis plus d'un an, avec tout simplement un verrou à code 80 E sur la porte d'entrée. C'est un garage mais on peut avoir ça partout. Explication du système:

Une carte UNO avec un code tout simple qui balaye l'état de 5 capteurs, et une sirène 12 V en sortie. J'ai mis 3 niveaux de sorties avec 3 temps différents pour allumer la sirène. 30 ms, 5 sec et 1 mn

J'ai donc 2 PIR qui sont à chaque angle extérieur du garage, qui fait l'excitation niveau 1. (j'ai l'intention d'y mettre une carte vocale à enregistrement signalant "alarme activée") 1 contact en bout du verrou qui met l'alarme ON/OFF. 1 contact en bout de la gâche de la poignée de porte qui excite le niveau 2 (quand quelqu’un veut rentrer, il commence par tourner la poignée je pense.) 1 contact magnétique en ouverture en haut de la porte si la porte est forcée.

J'ai aussi une LED rouge en flash à l'extérieur. pour vérifier le bon fonctionnement de loin.

C'est tout simple et ça marche bien. C'est sur le secteur, pas encore de batterie, est ce nécessaire ? Le plus difficile est de fixer un contact mécanique ou ILS en bout du verrou ou de la gâche, j'ai un porte en bois qui fait 2 fois 1.10m de large, et il y a pas mal de dilatation suivant les saisons. Mais on peut améliorer tout ça avec des astuces, ex faisceau IR.

Voilà, si ce système peut intéresser quelqu'un !!!

Bonsoir toues le monde, J'avance bien sur le code du digicode. Un premier écran invite à taper le code, c'est alors que rentre en compte une base de donnée reprenant Les code utilisateur, Les Zones active et les droits de chacun. Une fois le code validé, un écran affiche l'état des 6 Zones et on peut modifier suivant ses droits.

La prochaine étape est un menu pour le code maitre qui permettra de modifier les droits de tous, d'ajouter des utilisateurs.

Bonjour,

Je ne sais pas si tu l'as remarqué, tu te trouves dans la rubrique des Réalisations et Projets FINIS. Ton "affaire" ne répond pas à cette définition, elle n'a donc rien à faire ici.

Merci de bien vouloir respecter les règles de ce forum. Sinon, la rubrique des Réalisations et Projets FINIS n'a plus aucun sens.

Dans cette rubrique "Réalisations et Projets FINIS", une réalisation doit fournir au minimum (c'est mon avis) : - Description sommaire, le détail pouvant se trouver dans les pièces jointes. - le programme.ino et bibliothèques particulières éventuelles - Le schéma de câblage associé En options, des photos et bla bla bla...

Cordialement.

Bonjour geryko, je suis désolé d'avoir posté ici. Dans quel rubrique du forum est il possible de présenter ma Réalisation en cours? Tu n'est pas juste quand tu parle de faire une 'description sommaire'. J'ai fais l'effort de présenter ce que je voulais faire. Pour ce qui est des photo, j'ai bien essayé d'en poster, mais il semble que le lien proposé par l'hébergeur ne fonctionne pas. Vu les autre Réalisation en cours que j'ai pu voir, les photos ne sont pas toujours présente. Quel est la méthode pour ajouter les photo? Comme ça, je mettrai un schéma de principe de mon projet.

Cordialement, Nicolas.

Voici mon code avec encore quelques bug:

Sa bug surtout sur la transmission I2C.

//##########################################################################
//#                          Centrale d'alarme                             #
//#                                                                        #
//#Nicolas P                                                               #
//#v1 Création le 16/09/2016                                               #
//##########################################################################

/*


  Zone1: Périmetrique        Entrée 14
  Zone2: Volumetrique        Entrée 15
  Zone2: Détection Incendie  Entrée 16 Fumée/ 17 Monoxyde
  Zone4: Cabanon             Entrée ND
  Zone5: Garage              Entrée ND
  Zone6: Piscine             Entrée ND

  BP: Aquitement             Entrée 8

  R1: Siréne Int             Sortie 12
  R1: Siréne Ext             Sortie 11
  R1: NC                     Sortie 10
  R1: NC                     Sortie 9

  Comunication en i2c:
  Digicode Arduino nano, afficheur lcd 20x4, Horloge

  Code fonction
  0xx Base de donnéé
  001 Zones Active
  002 Droit Maitre
  003 Droit Utilisateur
  004 Droit Utilisateur Lite
  ----------
  1xx GSM
  ----------
  2xx Carte SD
  ----------
  3xx Ethernet
  ----------
  4xx Horlogz
  401 Demande de l'heure



*/


//##########################################################################
//                              Variables
//##########################################################################

int valeur;        //Valeur relevé sur la boucle de détection en cours
String Etat;       //Etat litéral de l'entrée scannée
String EtatBack;   //EtatBack=Etat du cycle précedant
int Alarme = 0;    //Etat 0: ok, 1: siréne int (R1), 2: siréne int+rxt (R1+R2)
int Zone;          //numerot de la fonction a appeler

//Horloge
String horloge;    //contiens la date et l'heure 'jj/mm/aaaa hh:mm'
//horloge = String();
String Jour;
String Mois;
String Annee;
String Heur;
String Min;

//indice de boucle
int i;
int j;
int k;
int l;
int m;

//i2c
int adr;             //adresse du participant
String fonc;         //Fonction de la data a transmettre |
String data;         //data a transmettre                | constitue la trame
String Transfert;    //Fonc+data -> transfert
char Transfert2;     //transfert aprés convertion
String reception;    //Recu de l'eqclave
char reception2;

char c;

//##########################################################################
//                               Library
//##########################################################################

//--------------------------------------------------------------------------
//i2c
#include <Wire.h>
//--------------------------------------------------------------------------
//Horloge
#include <RTClib.h>
RTC_Millis RTC;
//--------------------------------------------------------------------------
//String
#include <string.h>    //Fonction sur les string

//##########################################################################
//                           Base de données
//##########################################################################

//--------------------------------------------------------------------------
//Table des droits

const byte Lignes = 5;                         //NB de lignes du tableau pouvant varier suivant le NB d'utilisateur

char Table[Lignes][8] =
{
  //Niv- Code,   Z1,  Z2,  Z3,  Z4,  Z5,  Z6
  
  {'4', '0000', '14','15','16','17','18','19'}, //Entrée phisique
  {'0', '0000', '0', '1', '1', '0', '0', '1'},  //Zones Active,état
  {'1', '1234', '1', '1', '1', '1', '1', '1'},  //Droit Maitre
  {'2', '4321', '1', '1', '0', '1', '1', '1'},  //Droit Utilisateur
  {'3', '5678', '1', '1', '0', '0', '0', '0'}   //Droit Utilisateur Lite
};

/*int Table[Lignes][8] =
{
  //Niv-Code,Z1,Z2,Z3,Z4,Z5,Z6
  {4, 0000, 14, 15, 16, 17, 18, 19}, //Entrée phisique
  {0, 0000, 0, 1, 1, 0, 0, 1},       //Zones Active,état
  {1, 1234, 1, 1, 1, 1, 1, 1},       //Droit Maitre
  {2, 4321, 1, 1, 0, 1, 1, 1},       //Droit Utilisateur
  {3, 5678, 1, 1, 0, 0, 0, 0}        //Droit Utilisateur Lite
};*/
//--------------------------------------------------------------------------


//##########################################################################
//                                Setup
//##########################################################################

void setup() {

  Serial.begin (9600);                      //Communication Série
  Wire.begin();                             //inicialise i2c comme maitre
  RTC.begin(DateTime(__DATE__, __TIME__));  //Date & Heure de la compilation
  Wire.begin();                             //join i2c bus

  //Zones
  pinMode(A0, INPUT);                       //Z1: Périmetrique
  pinMode(A1, INPUT);                       //Z2: Volumetrique
  pinMode(A2, INPUT);                       //Z3: DI Fumée
  pinMode(A3, INPUT);                       //Z3: DI Monoxyde

  //
  pinMode(13, OUTPUT);                      //Témoin Déclanchement

  //Sortie relais
  pinMode(12, OUTPUT);                      //R1: Siréne interieur
  pinMode(11, OUTPUT);                      //R2: Siréne exterieur
  pinMode(10, OUTPUT);                      //R3: Voyant Externe Vert/Rouge
  pinMode(9, OUTPUT);                       //R4:

  //Entrée
  pinMode(8, INPUT);                        //Aquitement

  //Pilote les sorties relais qui fonctionne à l'enver
  digitalWrite(9, HIGH);
  digitalWrite(10, HIGH);
  digitalWrite(11, HIGH);
  digitalWrite(12, HIGH);

}

code suite:

//##########################################################################
//                               Loop
//##########################################################################
void loop() {
  Scan();                          //Scan les zones: ligne 2, colone de 2 a 7 de 'Table'
  Serial.print("Action alarme: ");
  Serial.println(Alarme);
  al();                            //Vérifi si une action est requise
  Rtc();                           //Envoie l'heure sur le bus
  Dialogue();                      //Dialogue i2c avec les esclaves

  //delay(1000);
}


//##########################################################################
//                             Fonction
//##########################################################################


//--------------------------------------------------------------------------
//Zone a Proteger
//Scan les zones: ligne 2, colone de 2 a 7 de 'Table'

int Scan()
{
  Serial.println("");
  for (i = 2; i < 8; i++)         //i=colone
  {
    Serial.print("num zone: ");
    Serial.print(i - 1);
    Serial.print(" Scan? ");
    Serial.println(Table [1] [i]);
    if (Table [1] [i] == '1')
    {
      switch (i - 1)
      {
        case 1:                   //Colone 2
          Zone = Z1();
          break;
        case 2:                   //Colone 3
          Zone = Z2();
          break;
        case 3:                   //Colone 4
          Zone = Z3();
          break;
        case 4:                   //Colone 5
          Zone = Z4();
          break;
        case 5:                   //Colone 6
          Zone = Z5();
          break;
        case 6:                   //Colone 7
          Zone = Z6();
          break;
      }
      //Retourne Alarme 0=ok, 1=RL1, 2=RL1&2
    }
  }

}

//--------------------------------------------------------------------------
//Alarme
int al()
{
  if (digitalRead(8) == 1)       //BP Aquitement
  {
    Serial.println("            Aquitement");
    EtatBack = Etat;
    Alarme = 0;
    delay(4000);
  }
  Serial.print("Action: ");
  Serial.println(Alarme);
  switch (Alarme)
  {
    case 0:                        //Aquitement
      digitalWrite(12, HIGH);
      digitalWrite(11, HIGH);
      digitalWrite(13, LOW) ;
      Etat = "";
      break;
    case 1:                       //Siréne int
      digitalWrite(12, LOW);
      break;
    case 2:                       //Siréne int & ext
      digitalWrite(12, LOW);
      digitalWrite(11, LOW);
      break;
  }
  Serial.print("Etat avant test: ");
  Serial.println(Etat);
  Serial.print("Etat back: ");
  Serial.println(EtatBack);

  if (EtatBack != Etat && Alarme != 0)
  {
    Serial.print(Rtc() + " " + Etat);
    EtatBack = Etat;
  }
}

//--------------------------------------------------------------------------
// Zone Périmetrique Z1
int Z1 ()
{
  Serial.println("Z1 Perimetrique:");
}

//--------------------------------------------------------------------------
// Zone Volumetrique Z2
int Z2 ()
{
  Serial.println("Z2 Volumetrique:");
  int valeur = analogRead (A1);

  if (valeur == 0 && valeur < 10)           //Ok Vert
  {
    digitalWrite(13, LOW) ;
    Serial.println("");
  }
  else
  {
  }
  if (valeur > 507 && valeur < 517)        //Ap Jaune
  {
    digitalWrite(13, HIGH) ;
    Serial.println("Autoprotection Volumetrique");
    Etat = "Autoprotection Volumetrique";
    Alarme = 1;
  }
  if (valeur > 579 && valeur < 589)        //Al+Ap Rouge et Jaune
  {
    digitalWrite(13, HIGH);
    Serial.println("Detection et Autoprotection Volumetrique");
    Etat = "Detection et Autoprotection Volumetrique";
    Alarme = 2;
  }
  if (valeur > 246 && valeur < 256)        //Al Rouge
  {
    digitalWrite(13, HIGH) ;
    Serial.println("Detection Volumetrique");
    Etat = "Detection Volumetrique";
    Alarme = 2;
  }
}

//--------------------------------------------------------------------------
// Zone Incendie Z3
int Z3 ()
{
  Serial.println("Z3 Incendie:");
  //-------------------------MQ2-------------------------------
  //Fumée
  valeur = analogRead(A2);     //Entrée détection fumée
  //Serial.println(valeur);      //Valeur lu par le détecteur
  if (valeur > 320)            //Niveau valeur limite a définir
  {
    digitalWrite(13, HIGH);
    Serial.println("Fumee: Limite haute!");
    Etat = "Alarme Feu";
    Alarme = 1;
  }
  //-------------------------MQ7-------------------------------
  //Monoxyde
  valeur = analogRead(A3);        //Entrée détection Monoxyde
  //Serial.print("Valeur Co2: ");
  //Serial.println(valeur);
  //Serial.print("Limite ");
  if (valeur > 350)               //Niveau valeur limite a définir
  {
    digitalWrite(13, HIGH);
    Serial.println("Monoxyde: Limite haute!");
    Etat = "Alarme Monoxyde";
    Alarme = 1;
  }
}

//--------------------------------------------------------------------------
// Cabanon
int Z4()
{
  Serial.println("Z4 Cabanon:");
}

//--------------------------------------------------------------------------
// Garage
int Z5()
{
  Serial.println("Z5 Garage:");
}

//--------------------------------------------------------------------------
// Piscine
int Z6()
{
  Serial.println("Z6 Piscine:");
}
//--------------------------------------------------------------------------
//Horloge
int Rtc()
{
  DateTime now = RTC.now();
  Jour = now.day();
  Mois = now.month();
  Annee = now.year();
  Heur = now.hour();
  Min = now.minute();

  horloge = Jour + '/' + Mois + '/' + Annee + ' ' + Heur + ':' + Min;
  Serial.println(horloge);



  return;
}
//--------------------------------------------------------------------------
//Transfert
int Transferts(String Transfert)
{
  char Transfert2 [Transfert.length() + 1];                // tableau de char de la taille du String Transfert+1 (caractère de fin de ligne)
  Transfert.toCharArray(Transfert2, Transfert.length() + 1);    // récupère Transfer2 dans le tableau de char

  Serial.print("Transfert: ");
  Serial.println(Transfert2);

  Wire.beginTransmission(adr); // transmettre a l'esclave #10
  Wire.write(Transfert2);      // envoie l'heure
  Wire.endTransmission();      // arrêter la transmission
  Serial.print("Transfert ok");
}

//--------------------------------------------------------------------------
//Ecoute
String Ecoute()                // retourne un string
{
  Wire.requestFrom(10, 3);     // recois 3 char de l'eslave #10

  l = Wire.available();
  char reception2[3];

  while (Wire.available())

  { delay(100);
    char c = Wire.read();     // receive un char
    m = Wire.available();
    m = l - m - 1;

    reception2[m] = c;


  }
  String reception = String(reception2); 

  return reception;
}

//--------------------------------------------------------------------------
//
int Dialogue()
{
  String reception = Ecoute();
  Serial.print("Ecoute: ");
  Serial.println(reception); //
  if (reception == "401") //Donne l'Heure
  { Serial.println("reception=='401' alors Transmet l'heure");
    adr = 10;
    Transfert = horloge;
    Transferts(Transfert);
  }

  if (reception == "001")       //Donne les zones Active
  {
    Serial.println("reception=='001' alors Transmet les zones Active");
    adr = 10;
    for (i=2;i==7;i++)          //i=colone de zone
    {
      Transfert = Table[1][i];
    Serial.println(Transfert);
    Transferts(Transfert);
    }
    
  }

}


//--------------------------------------------------------------------------

//############################### END ######################################

[/code]

Bonjour,
J’avance toujours, j’ai trouvé une parade a mon problème sur l’i2c. Au fur et à mesure du développement, je me rend compte que la clé de tout ça réside dans le dialogue i2c. C’est pourquoi, au début déjà j’avais mis en place un système de code à 3 chiffre qui servaient d’aiguillage en quelque sorte. après réception de ce code venaient les données.
Maintenant le codage à évolué:

Protocole de communication:

Type: Tableau de char
Syntax: ‘x x x x x x’
| | | | | |
La classe <-+ | | | | |
Lecture/ecriture <----+ | | | |
| | | |
Demande <-------±±±+


0xxxxx Base de donnéé

Chiffre des dixaine: 0->5 num de la ligne demandée
Chiffre des unité: 0->7 num de la colone demandée

1xxxxx GSM

2xxxxx Carte SD

3xxxxx Ethernet

4xxxxx Horloge

5xxxxx Dialogue interne
Syntax: ‘x x x x x x’
| | |
Scan <-+ | |
Num de la zone <-+ |
Type d’alarme <-+

Tout ceci va évoluer au niveau de chaque classe au fil du développement.

Bonjour, J'ai créé un tableau excel avec les codage car ça commence à devenir compliqué. Maintenant que l'i2c est ok, j'ai ajouté une fonction supplémentaire: Un enregistrement au fil de l'eau horodaté des évènements:

  • Démarrage des éléments
  • Identification utilisateur
  • Mise en/hors
  • Déclanchement
  • Alarme Technique (défaut secteur, Niveau battrerie bas...)

Maintenant, je suis sur la partie GSM pour la trans mission d'alarme.

Il faut que je me panche sur la partie alarme technique:

  • Autoprotection Centrale
  • Autoprotection Digicode
  • Autoprotection des capteurs
  • Rupture Bus
  • Défaut Secteur
  • Défaut batterie
  • Défaut 12v
  • Défaut 9v

Je vais également faire un diagramme fonctionnel.

Bonsoir, J'avance toujours sur mon projet. J'attends encore quelques elemments et notamment un transfo 12/9v pour toute la partie arduino. Je ne souhaite pas l'alimenter en 12v. J'ai quand même consacré mon dimanche à agencer et cabler le coffret de la centrale. Ce n'est pas encore terminé, mais ça commence à prendre forme.

|500x281

bonsoir, Je viens donner quelques nouvelles sur mon projet. Comme tous débutant, je galère pas mal et notamment sur la com. Au départ, je partais sur de l'i2c, puis finalement, ce sera du Serial.

La centrale: Sur la carte SD dans la centrale: J'utilise une base de donnée ou on peux trouver: Le type d'utilisateur avec les droits sur chaque zones (niveau d’habilitation) Les code d’accès (max5) avec leurs niveau d'habilitation Les RFID (max5) avec leurs niveau d'habilitation Les numéro de téléphone (max5) pour l'envoie de SMS Les nom de zone (texte clair) Les code alarme et alarme technique avec leurs texte clair

Cette base fait le lien entre le digicode et la centrale elle est donc consulté en permanence par les 2 parties.

Nous trouvons également le Fil De l'eau ou est consigné tous les évènements

Plus tard, il y aura des interaction avec le KNX de la maison avec le module de sortie en bas à droite ainsi qu'un module d'entrée (pas encore installé)

Le digicode: De loin le plus complexe des éléments (par rapport à l’intelligence, la gestion de l'affichage, les validation de code d’accès). Ici aussi, quelques changements, je suis passé du Nano à un Uno. Il est presque terminé. L'arborescence des menu est stocké dans une structure de 33 ligne de 8 éléments. Sur chaque ligne, on trouve: La page, la position du curseur sur le LCD, la page de destination, la touche attendue, le code alarme, l'action associée, le texte clair à afficher. |500x281

salut , stp comment vous avez fait pour la lecture de la boucle equilibree du radar ?