Horloge pour système d'alarme Diagral et simulation de présence

In: ELECTRONIQUE PRATIQUE AVEC L'ARDUINO On: Comment: 0 Hit: 763

L'objectif de ce Tuto est de vous donner des pistes pour automatiser votre système d'alarme Diagral:

  • vous aimeriez une mise en route automatique à des jours et heures prédéfinies ?
  • et/ou faire de la simulation de présence ?

Lisez la suite !

Petite parenthèse auparavant: de nombreuses autres réalisations peuvent être envisagées avec une carte Arduino munie de son horloge, par exemple déconnecter régulièrement l'alimentation de certains équipements (économies d'énergie), ou plus brièvement certains autres comme une Box Adsl qui "planterait de temps en temps", ce qui vous permettrait de ne pas perdre la main pour des applications domotiques à distance.

Ces exemples peuvent d'ailleurs se rajouter à l'application prévue ici puisque notre carte Arduino possède beaucoup de ressources !

A ce jour (février 2018), un produit "tout-fait" pour réaliser ce projet n'existe pas. Mais ce n'est pas bien compliqué à réaliser ! Pas besoin de s'appeler Mac Gyver. On peut y parvenir sur le même principe que des Lego ou Meccano, mais avec des modules électroniques.

C'est, je crois, à la portée d'un enfant de 12 ans, à condition d'être attiré par l'informatique et les technologies actuelles; on les retrouve absolument partout, que ce soit dans la machine à laver, le drône que vous avez reçu à Noël, ou la fusée Ariane.

Nous allons avancer pas à pas, histoire de n'effrayer personne !

Pour commencer, il nous faut:

  • un ordinateur (Mac ou PC)
  • une carte Arduino Mega 2560 et son câble Usb
  • un module RTC (c'est une petite horloge à pile)

Ces 2 derniers vous coûteront environ 20 € (en tout).

Nous supposons que vous savez installer le logiciel Arduino et connecter la carte Mega 2560 sur votre ordinateur (le pilote nécessaire s'installe en principe automatiquement).

Vérifiez, en cas de soucis, que le bon port de communication avec votre ordinateur est sélectionné (menu Outils) et que la bonne carte est sélectionnée (Mega 2560).

Utilisation du module horloge DS3231

vérifiez dans votre logiciel Arduino qu'il possède la bibliothèque DS3231. C'est dans sa version 1.02 que nous l'utilisons. Elle n'y est pas par défaut, il faut donc télécharger le .zip correspondant puis le charger (Menu Croquis, inclure une bibliothèque). Vous trouverez cette bibliothèque sur le site Arduino.

Connectez le module horloge sur la carte Arduino; il faut 4 fils: 0V et 5V pour l'alimentation, et les 2 fils pour le port de communication (SCL et SDA)

  • Copiez/collez le script suivant dans votre logiciel.
  • Affichez le moniteur série (Menu Outil)
  • et transférez le programme sur la carte.

Le programme s'exécute après son chargement; son seul rôle est d'enregistrer l'heure et la date dans votre module horloge. On affiche ensuite, en boucle toutes les secondes, les dates, heures et températures récupérées sur cette même carte horloge DS3231.

On affiche aussi la date et l'heure à laquelle vous avez compilé votre programme. Vous pourriez très bien les utiliser pour enregistrer la date et l'heure dans votre DS3231, mais il faut d'abord faire une gymnastique pour transformer ces valeurs "chaînes de caractères" en nombres (heures, minutes, etc). C'est probablement du travail inutile puisque vous n'avez besoin de mettre à jour votre horloge que lorsque vous enlevez sa pile de sauvegarde.

Le programme est commenté...

#include <Wire.h>      //il faut inclure la bibliothèque qui permet d'utiliser le port de communication I2C
#include "DS3231.h"    //il faut inclure la bibliothèque de sous-programmes pour notre module horloge

DS3231 Horloge;        // on dédinit la variable Horloge qui est du type DS3231
String HeureCompilation=((__TIME__)); //on recueille l'heure de compilation de ce programme  // on récupère l'heure puis la date de compilation (optionnel)
String DateCompilation=((__DATE__));  // on récupère la date de compilation de ce programme

int heures=14;   // on définit des variables (int = nombres entiers) et on leur attribue les bonnes valeurs (date et heure)
int minutes=30;
int secondes=00;
int jour=21;
int mois=2;
int annee=18;
int temperature;

bool h24;
bool PM;
bool Century=false;

void setup () {
    Serial.begin(9600);   // initialisation du port série
    Wire.begin();         // initialisation du port I2C

    Horloge.setSecond(secondes);   // on utilise les sous-programme de notre bibliothèque DS3231 pour programmer date et heure dans le module
    Horloge.setMinute(minutes);
    Horloge.setHour(heures);
    Horloge.setDate(jour);
    Horloge.setMonth(mois);
    Horloge.setYear(annee);
}

void loop () {   // on va récupérer date, heure et température dans notre horloge, puis les afficher
 
    secondes=Horloge.getSecond();
    minutes=Horloge.getMinute();
    heures=Horloge.getHour(h24,PM);
    jour=Horloge.getDate();
    mois=Horloge.getMonth(Century);
    annee=Horloge.getYear();
    temperature=Horloge.getTemperature();
    
    Serial.print(jour,DEC);
    Serial.print("-");
    Serial.print(mois,DEC);
    Serial.print('-');
    Serial.print("20");
    Serial.print(annee,DEC);

    Serial.print(' ');
    Serial.print(heures,DEC);
    Serial.print(':');
    Serial.print(minutes,DEC);
    Serial.print(':');
    Serial.print(secondes,DEC);

    Serial.print(" - Température: ");
    Serial.println(temperature,DEC);

    Serial.println(DateCompilation);
    Serial.println(HeureCompilation);

    delay(1000);  // pause de 1 seconde et on recommence la boucle
}

Voilà, ce programme nous aura surtout été utile pour programmer la date et l'heure courantes sur notre module DS3231. A relancer si vous enlevez sa pile !

Nous allons pouvons maintenant créer des automatismes en fonction de la date et de l'heure. Le module horloge DS3231 peut gérer 2 alarmes, mais nous n'utiliserons pas ces fonctions.

Notre objectif est de pouvoir contrôler une petite télécommande Diagral DIAG43ACK, capable de gérer 4 fonctions alarme + 4 fonctions de confort (commande de lumières ou d'appareils électriques en général); il est d'ailleurs possible, avec une seule action, de commander plusieurs récepteurs Diagral (donc plusieurs appareils électriques, volets ou éclairages différents); pour cela, il suffit de consulter la notice de la télécommande et de l'associer aux récepteurs désirés.

Pour se greffer sur une télécommande, nous n'allons pas créer un robot qui appuiera sur les touches de la télécommande (c'est faisable, mais plus long et plus cher à réaliser), mais juste connecter sur chaque bouton poussoir (les 4 principaux + 1 des boutons latéraux pour l'accès aux fonctions secondaires) un petit transistor et une résistance (quelques centimes)

Cette étape nécessite un petit fer à souder (avec une pointe fine !). Mais pas d'inquiétude, c'est simple.

  • Ouvrez la télécommande comme si vous deviez changer ses piles.
  • Au préalable, faites-là au minimum reconnaître par votre centrale d'alarme et/ou un récepteur quelconque (éclairage, volet, prise, etc...)
  • sortez la petite carte électronique de son logement
  • plus besoin des piles, nous allons brancher la télécommande sur le 0 et -5V de la carte Arduino (le plus simple est de souder 2 fils à l'arrière de la carte arduino et sur les contacts de la télécommande) -> voir photo

Arduino, horloge DS3231 et télécommande Diagral DIAG43ACK

Pour connecter une sortie de la carte Arduino vers un premier bouton poussoir de notre télécommande, il faut réaliser une toute petite interface électronique afin de ne pas perturber le fonctionnement normal de la télécommande (notamment les tensions qui sont légèrement différentes. Il faut un transistor NPN courant (nous avons pris un PN2222. sa patte du milieu est connectée à la sortie 2 de l'Arduino à travers une résistance d'environ 3,3 KOhms. Le collecteur et l'émetteur du transistor sont reliés au bouton poussoir (le sens n'est pas indifférent, sinon ça ne fonctionnera pas).

Dans le programme qui suit, nous voulons que chaque jour, à une certaine heure (heure + minute), une action soit générée. Nous en avons défini trois (1 fonction MARCHE pour l'alarme, 1 fonction ARRET et une fonction ALLUMAGE LUMIERES). Pour cette dernière, il faudra d'abord "appuyer" sur le bouton latéral, puis sur la touche 1 de la télécommande.

Nous utilisons les sorties 2 à 6 de la carte Arduino (la photo et le programme ne représentent que le câblage et les routines pour la gestion de la touche 1 et d'une touche latérale; il vous sera très facile de l'étendre à la totalité de la télécommande !

Vous pouvez aussi supprimer les lignes qui envoient l'heure et des commentaires sur le port série (le moniteur série de votre logiciel Arduino).

Ceux qui possèdent une centrale Diagral DIAG91 ainsi que le Box Alerte et Pilotage DIAG56AAX pourront, sur leur application e-One (sur Smartphone), vérifier l'état des éclairages. De même, ils peuvent recevoir les messages de mise en marche et d'arrêt de leur système d'alarme.

Conclusions:

Notre même carte Arduino ainsi que notre programme pourront gérer d'autres choses en même temps !

Quelques exemples:



//
// www.1ou2clics.com - France

#include <Wire.h>      //il faut inclure la bibliothèque qui permet d'utiliser le port de communication I2C
#include "DS3231.h"    //il faut inclure la bibliothèque de sous-programmes pour notre module horloge

DS3231 Horloge;        // on définit la variable Horloge qui est du type DS3231

int heures;   // on définit des variables (int = nombres entiers) et on leur attribue les bonnes valeurs (date et heure)
int minutes, secondes, jour, mois, annee;

bool h24;
bool PM;
bool Century=false;
String DateHeure;

int POUSSOIR1=2; //on affecte un nom à la broche 2 de notre carte Arduino (sortie pour commander le bouton poussoir 1 de la télécommande Diagral)
int POUSSOIRbis=6;  // bouton poussoir latéral de la témécommande

// on définit ici nos alarmes journalières (tous les jours de la semaine, à une certaine heure + minutes, on réalise une action

String HeureArret1="13:48";
String HeureMarcheTotale1="12:16";
String HeureLumiere1="13:49";

int HA1, HMT1, HL1;  // des variables pour nos actions journalières

void setup () {
    Serial.begin(9600);   // initialisation du port série
    Wire.begin();         // initialisation du port I2C
    pinMode(POUSSOIR1, OUTPUT); //met la broche 2 en sortie
    pinMode(POUSSOIRbis, OUTPUT);

// on va convertir l'heure programmée pour l'action journalière en minutes (heures*60 + minutes) 
    HA1 = ((HeureArret1.substring(0,2)).toInt())*60 + ((HeureArret1.substring(3,5)).toInt()); 
    HMT1 = ((HeureMarcheTotale1.substring(0,2)).toInt())*60 + ((HeureMarcheTotale1.substring(3,5)).toInt());  // on convertit l'heure programmée pour l'action journalière en minutes (heures*60 + minutes) 
    HL1 = ((HeureLumiere1.substring(0,2)).toInt())*60 + ((HeureLumiere1.substring(3,5)).toInt());  // on convertit l'heure programmée pour l'action journalière en minutes (heures*60 + minutes) 
    }

// nos 3 sous-programmes pour les actions à réaliser:
void MarcheTotale() {
    Serial.print(DateHeure);
    Serial.println("Marche Totale");
    }

void Arret() {
    digitalWrite(POUSSOIR1, HIGH);
    Serial.print(DateHeure);
    Serial.println("Arrêt");
    delay(500);
    digitalWrite(POUSSOIR1, LOW);
    }

void LumieresBouton1() {
    digitalWrite(POUSSOIRbis, HIGH);
    Serial.print(DateHeure);
    Serial.println("Lumière bureau");
    delay(200);
    digitalWrite(POUSSOIRbis, LOW);
    delay(50);
    digitalWrite(POUSSOIR1, HIGH);
    delay(500);
    digitalWrite(POUSSOIR1, LOW);
    }

void loop () {   // on va récupérer date, heure et température dans notre horloge, puis les afficher
 
    secondes=Horloge.getSecond();
    minutes=Horloge.getMinute();
    heures=Horloge.getHour(h24,PM);
    jour=Horloge.getDate();
    mois=Horloge.getMonth(Century);
    annee=Horloge.getYear();

    DateHeure = "Le ";
    DateHeure.concat(jour);
    DateHeure.concat("/");
    DateHeure.concat(mois);
    DateHeure.concat("/20");
    DateHeure.concat(annee);
    DateHeure.concat(" à ");
    DateHeure.concat(heures);
    DateHeure.concat(":");
    DateHeure.concat(minutes);
    DateHeure.concat(" -> ");
   
// on calcule l'heures en 'minutes passées dans la journée'
// du coup il sera plus simple de comparer l'heure actuelle avec l'heure programmée pour les actions

    int MinDuJour = heures*60+minutes;

    if (MinDuJour==HMT1 & secondes==0) {   // on ne réalise l'action qu'à la première seconde
    }
 
    if (MinDuJour==HA1 & secondes==0) {
    Arret();
    }

    if (MinDuJour==HL1 & secondes==0) {
    LumieresBouton1();
    }

    delay(1000);  // pause de 1 seconde et on recommence la boucle
}

Commentaires

Leave your comment