first commit

ESP8266_DOMOTICZ_BMP180/Domoticz.cpp

@@ -0,0 +1,330 @@
+#include "Domoticz.h"
+
+Domoticz::Domoticz(String domoticz, String port, const char* ssid, const char* pass)
+{
+  _domoticz = domoticz;
+  _port     = port;
+  _ssid     = ssid;
+  _pass     = pass;
+
+  //      // Domo
+  //  _domoc[_domoticz.length() + 1];
+  //  _domoticz.toCharArray(_domoc, _domoticz.length() + 1);
+  //
+  //  // Port
+  //  char portc[_port.length() + 1];
+  //  _port.toCharArray(portc, _port.length() + 1);
+  //  _iport = atoi(portc);
+
+}
+
+boolean Domoticz::connect()
+{
+
+  // Domo
+  char _domoc[_domoticz.length() + 1];
+  _domoticz.toCharArray(_domoc, _domoticz.length() + 1);
+
+  // Port
+  char portc[_port.length() + 1];
+  _port.toCharArray(portc, _port.length() + 1);
+  int _iport = atoi(portc);
+
+  boolean connected = _client.connect(_domoc, _iport);
+  Serial.print(_domoc);
+  Serial.print("  ");
+  Serial.print(_iport);
+  Serial.print("  ");
+  Serial.print(" connected ");
+  Serial.println(connected);
+
+  return connected;
+}
+
+void Domoticz::close()
+{
+
+}
+
+void Domoticz::initWifi()
+{
+  WiFi.mode(WIFI_AP);
+  WiFi.begin(_ssid, _pass); //Connect to local Wifi
+
+  Serial.println();
+  Serial.print("Connecting to WiFi");
+  while (WiFi.status() != WL_CONNECTED)
+  {
+    Serial.print(".");
+    delay(500);
+  }
+  Serial.println("WiFi Connected!");
+  Serial.print("Connexion au reseau ");
+  Serial.println(WiFi.localIP());
+}
+
+void Domoticz::initWifiStatic(
+  IPAddress ip,
+  IPAddress gateway,
+  IPAddress subnet,
+  IPAddress DNS)
+{
+  WiFi.config(ip, gateway, subnet, DNS);
+  delay(100);
+  WiFi.mode(WIFI_STA);
+
+  WiFi.begin(_ssid, _pass);
+  Serial.print("Connecting");
+  while (WiFi.status() != WL_CONNECTED) {
+      Serial.print(".");
+      delay(200);
+  }
+  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
+    Serial.println();
+    Serial.println("Fail connecting");
+    delay(5000);
+    ESP.restart();
+  }
+  Serial.print(" static OK ");
+  Serial.print("Module IP: ");
+  Serial.println(WiFi.localIP());
+}
+
+
+String Domoticz::generateKey()
+{
+  // WiFi.mode(WIFI_AP);
+
+  // Do a little work to get a unique-ish name. Append the
+  // last two bytes of the MAC (HEX'd) to "Thing-":
+  uint8_t mac[WL_MAC_ADDR_LENGTH];
+  WiFi.softAPmacAddress(mac);
+  String macID = String(mac[WL_MAC_ADDR_LENGTH - 2], HEX) + String(mac[WL_MAC_ADDR_LENGTH - 1], HEX);
+  macID.toUpperCase();
+  String AP_NameString = "ESP8266 Thing " + macID;
+
+  char AP_NameChar[AP_NameString.length() + 1];
+  memset(AP_NameChar, 0, AP_NameString.length() + 1);
+
+  for (int i = 0; i < AP_NameString.length(); i++)
+  {
+    AP_NameChar[i] = AP_NameString.charAt(i);
+  }
+
+  // WiFi.softAP(AP_NameChar, WiFiAPPSK);
+
+  Serial.println("macID=" + macID);
+
+  return macID;
+}
+
+void Domoticz::getIdFromDomoticz(String macID, Params * params)
+{
+  String separator  = ",";
+  int nb            = 0;
+
+  Serial.println("Dans getIdFromDomoticz " + macID);
+
+  // -------------------
+  // LECTURE PARAM
+  // -------------------
+  if (params->esp8266_id == "") {
+    boolean connected = connect();
+
+    if (connected) {
+      Serial.println("Connected to domoticz");
+      executeJson("/json.htm?type=command&param=getuservariables", "", "");
+      // Read the first line of the request
+      while (1) {
+        String req = readLine();
+        if (req.indexOf(macID) != -1) {
+          Serial.println(req);
+          req = readLine();
+          req = readLine();
+          String val = req.substring(req.indexOf(":") + 2, req.length() - 1);
+          Serial.println(val);
+          val.replace("\"", "");
+          params->esp8266_id = getIndexOfString(val, separator, 0);
+          String tmp = getIndexOfString(val, separator, 1);
+          if (tmp != "") {
+            char tmpc[tmp.length() + 1];
+            tmp.toCharArray(tmpc, tmp.length() + 1);
+            params->sleepTime = atoi(tmpc);
+            if (params->sleepTime <= 0) {
+              params->sleepTime = 60;
+            }
+          }
+          params->esp8266_id_Vcc = getIndexOfString(val, separator, 2);
+
+          params->esp8266_id_lum = getIndexOfString(val, separator, 3);
+          Serial.println("val1=" + params->esp8266_id);
+          Serial.print("val2=");
+          Serial.println(params->sleepTime);
+          Serial.println("val3=" + params->esp8266_id_Vcc);
+          Serial.println("val4=" + params->esp8266_id_lum);
+          
+          break;
+        }
+        if (req == "" || nb > 500) {
+          break;
+        }
+        nb++;
+      }
+      _client.stop();
+      delay(100);
+    }
+  }
+
+}
+
+IPAddress Domoticz::getIP(String macId)
+{
+  IPAddress ip; //(192, 168, 1, 222);
+
+  String fst = macId.substring(0, 2);
+  String sec = macId.substring(2);
+
+  char fstc[fst.length() + 1];
+  fst.toCharArray(fstc, fst.length() + 1);
+
+  char secc[sec.length() + 1];
+  sec.toCharArray(secc, fst.length() + 1);
+  
+  return IPAddress(192, 168, strtol(fstc, 0, 16), strtol(secc, 0, 16));
+  
+}
+
+void Domoticz::executeJson(String json, String svalue, String nvalue)
+{
+  
+  // Domo
+  char _domoc[_domoticz.length() + 1];
+  _domoticz.toCharArray(_domoc, _domoticz.length() + 1);
+
+  // Port
+  char portc[_port.length() + 1];
+  _port.toCharArray(portc, _port.length() + 1);
+  int _iport = atoi(portc);
+
+  _client.print("GET " + json); //"GET /json.htm?type=command&param=getuservariables");
+
+  if (svalue != "") {
+    _client.print("&svalue=" + svalue);
+  }
+  if (nvalue != "") {
+    _client.print("&nvalue=" + nvalue);
+  }
+  Serial.println(json + "&svalue=" + svalue + "&nvalue=" + nvalue);
+
+  _client.println(" HTTP/1.1");
+  _client.print("Host: ");
+  _client.print(_domoc);
+  _client.print(":");
+  _client.println(_iport);
+  _client.println("User-Agent: Arduino-ethernet");
+  _client.println("Connection: close");
+  _client.println();
+}
+
+void Domoticz::readResponse()
+{
+  int x = 0;  // variable for looping
+  char dataStr[16];     //array to store the response
+  char c;
+  
+  while(_client.available()) { //_client.connected() || _client.available()) {
+    String req = readLine();
+    Serial.println(req);
+    if (req == "") {
+      break;
+    }
+//    c = _client.read();    //read first character
+//    while (c!= '<') {     //while < character is not coming yet, keep reading character
+//      c = _client.read();
+//    }
+//    c = _client.read();    //read the '<' character, but not storing in array
+//    while (c != '>') {    //while > character is not coming yet,
+//      dataStr[x] = c;   //Store character in array
+//      x++;    //incrementing index array
+//    }
+//    for (x=0; x<12; x++) {
+//      Serial.print(dataStr[x]);
+//    }
+  }
+  Serial.println("Fin réponse");
+}
+
+//--------------------------------------------------------------------------------------------------
+// Read current supply voltage
+//--------------------------------------------------------------------------------------------------
+String Domoticz::readVcc() {
+  // most exact output
+  uint16_t v = ESP.getVcc();
+  float_t v_cal = ((float) v / 1024.0f);
+  char v_str[10];
+  dtostrf(v_cal, 5, 3, v_str);
+  sprintf(v_str, "%s", v_str);
+  Serial.print("Tension lue ");
+  Serial.println(String(v_str));
+
+  return String(v_str); //ESP.getVcc() / 1024.0f; // Vcc in millivolts
+}
+
+String Domoticz::getIndexOfString(String data, String separator, int index)
+{
+  int found = 0;
+  int strIndex[] = { 0, -1 };
+  int maxIndex = data.length() - 1;
+
+  for (int i = 0; i <= maxIndex && found <= index; i++) {
+    if (data.charAt(i) == separator.charAt(0) || i == maxIndex) {
+      found++;
+      strIndex[0] = strIndex[1] + 1;
+      strIndex[1] = (i == maxIndex) ? i + 1 : i;
+    }
+  }
+  return found > index ? data.substring(strIndex[0], strIndex[1]) : "";
+}
+
+String Domoticz::readLine()
+{
+  return _client.readStringUntil('\n');
+}
+
+void Domoticz::readTempDayValues(String idx)
+{
+  String json = "/json.htm?type=graph&sensor=temp&idx=" + idx + "&range=day";
+  int nb      = 0;
+  int nbVal   = 0;
+  Serial.println("readTempDayValues " + idx);
+  connect();
+  executeJson(json, "", "");
+  while (1)
+  {
+    String line = readLine();
+
+    if (line == "") {
+      break;
+    }
+
+    if (line.indexOf("\"te\"") != -1) {
+      //Serial.print(line + " ");
+      nbVal++;
+      if (nbVal % 10) {
+        String val = line.substring(line.indexOf(":") + 2, line.length());
+        // Serial.println(val);
+      }
+    }
+    nb++;
+  }
+  Serial.print("Nombre de lignes ");
+  Serial.println(nb);
+  close();
+}
+
+int Domoticz::strToHex(char str[])
+{
+  return (int) strtol(str, 0, 16);
+}
+
+

ESP8266_DOMOTICZ_BMP180/Domoticz.h

@@ -0,0 +1,42 @@
+#ifndef Domoticz_h
+#define Domoticz_h
+
+#include <ESP8266WiFi.h>
+#include "Params.h"
+
+//IPAddress ip(192, 168, 1, 222);
+
+class Domoticz
+{
+  public:
+    Domoticz(String domoticz, String port, const char* ssid, const char* pass);
+    boolean connect();
+    void    close();
+    void    initWifi();
+    void    initWifiStatic(IPAddress ip, IPAddress gateway, IPAddress subnet, IPAddress DNS);
+    void    executeJson(String json, String svalue, String nvalue);
+    //String getIdFromDomoticz();
+    String  generateKey();
+    IPAddress getIP(String macId);
+    String  readLine();
+    void    readResponse();
+    String  readVcc();
+    void    readTempDayValues(String idx);
+    void    getIdFromDomoticz(String macID, Params * params);
+    int     strToHex(char str[]);
+
+    static String getIndexOfString(String data, String separator, int index);
+  private:
+
+    const char* _ssid;
+    const char* _pass;
+  public:
+    WiFiClient _client;
+    char _domoc[];
+    int _iport;
+    String _domoticz;
+    String _port;
+
+};
+
+#endif

ESP8266_DOMOTICZ_BMP180/ESP8266_DOMOTICZ_BMP180.ino

@@ -0,0 +1,119 @@
+//extern "C" {
+//#include "user_interface.h"
+//}
+
+// Need for getVcc
+ADC_MODE(ADC_VCC);
+
+/////////////////////
+// Domoticz Classe
+/////////////////////
+    
+#include "Domoticz.h"
+
+Domoticz domo("192.168.1.3", "81", "Livebox-37cc", "8A6060920A8A86896F770F2C47");
+#include "Modules.h"
+Modules  modules;
+Params   * params;
+
+
+IPAddress gateway(192, 168, 1, 1);
+IPAddress subnet(255, 255, 0, 0);
+IPAddress DNS(192, 168, 1, 1);
+
+void setup()
+{
+//  pinMode(PIN_ALIM_DS, OUTPUT);
+//  digitalWrite(PIN_ALIM_DS, HIGH);
+  //Wire.begin(SDA, SCL);
+  
+  Serial.begin(9600);
+  //delay(200);
+  String macId = domo.generateKey();
+  IPAddress ip = domo.getIP(macId);
+  
+  // Conversion d'objet en pointeur
+  Params p;
+  params = &p;
+  domo.initWifiStatic(ip, gateway, subnet, DNS);
+  //domo.initWifi();
+  domo.getIdFromDomoticz(macId, params);
+
+  modules.barometre();
+
+  // modules.readLuminosite();
+
+//  digitalWrite(PIN_ALIM_DS,LOW);
+
+  printInfo();
+
+  modules.sleep(params->sleepTime);
+  //delay(5000);
+}
+
+void loop()
+{
+
+}
+
+void printInfo()
+{
+  // Domoticz format /json.htm?type=command&param=udevice&idx=IDX&nvalue=0&svalue=TEMP;HUM;HUM_STAT;BAR;BAR_FOR
+
+  Serial.println("Dans printInfo " + params->esp8266_id);
+
+  boolean connected = domo.connect();
+  
+  if (connected && modules.temp > 0 && params->esp8266_id != "" ) {
+    Serial.println("Dans set temperature");
+    String svalue = String(modules.temp) 
+      + ";"   + String(modules.humidity) 
+      + ";0;" + String(modules.pression) 
+      + ";"   + String(modules.pressionHg);
+    Serial.println(svalue);
+    domo.executeJson("/json.htm?type=command&param=udevice&idx=" + params->esp8266_id, svalue, "0");
+
+//    delay(200);
+//    Serial.println("Response: ");
+//
+//    domo.readResponse();
+    domo._client.stop();
+
+    delay(200);
+    
+  }
+
+  connected = domo.connect();
+  if (connected && params->esp8266_id_Vcc != "") {
+    Serial.print(" Envoi tension ");
+    Serial.print(params->esp8266_id_Vcc);
+    Serial.print(" ");
+    String vcc = domo.readVcc();
+    Serial.println(vcc);
+
+    // domo._client.print("GET /json.htm?type=command&param=udevice&idx=");
+    domo.executeJson("/json.htm?type=command&param=udevice&idx=" + params->esp8266_id_Vcc, vcc, "0");
+
+    domo._client.stop();
+  }
+
+//  Serial.print("Luminosite ");
+//  Serial.println(modules.lum);
+//
+//  connected = domo.connect();
+//  if (connected && params->esp8266_id_lum != "") {
+//    Serial.print(" Envoi luminosite ");
+//    Serial.print(params->esp8266_id_lum);
+//    Serial.print(" ");
+//    Serial.println(modules.lum);
+//
+//    // domo._client.print("GET /json.htm?type=command&param=udevice&idx=");
+//    domo.executeJson("/json.htm?type=command&param=udevice&idx=" + params->esp8266_id_lum, String(modules.lum), "0");
+//    domo._client.stop();
+//  }
+
+  Serial.print("Time = ");
+  Serial.println(millis());
+
+   delay(200);
+}

ESP8266_DOMOTICZ_BMP180/Modules.cpp

@@ -0,0 +1,105 @@
+#include "Modules.h"
+
+Modules::Modules()
+{
+
+}
+
+void Modules::barometre() {
+  /* See Example: TypeA_WithDIPSwitches */
+Wire.begin(SDA, SCL);
+delay(200);
+  // init
+  bmp.init();
+  
+  // Initialize the sensor (it is important to get calibration values stored on the device).
+
+  if (bmp.hasValidID())
+    Serial.println("BMP180 init success");
+  else
+  {
+    // Oops, something went wrong, this is usually a connection problem,
+    // see the comments at the top of this sketch for the proper connections.
+
+    Serial.println("BMP180 init fail");
+    return; 
+  }
+  
+  delay(500);
+  Serial.println("Barometre: ");
+
+  temp = bmp.getTemperature();
+  pressure = bmp.getPressure();
+      // Print out the measurement:
+  Serial.print("temperature: ");
+  Serial.print(temp,2);
+  Serial.print(" deg C, ");
+  Serial.print((9.0/5.0) * temp + 32.0,2);
+  Serial.println(" deg F");
+  // Print out the measurement:
+  Serial.print("absolute pressure: ");
+  Serial.print(pressure, 2);
+  Serial.print(" mb, ");
+  Serial.print(pressure * 0.0295333727, 2);
+  Serial.println(" inHg");
+  
+//  // The pressure sensor returns abolute pressure, which varies with altitude.
+//  // To remove the effects of altitude, use the sealevel function and your current altitude.
+//  // This number is commonly used in weather reports.
+//  // Parameters: P = absolute pressure in mb, ALTITUDE = current altitude in m.
+//  // Result: pression = sea-level compensated pressure in mb
+//  
+  pression = sealevel(pressure,ALTITUDE); // we're at n meters 
+  Serial.print("relative (sea-level) pressure: ");
+  Serial.print(pression,2);
+  Serial.print(" mb, ");
+  pressionHg = pression*0.0295333727;
+  Serial.print(pressionHg,2);
+  Serial.println(" inHg");
+  
+  // On the other hand, if you want to determine your altitude from the pressure reading,
+  // use the altitude function along with a baseline pressure (sea-level or other).
+  // Parameters: P = absolute pressure in mb, p0 = baseline pressure in mb.
+  // Result: a = altitude in m.
+  
+  alt = altitude(pressure,pression);
+  Serial.print("computed altitude: ");
+  Serial.print(alt, 0);
+  Serial.print(" meters, ");
+  Serial.print(alt * 3.28084,0);
+  Serial.println(" feet");
+}
+
+
+void Modules::sleep(int sleepTime)
+{
+  Serial.print("Go to sleep ");
+  Serial.println(sleepTime);
+  delay(20);
+
+  ESP.deepSleep(sleepTime * 1000000L); 
+
+  //sleepWifi();
+  delay(200);
+}
+
+void Modules::readLuminosite()
+{
+    lum = analogRead(PIN_LUM);
+}
+
+double Modules::sealevel(double P, double A)
+// Given a pressure P (mb) taken at a specific altitude (meters),
+// return the equivalent pressure (mb) at sea level.
+// This produces pressure readings that can be used for weather measurements.
+{
+        return(P/pow(1-(A/44330.0),5.255));
+}
+
+
+double Modules::altitude(double P, double P0)
+// Given a pressure measurement P (mb) and the pressure at a baseline P0 (mb),
+// return altitude (meters) above baseline.
+{
+        return(44330.0*(1-pow(P/P0,1/5.255)));
+}

ESP8266_DOMOTICZ_BMP180/Modules.h

@@ -0,0 +1,35 @@
+#ifndef Modules_h
+#define Modules_h
+
+#include <BMP180.h>
+#include <Wire.h>
+#include "Pins.h"
+
+// ################# Barometre ####
+#define ALTITUDE      19.0 // Altitude of SparkFun's HQ in Boulder, CO. in meters
+
+
+// #####################
+
+class Modules
+{
+  public:
+    Modules();
+    void barometre();
+    void readLuminosite();
+    void sleep(int sleepTime);
+    double sealevel(double P, double A);
+    double altitude(double P, double P0);
+  private:
+  public:
+  BMP180 bmp;
+  double humidity = 0;
+  double temp     = -127;
+  double pression = 0;
+  double pressure = 0;
+  double pressionHg = 0;
+  double alt      = 0;
+  double lum      = 0;
+
+};
+#endif

ESP8266_DOMOTICZ_BMP180/Params.cpp

@@ -0,0 +1,7 @@
+#include "Params.h"
+
+Params::Params()
+{
+  
+}
+

ESP8266_DOMOTICZ_BMP180/Params.h

@@ -0,0 +1,16 @@
+#ifndef Params_h
+#define Params_h
+#include <Arduino.h>
+
+
+class Params {
+  public :
+    Params();
+    public :
+    String esp8266_id;
+    String esp8266_id_Vcc;
+    String esp8266_id_lum;
+    int sleepTime = 120;
+};
+
+#endif

ESP8266_DOMOTICZ_BMP180/Pins.h

@@ -0,0 +1,12 @@
+#ifndef Pins_h
+#define Pins_h
+#include <Arduino.h>
+
+//#define SDA          D2
+//#define SCL          D1
+//#define PIN_ALIM_DS   D3
+//
+#define PIN_LUM       A0
+
+
+#endif