Ready to go Arduino prog template. Only needs io mapping and logic customization.HEADmaster

2 files changed, 515 insertions, 0 deletions

diff --git a/ecl_maison.ino b/ecl_maison.ino
new file mode 100644
index 0000000..c28112f
--- /dev/null
+++ b/ecl_maison.ino
@@ -0,0 +1,481 @@
+#include <SPI.h>
+#include <EEPROM.h>
+#include <Ethernet.h>
+#include <EthernetUdp.h>
+#include <WebServer.h>
+
+/**************
+ * PARAMETRES *
+ **************/
+// Declaration des lignes, boutons, IO et enums associés
+#include "io_declarations.h"
+// Doit etre dans un fichier séparé car les prototypes des fonctions du fichier .ino
+// sont générés automatiquement et placés au dessus des déclarations des enums sinon.
+
+// Activation debug (1 = oui, 0 = non)
+#define DEBUG_VIA_SYSLOG 0
+#define DEBUG_VIA_SERIAL 0
+
+// Définition de la sortie pour la LED de statut (13 = LED soudée sur l'arduino)
+#define STATUS_LED 13
+
+// Paramètres Syslog  (ip/port du serveur syslog-ng)
+static uint8_t ip_debug[] = { 192, 168, 1, 10 };
+static uint16_t port_debug = 514; 
+
+// Paramètres Ethernet (mac et ip locales pour serveur web)
+static uint8_t mac[] = { 0xFE, 0xED, 0xDE, 0xAD, 0xBE, 0xEF };
+static uint8_t ip[] = { 192, 168, 1, 178 };
+
+// Paramètres détection alea
+#define ALEA_NB_APPELS_MAX 20
+#define ALEA_FENETRE_MILLIS 10000 // 5 secondes
+#define ALEA_BLOQUAGE_MILLIS 60000 // 1 minute
+
+// Pamètres détection entrées
+#define DUREE_MIN_BOUTON_PRESSE 50 // millisecondes
+
+// Paramètres WebServer
+#define PREFIX ""
+#define NAMELEN 32
+#define VALUELEN 32
+
+// Paramètres persistance
+#define EEPROM_BASE_ADDR_DATA 15
+#define CHECKSUM_INIT 10
+#define CHECKSUM_INVALID 0xFF
+#define CONSIGNE_PAR_DEFAUT HIGH
+
+/******************
+ * OBJETS GLOBAUX *
+ *****************/
+WebServer webserver(PREFIX, 80); // Serveur Web
+EthernetUDP Udp; // Socket UDP pour debug Syslog
+
+static uint8_t etat_entrees[NUM_ENTREES]; // Etat actuel des entrées
+static unsigned long millis_precedent_front_descendant[NUM_ENTREES]; // Stockage timing pour filtrage des entrées
+static uint8_t consigne_sorties[NUM_SORTIES]; // Consignes à appliquer sur les sorties
+
+
+/************************
+ * ROUTINES PRINCIPALES *
+ ************************/
+// Initialisation de l'ensemble des composants
+void setup(){
+  Ethernet.begin(mac, ip);
+  log_init();
+  webserver_setup();
+
+  // Restaurer de l'EEPROM les consignes et positionner les bascules D des pins de sortie
+  // N'applique pas la tension de sortie immédiatement car le paramètrage des pin en OUTPUT n'est pas encore fait
+  charger_consignes();
+  appliquer_consignes(false);
+
+  // Paramétrer le mode de toutes les pins utilisées en entrée
+  for (int i=0; i<NUM_ENTREES; i++){ 
+    etat_entrees[i]=HIGH;
+    millis_precedent_front_descendant[i]=0;
+    pinMode(pin_entrees[i], INPUT_PULLUP);
+  }
+  
+  // Paramétrer le mode de toutes les pins utilisées en sortie
+  for (int i=0; i<NUM_SORTIES; i++){ 
+    pinMode(pin_sorties[i], OUTPUT);
+  }
+  
+  // Flasher 10 fois rapidement  la LED de l'arduino pour signaler la fin de l'initialisation
+  digitalWrite(STATUS_LED, LOW);
+  pinMode(STATUS_LED, OUTPUT);
+  int v = HIGH;
+  for (int i=0; i<20; i++) {
+    digitalWrite(STATUS_LED, v);
+    delay(100);
+    v = !v;
+  }
+}
+
+// Boucle principale de fonctionnement
+void loop(){
+  // Traiter les requêtes web
+  webserver.processConnection();
+
+  // Lire les entrées
+  entree_t evenement_entree = lire_entrees();
+
+  // Si un évènement est détecté...
+  if ( evenement_entree != -1 ) {
+    // Modifier les consignes en conséquence
+    modifier_consignes(evenement_entree);
+    // Appliquer les consignes sur les sorties
+    appliquer_consignes(false);
+  }
+}
+
+
+/**************************************************
+ * Logique d'action des entrées sur les consignes *
+ **************************************************/
+void modifier_consignes(entree_t evenement_entree) {
+    switch ( evenement_entree ) {
+
+      case bt_test_arduino:
+        consigne_sorties[led_arduino] = (consigne_sorties[led_arduino]==HIGH)?LOW:HIGH;
+        break;
+
+      case bt_ext_cote_rue:
+        consigne_sorties[rl_ecl_ext_jardin] = (consigne_sorties[rl_ecl_ext_jardin]==HIGH)?LOW:HIGH;
+        break;
+
+    }
+}
+
+
+/***************
+ * SERVEUR WEB *
+ ***************/
+// Définition de l'opérateur << pour envoyer facilement des chaînes de caractères vers le client web
+template<class T> inline Print &operator <<(Print &obj, T arg) { obj.print(arg); return obj; }
+
+// Code gérant la réponse à la requête HTTP permettant d'afficher l'état des consignes
+void servlet_list(WebServer &server, WebServer::ConnectionType type, char *url_tail, bool tail_complete) {
+  server.httpSuccess();
+
+  server << "<!DOCTYPE html>";
+  server << "<html>";
+  server << "<head><title>Domotique étage</title>";
+  server << "<style type=\"text/css\">";
+  server << "input{ width: 100px; height: 35px; border: solid 1px #000000; color: #000000; }";
+  server << ".on{ background: #a7ffa5; }";
+  server << ".on:hover{ background: #ffa8a8; }";
+  server << ".off{ background: #ffa8a8; }";
+  server << ".off:hover{ background: #a7ffa5; }";
+  server << "</style>";
+  server << "</head>";
+  server << "<body>";
+  server << "<h1>Domotique étage</h1>";
+  server << "<table>";
+
+  sortie_t empty = (sortie_t) -1;
+  // Salon
+  html_tr_6_sorties(server, led_arduino, rl_ecl_ext_jardin, empty, empty, empty, empty);
+  //html_tr_6_sorties(server, rl_sal_spot_left, empty, rl_sal_ecl_plaf, empty, rl_sal_spot_right, empty);
+  //html_tr_6_sorties(server, empty, rl_sam_gu10_1, rl_sam_gu10_3, rl_sam_gu10_5, empty, empty);
+  //html_tr_6_sorties(server, empty, empty, rl_sam_gu10_2, rl_sam_gu10_4, empty, empty);
+  //html_tr_6_sorties(server, empty, empty, empty, empty, rl_sas_gu10_left, empty);
+  //html_tr_6_sorties(server, rl_sam_pc_left, empty, empty, empty, rl_sas_gu10_right, rl_sas_ecl_plaf);
+  //html_tr_6_sorties(server, empty, empty, rl_cuis_gu10_2, rl_cuis_gu10_1, empty, rl_coul_plaf);
+  //html_tr_6_sorties(server, empty, rl_cuis_ecl_evier, empty, rl_cuis_ecl_plaf, empty, empty);
+
+  server << "</table>";
+  server << "</body>";
+  server << "</html>";
+}
+
+// Formattage d'une case de tableau
+void html_td_sortie(Print &p, sortie_t s) {
+  if ( s == -1 ) {
+    p << "<td>&nbsp;</td>";
+  } else {
+    p << "<td>";
+    p << "<input type=\"button\" value=\"" << desc_sorties[s] << "\" ";
+    p << "class=\"" << ( consigne_sorties[s]==HIGH ? "off" : "on") << "\" ";
+    p << "onclick=\"document.location = '/set?" << s;
+    p << "=" << ( consigne_sorties[s]==HIGH ? "0" : "1") << "'; return false;\" />";
+    p << "</td>";
+  }
+}
+
+// Formattage d'une ligne de tableau à 6 colonnes
+void html_tr_6_sorties(Print &p, sortie_t s1, sortie_t s2, sortie_t s3, sortie_t s4, sortie_t s5, sortie_t s6) {
+  p << "<tr>";
+  html_td_sortie(p, s1);
+  html_td_sortie(p, s2);
+  html_td_sortie(p, s3);
+  html_td_sortie(p, s4);
+  html_td_sortie(p, s5);
+  html_td_sortie(p, s6);
+  p << "</tr>";
+}
+
+// Code gérant la réponse à la requête HTTP permettant de modifier l'état d'une consigne
+void servlet_set(WebServer &server, WebServer::ConnectionType type, char *url_tail, bool tail_complete) {
+  URLPARAM_RESULT rc;
+  char name[NAMELEN]; int name_len;
+  char value[VALUELEN]; int value_len;
+
+  if (type == WebServer::HEAD) return;
+
+  while (strlen(url_tail)) {
+    rc = server.nextURLparam(&url_tail, name, NAMELEN, value, VALUELEN);
+    if (rc != URLPARAM_EOS) {
+      int key = strtoul(name, NULL, 10);
+      int val = strtoul(value, NULL, 10);
+      if ( key >= 0 && key < NUM_SORTIES ) {
+        consigne_sorties[key] = (val==1)?HIGH:LOW;
+      }
+    }
+  }
+  appliquer_consignes(true);
+  server.httpSeeOther(PREFIX "/");
+}
+
+// Initialisation et paramétrage du serveur Web
+void webserver_setup() {
+  webserver.begin();
+  webserver.setDefaultCommand(&servlet_list);
+  webserver.addCommand("set", &servlet_set);
+}
+
+/**********************
+ * I/O ET PERSISTENCE *
+ **********************/
+/* Lit les valeurs de consigne_sorties[] et :
+    - met à jour l'état des bascules de la sortie (pin) correspondante
+    - écrit cet état dans l'EEPROM
+
+  forcer : permet d'outrepasser le temps de pause en cas d'une précédente détection d'aléa (cf protection_alea())
+*/
+void appliquer_consignes(boolean forcer) {
+  uint8_t checksum ;
+  int i;
+
+  if (!protection_alea() && !forcer) return;
+
+  // Invalide les infos stockées dans l'EEPROM
+  EEPROM.write(EEPROM_BASE_ADDR_DATA, CHECKSUM_INVALID);
+
+  log_begin_line();
+  log_print("appliquer_consignes() : Sorties ");
+  checksum = CHECKSUM_INIT;
+  for (i=0; i<NUM_SORTIES; i++) {
+    digitalWrite(pin_sorties[i], consigne_sorties[i]);
+    if ( consigne_sorties[i] ) checksum++;
+    EEPROM.write(EEPROM_BASE_ADDR_DATA + 1 + i, consigne_sorties[i]);
+    switch (consigne_sorties[i]) {
+      case HIGH:
+        log_print("H");
+        break;
+      case LOW:
+        log_print("L");
+        break;
+      default:
+        log_print("#");
+    }
+  }
+
+  // Valide les infos stockées dans l'EEPROM
+  log_print(" checksum==");
+  EEPROM.write(EEPROM_BASE_ADDR_DATA, checksum);
+  log_printInt(checksum);
+
+  log_end_line();
+}
+
+/* Charge le tableau consigne_sorties[] depuis la sauvegarde contenue dans l'EEPROM
+   Permet de retrouver l'état des sorties actives / inactives lors d'un reboot ou après un défaut d'alimentation
+*/
+void charger_consignes() {
+    uint8_t checksum_lu, checksum_calcule;
+  int i;
+
+  checksum_calcule= CHECKSUM_INIT;
+  for (i=0; i<NUM_SORTIES; i++) {
+    consigne_sorties[i] = EEPROM.read(EEPROM_BASE_ADDR_DATA + 1 + i);
+    if ( consigne_sorties[i] ) checksum_calcule++;
+  }
+
+  checksum_lu = EEPROM.read(EEPROM_BASE_ADDR_DATA);
+  if ( checksum_lu != checksum_calcule ) {
+    for (i=0; i<NUM_SORTIES; i++) {
+      consigne_sorties[i] = CONSIGNE_PAR_DEFAUT;
+    }
+  }
+  log_begin_line();
+  log_print("charger_consignes() : checksum_lu==");
+  log_printInt(checksum_lu);
+  log_print(" checksum_calcule==");
+  log_printInt(checksum_calcule);
+  log_end_line();
+}
+
+
+/* Récupère l'état des pin d'entrée
+   Filtre les valeurs pour éviter les rebonds et faux contacts (mémorisé dans etat_entrees[])
+   Si un évènement vient de se produire :
+     Retourne le numéro de l'entrée
+   Sinon
+     Retourne -1
+*/
+entree_t lire_entrees() {
+  int i, evenement_entree = -1;
+  uint8_t precedent, actuel;
+  unsigned long maintenant;
+  
+  log_begin_line();
+  log_print("lire_entrees() : Entrees ");
+  
+  for (i=0; i<NUM_ENTREES; i++){
+    precedent = etat_entrees[i];
+    actuel = digitalRead(pin_entrees[i]);
+    maintenant = millis();
+    etat_entrees[i] = actuel;
+ 
+    if ( precedent==HIGH && actuel==LOW ) {
+      // Front descendant
+      millis_precedent_front_descendant[i] = maintenant;
+      log_print("\\");
+      
+    } else if( precedent==LOW && actuel==HIGH ) {
+      // Front montant
+      millis_precedent_front_descendant[i] = 0;
+      log_print("/");
+      
+    } else if ( precedent==HIGH && actuel==HIGH ) {
+    // Niveau haut
+      millis_precedent_front_descendant[i] = 0;
+      log_print("H");
+      
+    } else if ( precedent==LOW && actuel==LOW  ) {
+      // Niveau bas (bouton pressé)
+      
+      // On filtre les rebonds ou les bruits : on prends en compte l'évènement
+      // que si la pression du bouton dure assez longtemps
+      if ( millis_precedent_front_descendant[i] != 0 ) {
+        // Le front descendant à été mémorisé
+        if ( (maintenant - millis_precedent_front_descendant[i]) > DUREE_MIN_BOUTON_PRESSE ) {
+          // L'entrée est restées assez longtemps en front bas
+          evenement_entree = (entree_t) i;
+          millis_precedent_front_descendant[i] = 0;
+          log_print("!");
+        } else {
+          log_print("w");
+        }
+      } else {
+        log_print("r");
+      }
+    }
+  }
+
+  log_print(" retour ");
+  log_printInt(evenement_entree);
+  log_end_line();
+
+  return (entree_t)evenement_entree;
+}
+
+
+/************
+ * SECURITE *
+ ************/
+/* Comptabilise le nombre d'évènements qui se produit sur les sorties
+    ( = nbre d'appels de protection_alea() par appliquer_consignes() )
+   - retourne false si un trop grand nombre de changements d'état à été détecté il y a moins de ALEA_BLOQUAGE_MILLIS ms
+   - retourne true si on est en situation normale
+*/
+boolean protection_alea() {
+  static uint8_t curseur_appels = 0;
+  static unsigned long millis_precedents_appels[ALEA_NB_APPELS_MAX];
+  static unsigned long millis_debut_blocage;
+  
+  unsigned long millis_oldest, maintenant;
+ 
+  maintenant = millis();
+
+  // Ajout de cet appel ) protection_alea() dans le buffer rotatif millis_precedents_appels
+  millis_precedents_appels[curseur_appels] = maintenant;
+  curseur_appels = (curseur_appels + 1) % ALEA_NB_APPELS_MAX;
+
+  // Si on est en période de blocage, retourner false tout de suite. Si en fin de période, oublier le blocage
+  if ( millis_debut_blocage > 0 ) {
+    if ( maintenant - millis_debut_blocage < ALEA_BLOQUAGE_MILLIS ) {
+      return false;
+    } else {
+      millis_debut_blocage = 0;
+      log_begin_line();
+      log_print("protection_alea() : Fin de blocage");
+      log_end_line();
+    }
+  }
+
+  // Si le plus viel appel enregistré est moins vieux que (maintenant - ALEA_FENETRE_MILLIS)
+  // Alors c'est qu'on a une trop grande fréquence d'évènements, bloquer le système pdt ALEA_BLOQUAGE_MILLIS 
+  millis_oldest = millis_precedents_appels[curseur_appels];
+  if ( millis_oldest > (maintenant - ALEA_FENETRE_MILLIS)  ) {
+    millis_debut_blocage = maintenant;
+
+    log_begin_line();
+    log_print("protection_alea() : ");
+    log_printInt(ALEA_NB_APPELS_MAX);
+    log_print(" appels en moins de ");
+    log_printInt(ALEA_FENETRE_MILLIS);
+    log_print(" millisecondes. Blocage pendant ");
+    log_printInt(ALEA_BLOQUAGE_MILLIS / 1000);
+    log_print(" secondes");
+    log_end_line();
+  }
+  
+  return true;
+}
+
+
+/*************
+ * DEBUGGING *
+ *************/
+void log_init() {
+#if DEBUG_VIA_SYSLOG == 1
+  Udp.begin(port_debug); // port local comme le port de destination (rsyslog)
+#endif
+#if DEBUG_VIA_SERIAL == 1
+  Serial.begin(9600);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for Leonardo only
+  }
+#endif
+
+  log_begin_line();
+  log_print("log_init() : Mode debug initialisé");
+  log_end_line();
+}
+
+void log_begin_line() {
+#if DEBUG_VIA_SYSLOG == 1
+  Udp.beginPacket(ip_debug, port_debug);
+  Udp.print("<15> "); // Syslog header : facility * 8 (1 == user) + severity (7 == debug)
+  Udp.print("millis()==");
+  Udp.print(millis());
+  Udp.print(" ");
+#endif
+#if DEBUG_VIA_SERIAL == 1
+  Serial.print("millis()==");
+  Serial.print(millis());
+  Serial.print(" ");
+#endif
+}
+
+void log_print(const char *str) {
+#if DEBUG_VIA_SYSLOG == 1
+  Udp.print(str);
+#endif
+#if DEBUG_VIA_SERIAL == 1
+  Serial.print(str);
+#endif
+}
+
+void log_printInt(long val) {
+#if DEBUG_VIA_SYSLOG == 1
+  Udp.print(val);
+#endif
+#if DEBUG_VIA_SERIAL == 1
+  Serial.print(val);
+#endif
+}
+
+void log_end_line() {
+#if DEBUG_VIA_SYSLOG == 1
+  Udp.endPacket();
+#endif
+#if DEBUG_VIA_SERIAL == 1
+  Serial.println("");
+#endif
+}
+
diff --git a/io_declarations.h b/io_declarations.h
new file mode 100644
index 0000000..ea7ef74
--- /dev/null
+++ b/io_declarations.h
@@ -0,0 +1,34 @@
+
+// ========================================
+// == INTERRUPTEURS =======================
+// ========================================
+typedef enum { 
+  bt_test_arduino, bt_ext_cote_rue,
+
+  NUM_ENTREES
+} entree_t;
+
+static uint8_t pin_entrees[NUM_ENTREES] = {
+  0, 4,
+};
+
+
+// ========================================
+// == LIGNES ==============================
+// ========================================
+  
+typedef enum { 
+  led_arduino, rl_ecl_ext_jardin,
+  
+  NUM_SORTIES
+} sortie_t;
+
+
+static uint8_t pin_sorties[NUM_SORTIES] = {
+  13, 41,
+};
+
+static char desc_sorties[NUM_SORTIES][16] = {
+  "LED Arduino", "Jardin",  
+};
+