SHARE
TWEET

Untitled

a guest Aug 25th, 2019 72 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. ////////
  2. //
  3. // Sketch Arduino pour le Plugin JEEDOUINO v097+ de JEEDOM
  4. // Connection via Ethernet
  5. //
  6. // Généré le 2019-08-25 07:38:08.
  7. // Pour l'équipement test arduino jeedom (EqID : 7 ).
  8. // Modèle de carte : auno.
  9. ////////
  10. #define DEBUGtoSERIAL 1  // 0, ou 1 pour debug dans la console serie
  11. #define UseWatchdog 0
  12. #define NODHCP 1          // 0 pour IP via DHCP, 1 pour IP fixée dans le sketch.
  13. #define UseDHT 1
  14. #define UseDS18x20 1
  15. #define UseTeleInfo 0
  16. #define UseLCD16x2 0  // 0 = None(Aucun) / 1 = LCD Standard 6 pins / 2 = LCD via I2C
  17. #define UseEthernet 0   // Choix de la lib suivant shield ethernet : 0 = W5100 / 1 = ENC28J60 / 2 = W5500 - Voir note ci-dessous
  18. #define UseHCSR04 0
  19. #define UsePwm_input 0 // Code obsolete (sera supprimé) - Entrée Numérique Variable (0-255 sur 10s) en PULL-UP
  20. #define UseBMP180 0 // pour BMP085/180 Barometric Pressure & Temp Sensor
  21. #define UseServo 0    // Pour controler la postion d'un servo.
  22. #define UseWS2811 0 // Pour gerer les led stips a base de WS2811/2 avec l'excellente lib Adafruit_NeoPixel
  23.  
  24. // Vous permet d'inclure du sketch perso - voir Doc / FAQ.
  25. // Il faut activer l'option dans la configuration du plugin.
  26. // Puis choisir le nombre de variables utilisateur sous l'onglet Pins/GPIO de votre équipement.
  27. #define UserSketch 0
  28. // Tags pour rechercher l'emplacement pour votre code :
  29. //UserVars
  30. //UserSetup
  31. //UserLoop
  32.  
  33. #if (UseWatchdog == 1)
  34.   #include <avr/wdt.h>
  35. #endif
  36.  
  37. #include <SPI.h>
  38. // Pour shield avec W5100
  39. #if (UseEthernet == 0)
  40.   #include <Ethernet.h>
  41. #endif
  42. // Pour shield avec W5500
  43. #if (UseEthernet == 2)
  44.   #include <Ethernet2.h>
  45. #endif
  46. // Pour shield avec ENC28J60 - Note : il faut passer NODHCP à 1 ci-dessus.
  47. // Attention, problèmes de mémoire possibles sur arduino nano/uno/328 avec cette lib (v1.59)!
  48. // Pour la récupérer, et l'installer dans l'IDE, voir : https://github.com/ntruchsess/arduino_uip/tree/Arduino_1.5.x
  49. //
  50. // Il faudra modifier dans le fichier \arduino-IDE\libraries\arduino_uip-master\utility\uipethernet-conf
  51. // les lignes suivantes:
  52. //#define UIP_SOCKET_NUMPACKETS   3
  53. //#define UIP_CONF_MAX_CONNECTIONS 2
  54. //#define UIP_CONF_UDP             0
  55. //
  56. #if (UseEthernet == 1)
  57.   #include <UIPEthernet.h>  // v1.59
  58. #endif
  59. // Traitement spécifique a cette librairie (pb de deconnection):
  60. int UIPEFailCount = 0;
  61. unsigned long UIPEFailTime = millis();
  62.  
  63. ////////
  64. // DHT
  65. // https://github.com/adafruit/DHT-sensor-library
  66. #if (UseDHT == 1)
  67.   #include <DHT.h>
  68. #endif
  69.  
  70. ////////
  71. // DS18x20
  72. // https://github.com/PaulStoffregen/OneWire
  73. #if (UseDS18x20 == 1)
  74.   #include <OneWire.h>
  75. #endif
  76.  
  77. byte IP_ARDUINO[] = { 192, 168, 1, 203 };
  78. byte IP_JEEDOM[] = { 192, 168, 1, 9 };
  79. byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xE7 };
  80. EthernetServer server(8000);
  81.  
  82. #include <EEPROM.h>
  83.  
  84. // CONFIGURATION VARIABLES
  85.  
  86. #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  87.   #define NB_DIGITALPIN 54
  88.   #define NB_ANALOGPIN 16
  89. #else
  90.   #define NB_DIGITALPIN 14
  91.   #define NB_ANALOGPIN 6
  92. #endif
  93. #define NB_TOTALPIN ( NB_DIGITALPIN + NB_ANALOGPIN)
  94.  
  95. // Etat des pins de l'arduino ( Mode )
  96. char Status_pins[NB_TOTALPIN];
  97. byte pin_id;
  98. byte echo_pin;
  99.  
  100. String eqLogic = "";
  101. String inString = "";
  102. String Message = "";
  103. byte BootMode;
  104.  
  105. // Pour la detection des changements sur pins en entree
  106. byte PinValue;
  107. byte OLDPinValue[NB_TOTALPIN ];
  108. unsigned long AnalogPinValue;
  109. unsigned long OLDAnalogPinValue[NB_TOTALPIN ];
  110. unsigned long CounterPinValue[NB_TOTALPIN ];
  111. unsigned long PinNextSend[NB_TOTALPIN ];
  112. byte swtch[NB_TOTALPIN];
  113. // pour envoi ver jeedom
  114. String jeedom = "\0";
  115. // reception commande
  116. char c[250];
  117. byte n=0;
  118. byte RepByJeedom=0;
  119. // Temporisation sorties
  120. unsigned long TempoPinHIGH[NB_TOTALPIN ]; // pour tempo pins sorties HIGH
  121. unsigned long TempoPinLOW[NB_TOTALPIN ]; // pour tempo pins sorties LOW
  122. unsigned long pinTempo=0;
  123. unsigned long NextRefresh=0;
  124. unsigned long ProbeNextSend=millis();
  125. unsigned long timeout = 0;
  126.  
  127. #if (UseDHT == 1)
  128.   DHT *myDHT[NB_TOTALPIN];
  129. #endif
  130.  
  131. #if (UseServo == 1)
  132.   #include <Servo.h>
  133.   Servo myServo[NB_TOTALPIN];
  134. #endif
  135.  
  136. #if (UseWS2811 == 1)
  137.   // More info at https://github.com/adafruit/Adafruit_NeoPixel
  138.   #include <Adafruit_NeoPixel.h>
  139.   // Parameter 1 = number of pixels in strip
  140.   // Parameter 2 = Arduino pin number (most are valid)
  141.   // Parameter 3 = pixel type flags, add together as needed:
  142.   //   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
  143.   //   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
  144.   //   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
  145.   //   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
  146.   //   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
  147.   #define WS2811PIN 6
  148.   Adafruit_NeoPixel strip = Adafruit_NeoPixel(50, WS2811PIN, NEO_GRB + NEO_KHZ800);
  149. #endif
  150.  
  151. #if (UseTeleInfo == 1)
  152.   // TeleInfo / Software serial
  153.   #include <SoftwareSerial.h>
  154.   byte teleinfoRX = 0;
  155.   byte teleinfoTX = 0;
  156.   SoftwareSerial teleinfo(6,7); // definir vos pins RX , TX
  157. #endif
  158.  
  159. #if (UseLCD16x2 == 1)
  160.   // LiquidCrystal Standard (not i2c)
  161.   #include <LiquidCrystal.h>
  162.   LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
  163. #endif
  164. #if (UseLCD16x2 == 2)
  165.   // LiquidCrystal  i2c
  166.   #include <Wire.h>
  167.   #include <LiquidCrystal_I2C.h>
  168.   LiquidCrystal_I2C lcd(0x27,16,2);
  169. #endif
  170. #if (UseBMP180 == 1)
  171.   //  BMP085/180 Barometric Pressure & Temp Sensor
  172.   //  https://learn.adafruit.com/bmp085/downloads
  173.   #include <Wire.h>
  174.   #include <Adafruit_BMP085.h>
  175.   Adafruit_BMP085 bmp;
  176. #endif
  177.  
  178. #if (UserSketch == 1)
  179.   // UserVars
  180.   // Vos declarations de variables / includes etc....
  181.   //#include <your_stuff_here.h>
  182. #endif
  183.  
  184. // SETUP
  185.  
  186. void setup()
  187. {
  188.   jeedom.reserve(256);
  189.   Message.reserve(16);
  190.   inString.reserve(4);
  191.   #if (DEBUGtoSERIAL == 1)
  192.     Serial.begin(9600); // Init du Port serie/USB
  193.     Serial.setTimeout(5); // Timeout 5ms
  194.     Serial.println(F("JEEDOUINO IS HERE."));
  195.   #endif
  196.   if (EEPROM.read(13) != 'J')
  197.   {
  198.     Init_EEPROM();
  199.   #if (NODHCP == 0)
  200.     if (Ethernet.begin(mac) == 0)   // 1er demarrage 1er flash Jeedouino, on essaye via dhcp
  201.     {
  202.       #if (DEBUGtoSERIAL == 1)
  203.         Serial.println(F("Connection via DHCP failed."));
  204.       #endif
  205.       #if (UseWatchdog == 1)
  206.         wdt_enable(WDTO_15MS); // try reboot
  207.       #endif
  208.       while(1){}
  209.     }
  210.     IPAddress IP_ARDUINO = Ethernet.localIP();
  211.     jeedom = F("&ipwifi=");
  212.     jeedom += IP_ARDUINO[0];
  213.     jeedom += '.';
  214.     jeedom += IP_ARDUINO[1];
  215.     jeedom += '.';
  216.     jeedom += IP_ARDUINO[2];
  217.     jeedom += '.';
  218.     jeedom += IP_ARDUINO[3];
  219.     SendToJeedom();
  220.   #else
  221.     Ethernet.begin(mac, IP_ARDUINO);
  222.   #endif
  223.   }
  224.   else Ethernet.begin(mac, IP_ARDUINO);
  225.  
  226.   #if (DEBUGtoSERIAL == 1)
  227.     Serial.println(F("Connection to LAN."));
  228.   #endif
  229.   server.begin();
  230.   Load_EEPROM(1);
  231.  
  232.   #if (DEBUGtoSERIAL == 1)
  233.     Serial.print(F("\nEqLogic:"));
  234.     Serial.println(eqLogic);
  235.   #endif
  236.  
  237.   #if (UseTeleInfo == 1)
  238.     teleinfo.begin(1200);  // vitesse par EDF
  239.   #endif
  240.  
  241.   #if (UseLCD16x2 == 1)
  242.     lcd.begin(16, 2);
  243.     lcd.setCursor(0,0);
  244.     lcd.print(F("JEEDOUINO v097+"));
  245.   #endif
  246.   #if (UseLCD16x2 == 2)
  247.     lcd.init();
  248.     lcd.backlight();
  249.     lcd.home();
  250.     lcd.print(F("JEEDOUINO v097+"));
  251.   #endif
  252.  
  253.   #if (UseBMP180 == 1)
  254.     bmp.begin();
  255.   #endif
  256.  
  257.   #if (UseWS2811 == 1)
  258.     strip.begin();
  259.     strip.show();
  260.   #endif
  261.  
  262.   #if (UserSketch == 1)
  263.     UserSetup(); // Appel de votre setup()
  264.   #endif
  265. }
  266. //// User Setup
  267. #if (UserSketch == 1)
  268.   void UserSetup()
  269.   {
  270.     // Votre setup()
  271.   }
  272. #endif
  273.  
  274. // LOOP
  275.  
  276. void loop()
  277. {
  278.   // TRAITEMENT DES TEMPO SORTIES SI IL Y EN A
  279.   jeedom="";
  280.   for (int i = 2; i < NB_TOTALPIN; i++)
  281.   {
  282.     if (TempoPinHIGH[i]!=0 && TempoPinHIGH[i]<millis()) // depassement de la temporisation
  283.     {
  284.       TempoPinHIGH[i]=0; // Suppression de la temporisation
  285.       PinWriteHIGH(i);
  286.     }
  287.     else if (TempoPinLOW[i]!=0 && TempoPinLOW[i]<millis()) // depassement de la temporisation
  288.     {
  289.       TempoPinLOW[i]=0; // Suppression de la temporisation
  290.       PinWriteLOW(i);
  291.     }
  292.   }
  293.   // FIN TEMPO
  294.  
  295.   // On ecoute le reseau
  296.   EthernetClient client = server.available();
  297.  
  298.   if (client)
  299.   {
  300.     // on regarde si on recois des donnees
  301.     n=0;
  302.     #if (DEBUGtoSERIAL == 1)
  303.       Serial.println(F("\nRECEIVING:"));
  304.     #endif
  305.     timeout = millis()+30000; // 30s
  306.     while (client.connected() and timeout>millis())
  307.     {
  308.       if (client.available())
  309.       {
  310.         c[n] = client.read();
  311.         if (c[n]=='\r') c[n]='\n';
  312.         if (c[n]=='\n')
  313.         {
  314.           while (client.available()) c[n+1] = client.read();
  315.           break;
  316.         }
  317.         n++;
  318.       }
  319.     }
  320.     #if (DEBUGtoSERIAL == 1)
  321.       if (timeout<millis()) Serial.println(F("\nTimeOut:"));
  322.       for (int i = 0; i <= n; i++)  Serial.print(c[i]);
  323.     #endif
  324.  
  325.     if (n && c[n]=='\n')
  326.     {
  327.       n--;
  328.       // on les traites
  329.       if (c[0]=='C' && c[n]=='C')  // Configuration de l'etat des pins
  330.       {
  331.         // NB_TOTALPIN = NB_DIGITALPIN  + NB_ANALOGPIN
  332.  
  333.         if (n==(NB_TOTALPIN+1))        // Petite securite
  334.         {
  335.           for (int i = 0; i < NB_TOTALPIN; i++)
  336.           {
  337.             EEPROM.update(30+i, c[i+1]);      // Sauvegarde mode des pins
  338.           }
  339.           Load_EEPROM(0);             // On met en place
  340.           client.print(F("COK"));              // On reponds a JEEDOM
  341.           jeedom+=F("&REP=COK");
  342.           ProbeNextSend=millis()+60000; // Décalage pour laisser le temps aux differents parametrages d'arriver de Jeedom
  343.         }
  344.       }
  345.       else if (c[0]=='E' && c[n]=='Q')  // Recuperation de l' eqLogic de Jeedom concernant cet arduino
  346.       {
  347.         eqLogic = "";
  348.         EEPROM.update(15, n);        // Sauvegarde de la longueur du eqLogic
  349.         for (int i = 1; i < n; i++)
  350.         {
  351.           EEPROM.update(15+i, c[i]-'0');      // Sauvegarde de l' eqLogic
  352.           eqLogic += (char)c[i];
  353.         }
  354.         client.print(F("EOK"));              // On reponds a JEEDOM
  355.         jeedom+=F("&REP=EOK");
  356.         ProbeNextSend=millis()+60000; // Décalage pour laisser le temps aux differents parametrages d'arriver de Jeedom
  357.       }
  358.       else if (c[0]=='I' && c[n]=='P')  // Recuperation de l' IP de Jeedom ( I192.168.000.044P )
  359.       {
  360.         if (n<17)      // Petite securite
  361.         {
  362.           int ip=0;
  363.           inString="";
  364.           for (int i = 1; i <= n; i++)  //jusqu'a n car il faut un caractere non digit pour finir
  365.           {
  366.           if (isDigit(c[i]))
  367.           {
  368.             inString += (char)c[i];
  369.           }
  370.           else
  371.           {
  372.             IP_JEEDOM[ip]=inString.toInt();
  373.             inString="";
  374.             ip++;
  375.           }
  376.           }
  377.           EEPROM.update(26, IP_JEEDOM[0]);          // Sauvegarde de l' IP
  378.           EEPROM.update(27, IP_JEEDOM[1]);
  379.           EEPROM.update(28, IP_JEEDOM[2]);
  380.           EEPROM.update(29, IP_JEEDOM[3]);
  381.           client.print(F("IPOK"));              // On reponds a JEEDOM
  382.           jeedom+=F("&REP=IPOK");
  383.           ProbeNextSend=millis()+60000; // Décalage pour laisser le temps aux differents parametrages d'arriver de Jeedom
  384.         }
  385.       }
  386.       else if (c[0]=='S' && c[n]=='S')  // Modifie la valeur d'une pin sortie
  387.       {
  388.         jeedom+=F("&REP=SOK");
  389.         for (int i = 1; i < n; i++)
  390.         {
  391.           if (isDigit(c[i])) c[i]=c[i]-'0';
  392.         }
  393.  
  394.         pin_id=10*int(c[1])+int(c[2]);          // recuperation du numero de la pin
  395.  
  396.         Set_OutputPin(pin_id);
  397.         client.print(F("SOK"));              // On reponds a JEEDOM
  398.         ProbeNextSend=millis()+10000; // Décalage pour laisser le temps au differents parametrages d'arriver de Jeedom
  399.       }
  400.       else if ((c[0]=='S' || c[0]=='R') && c[n]=='C')     // Reçoie la valeur SAUVEE d'une pin compteur (suite reboot)
  401.       {                                       // ou RESET suite sauvegarde equipement.
  402.           if (n>3)                    // Petite securite
  403.           {
  404.             for (int i = 1; i < n; i++)
  405.             {
  406.               if (isDigit(c[i])) c[i]=c[i]-'0';
  407.             }
  408.  
  409.             if (c[0]=='R') CounterPinValue[pin_id]=0; // On reset la valeur si demandé.
  410.  
  411.             pin_id=10*int(c[1])+int(c[2]);                    // récupération du numéro de la pin
  412.             int multiple=1;
  413.             for (int i = n-1; i >= 3; i--)                    // récupération de la valeur
  414.             {
  415.               CounterPinValue[pin_id] += int(c[i])*multiple;
  416.               multiple *= 10;
  417.             }
  418.             PinNextSend[pin_id]=millis()+2000;
  419.             NextRefresh=millis()+2000;
  420.             ProbeNextSend=millis()+10000; // Décalage pour laisser le temps au differents parametrages d'arriver de Jeedom
  421.  
  422.             client.print(F("SCOK"));                        // On reponds a JEEDOM
  423.             jeedom+=F("&REP=SCOK");
  424.           }
  425.       }
  426.       else if (c[0]=='S' && c[n]=='F')  // Modifie la valeur de toutes les pins sortie (suite reboot )
  427.       {
  428.         // NB_TOTALPIN = NB_DIGITALPIN  + NB_ANALOGPIN
  429.         if (n==(NB_TOTALPIN+1))      // Petite securite
  430.         {
  431.           jeedom+=F("&REP=SFOK");
  432.           for (int i = 2; i < NB_TOTALPIN; i++)
  433.           {
  434.             switch (Status_pins[i])
  435.             {
  436.               case 'o': // output
  437.               case 's': // switch
  438.               case 'l': // low_relais
  439.               case 'h': // high_relais
  440.               case 'u': // output_pulse
  441.               case 'v': // low_pulse
  442.               case 'w': // high_pulse
  443.                 if (c[i+1]=='0')
  444.                 {
  445.                   PinWriteLOW(i);
  446.                 }
  447.                 else if (c[i+1]=='1')
  448.                 {
  449.                   PinWriteHIGH(i);
  450.                 }
  451.               break;
  452.             }
  453.           }
  454.         RepByJeedom=0; // Demande repondue, pas la peine de redemander a la fin de loop()
  455.           client.print(F("SFOK"));              // On reponds a JEEDOM
  456.           ProbeNextSend=millis()+20000; // Décalage pour laisser le temps au differents parametrages d'arriver de Jeedom
  457.         }
  458.       }
  459.       else if (c[0]=='S' && (c[n]=='L' || c[n]=='H' || c[n]=='A')) // Modifie la valeur de toutes les pins sortie a LOW / HIGH / SWITCH / PULSE
  460.       {
  461.         if (n==2 || n==7)     // Petite securite  : S2L / S2H / S2A / SP00007L /SP00007H
  462.         {
  463.           jeedom+=F("&REP=SOK");
  464.           for (int i = 1; i < n; i++)
  465.           {
  466.             if (isDigit(c[i])) c[i]=c[i]-'0';
  467.           }
  468.           if (c[1]=='P') pinTempo = 10000*int(c[2])+1000*int(c[3])+100*int(c[4])+10*int(c[5])+int(c[6]);
  469.           for (int i = 2; i < NB_TOTALPIN; i++)
  470.           {
  471.             TempoPinHIGH[i] = 0;
  472.             TempoPinLOW[i] = 0;
  473.             switch (Status_pins[i])
  474.             {
  475.               case 'o': // output
  476.               case 's': // switch
  477.               case 'l': // low_relais
  478.               case 'h': // high_relais
  479.               case 'u': // output_pulse
  480.               case 'v': // low_pulse
  481.               case 'w': // high_pulse
  482.                 if (c[n]=='L')
  483.                 {
  484.                   if (c[1] == 'P') TempoPinHIGH[i] = pinTempo;
  485.                   PinWriteLOW(i);
  486.                 }
  487.                 else if (c[n] == 'H')
  488.                 {
  489.                   if (c[1] == 'P') TempoPinLOW[i] = pinTempo;
  490.                   PinWriteHIGH(i);
  491.                 }
  492.                 else
  493.                 {
  494.                   if (swtch[i]==1) PinWriteLOW(i);
  495.                   else PinWriteHIGH(i);
  496.                 }
  497.               break;
  498.             }
  499.           }
  500.           client.print(F("SOK"));             // On reponds a JEEDOM
  501.           ProbeNextSend=millis()+10000; // Décalage pour laisser le temps au differents parametrages d'arriver de Jeedom
  502.         }
  503.       }
  504.       else if (c[0]=='B' && c[n]=='M')  // Choix du BootMode
  505.       {
  506.         BootMode=int(c[1]-'0');
  507.         EEPROM.update(14, BootMode);
  508.  
  509.         client.print(F("BMOK"));                // On reponds a JEEDOM
  510.         jeedom+=F("&REP=BMOK");
  511.         ProbeNextSend=millis()+3000; // Décalage pour laisser le temps au differents parametrages d'arriver de Jeedom
  512.       }
  513.     #if (UseHCSR04 == 1)
  514.       else if (c[0]=='T' && c[n]=='E')  // Trigger pin + pin Echo pour le support du HC-SR04 (ex: T0203E)
  515.       {
  516.         if (n==5)        // Petite securite
  517.         {
  518.           client.print(F("SOK"));               // On reponds a JEEDOM
  519.           jeedom+=F("&REP=SOK");
  520.           ProbeNextSend=millis()+10000; // Décalage pour laisser le temps aux differents parametrages d'arriver de Jeedom
  521.  
  522.           for (int i = 1; i < n; i++)
  523.           {
  524.             if (isDigit(c[i])) c[i]=c[i]-'0';
  525.           }
  526.           pin_id=10*int(c[1])+int(c[2]);          // recuperation du numero de la pin trigger
  527.           echo_pin=10*int(c[3])+int(c[4]);      // recuperation du numero de la pin echo
  528.  
  529.           digitalWrite(pin_id, HIGH);             // impulsion de 10us pour demander la mesure au HC-SR04
  530.           delayMicroseconds(10);
  531.           digitalWrite(pin_id, LOW);
  532.           long distance = pulseIn(echo_pin, HIGH);  // attente du retour de la mesure (en us) - timeout 1s
  533.           distance = distance * 0.034 / 2;          // conversion en distance (cm). NOTE : V=340m/s, fluctue en foncion de la temperature
  534.           // on envoi le resultat a jeedom
  535.           jeedom += '&';
  536.           jeedom += echo_pin;
  537.           jeedom += '=';
  538.           jeedom += distance;
  539.         }
  540.       }
  541.     #endif
  542.     #if (UseLCD16x2 == 1 || UseLCD16x2 == 2)
  543.       else if (c[0]=='S' && c[n]=='M')  // Send Message to LCD
  544.       {
  545.           client.print(F("SMOK"));                // On reponds a JEEDOM
  546.           jeedom+=F("&REP=SMOK");
  547.           ProbeNextSend=millis()+10000; // Décalage pour laisser le temps aux differents parametrages d'arriver de Jeedom
  548.  
  549.           //pin_id=10*int(c[1]-'0')+int(c[2]-'0');
  550.           lcd.clear();
  551.           Message = "";
  552.           int i = 3; // Normal, utilise dans les 2x FOR
  553.           for (i; i < n; i++) //S17Title|MessageM >>> S 17 Title | Message M  // Title & Message <16chars chacun
  554.           {
  555.             if (c[i] == '|') break;
  556.             Message += (char)c[i];
  557.           }
  558.           lcd.setCursor(0,0); // Title
  559.           lcd.print(Message);
  560.           i++;
  561.           Message = "";
  562.           for (i; i < n; i++)
  563.           {
  564.             Message += (char)c[i];
  565.           }
  566.           lcd.setCursor(0,1); // Message
  567.           lcd.print(Message);
  568.       }
  569.     #endif
  570.     #if (UseWS2811 == 1)
  571.       else if (c[0]=='C' && c[n]=='R')  // COLOR : C09LFF00FFR ou C09M12R pin 09 color L or effect M
  572.       {
  573.         for (int i = 1; i < n; i++)
  574.         {
  575.           if (isDigit(c[i])) c[i]=c[i]-'0';
  576.           if ((c[i] >= 'A') && (c[i] <= 'F')) c[i]=c[i] - 'A' + 10; // For hex
  577.         }
  578.         if (c[3]=='M')
  579.         {
  580.           client.print(F("SOK")); // On reponds a JEEDOM avant le TIMEOUT
  581.           pinTempo = 10 * int(c[4]) + int(c[5]);
  582.           #if (DEBUGtoSERIAL == 1)
  583.             Serial.print(F("\startShow: "));
  584.             Serial.println(pinTempo);
  585.           #endif
  586.           startShow(pinTempo);
  587.         }
  588.         else if (c[3]=='L')
  589.         {
  590.           client.print(F("SOK")); // On reponds a JEEDOM avant le TIMEOUT
  591.           if (n == 10)       // Petite securite
  592.           {
  593.             uint8_t r = 16 * int(c[4]) + int(c[5]);
  594.             uint8_t g = 16 * int(c[6]) + int(c[7]);
  595.             uint8_t b = 16 * int(c[8]) + int(c[9]);
  596.             #if (DEBUGtoSERIAL == 1)
  597.               Serial.print(F("\R: "));
  598.               Serial.println(r);
  599.               Serial.print(F("\G: "));
  600.               Serial.println(g);
  601.               Serial.print(F("\B: "));
  602.               Serial.println(b);
  603.             #endif
  604.             for(uint16_t z = 0; z < strip.numPixels(); z++)
  605.             {
  606.               strip.setPixelColor(z, r, b, g);
  607.             }
  608.             strip.show();
  609.           }
  610.         }
  611.         else client.print(F("NOK"));  // On reponds a JEEDOM
  612.       }
  613.     #endif    
  614.     #if (UserSketch == 1)
  615.       else if (c[0]=='U' && c[n]=='R')  // UseR Action
  616.       {
  617.         client.print(F("SOK")); // On reponds a JEEDOM
  618.         UserAction();
  619.       }
  620.     #endif
  621.  
  622.       else
  623.       {
  624.         client.print(F("NOK"));                  // On reponds a JEEDOM
  625.         jeedom+=F("&REP=NOK");
  626.       }
  627.     }
  628.   }
  629.   client.stop();
  630.   // On ecoute les pins en entree
  631.   //jeedom="";
  632.   for (int i = 2; i < NB_TOTALPIN; i++)
  633.   {
  634.     byte BPvalue = 0;
  635.     switch (Status_pins[i])
  636.     {
  637.     case 'i': // input
  638.     case 'p': // input_pullup
  639.       PinValue = digitalRead(i);
  640.       if (PinValue!=OLDPinValue[i] && (PinNextSend[i]<millis() || NextRefresh<millis()))
  641.       {
  642.         OLDPinValue[i]=PinValue;
  643.         jeedom += '&';
  644.         jeedom += i;
  645.         jeedom += '=';
  646.         jeedom += PinValue;
  647.         PinNextSend[i]=millis()+1000; // Delai pour eviter trop d'envois
  648.       }
  649.       break;
  650.     case 'n':   // BP_input_pulldown
  651.       BPvalue = 1;
  652.     case 'q':   // BP_input_pullup
  653.       PinValue = digitalRead(i);
  654.       if (PinValue != OLDPinValue[i])
  655.       {
  656.         PinNextSend[i] = millis() + 50;  // Delai antirebond
  657.         OLDPinValue[i] = PinValue;
  658.         ProbeNextSend = millis() + 5000; // decale la lecture des sondes pour eviter un conflit
  659.       }
  660.       if (PinNextSend[i] < millis() && PinValue != swtch[i])
  661.       {
  662.         if (PinValue == BPvalue) CounterPinValue[i] += 1;
  663.         OLDAnalogPinValue[i] = millis() + 250;   // Delai entre clicks
  664.         swtch[i] = PinValue;
  665.       }
  666.       if (OLDAnalogPinValue[i] < millis() && CounterPinValue[i] != 0)
  667.       {
  668.         if (PinValue == BPvalue) CounterPinValue[i] = 99; // Appui long
  669.         jeedom += '&';
  670.         jeedom += i;
  671.         jeedom += '=';
  672.         jeedom += CounterPinValue[i];
  673.         CounterPinValue[i] = 0;
  674.         OLDAnalogPinValue[i] = millis() + 1000;
  675.       }
  676.       break;
  677.     #if (UsePwm_input == 1)
  678.     case 'g': // input_variable suivant tempo
  679.       PinValue = digitalRead(i);
  680.       // Calcul
  681.       if (PinNextSend[i]>millis()) // bouton laché avant les 10s
  682.       {
  683.         pinTempo=255-((PinNextSend[i]-millis())*255/10000); // pas de 25.5 par seconde
  684.       }
  685.       else pinTempo=255;  // si bouton laché après les 10s, on bloque la valeur a 255
  686.  
  687.       if (PinValue!=OLDPinValue[i]) // changement état entrée = bouton appuyé ou bouton relaché
  688.       {
  689.         OLDPinValue[i]=PinValue;
  690.         if (swtch[i]==1)  // on vient de lacher le bouton.
  691.         {
  692.           swtch[i]=0; // on enregistre le laché.
  693.           jeedom += '&';
  694.           jeedom += i;
  695.           jeedom += '=';
  696.           jeedom += pinTempo;
  697.           PinNextSend[i]=millis();
  698.         }
  699.         else
  700.         {
  701.           swtch[i]=1; // on vient d'appuyer sur le bouton, on enregistre.
  702.           PinNextSend[i]=millis()+10000; // Delai pour la tempo de maintient du bouton.
  703.           CounterPinValue[i]==millis(); // reutilisation pour economie de ram
  704.           ProbeNextSend=millis()+15000; // decale la lecture des sondes pour eviter un conflit
  705.         }
  706.       }
  707.       else
  708.       {
  709.         if (swtch[i]==1 && CounterPinValue[i]<millis())
  710.         {
  711.           jeedom += '&';
  712.           jeedom += i;
  713.           jeedom += '=';
  714.           jeedom += pinTempo;
  715.           CounterPinValue[i]==millis()+1000; // reactualisation toutes les secondes pour ne pas trop charger Jeedom
  716.         }
  717.       }
  718.       break;
  719.     #endif
  720.     case 'a': // analog_input
  721.         AnalogPinValue = analogRead(i);
  722.         if (AnalogPinValue!=OLDAnalogPinValue[i] && (PinNextSend[i]<millis() || NextRefresh<millis()))
  723.         {
  724.           if (abs(AnalogPinValue-OLDAnalogPinValue[i])>20)    // delta correctif pour eviter les changements negligeables
  725.           {
  726.             int j=i;
  727.             if (i<54) j=i+40;  // petit correctif car dans Jeedom toutes les pins Analog commencent a l'id 54+
  728.             OLDAnalogPinValue[i]=AnalogPinValue;
  729.             //jeedom += '&' + j + '=' + AnalogPinValue;
  730.             jeedom += '&';
  731.             jeedom += j;
  732.             jeedom += '=';
  733.             jeedom += AnalogPinValue;
  734.             PinNextSend[i]=millis()+5000; // Delai pour eviter trop d'envois
  735.           }
  736.         }
  737.         break;
  738.     case 'c': // compteur_pullup CounterPinValue
  739.       PinValue = digitalRead(i);
  740.       if (PinValue!=OLDPinValue[i])
  741.       {
  742.         OLDPinValue[i]=PinValue;
  743.         CounterPinValue[i]+=PinValue;
  744.       }
  745.       if (NextRefresh<millis() || PinNextSend[i]<millis())
  746.       {
  747.         jeedom += '&';
  748.         jeedom += i;
  749.         jeedom += '=';
  750.         jeedom += CounterPinValue[i];
  751.         PinNextSend[i]=millis()+10000;    // Delai 10s pour eviter trop d'envois
  752.       }
  753.       break;
  754.     #if (UseDHT == 1)
  755.     case 'd': // DHT11
  756.     case 'e': // DHT21
  757.     case 'f': // DHT22
  758.       if (PinNextSend[i]<millis() and ProbeNextSend<millis())
  759.       {
  760.         jeedom += '&';
  761.         jeedom += i;
  762.         jeedom += '=';
  763.         jeedom += int (myDHT[i]->readTemperature()*100);
  764.         jeedom += '&';
  765.         jeedom += i+1000;
  766.         jeedom += '=';
  767.         jeedom += int (myDHT[i]->readHumidity()*100);
  768.         PinNextSend[i]=millis()+300000; // Delai 60s entre chaque mesures pour eviter trop d'envois
  769.         ProbeNextSend=millis()+10000; // Permet de decaler la lecture entre chaque sonde DHT sinon ne marche pas cf librairie (3000 mini)
  770.         //jeedom += F("&FREERAM=");
  771.         //jeedom += freeRam();
  772.       }
  773.       break;
  774.     #endif
  775.     #if (UseDS18x20 == 1)
  776.     case 'b': // DS18x20
  777.       if (PinNextSend[i]<millis() and ProbeNextSend<millis())
  778.       {
  779.         jeedom += '&';
  780.         jeedom += i;
  781.         jeedom += '=';
  782.         jeedom += read_DSx(i); // DS18x20
  783.         PinNextSend[i]=millis()+300000; // Delai 60s entre chaque mesures pour eviter trop d'envois
  784.         ProbeNextSend=millis()+10000; // Permet de laisser du temps pour les commandes 'action', probabilite de blocage moins grande idem^^
  785.       }
  786.       break;
  787.     #endif
  788.     #if (UseTeleInfo == 1)
  789.     case 'j': // teleinfoRX
  790.       if (PinNextSend[i]<millis() || NextRefresh<millis())
  791.       {
  792.         #if (DEBUGtoSERIAL == 1)
  793.           Serial.print(F("\nTeleinfoRX ("));
  794.           Serial.print(i);
  795.           Serial.print(F(") : "));
  796.         #endif
  797.         char recu = 0;
  798.         int cntChar=0;
  799.         timeout = millis()+2000;  // 2s
  800.         while (recu != 0x02 and timeout>millis())
  801.         {
  802.           if (teleinfo.available()) recu = teleinfo.read() & 0x7F;
  803. /*          #if (DEBUGtoSERIAL == 1)
  804.             Serial.print(recu);
  805.           #endif   */
  806.         }
  807.         jeedom += F("&ADCO=");
  808.         timeout = millis()+2000;  // 2s
  809.         while (timeout>millis())
  810.         {
  811.           if (teleinfo.available())
  812.           {
  813.             recu = teleinfo.read() & 0x7F;
  814. /*            #if (DEBUGtoSERIAL == 1)
  815.               Serial.print(recu);
  816.             #endif */
  817.             cntChar++;
  818.             if (cntChar > 280) break;
  819.             if (recu == 0) break;
  820.             if (recu == 0x04) break; // EOT
  821.             if (recu == 0x03) break; // permet d'eviter ce caractere dans la chaine envoyée (economise du code pour le traiter)
  822.             if (recu == 0x0A) continue;       // Debut de groupe
  823.             if (recu == 0x0D)
  824.             {
  825.               jeedom += ';';  // Fin de groupe
  826.               continue;
  827.             }
  828.             if (recu<33)
  829.             {
  830.               jeedom += '_';
  831.             }
  832.             else jeedom += recu;
  833.           }
  834.         }
  835.         #if (DEBUGtoSERIAL == 1)
  836.           Serial.println(F("/finRX"));
  837.         #endif
  838.         PinNextSend[i]=millis()+30000;  // Delai 30s entre chaque mesures pour eviter trop d'envois
  839.       }
  840.       break;
  841.     #endif
  842.     #if (UseBMP180 == 1)
  843.     case 'r': // BMP085/180
  844.       if (PinNextSend[i]<millis())
  845.       {
  846.         jeedom += '&';
  847.         jeedom += i;
  848.         jeedom += '=';
  849.         jeedom += bmp.readTemperature();
  850.         jeedom += '&';
  851.         jeedom += i + 1000;
  852.         jeedom += '=';
  853.         jeedom += bmp.readPressure();
  854.         PinNextSend[i] = millis() + 60000;  // Delai 60s entre chaque mesures pour eviter trop d'envois
  855.       }
  856.       break;
  857.     #endif
  858.  
  859.     }
  860.   }
  861.   if (NextRefresh<millis())
  862.   {
  863.     NextRefresh=millis()+60000; // Refresh auto toutes les 60s
  864.     if (RepByJeedom) // sert a verifier que jeedom a bien repondu a la demande dans Load_eeprom
  865.     {
  866.       jeedom += F("&ASK=1"); // Sinon on redemande
  867.     }
  868.   }
  869.  
  870.   #if (UserSketch == 1)
  871.     UserLoop(); // Appel de votre loop() permanent
  872.     // if (NextRefresh<millis()) UserLoop(); // Appel de votre loop() toutes les 60s
  873.   #endif
  874.  
  875. /*  #if (UseLCD16x2 == 1 || UseLCD16x2 == 2)
  876.     lcd.setCursor(0,1);
  877.     lcd.print(jeedom);
  878.   #endif */
  879.  
  880.   if (jeedom != "") SendToJeedom();
  881. }
  882. //// User Loop + Action
  883. #if (UserSketch == 1)
  884.   void UserLoop()
  885.   {
  886.     // Votre loop()
  887.     // pour envoyer une valeur a jeedom, il suffit de remplir la variable jeedom comme cela :
  888.     // jeedom += '&';
  889.     // jeedom += u; // avec u = numero de la pin "info" dans l'equipement jeedom - info pin number
  890.     // jeedom += '=';
  891.     // jeedom += info; // la valeur a envoyer - info value to send
  892.     //
  893.     // Ex:
  894.     // jeedom += '&';
  895.     // jeedom += 500; // Etat pin 500
  896.     // jeedom += '=';
  897.     // jeedom += '1';   // '0' ou '1'
  898.     //
  899.     // jeedom += '&';
  900.     // jeedom += 504; // pin 504
  901.     // jeedom += '=';
  902.     // jeedom += millis();  // valeur numerique
  903.     //
  904.     // jeedom += '&';
  905.     // jeedom += 506; // pin 506
  906.     // jeedom += '=';
  907.     // jeedom += "Jeedouino%20speaking%20to%20Jeedom...";  // valeur string
  908.  
  909.     // /!\ attention de ne pas mettre de code bloquant (avec trop de "delays") - max time 2s
  910.   }
  911.   void UserAction()
  912.   {
  913.     // Ens cas d'une reception d'une commande user action depuis jeedom
  914.     // c[0]='U' & c[n]='R')
  915.     //
  916.     // c[1] = c[1]-'0'; ==5 (user pin start at 500)
  917.     // c[2] = c[2]-'0';
  918.     // c[3] = c[3]-'0';
  919.     // pin_id = 100 * int(c[1]) + 10 * int(c[2]) + int(c[3]);   // pin action number
  920.     //
  921.     // c[4] to c[n-1]   // pin action value
  922.     //
  923.     // Ex:
  924.     // U5000R -> U 500 0 R = binary 0 pin 500
  925.     // U5001R -> U 500 1 R = binary 1 pin 500
  926.     // U502128R -> U 502 128 R = Slider Value 128 pin 502
  927.     // U507[Jeedom] Message|Ceci est un testR -> U 507 [Jeedom] Message | Ceci est un test R = Message pin 507
  928.  
  929.     // /!\ attention de ne pas mettre de code bloquant (avec trop de "delays") - max time 2s
  930.   }
  931. #endif
  932.  
  933. // FONCTIONS
  934.  
  935. void SendToJeedom()
  936. {
  937.   EthernetClient JEEDOMclient = server.available();
  938.   #if (DEBUGtoSERIAL == 1)
  939.     Serial.print(F("\nSending: "));
  940.     Serial.println(jeedom);
  941.     Serial.print(F("To eqLogic: "));
  942.     Serial.println(eqLogic);
  943.   #endif
  944.   int J=JEEDOMclient.connect(IP_JEEDOM, 80);
  945.   if (J)
  946.   {
  947.     JEEDOMclient.print(F("GET /plugins/jeedouino/core/php/Callback.php?BoardEQ="));
  948.     JEEDOMclient.print(eqLogic);
  949.     JEEDOMclient.print(jeedom);
  950.     JEEDOMclient.println(F(" HTTP/1.1"));
  951.     JEEDOMclient.print(F("Host: "));
  952.     JEEDOMclient.print(IP_JEEDOM[0]);
  953.     JEEDOMclient.print('.');
  954.     JEEDOMclient.print(IP_JEEDOM[1]);
  955.     JEEDOMclient.print('.');
  956.     JEEDOMclient.print(IP_JEEDOM[2]);
  957.     JEEDOMclient.print('.');
  958.     JEEDOMclient.println(IP_JEEDOM[3]);
  959.     delay(111);
  960.     JEEDOMclient.println(F("Connection: close"));
  961.     JEEDOMclient.println();
  962.     delay(111);
  963.     JEEDOMclient.stop();
  964.   #if (DEBUGtoSERIAL == 1)
  965.     Serial.print(F("At IP: "));
  966.     Serial.print(IP_JEEDOM[0]);
  967.     Serial.print('.');
  968.     Serial.print(IP_JEEDOM[1]);
  969.     Serial.print('.');
  970.     Serial.print(IP_JEEDOM[2]);
  971.     Serial.print('.');
  972.     Serial.println(IP_JEEDOM[3]);
  973.   #endif
  974.  
  975.     UIPEFailTime = millis();
  976.     UIPEFailCount = 0;
  977.   }
  978.   else
  979.   {
  980.     JEEDOMclient.stop();
  981.     UIPEFailCount++;
  982.   #if (DEBUGtoSERIAL == 1)
  983.     Serial.print(F("connection failed : "));
  984.     Serial.println(J);
  985.     Serial.print(F("UIPEFailCount : "));
  986.     Serial.println(UIPEFailCount);
  987.   #endif
  988.     if (UIPEFailCount>10 and millis()>UIPEFailTime+60000)
  989.     {
  990.       #if (DEBUGtoSERIAL == 1)
  991.         Serial.println(F("Waiting 10s & reboot if wdg"));
  992.       #endif
  993.       delay(10000); // tentative soft pour laisser le temps a la lib de se resaisir
  994.       #if (UseWatchdog == 1)
  995.         wdt_enable(WDTO_15MS); // try reboot
  996.       #endif
  997.       delay(20000); // tentative soft pour laisser le temps a la lib de se resaisir
  998.       JEEDOMclient.stop();
  999.       Ethernet.begin(mac, IP_ARDUINO);
  1000.       server.begin();
  1001.       UIPEFailTime = millis()+60000;
  1002.       delay(999);
  1003.     }
  1004.   }
  1005.   jeedom="";
  1006.   delay(444);
  1007.   //JEEDOMclient.stop();
  1008. }
  1009.  
  1010. void Set_OutputPin(int i)
  1011. {
  1012.   TempoPinHIGH[i]=0;
  1013.   TempoPinLOW[i]=0;
  1014.  
  1015.   switch (Status_pins[i])
  1016.   {
  1017.     #if (UseServo == 1)
  1018.     case 'x':
  1019.       pinTempo = 100 * int(c[3]) + 10 * int(c[4]) + int(c[5]);
  1020.       myServo[i].write(pinTempo);
  1021.       delay(15);
  1022.       break;
  1023.     #endif
  1024.     case 'o': // output      // S131S pin 13 set to 1 (ou S130S pin 13 set to 0)
  1025.     case 'l': // low_relais // S13S pin 13 set to 0
  1026.     case 'h': // high_relais  // S13S pin 13 set to 1
  1027.       if (c[3]==0)
  1028.       {
  1029.         PinWriteLOW(i);
  1030.       }
  1031.       else
  1032.       {
  1033.         PinWriteHIGH(i);
  1034.       }
  1035.       break;
  1036.  
  1037.     case 's': // switch     // S13 pin 13 set to 1 si 0 sinon set to 0 si 1
  1038.       if (swtch[i]==1)
  1039.       {
  1040.         PinWriteLOW(i);
  1041.       }
  1042.       else
  1043.       {
  1044.         PinWriteHIGH(i);
  1045.       }
  1046.       break;
  1047.  
  1048.     //
  1049.     // ON VERIFIE SI UNE TEMPORISATION EST DEMANDEE SUR UNE DES SORTIES
  1050.     // On essai d'etre sur une precision de 0.1s mais ca peut fluctuer en fonction de la charge cpu
  1051.     // Testé seulement sur mega2560
  1052.     //
  1053.     case 'u': // output_pulse // Tempo ON : S1309999S : pin 13 set to 0 during 999.9 seconds then set to 1 (S1319999 : set to 1 then to 0)
  1054.       pinTempo=10000*int(c[4])+1000*int(c[5])+100*int(c[6])+10*int(c[7])+int(c[8]);
  1055.       // pinTempo est donc en dixieme de seconde
  1056.       pinTempo = pinTempo*100+millis(); // temps apres lequel la pin doit retourner dans l'autre etat.
  1057.  
  1058.       // Peut buguer quand millis() arrive vers 50jours si une tempo est en cours pendant la remise a zero de millis().
  1059.       // Risque faible si les tempo sont de l'ordre de la seconde (impulsions sur relais par ex.).
  1060.       if (c[3]==0)
  1061.       {
  1062.         TempoPinHIGH[i]=pinTempo;
  1063.         PinWriteLOW(i);
  1064.       }
  1065.       else if (c[3]==1)
  1066.       {
  1067.         TempoPinLOW[i]=pinTempo;
  1068.         PinWriteHIGH(i);
  1069.       }
  1070.       break;
  1071.  
  1072.     case 'v': // low_pulse    // Tempo ON : S139999S : pin 13 set to 0 during 999.9 seconds then set to 1
  1073.       if (c[3]==0)
  1074.       {
  1075.         pinTempo=10000*int(c[4])+1000*int(c[5])+100*int(c[6])+10*int(c[7])+int(c[8]);
  1076.         // pinTempo est donc en dixieme de seconde
  1077.         pinTempo = pinTempo*100+millis();  // temps apres lequel la pin doit retourner dans l'autre etat.
  1078.  
  1079.         TempoPinHIGH[i]=pinTempo;
  1080.         PinWriteLOW(i);
  1081.       }
  1082.       else
  1083.       {
  1084.         PinWriteHIGH(i);
  1085.       }
  1086.       break;
  1087.  
  1088.     case 'w': // high_pulse  // Tempo ON : S139999S : pin 13 set to 1 during 999.9 seconds then set to 0
  1089.       if (c[3]==0)
  1090.       {
  1091.         PinWriteLOW(i);
  1092.       }
  1093.       else
  1094.       {
  1095.         pinTempo=10000*int(c[4])+1000*int(c[5])+100*int(c[6])+10*int(c[7])+int(c[8]);
  1096.         // pinTempo est donc en dixieme de seconde
  1097.         pinTempo = pinTempo*100+millis();  // temps apres lequel la pin doit retourner dans l'autre etat.
  1098.  
  1099.         TempoPinLOW[i]=pinTempo;
  1100.         PinWriteHIGH(i);
  1101.       }
  1102.       break;
  1103.  
  1104.     case 'm': // pwm_output
  1105.       pinTempo=100*int(c[3])+10*int(c[4])+int(c[5]);  // the duty cycle: between 0 (always off) and 255 (always on).
  1106.       analogWrite(i, pinTempo);
  1107.       break;
  1108.   }
  1109. }
  1110.  
  1111. void Load_EEPROM(int k)
  1112. {
  1113.   // on recupere le BootMode
  1114.   BootMode=EEPROM.read(14);
  1115.   // Recuperation de l'eqLogic
  1116.   eqLogic = "";
  1117.   n=EEPROM.read(15);        // Recuperation de la longueur du eqLogic
  1118.   if (n>0)        // bug probable si eqLogic_id<10 dans jeedom
  1119.   {
  1120.     for (int i = 1; i < n; i++)
  1121.     {
  1122.       eqLogic += EEPROM.read(15+i);
  1123.     }
  1124.   }
  1125.   // Recuperation de l'IP
  1126.   IP_JEEDOM[0]=EEPROM.read(26);
  1127.   IP_JEEDOM[1]=EEPROM.read(27);
  1128.   IP_JEEDOM[2]=EEPROM.read(28);
  1129.   IP_JEEDOM[3]=EEPROM.read(29);
  1130.  
  1131.   // on met en place le mode des pins
  1132.   jeedom="";
  1133.   byte y=1;
  1134.   #if (UseTeleInfo == 1)
  1135.     teleinfoRX = 0;
  1136.     teleinfoTX = 0;
  1137.   #endif
  1138.   #if (DEBUGtoSERIAL == 1)
  1139.     Serial.println(F("Conf. Pins:"));
  1140.     for (int i = 0; i < NB_TOTALPIN; i++) Serial.print((char)EEPROM.read(30+i));
  1141.     Serial.println();
  1142.   #endif
  1143.   for (int i = 2; i < NB_TOTALPIN; i++)
  1144.   {
  1145.     Status_pins[i] = EEPROM.read(30+i); // Etats des pins
  1146.  
  1147.     // INITIALISATION DES TABLEAUX DE TEMPO SORTIES
  1148.     TempoPinHIGH[i] = 0;
  1149.     TempoPinLOW[i] = 0;
  1150.     //
  1151.     switch (Status_pins[i])
  1152.     {
  1153.       case 'i': // input
  1154.       case 'a': // analog_input
  1155.       case 'n':   // BP_input_pulldown
  1156.         pinMode(i, INPUT);
  1157.         break;
  1158.       #if (UseTeleInfo == 1)
  1159.       case 'j':   // teleinfoRX pin
  1160.         teleinfoRX = i;
  1161.         pinMode(i, INPUT);
  1162.         break;
  1163.       case 'k':   // teleinfoTX pin
  1164.         teleinfoTX = i;
  1165.         pinMode(i, OUTPUT);
  1166.         break;
  1167.       #endif
  1168.       #if (UseDHT == 1)
  1169.       case 'd': // DHT11
  1170.         myDHT[i] = new DHT(i, 11);  // DHT11
  1171.         PinNextSend[i]=millis()+300000;
  1172.         break;
  1173.       case 'e': // DHT21
  1174.         myDHT[i] = new DHT(i, 21);  // DHT21
  1175.         PinNextSend[i]=millis()+300000;
  1176.         break;
  1177.       case 'f': // DHT 22
  1178.         myDHT[i] = new DHT(i, 22);  // DHT22
  1179.         PinNextSend[i]=millis()+300000;
  1180.         break;
  1181.       #endif
  1182.       #if (UseDS18x20 == 1)
  1183.       case 'b': // DS18x20
  1184.         PinNextSend[i]=millis()+300000;
  1185.         break;
  1186.       #endif
  1187.       #if (UseServo == 1)
  1188.       case 'x':
  1189.         myServo[i].attach(i);
  1190.         break;
  1191.       #endif
  1192.       case 't':   // trigger pin
  1193.         pinMode(i, OUTPUT);
  1194.         digitalWrite(i, LOW);
  1195.         break;
  1196.       case 'z':   // echo pin
  1197.         pinMode(i, INPUT);
  1198.         break;
  1199.       case 'p':    // input_pullup
  1200.       case 'g':    // pwm_input
  1201.       case 'q':   // BP_input_pullup
  1202.           pinMode(i, INPUT_PULLUP); // pour eviter les parasites en lecture, mais inverse l'etat de l'entree : HIGH = input open, LOW = input closed
  1203.           // Arduino Doc : An internal 20K-ohm resistor is pulled to 5V.
  1204.         swtch[i]=0;   // init pour pwm_input
  1205.         OLDPinValue[i]=1;
  1206.         PinNextSend[i]=millis();
  1207.           break;
  1208.       case 'c':    // compteur_pullup
  1209.           pinMode(i, INPUT_PULLUP); // pour eviter les parasites en lecture, mais inverse l'etat de l'entree : HIGH = input open, LOW = input closed
  1210.           // Arduino Doc : An internal 20K-ohm resistor is pulled to 5V.
  1211.           if (k)
  1212.           {
  1213.             jeedom += F("&CPT_"); // On demande à Jeedom de renvoyer la dernière valeur connue pour la pin i
  1214.             jeedom += i;
  1215.             jeedom += '=';
  1216.             jeedom += i;
  1217.           }
  1218.           break;
  1219.       case 'o': // output
  1220.       case 's': // switch
  1221.       case 'l': // low_relais
  1222.       case 'h': // high_relais
  1223.       case 'u': // output_pulse
  1224.       case 'v': // low_pulse
  1225.       case 'w': // high_pulse
  1226.         pinMode(i, OUTPUT);
  1227.         // restauration de l'etat des pins DIGITAL OUT au demarrage
  1228.        if (k)
  1229.        {
  1230.         switch (BootMode)
  1231.         {
  1232.           case 0:
  1233.             // On laisse tel quel
  1234.             break;
  1235.           case 1:
  1236.             PinWriteLOW(i);
  1237.             break;
  1238.           case 2:
  1239.             PinWriteHIGH(i);
  1240.             break;
  1241.           case 3:
  1242.             PinWriteHIGH(i);
  1243.             // On demande a Jeedom d'envoyer la valeur des pins
  1244.             if (y)
  1245.             {
  1246.               jeedom += F("&ASK=1");
  1247.               y=0;
  1248.               RepByJeedom=1; // sert a verifier que jeedom a bien repondu a la demande
  1249.             }
  1250.             break;
  1251.           case 4:
  1252.             if (EEPROM.read(110+i) == 0) PinWriteLOW(i);
  1253.             else PinWriteHIGH(i);
  1254.             break;
  1255.           case 5:
  1256.             PinWriteLOW(i);
  1257.             // On demande a Jeedom d'envoyer la valeur des pins
  1258.             if (y)
  1259.             {
  1260.               jeedom += F("&ASK=1");
  1261.               y=0;
  1262.               RepByJeedom=1; // sert a verifier que jeedom a bien repondu a la demande
  1263.             }
  1264.             break;
  1265.           }
  1266.        }
  1267.         // fin restauration
  1268.  
  1269.         break;
  1270.  
  1271.       case 'm': // pwm_output
  1272.         pinMode(i, OUTPUT);
  1273.         break;
  1274.     }
  1275.   }
  1276.   #if (UseTeleInfo == 1)
  1277.     if (teleinfoRX != 0)
  1278.     {
  1279.         #if (DEBUGtoSERIAL == 1)
  1280.       Serial.print(F("\nteleinfoRX:"));
  1281.       Serial.println(teleinfoRX);
  1282.       Serial.print(F("\nteleinfoTX:"));
  1283.       Serial.println(teleinfoTX);
  1284.       #endif
  1285.       //SoftwareSerial teleinfo(teleinfoRX, teleinfoTX);
  1286.     }
  1287.   #endif
  1288.   if (jeedom!="") SendToJeedom();
  1289. }
  1290. void PinWriteHIGH(long p)
  1291. {
  1292.   digitalWrite(p, HIGH);
  1293.   swtch[p]=1;
  1294.   jeedom += '&';
  1295.   jeedom += p;
  1296.   jeedom += F("=1");
  1297.   // Si bootmode=4 sauvegarde de l'etat de la pin (en sortie) - !!! Dangereux pour l'eeprom à long terme !!!
  1298.   if (BootMode==4) EEPROM.update(110+p, 1);
  1299.   #if (DEBUGtoSERIAL == 1)
  1300.     Serial.print(F("SetPin "));
  1301.     Serial.print(p);
  1302.     Serial.println(F(" to 1"));
  1303.   #endif
  1304. }
  1305. void PinWriteLOW(long p)
  1306. {
  1307.   digitalWrite(p, LOW);
  1308.   swtch[p]=0;
  1309.   jeedom += '&';
  1310.   jeedom += p;
  1311.   jeedom += F("=0");
  1312.   // Si bootmode=4 sauvegarde de l'etat de la pin (en sortie) - !!! Dangereux pour l'eeprom à long terme !!!
  1313.   if (BootMode==4) EEPROM.update(110+p, 0);
  1314.   #if (DEBUGtoSERIAL == 1)
  1315.     Serial.print(F("SetPin "));
  1316.     Serial.print(p);
  1317.     Serial.println(F(" to 0"));
  1318.   #endif
  1319. }
  1320.  
  1321. void Init_EEPROM()
  1322. {
  1323.   // Un marqueur
  1324.   EEPROM.update(13, 'J');  // JEEDOUINO
  1325.  
  1326.   // BootMode choisi au demarrage de l'arduino
  1327.   // 0 = Pas de sauvegarde - Toutes les pins sorties non modifi�es au d�marrage.
  1328.   // 1 = Pas de sauvegarde - Toutes les pins sorties mises � LOW au d�marrage.
  1329.   // 2 = Pas de sauvegarde - Toutes les pins sorties mises � HIGH au d�marrage.
  1330.   // 3 = Sauvegarde sur JEEDOM - Toutes les pins sorties mises suivant leur sauvegarde dans Jeedom. Jeedom requis, sinon pins mises � OFF.
  1331.   // 4 = Sauvegarde sur EEPROM- Toutes les pins sorties mises suivant leur sauvegarde dans l\'EEPROM. Autonome, mais dur�e de vie de l\'eeprom fortement r�duite.
  1332.   EEPROM.update(14, 2);
  1333.   BootMode=2;
  1334.  
  1335.   // Initialisation par default
  1336.   for (int i = 30; i < 200; i++)
  1337.   {
  1338.     EEPROM.update(i, 1);  // Valeur des pins OUT au 1er demarrage ( mes relais sont actis a 0, donc je met 1 pour eviter de les actionner au 1er boot)
  1339.   }
  1340.   EEPROM.update(26, IP_JEEDOM[0]);          // Sauvegarde de l' IP
  1341.   EEPROM.update(27, IP_JEEDOM[1]);
  1342.   EEPROM.update(28, IP_JEEDOM[2]);
  1343.   EEPROM.update(29, IP_JEEDOM[3]);
  1344.  
  1345.   eqLogic = F("7");                   // Sauvegarde de eqLogic pour 1er boot apres 1er flashage
  1346.   EEPROM.update(15, 2);         // Sauvegarde de la longueur du eqLogic
  1347.   for (int i = 1; i < 2; i++)
  1348.   {
  1349.     EEPROM.update(15+i, eqLogic[i-1]-'0');        // Sauvegarde de l' eqLogic
  1350.   }
  1351.  
  1352.   // fin initialisation
  1353. }
  1354. //int freeRam ()
  1355. //{
  1356. //  extern int __heap_start, *__brkval;
  1357. //  int v;
  1358. //  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
  1359. //}
  1360. #if (UseDS18x20 == 1)
  1361. int read_DSx(int pinD)
  1362. {
  1363.   byte present = 0;
  1364.   byte type_s;
  1365.   byte data[12];
  1366.   byte addr[8];
  1367.   OneWire ds(pinD);
  1368.  
  1369.   if ( !ds.search(addr))
  1370.   {
  1371.     ds.reset_search();
  1372.   #if (DEBUGtoSERIAL == 1)
  1373.     Serial.println(F("ds not found..."));
  1374.   #endif
  1375.     delay(250);
  1376.     return 0;
  1377.   }
  1378.  
  1379.   if (OneWire::crc8(addr, 7) != addr[7]) //Check if there is no errors on transmission
  1380.   {
  1381.     #if (DEBUGtoSERIAL == 1)
  1382.     Serial.println(F("CRC invalide..."));
  1383.     #endif
  1384.     return 0;
  1385.   }
  1386.  
  1387.   // the first ROM byte indicates which chip
  1388.   switch (addr[0])
  1389.   {
  1390.     case 0x10:
  1391.   #if (DEBUGtoSERIAL == 1)
  1392.      Serial.println(F(" Chip = DS18S20")); // or old DS1820
  1393.   #endif
  1394.      type_s = 1;
  1395.      break;
  1396.     case 0x28:
  1397.   #if (DEBUGtoSERIAL == 1)
  1398.      Serial.println(F(" Chip = DS18B20"));
  1399.   #endif
  1400.      type_s = 0;
  1401.      break;
  1402.     case 0x22:
  1403.   #if (DEBUGtoSERIAL == 1)
  1404.      Serial.println(F(" Chip = DS1822"));
  1405.   #endif
  1406.      type_s = 0;
  1407.      break;
  1408.     default:
  1409.   #if (DEBUGtoSERIAL == 1)
  1410.      Serial.println(F("Device is not a DS18x20 family device."));
  1411.   #endif
  1412.      return 0;
  1413.   }
  1414.  
  1415.   ds.reset();
  1416.   ds.select(addr);
  1417.   ds.write(0x44,1);      // start conversion, with parasite power on at the end
  1418.   delay(800);
  1419.   present = ds.reset();
  1420.   ds.select(addr);
  1421.   ds.write(0xBE);      // Read Scratchpad
  1422.   byte ii;
  1423.   for ( ii = 0; ii < 9; ii++)
  1424.   {        // we need 9 bytes
  1425.     data[ii] = ds.read();
  1426.   }
  1427.  
  1428.   // convert the data to actual temperature
  1429.  
  1430.   unsigned int raw = (data[1] << 8) | data[0];
  1431.   if (type_s)
  1432.   {
  1433.     raw = raw << 3; // 9 bit resolution default
  1434.     if (data[7] == 0x10)
  1435.     {
  1436.       // count remain gives full 12 bit resolution
  1437.       raw = (raw & 0xFFF0) + 12 - data[6];
  1438.     }
  1439.   }
  1440.   else
  1441.   {
  1442.     byte cfg = (data[4] & 0x60);
  1443.     if (cfg == 0x00) raw = raw << 3;  // 9 bit resolution, 93.75 ms
  1444.     else if (cfg == 0x20) raw = raw << 2; // 10 bit res, 187.5 ms
  1445.     else if (cfg == 0x40) raw = raw << 1; // 11 bit res, 375 ms
  1446.  
  1447.   }
  1448.   #if (DEBUGtoSERIAL == 1)
  1449.   Serial.println(raw/16);
  1450.   #endif
  1451.   return raw;
  1452. }
  1453. #endif
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top