GitList
Browse code

Am adaugat fisierele in directoare cu acelasi nume ca sa le putem deschide direct cu 'Arduino'

Liviu Pislaru authored on 28/02/2018 15:10:25
Showing 8 changed files
arduino/nodemcu/credentiale.ino
History View file @ 04250b8
1 1 
deleted file mode 100644
... ... 
@@ -1,159 +0,0 @@
1 
-#include <FS.h>                   //this needs to be first, or it all crashes and burns...
2 
-#include <ESP8266WiFi.h>          //https://github.com/esp8266/Arduino
3 
-#include <DNSServer.h>
4 
-#include <ESP8266WebServer.h>
5 
-#include <WiFiManager.h>          //https://github.com/tzapu/WiFiManager
6 
-#include <ArduinoJson.h>          //https://github.com/bblanchon/ArduinoJson pentru salvarea credentialelor in eprom
7 
-
8 
-
9 
-
10 
-const char* comanda="save"; //valori posibile: save, erase
11 
-char* set_mqtt_user="exwrgq";
12 
-char* set_mqtt_devid="2638";
13 
-
14 
-
15 
-
16 
-/*******************************
17 
-*       NU EDITA MAI JOS       *
18 
-*******************************/
19 
-
20 
-char mqtt_user[9];
21 
-char mqtt_devid[5];
22 
-
23 
-void setup() {
24 
-  Serial.begin(115200);
25 
-
26 
-  //clean FS, for testing
27 
-  if (comanda == "erase"){
28 
-    SPIFFS.format();
29 
-    Serial.println("am formatat !");
30 
-    delay(1000000);
31 
-  }
32 
-  readFS();
33 
-
34 
-  // The extra parameters to be configured (can be either global or just in the setup)
35 
-  // After connecting, parameter.getValue() will get you the configured value
36 
-  // id/name placeholder/prompt default length
37 
-  WiFiManagerParameter custom_mqtt_user("user", "mqtt user", mqtt_user, 9);
38 
-  WiFiManagerParameter custom_mqtt_devid("devid", "mqtt devid", mqtt_devid, 5);
39 
-
40 
-  //WiFiManager
41 
-  //Local intialization. Once its business is done, there is no need to keep it around
42 
-  WiFiManager wifiManager;
43 
-
44 
-  //set config save notify callback
45 
-  //wifiManager.setSaveConfigCallback(saveConfigCallback);
46 
-
47 
-  //add all your parameters here
48 
-  //sters wifiManager.addParameter(&custom_mqtt_user); //apare campul in interfata web alaturi de SSID si pass de la WIfi
49 
-  //sters wifiManager.addParameter(&custom_mqtt_devid);
50 
-
51 
-  //reset settings - for testing
52 
-  //wifiManager.resetSettings();
53 
-
54 
-  //set minimu quality of signal so it ignores AP's under that quality
55 
-  //defaults to 8%
56 
-  //wifiManager.setMinimumSignalQuality();
57 
-
58 
-  //sets timeout until configuration portal gets turned off
59 
-  //useful to make it all retry or go to sleep
60 
-  //in seconds
61 
-  //wifiManager.setTimeout(120);
62 
-
63 
-  //fetches ssid and pass and tries to connect
64 
-  //if it does not connect it starts an access point with the specified name
65 
-  //here  "AutoConnectAP"
66 
-  //and goes into a blocking loop awaiting configuration
67 
-  /*
68 
-  if (!wifiManager.autoConnect("ClickHOME")) {
69 
-    Serial.println("failed to connect and hit timeout");
70 
-    delay(3000);
71 
-    //reset and try again, or maybe put it to deep sleep
72 
-    ESP.reset();
73 
-    delay(5000);
74 
-  }
75 
-  */
76 
-
77 
-  //read updated parameters
78 
-  strcpy(mqtt_user, custom_mqtt_user.getValue());
79 
-  strcpy(mqtt_devid, custom_mqtt_devid.getValue());
80 
-
81 
-  Serial.print("setup read updated mqtt_user:");
82 
-  Serial.print(mqtt_user);
83 
-  Serial.println("read mqtt_devid:");
84 
-  Serial.println(mqtt_devid);
85 
-
86 
-  if (comanda == "save"){
87 
-    strcpy(mqtt_user, set_mqtt_user);
88 
-    strcpy(mqtt_devid, set_mqtt_devid);
89 
-    saveFS();
90 
-  }
91 
-}
92 
-
93 
-void saveFS(){
94 
-  //save the custom parameters to FS
95 
-  Serial.println("saving config");
96 
-  DynamicJsonBuffer jsonBuffer;
97 
-  JsonObject& json = jsonBuffer.createObject();
98 
-  json["mqtt_user"] = mqtt_user;
99 
-  json["mqtt_devid"] = mqtt_devid;
100 
-
101 
-  File configFile = SPIFFS.open("/config.json", "w");
102 
-  if (!configFile) {
103 
-    Serial.println("failed to open config file for writing");
104 
-  }
105 
-
106 
-  json.printTo(Serial);
107 
-  json.printTo(configFile);
108 
-  configFile.close();
109 
-  //end save
110 
-}
111 
-
112 
-void readFS(){
113 
-  //read configuration from FS json
114 
-  Serial.println("mounting FS...");
115 
-
116 
-  if (SPIFFS.begin()) {
117 
-    Serial.println("mounted file system");
118 
-    if (SPIFFS.exists("/config.json")) {
119 
-      //file exists, reading and loading
120 
-      Serial.println("reading config file");
121 
-      File configFile = SPIFFS.open("/config.json", "r");
122 
-      if (configFile) {
123 
-        Serial.println("opened config file");
124 
-
125 
-        size_t size = configFile.size();
126 
-        // Allocate a buffer to store contents of the file.
127 
-        std::unique_ptr<char[]> buf(new char[size]);
128 
-
129 
-        configFile.readBytes(buf.get(), size);
130 
-        DynamicJsonBuffer jsonBuffer;
131 
-        JsonObject& json = jsonBuffer.parseObject(buf.get());
132 
-        json.printTo(Serial);
133 
-        if (json.success()) {
134 
-          Serial.println("\nparsed json");
135 
-
136 
-          strcpy(mqtt_user, json["mqtt_user"]);
137 
-          strcpy(mqtt_devid, json["mqtt_devid"]);
138 
-
139 
-          Serial.print("read from FS updated mqtt_user:");
140 
-          Serial.println(mqtt_user);
141 
-          Serial.print("read mqtt_devid:");
142 
-          Serial.println(mqtt_devid);
143 
-
144 
-
145 
-        } else {
146 
-          Serial.println("failed to load json config");
147 
-        }
148 
-      }
149 
-    }
150 
-  } else {
151 
-    Serial.println("failed to mount FS");
152 
-  }
153 
-  //end read
154 
-}
155 
-
156 
-void loop() {
157 
-  Serial.println("gata!");
158 
-  delay(100000);
159 
-}
arduino/nodemcu/credentiale/credentiale.ino
History View file @ 04250b8
160 1 
new file mode 100644
... ... 
@@ -0,0 +1,159 @@
0 
+#include <FS.h>                   //this needs to be first, or it all crashes and burns...
1 
+#include <ESP8266WiFi.h>          //https://github.com/esp8266/Arduino
2 
+#include <DNSServer.h>
3 
+#include <ESP8266WebServer.h>
4 
+#include <WiFiManager.h>          //https://github.com/tzapu/WiFiManager
5 
+#include <ArduinoJson.h>          //https://github.com/bblanchon/ArduinoJson pentru salvarea credentialelor in eprom
6 
+
7 
+
8 
+
9 
+const char* comanda="save"; //valori posibile: save, erase
10 
+char* set_mqtt_user="exwrgq";
11 
+char* set_mqtt_devid="2638";
12 
+
13 
+
14 
+
15 
+/*******************************
16 
+*       NU EDITA MAI JOS       *
17 
+*******************************/
18 
+
19 
+char mqtt_user[9];
20 
+char mqtt_devid[5];
21 
+
22 
+void setup() {
23 
+  Serial.begin(115200);
24 
+
25 
+  //clean FS, for testing
26 
+  if (comanda == "erase"){
27 
+    SPIFFS.format();
28 
+    Serial.println("am formatat !");
29 
+    delay(1000000);
30 
+  }
31 
+  readFS();
32 
+
33 
+  // The extra parameters to be configured (can be either global or just in the setup)
34 
+  // After connecting, parameter.getValue() will get you the configured value
35 
+  // id/name placeholder/prompt default length
36 
+  WiFiManagerParameter custom_mqtt_user("user", "mqtt user", mqtt_user, 9);
37 
+  WiFiManagerParameter custom_mqtt_devid("devid", "mqtt devid", mqtt_devid, 5);
38 
+
39 
+  //WiFiManager
40 
+  //Local intialization. Once its business is done, there is no need to keep it around
41 
+  WiFiManager wifiManager;
42 
+
43 
+  //set config save notify callback
44 
+  //wifiManager.setSaveConfigCallback(saveConfigCallback);
45 
+
46 
+  //add all your parameters here
47 
+  //sters wifiManager.addParameter(&custom_mqtt_user); //apare campul in interfata web alaturi de SSID si pass de la WIfi
48 
+  //sters wifiManager.addParameter(&custom_mqtt_devid);
49 
+
50 
+  //reset settings - for testing
51 
+  //wifiManager.resetSettings();
52 
+
53 
+  //set minimu quality of signal so it ignores AP's under that quality
54 
+  //defaults to 8%
55 
+  //wifiManager.setMinimumSignalQuality();
56 
+
57 
+  //sets timeout until configuration portal gets turned off
58 
+  //useful to make it all retry or go to sleep
59 
+  //in seconds
60 
+  //wifiManager.setTimeout(120);
61 
+
62 
+  //fetches ssid and pass and tries to connect
63 
+  //if it does not connect it starts an access point with the specified name
64 
+  //here  "AutoConnectAP"
65 
+  //and goes into a blocking loop awaiting configuration
66 
+  /*
67 
+  if (!wifiManager.autoConnect("ClickHOME")) {
68 
+    Serial.println("failed to connect and hit timeout");
69 
+    delay(3000);
70 
+    //reset and try again, or maybe put it to deep sleep
71 
+    ESP.reset();
72 
+    delay(5000);
73 
+  }
74 
+  */
75 
+
76 
+  //read updated parameters
77 
+  strcpy(mqtt_user, custom_mqtt_user.getValue());
78 
+  strcpy(mqtt_devid, custom_mqtt_devid.getValue());
79 
+
80 
+  Serial.print("setup read updated mqtt_user:");
81 
+  Serial.print(mqtt_user);
82 
+  Serial.println("read mqtt_devid:");
83 
+  Serial.println(mqtt_devid);
84 
+
85 
+  if (comanda == "save"){
86 
+    strcpy(mqtt_user, set_mqtt_user);
87 
+    strcpy(mqtt_devid, set_mqtt_devid);
88 
+    saveFS();
89 
+  }
90 
+}
91 
+
92 
+void saveFS(){
93 
+  //save the custom parameters to FS
94 
+  Serial.println("saving config");
95 
+  DynamicJsonBuffer jsonBuffer;
96 
+  JsonObject& json = jsonBuffer.createObject();
97 
+  json["mqtt_user"] = mqtt_user;
98 
+  json["mqtt_devid"] = mqtt_devid;
99 
+
100 
+  File configFile = SPIFFS.open("/config.json", "w");
101 
+  if (!configFile) {
102 
+    Serial.println("failed to open config file for writing");
103 
+  }
104 
+
105 
+  json.printTo(Serial);
106 
+  json.printTo(configFile);
107 
+  configFile.close();
108 
+  //end save
109 
+}
110 
+
111 
+void readFS(){
112 
+  //read configuration from FS json
113 
+  Serial.println("mounting FS...");
114 
+
115 
+  if (SPIFFS.begin()) {
116 
+    Serial.println("mounted file system");
117 
+    if (SPIFFS.exists("/config.json")) {
118 
+      //file exists, reading and loading
119 
+      Serial.println("reading config file");
120 
+      File configFile = SPIFFS.open("/config.json", "r");
121 
+      if (configFile) {
122 
+        Serial.println("opened config file");
123 
+
124 
+        size_t size = configFile.size();
125 
+        // Allocate a buffer to store contents of the file.
126 
+        std::unique_ptr<char[]> buf(new char[size]);
127 
+
128 
+        configFile.readBytes(buf.get(), size);
129 
+        DynamicJsonBuffer jsonBuffer;
130 
+        JsonObject& json = jsonBuffer.parseObject(buf.get());
131 
+        json.printTo(Serial);
132 
+        if (json.success()) {
133 
+          Serial.println("\nparsed json");
134 
+
135 
+          strcpy(mqtt_user, json["mqtt_user"]);
136 
+          strcpy(mqtt_devid, json["mqtt_devid"]);
137 
+
138 
+          Serial.print("read from FS updated mqtt_user:");
139 
+          Serial.println(mqtt_user);
140 
+          Serial.print("read mqtt_devid:");
141 
+          Serial.println(mqtt_devid);
142 
+
143 
+
144 
+        } else {
145 
+          Serial.println("failed to load json config");
146 
+        }
147 
+      }
148 
+    }
149 
+  } else {
150 
+    Serial.println("failed to mount FS");
151 
+  }
152 
+  //end read
153 
+}
154 
+
155 
+void loop() {
156 
+  Serial.println("gata!");
157 
+  delay(100000);
158 
+}
arduino/nodemcu/releu.ino
History View file @ 04250b8
0 159 
deleted file mode 100644
... ... 
@@ -1,219 +0,0 @@
1 
-#include <ESP8266WiFi.h>
2 
-#include <PubSubClient.h>
3 
-#include <WiFiManager.h>        //https://github.com/tzapu/WiFiManager
4 
-#include <WiFiClient.h>
5 
-#include <OneWire.h>
6 
-#include <ESP8266HTTPClient.h>
7 
-#include <ESP8266httpUpdate.h>
8 
-
9 
-#define RELAY D2 //  pinul de date (la mine am pus releu pe D2)
10 
-
11 
-// Modifica cu datele tale
12 
-const char* mqttUser = "qbzesh";
13 
-const char* mqttPassword = "8219CHqbzesh";
14 
-const char* mqttSUB = "cmnd/qbzesh-1432/ESP";
15 
-const char* mqttESP = "stat/qbzesh-1432/ESP";
16 
-const char* mqttRELAY = "stat/qbzesh-1432/RELAY";
17 
-const char* mqttLWT = "tele/qbzesh-1432/LWT";
18 
-const char* espName ="qbzesh-1432";
19 
-
20 
-//#######################################################################
21 
-// NU EDITA MAI JOS
22 
-//#######################################################################
23 
-const String model = "NodeMCU Releu";
24 
-const String ver = "v1.0.5";
25 
-const char* mqttServer = "mqtt.clickhome.ro";
26 
-const int mqttPort = 1883;
27 
-long loopTimer = 900000; // miliseconds - by default trimite la 15 minute
28 
-long lastMsg = 0;
29 
-float loopTemp = 0;
30 
-String mqttMessage;
31 
-
32 
-WiFiClient espClient;
33 
-PubSubClient client(espClient);
34 
-
35 
-String ipToString(IPAddress ip){
36 
-  String s="";
37 
-  for (int i=0; i<4; i++)
38 
-    s += i  ? "." + String(ip[i]) : String(ip[i]);
39 
-  return s;
40 
-}
41 
-String getMacAddress() {
42 
-  byte mac[6];
43 
-  WiFi.macAddress(mac);
44 
-  String cMac = "";
45 
-  for (int i = 0; i < 6; ++i) {
46 
-    cMac += String(mac[i],HEX);
47 
-    if(i<5)
48 
-    cMac += "-";
49 
-  }
50 
-  cMac.toUpperCase();
51 
-  return cMac;
52 
-}
53 
-
54 
-void reconnect()
55 
-{
56 
-  while (!client.connected())
57 
-  {
58 
-    Serial.print("AtloopTempting MQTT connection...");
59 
-     // Incerc sa ma reconectez cu LWT din 60 in 60 secunde
60 
-    if (client.connect(espName, mqttUser, mqttPassword, mqttLWT, 1, 1, "Offline"))
61 
-    {
62 
-        Serial.println("Releu reconectat la MQTT.");
63 
-        client.publish(mqttLWT,"Online",TRUE);
64 
-        // trimit informatii utile cand ma conectez
65 
-        String esp_info = "{\"ESPMac\":\"";
66 
-        esp_info += getMacAddress();
67 
-        esp_info += "\", \"IPAddress\":\"";
68 
-        esp_info += ipToString(WiFi.localIP());
69 
-        esp_info += "\"}";
70 
-        String netinfo = "{\"Module\":\"";
71 
-        netinfo += String (model);
72 
-        netinfo += "\", \"Version\":\"";
73 
-        netinfo += String (ver);
74 
-        netinfo += "\"}";
75 
-
76 
-        client.publish(mqttESP, netinfo.c_str(),TRUE);
77 
-        Serial.println(netinfo);
78 
-        client.publish(mqttESP, esp_info.c_str(),TRUE);
79 
-        Serial.println(esp_info);
80 
-        client.subscribe(mqttSUB);
81 
-    }
82 
-    else {
83 
-        Serial.println("Reconectare MQTT esuata: ");
84 
-        Serial.println(client.state());
85 
-        Serial.println("fac o alta incercare in 60 de secunde");
86 
-        delay(60000);
87 
-    }
88 
-  }
89 
-}
90 
-
91 
-void setup()
92 
-{
93 
-  Serial.begin(115200);
94 
-  pinMode(RELAY,OUTPUT);
95 
-
96 
-  // ma conectez la AP via wifi
97 
-   WiFiManager wifi;
98 
-   wifi.setTimeout(180); // sta AP 3 minute apoi se reseteaza din nou
99 
-   if (!wifi.autoConnect("ClickHome")) {
100 
-     Serial.println("timeout - going to sleep");
101 
-  }
102 
-  delay(200);
103 
-
104 
-  // ma conectez la mqtt server
105 
-  client.setServer(mqttServer, mqttPort);
106 
-    while (!client.connected()) {
107 
-    Serial.println("Connecting to MQTT...");
108 
-    // fac connect cu LWT
109 
-    if (client.connect(espName, mqttUser, mqttPassword, mqttLWT, 1, 1, "Offline")) {
110 
-      // trimit starea Online pe topic LWT cand ma conectez
111 
-      client.publish(mqttLWT,"Online",TRUE);
112 
-      // trimit starea OFF cand il aprind
113 
-      digitalWrite(RELAY,LOW);
114 
-      client.publish(mqttRELAY, "{\"Relay\":\"0\"}", TRUE);
115 
-      Serial.println("connected");
116 
-      // trimit informatii utile cand ma conectez
117 
-        String esp_info = "{\"ESPMac\":\"";
118 
-        esp_info += getMacAddress();
119 
-        esp_info += "\", \"IPAddress\":\"";
120 
-        esp_info += ipToString(WiFi.localIP());
121 
-        esp_info += "\"}";
122 
-        String netinfo = "{\"Module\":\"";
123 
-        netinfo += String (model);
124 
-        netinfo += "\", \"Version\":\"";
125 
-        netinfo += String (ver);
126 
-        netinfo += "\"}";
127 
-
128 
-        client.publish(mqttESP, netinfo.c_str(),TRUE);
129 
-        Serial.println(netinfo);
130 
-        client.publish(mqttESP, esp_info.c_str(),TRUE);
131 
-        Serial.println(esp_info);
132 
-      client.subscribe(mqttSUB);
133 
-    }
134 
-      else {
135 
-        Serial.print("Conectare MQTT esuata: ");
136 
-        Serial.print(client.state());
137 
-        delay(2000);
138 
-    }
139 
-  }
140 
-  // astept mesajul de la serverul MQTT
141 
-  client.setCallback(getMessage);
142 
- // pinMode(RELAY,OUTPUT);
143 
-}
144 
-
145 
-void getMessage(char* topic, byte* payload, unsigned int length) {
146 
-  float t = 0;
147 
-  mqttMessage="";
148 
-  Serial.print("Message arrived in topic: ");
149 
-  Serial.println(topic);
150 
-  Serial.print("Message:");
151 
-  for (int i = 0; i < length; i++) {
152 
-    mqttMessage += (char)payload[i];
153 
-  }
154 
-  Serial.println(mqttMessage);
155 
-
156 
-  // daca a primit on
157 
-  if (mqttMessage == "ON")
158 
-  {
159 
-    Serial.println("Pornesc releu");
160 
-    digitalWrite(RELAY,HIGH);
161 
-    String json = "{\"Relay\":\"1\"}";
162 
-    client.publish(mqttRELAY, json.c_str(),TRUE);
163 
-  }
164 
-  if (mqttMessage == "OFF")
165 
-  {
166 
-     long now = millis();
167 
-    Serial.println("Opresc releu");
168 
-    Serial.println(now);
169 
-    digitalWrite(RELAY,LOW);
170 
-    String json = "{\"Relay\":\"0\"}";
171 
-    client.publish(mqttRELAY, json.c_str(),TRUE);
172 
-  }
173 
-   // procedura de software update via WEB
174 
-   if (mqttMessage == "update")
175 
-   {
176 
-        String msg="Software update: ";
177 
-        t_httpUpdate_return ret;
178 
-        //ESPhttpUpdate.rebootOnUpdate(false);
179 
-        ret = ESPhttpUpdate.update("http://update.clickhome.ro/releu/arduino.bin");
180 
-        switch(ret) {
181 
-           case HTTP_UPDATE_FAILED:
182 
-               msg.concat(" eroare:");
183 
-               msg.concat(ESPhttpUpdate.getLastError());
184 
-               msg.concat(" motiv:");
185 
-               msg.concat(ESPhttpUpdate.getLastErrorString().c_str());
186 
-               break;
187 
-           case HTTP_UPDATE_NO_UPDATES:
188 
-               msg.concat(" no update.");
189 
-               break;
190 
-           case HTTP_UPDATE_OK:
191 
-               msg.concat(" success.");
192 
-               break;
193 
-        }
194 
-        Serial.println(msg);
195 
-   }
196 
-
197 
-  if (mqttMessage == "stare")
198 
-  {
199 
-    // citesc starea si o trimit
200 
-    String json = "{\"Relay\":\"";
201 
-    json += String (digitalRead(RELAY));
202 
-    json += "\"}";
203 
-    client.publish(mqttRELAY, json.c_str(),TRUE);
204 
-  }
205 
-}
206 
-void loop()
207 
-{
208 
-  if (!client.connected())
209 
-  {
210 
-    reconnect();
211 
-  }
212 
-  client.loop();
213 
-  long now = millis();
214 
-  if (now - lastMsg > loopTimer)
215 
-  {
216 
-    lastMsg = now;
217 
-       Serial.println("Nu fac nimic in bucla");
218 
-  }
219 
-}
arduino/nodemcu/releu/releu.ino
History View file @ 04250b8
220 1 
new file mode 100644
... ... 
@@ -0,0 +1,219 @@
0 
+#include <ESP8266WiFi.h>
1 
+#include <PubSubClient.h>
2 
+#include <WiFiManager.h>        //https://github.com/tzapu/WiFiManager
3 
+#include <WiFiClient.h>
4 
+#include <OneWire.h>
5 
+#include <ESP8266HTTPClient.h>
6 
+#include <ESP8266httpUpdate.h>
7 
+
8 
+#define RELAY D2 //  pinul de date (la mine am pus releu pe D2)
9 
+
10 
+// Modifica cu datele tale
11 
+const char* mqttUser = "qbzesh";
12 
+const char* mqttPassword = "8219CHqbzesh";
13 
+const char* mqttSUB = "cmnd/qbzesh-1432/ESP";
14 
+const char* mqttESP = "stat/qbzesh-1432/ESP";
15 
+const char* mqttRELAY = "stat/qbzesh-1432/RELAY";
16 
+const char* mqttLWT = "tele/qbzesh-1432/LWT";
17 
+const char* espName ="qbzesh-1432";
18 
+
19 
+//#######################################################################
20 
+// NU EDITA MAI JOS
21 
+//#######################################################################
22 
+const String model = "NodeMCU Releu";
23 
+const String ver = "v1.0.5";
24 
+const char* mqttServer = "mqtt.clickhome.ro";
25 
+const int mqttPort = 1883;
26 
+long loopTimer = 900000; // miliseconds - by default trimite la 15 minute
27 
+long lastMsg = 0;
28 
+float loopTemp = 0;
29 
+String mqttMessage;
30 
+
31 
+WiFiClient espClient;
32 
+PubSubClient client(espClient);
33 
+
34 
+String ipToString(IPAddress ip){
35 
+  String s="";
36 
+  for (int i=0; i<4; i++)
37 
+    s += i  ? "." + String(ip[i]) : String(ip[i]);
38 
+  return s;
39 
+}
40 
+String getMacAddress() {
41 
+  byte mac[6];
42 
+  WiFi.macAddress(mac);
43 
+  String cMac = "";
44 
+  for (int i = 0; i < 6; ++i) {
45 
+    cMac += String(mac[i],HEX);
46 
+    if(i<5)
47 
+    cMac += "-";
48 
+  }
49 
+  cMac.toUpperCase();
50 
+  return cMac;
51 
+}
52 
+
53 
+void reconnect()
54 
+{
55 
+  while (!client.connected())
56 
+  {
57 
+    Serial.print("AtloopTempting MQTT connection...");
58 
+     // Incerc sa ma reconectez cu LWT din 60 in 60 secunde
59 
+    if (client.connect(espName, mqttUser, mqttPassword, mqttLWT, 1, 1, "Offline"))
60 
+    {
61 
+        Serial.println("Releu reconectat la MQTT.");
62 
+        client.publish(mqttLWT,"Online",TRUE);
63 
+        // trimit informatii utile cand ma conectez
64 
+        String esp_info = "{\"ESPMac\":\"";
65 
+        esp_info += getMacAddress();
66 
+        esp_info += "\", \"IPAddress\":\"";
67 
+        esp_info += ipToString(WiFi.localIP());
68 
+        esp_info += "\"}";
69 
+        String netinfo = "{\"Module\":\"";
70 
+        netinfo += String (model);
71 
+        netinfo += "\", \"Version\":\"";
72 
+        netinfo += String (ver);
73 
+        netinfo += "\"}";
74 
+
75 
+        client.publish(mqttESP, netinfo.c_str(),TRUE);
76 
+        Serial.println(netinfo);
77 
+        client.publish(mqttESP, esp_info.c_str(),TRUE);
78 
+        Serial.println(esp_info);
79 
+        client.subscribe(mqttSUB);
80 
+    }
81 
+    else {
82 
+        Serial.println("Reconectare MQTT esuata: ");
83 
+        Serial.println(client.state());
84 
+        Serial.println("fac o alta incercare in 60 de secunde");
85 
+        delay(60000);
86 
+    }
87 
+  }
88 
+}
89 
+
90 
+void setup()
91 
+{
92 
+  Serial.begin(115200);
93 
+  pinMode(RELAY,OUTPUT);
94 
+
95 
+  // ma conectez la AP via wifi
96 
+   WiFiManager wifi;
97 
+   wifi.setTimeout(180); // sta AP 3 minute apoi se reseteaza din nou
98 
+   if (!wifi.autoConnect("ClickHome")) {
99 
+     Serial.println("timeout - going to sleep");
100 
+  }
101 
+  delay(200);
102 
+
103 
+  // ma conectez la mqtt server
104 
+  client.setServer(mqttServer, mqttPort);
105 
+    while (!client.connected()) {
106 
+    Serial.println("Connecting to MQTT...");
107 
+    // fac connect cu LWT
108 
+    if (client.connect(espName, mqttUser, mqttPassword, mqttLWT, 1, 1, "Offline")) {
109 
+      // trimit starea Online pe topic LWT cand ma conectez
110 
+      client.publish(mqttLWT,"Online",TRUE);
111 
+      // trimit starea OFF cand il aprind
112 
+      digitalWrite(RELAY,LOW);
113 
+      client.publish(mqttRELAY, "{\"Relay\":\"0\"}", TRUE);
114 
+      Serial.println("connected");
115 
+      // trimit informatii utile cand ma conectez
116 
+        String esp_info = "{\"ESPMac\":\"";
117 
+        esp_info += getMacAddress();
118 
+        esp_info += "\", \"IPAddress\":\"";
119 
+        esp_info += ipToString(WiFi.localIP());
120 
+        esp_info += "\"}";
121 
+        String netinfo = "{\"Module\":\"";
122 
+        netinfo += String (model);
123 
+        netinfo += "\", \"Version\":\"";
124 
+        netinfo += String (ver);
125 
+        netinfo += "\"}";
126 
+
127 
+        client.publish(mqttESP, netinfo.c_str(),TRUE);
128 
+        Serial.println(netinfo);
129 
+        client.publish(mqttESP, esp_info.c_str(),TRUE);
130 
+        Serial.println(esp_info);
131 
+      client.subscribe(mqttSUB);
132 
+    }
133 
+      else {
134 
+        Serial.print("Conectare MQTT esuata: ");
135 
+        Serial.print(client.state());
136 
+        delay(2000);
137 
+    }
138 
+  }
139 
+  // astept mesajul de la serverul MQTT
140 
+  client.setCallback(getMessage);
141 
+ // pinMode(RELAY,OUTPUT);
142 
+}
143 
+
144 
+void getMessage(char* topic, byte* payload, unsigned int length) {
145 
+  float t = 0;
146 
+  mqttMessage="";
147 
+  Serial.print("Message arrived in topic: ");
148 
+  Serial.println(topic);
149 
+  Serial.print("Message:");
150 
+  for (int i = 0; i < length; i++) {
151 
+    mqttMessage += (char)payload[i];
152 
+  }
153 
+  Serial.println(mqttMessage);
154 
+
155 
+  // daca a primit on
156 
+  if (mqttMessage == "ON")
157 
+  {
158 
+    Serial.println("Pornesc releu");
159 
+    digitalWrite(RELAY,HIGH);
160 
+    String json = "{\"Relay\":\"1\"}";
161 
+    client.publish(mqttRELAY, json.c_str(),TRUE);
162 
+  }
163 
+  if (mqttMessage == "OFF")
164 
+  {
165 
+     long now = millis();
166 
+    Serial.println("Opresc releu");
167 
+    Serial.println(now);
168 
+    digitalWrite(RELAY,LOW);
169 
+    String json = "{\"Relay\":\"0\"}";
170 
+    client.publish(mqttRELAY, json.c_str(),TRUE);
171 
+  }
172 
+   // procedura de software update via WEB
173 
+   if (mqttMessage == "update")
174 
+   {
175 
+        String msg="Software update: ";
176 
+        t_httpUpdate_return ret;
177 
+        //ESPhttpUpdate.rebootOnUpdate(false);
178 
+        ret = ESPhttpUpdate.update("http://update.clickhome.ro/releu/arduino.bin");
179 
+        switch(ret) {
180 
+           case HTTP_UPDATE_FAILED:
181 
+               msg.concat(" eroare:");
182 
+               msg.concat(ESPhttpUpdate.getLastError());
183 
+               msg.concat(" motiv:");
184 
+               msg.concat(ESPhttpUpdate.getLastErrorString().c_str());
185 
+               break;
186 
+           case HTTP_UPDATE_NO_UPDATES:
187 
+               msg.concat(" no update.");
188 
+               break;
189 
+           case HTTP_UPDATE_OK:
190 
+               msg.concat(" success.");
191 
+               break;
192 
+        }
193 
+        Serial.println(msg);
194 
+   }
195 
+
196 
+  if (mqttMessage == "stare")
197 
+  {
198 
+    // citesc starea si o trimit
199 
+    String json = "{\"Relay\":\"";
200 
+    json += String (digitalRead(RELAY));
201 
+    json += "\"}";
202 
+    client.publish(mqttRELAY, json.c_str(),TRUE);
203 
+  }
204 
+}
205 
+void loop()
206 
+{
207 
+  if (!client.connected())
208 
+  {
209 
+    reconnect();
210 
+  }
211 
+  client.loop();
212 
+  long now = millis();
213 
+  if (now - lastMsg > loopTimer)
214 
+  {
215 
+    lastMsg = now;
216 
+       Serial.println("Nu fac nimic in bucla");
217 
+  }
218 
+}
arduino/nodemcu/senzor-dallas.ino
History View file @ 04250b8
0 219 
deleted file mode 100644
... ... 
@@ -1,273 +0,0 @@
1 
-#include <FS.h>                   //this needs to be first, e folosit de salvarea credentialelor pe FS
2 
-#include <ESP8266WiFi.h>
3 
-#include <PubSubClient.h>
4 
-#include <WiFiManager.h>        //https://github.com/tzapu/WiFiManager
5 
-#include <ArduinoJson.h>          //https://github.com/bblanchon/ArduinoJson pentru salvarea credentialelor in eprom
6 
-#include <WiFiClient.h>
7 
-#include <OneWire.h>
8 
-#include <DallasTemperature.h>
9 
-
10 
-char mqtt_user[9]; //le va lua din FS
11 
-char mqtt_devid[5]; //le va lua din FS
12 
-char mqttPassword[15]; //urmatoarele le va genera cu functia gen
13 
-char mqttSUB[22];
14 
-char espName[13];
15 
-char mqttESP[22];
16 
-char mqttTEMP[23];
17 
-char mqttLWT[22];
18 
-
19 
-const String model = "NodeMCU Dallas";
20 
-const String ver = "v2.0.0";
21 
-const char* mqttServer = "mqtt.clickhome.ro";
22 
-const int mqttPort = 1883;
23 
-long loopTimer = 900000; // miliseconds - by default trimite la 15 minute
24 
-long lastMsg = 0;
25 
-float loopTemp = 0;
26 
-int inPin = 5;
27 
-String mqttMessage;
28 
-
29 
-// senzor de temperatura DALLAS
30 
-#define ONE_WIRE_BUS D4  // pinul de date (la mine am pus senzor pe D4)
31 
-OneWire oneWire(ONE_WIRE_BUS);
32 
-DallasTemperature sensors(&oneWire);
33 
-
34 
-//*********************************************************************
35 
-
36 
-WiFiClient espClient;
37 
-PubSubClient client(espClient);
38 
-
39 
-void generate_vars(){
40 
-  strcpy (mqttPassword, "8219CH");
41 
-  strcat (mqttPassword, mqtt_user);
42 
-
43 
-  strcpy (espName, mqtt_user);
44 
-  strcat (espName, "-");
45 
-  strcat (espName, mqtt_devid);
46 
-
47 
-  strcpy (mqttSUB, "cmnd/");
48 
-  strcat (mqttSUB, espName);
49 
-  strcat (mqttSUB, "/ESP");
50 
-
51 
-  strcpy (mqttESP, "stat/");
52 
-  strcat (mqttESP, espName);
53 
-  strcat (mqttESP, "/ESP");
54 
-
55 
-  strcpy (mqttTEMP, "stat/");
56 
-  strcat (mqttTEMP, espName);
57 
-  strcat (mqttTEMP, "/TEMP");
58 
-
59 
-  strcpy (mqttLWT, "tele/");
60 
-  strcat (mqttLWT, espName);
61 
-  strcat (mqttLWT, "/LWT");
62 
-}
63 
-
64 
-String ipToString(IPAddress ip){
65 
-  String s="";
66 
-  for (int i=0; i<4; i++)
67 
-    s += i  ? "." + String(ip[i]) : String(ip[i]);
68 
-  return s;
69 
-}
70 
-
71 
-String getMacAddress() {
72 
-  byte mac[6];
73 
-  WiFi.macAddress(mac);
74 
-  String cMac = "";
75 
-  for (int i = 0; i < 6; ++i) {
76 
-    cMac += String(mac[i],HEX);
77 
-    if(i<5)
78 
-    cMac += "-";
79 
-  }
80 
-  cMac.toUpperCase();
81 
-  return cMac;
82 
-}
83 
-
84 
-void reconectez() {
85 
-  while (String(mqtt_user)==""){
86 
-    Serial.println("Invalid user!");
87 
-    delay(99999999);
88 
-  }
89 
-
90 
-  // ma conectez la mqtt server
91 
-  while (!client.connected()) {
92 
-    client.setServer(mqttServer, mqttPort);
93 
-    Serial.print("AtloopTempting MQTT connection...");
94 
-    // Incerc sa ma reconectez cu LWT din 5 in 5 secunde
95 
-    if (client.connect(espName, mqtt_user, mqttPassword, mqttLWT, 1, 1, "Offline")) {
96 
-      Serial.println("connected");
97 
-      client.publish(mqttLWT,"Online",TRUE);
98 
-      // trimit informatii utile cand ma conectez
99 
-        String esp_info = "{\"ESPMac\":\"";
100 
-        esp_info += getMacAddress();
101 
-        esp_info += "\", \"IPAddress\":\"";
102 
-        esp_info += ipToString(WiFi.localIP());
103 
-        esp_info += "\"}";
104 
-        String netinfo = "{\"Module\":\"";
105 
-        netinfo += String (model);
106 
-        netinfo += "\", \"Version\":\"";
107 
-        netinfo += String (ver);
108 
-        netinfo += "\"}";
109 
-
110 
-        client.publish(mqttESP, netinfo.c_str(),TRUE);
111 
-        Serial.println(netinfo);
112 
-        client.publish(mqttESP, esp_info.c_str(),TRUE);
113 
-        Serial.println(esp_info);
114 
-        client.publish(mqttESP, "15 minute",TRUE); // trimit intervalul default
115 
-        client.subscribe(mqttSUB);
116 
-    } else {
117 
-      Serial.print("failed, rc=");
118 
-      Serial.print(client.state());
119 
-      Serial.println(" try again in 60 seconds");
120 
-      // Wait 60 seconds before retrying
121 
-      delay(60000);
122 
-    }
123 
-  }
124 
-}
125 
-
126 
-void setup()
127 
-{
128 
-  Serial.begin(115200);
129 
-  //generez variabilele
130 
-  readFS();
131 
-  // The extra parameters to be configured (can be either global or just in the setup)
132 
-  // After connecting, parameter.getValue() will get you the configured value
133 
-  // id/name placeholder/prompt default length
134 
-
135 
-  WiFiManagerParameter custom_mqtt_user("user", "mqtt user", mqtt_user, 9);
136 
-  WiFiManagerParameter custom_mqtt_devid("devid", "mqtt devid", mqtt_devid, 5);
137 
-
138 
-  // ma conectez la AP via wifi
139 
-   WiFiManager wifi;
140 
-   wifi.setConfigPortalTimeout(120); // a timeout so the ESP doesn't hang waiting to be configured, for instance after a power failure
141 
-   wifi.setTimeout(180); // sta AP 3 minute apoi se reseteaza din nou
142 
-   if (!wifi.autoConnect("ClickHome")) {
143 
-     Serial.println("timeout - going to sleep");
144 
-  }
145 
-  delay(200);
146 
-
147 
-  strcpy(mqtt_user, custom_mqtt_user.getValue()); //citesc datele salvate anterior pe FS
148 
-  strcpy(mqtt_devid, custom_mqtt_devid.getValue());
149 
-  generate_vars(); //genereaza topicurile de mqtt in baza mqtt_user si mqtt_devid
150 
-  reconectez();
151 
-  client.setCallback(getMessage); //setez functia care parseaza mesajele venite prin mqtt
152 
-
153 
-  pinMode(inPin, INPUT);
154 
-  sensors.begin();
155 
-}
156 
-
157 
-void getMessage(char* topic, byte* payload, unsigned int length) {
158 
-  float t = 0;
159 
-  mqttMessage="";
160 
-  Serial.print("Message arrived in topic: ");
161 
-  Serial.println(topic);
162 
-  Serial.print("Message:");
163 
-  for (int i = 0; i < length; i++) {
164 
-    mqttMessage += (char)payload[i];
165 
-  }
166 
-  Serial.println(mqttMessage);
167 
-
168 
-  // daca a primit sendTemp trimite temperatura
169 
-  if (mqttMessage == "temp")
170 
-  {
171 
-    Serial.println("Trimit temperatura");
172 
-    sensors.setResolution(12);
173 
-    sensors.requestTemperatures(); // Send the command to get Temperatures
174 
-    t = sensors.getTempCByIndex(0);
175 
-      String json = "{\"Temp\":";
176 
-      json += String (t);
177 
-      json += "}";
178 
-      client.publish(mqttTEMP, json.c_str(),TRUE);
179 
-      Serial.println(json);
180 
-  }
181 
-
182 
-  // daca a primit valoarea in minute seteaza loopTimer si-l trimite in DB
183 
-
184 
-   if (mqttMessage == "debug")
185 
-   {
186 
-        loopTimer=30000; // setez sa trimita valori la 30 de secunde ca sa fac debug
187 
-        client.publish(mqttESP, "{\"LoopInterval\":\"30 secunde\"}",TRUE);
188 
-   }
189 
-   if (mqttMessage == "10")
190 
-   {
191 
-        loopTimer=600000; // setez sa trimita valori la 10 minute
192 
-        client.publish(mqttESP, "{\"LoopInterval\":\"10 minute\"}",TRUE);
193 
-   }
194 
-   if (mqttMessage == "15")
195 
-   {
196 
-        loopTimer=900000; // setez sa trimita valori la 15 minute
197 
-        client.publish(mqttESP, "{\"LoopInterval\":\"15 minute\"}",TRUE);
198 
-   }
199 
-   if (mqttMessage == "30")
200 
-   {
201 
-        loopTimer=1800000; // setez sa trimita valori la 30 de minute
202 
-        client.publish(mqttESP, "{\"LoopInterval\":\"30 de minute\"}",TRUE);
203 
-   }
204 
-   if (mqttMessage == "60")
205 
-   {
206 
-        loopTimer=3600000; // setez sa trimita valori la o ora
207 
-        client.publish(mqttESP, "{\"LoopInterval\":\"o ora\"}",TRUE);
208 
-   }
209 
-   if (mqttMessage == "stop")
210 
-   {
211 
-        loopTimer=3600000000; // setez sa nu trimita valori
212 
-        client.publish(mqttESP, "{\"LoopInterval\":\"oprit\"}",TRUE);
213 
-   }
214 
-}
215 
-
216 
-void readFS(){
217 
-  //read configuration from FS json
218 
-  //Serial.println("mounting FS...");
219 
-
220 
-  if (SPIFFS.begin()) {
221 
-    //Serial.println("mounted file system");
222 
-    if (SPIFFS.exists("/config.json")) {
223 
-      //file exists, reading and loading
224 
-      //Serial.println("reading config file");
225 
-      File configFile = SPIFFS.open("/config.json", "r");
226 
-      if (configFile) {
227 
-        //Serial.println("opened config file");
228 
-
229 
-        size_t size = configFile.size();
230 
-        // Allocate a buffer to store contents of the file.
231 
-        std::unique_ptr<char[]> buf(new char[size]);
232 
-
233 
-        configFile.readBytes(buf.get(), size);
234 
-        DynamicJsonBuffer jsonBuffer;
235 
-        JsonObject& json = jsonBuffer.parseObject(buf.get());
236 
-        //json.printTo(Serial);
237 
-        if (json.success()) {
238 
-          //Serial.println("\nparsed json");
239 
-          strcpy(mqtt_user, json["mqtt_user"]);
240 
-          strcpy(mqtt_devid, json["mqtt_devid"]);
241 
-        } else {
242 
-          //Serial.println("failed to load json config");
243 
-        }
244 
-      }
245 
-    }
246 
-  } else {
247 
-    //Serial.println("failed to mount FS");
248 
-  }
249 
-  //end read
250 
-}
251 
-
252 
-void loop()
253 
-{
254 
-  if (!client.connected()) {
255 
-    reconectez();
256 
-  }
257 
-  client.loop();
258 
-  long now = millis();
259 
-  if (now - lastMsg > loopTimer) {
260 
-    lastMsg = now;
261 
-    sensors.setResolution(12);
262 
-    sensors.requestTemperatures(); // Send the command to get loopTemperatures
263 
-    loopTemp = sensors.getTempCByIndex(0);
264 
-    Serial.println(loopTemp);
265 
-    if((loopTemp > -20) && (loopTemp <60))
266 
-      {
267 
-     String val = "{\"Temp\":";
268 
-      val += String (loopTemp);
269 
-      val += "}";
270 
-      client.publish(mqttESP, val.c_str(),TRUE);
271 
-      }
272 
-  }
273 
-}
arduino/nodemcu/senzor-dallas/senzor-dallas.ino
History View file @ 04250b8
274 1 
new file mode 100644
... ... 
@@ -0,0 +1,273 @@
0 
+#include <FS.h>                   //this needs to be first, e folosit de salvarea credentialelor pe FS
1 
+#include <ESP8266WiFi.h>
2 
+#include <PubSubClient.h>
3 
+#include <WiFiManager.h>        //https://github.com/tzapu/WiFiManager
4 
+#include <ArduinoJson.h>          //https://github.com/bblanchon/ArduinoJson pentru salvarea credentialelor in eprom
5 
+#include <WiFiClient.h>
6 
+#include <OneWire.h>
7 
+#include <DallasTemperature.h>
8 
+
9 
+char mqtt_user[9]; //le va lua din FS
10 
+char mqtt_devid[5]; //le va lua din FS
11 
+char mqttPassword[15]; //urmatoarele le va genera cu functia gen
12 
+char mqttSUB[22];
13 
+char espName[13];
14 
+char mqttESP[22];
15 
+char mqttTEMP[23];
16 
+char mqttLWT[22];
17 
+
18 
+const String model = "NodeMCU Dallas";
19 
+const String ver = "v2.0.999";
20 
+const char* mqttServer = "mqtt.clickhome.ro";
21 
+const int mqttPort = 1883;
22 
+long loopTimer = 900000; // miliseconds - by default trimite la 15 minute
23 
+long lastMsg = 0;
24 
+float loopTemp = 0;
25 
+int inPin = 5;
26 
+String mqttMessage;
27 
+
28 
+// senzor de temperatura DALLAS
29 
+#define ONE_WIRE_BUS D4  // pinul de date (la mine am pus senzor pe D4)
30 
+OneWire oneWire(ONE_WIRE_BUS);
31 
+DallasTemperature sensors(&oneWire);
32 
+
33 
+//*********************************************************************
34 
+
35 
+WiFiClient espClient;
36 
+PubSubClient client(espClient);
37 
+
38 
+void generate_vars(){
39 
+  strcpy (mqttPassword, "8219CH");
40 
+  strcat (mqttPassword, mqtt_user);
41 
+
42 
+  strcpy (espName, mqtt_user);
43 
+  strcat (espName, "-");
44 
+  strcat (espName, mqtt_devid);
45 
+
46 
+  strcpy (mqttSUB, "cmnd/");
47 
+  strcat (mqttSUB, espName);
48 
+  strcat (mqttSUB, "/ESP");
49 
+
50 
+  strcpy (mqttESP, "stat/");
51 
+  strcat (mqttESP, espName);
52 
+  strcat (mqttESP, "/ESP");
53 
+
54 
+  strcpy (mqttTEMP, "stat/");
55 
+  strcat (mqttTEMP, espName);
56 
+  strcat (mqttTEMP, "/TEMP");
57 
+
58 
+  strcpy (mqttLWT, "tele/");
59 
+  strcat (mqttLWT, espName);
60 
+  strcat (mqttLWT, "/LWT");
61 
+}
62 
+
63 
+String ipToString(IPAddress ip){
64 
+  String s="";
65 
+  for (int i=0; i<4; i++)
66 
+    s += i  ? "." + String(ip[i]) : String(ip[i]);
67 
+  return s;
68 
+}
69 
+
70 
+String getMacAddress() {
71 
+  byte mac[6];
72 
+  WiFi.macAddress(mac);
73 
+  String cMac = "";
74 
+  for (int i = 0; i < 6; ++i) {
75 
+    cMac += String(mac[i],HEX);
76 
+    if(i<5)
77 
+    cMac += "-";
78 
+  }
79 
+  cMac.toUpperCase();
80 
+  return cMac;
81 
+}
82 
+
83 
+void reconectez() {
84 
+  while (String(mqtt_user)==""){
85 
+    Serial.println("Invalid user!");
86 
+    delay(99999999);
87 
+  }
88 
+
89 
+  // ma conectez la mqtt server
90 
+  while (!client.connected()) {
91 
+    client.setServer(mqttServer, mqttPort);
92 
+    Serial.print("AtloopTempting MQTT connection...");
93 
+    // Incerc sa ma reconectez cu LWT din 5 in 5 secunde
94 
+    if (client.connect(espName, mqtt_user, mqttPassword, mqttLWT, 1, 1, "Offline")) {
95 
+      Serial.println("connected");
96 
+      client.publish(mqttLWT,"Online",TRUE);
97 
+      // trimit informatii utile cand ma conectez
98 
+        String esp_info = "{\"ESPMac\":\"";
99 
+        esp_info += getMacAddress();
100 
+        esp_info += "\", \"IPAddress\":\"";
101 
+        esp_info += ipToString(WiFi.localIP());
102 
+        esp_info += "\"}";
103 
+        String netinfo = "{\"Module\":\"";
104 
+        netinfo += String (model);
105 
+        netinfo += "\", \"Version\":\"";
106 
+        netinfo += String (ver);
107 
+        netinfo += "\"}";
108 
+
109 
+        client.publish(mqttESP, netinfo.c_str(),TRUE);
110 
+        Serial.println(netinfo);
111 
+        client.publish(mqttESP, esp_info.c_str(),TRUE);
112 
+        Serial.println(esp_info);
113 
+        client.publish(mqttESP, "15 minute",TRUE); // trimit intervalul default
114 
+        client.subscribe(mqttSUB);
115 
+    } else {
116 
+      Serial.print("failed, rc=");
117 
+      Serial.print(client.state());
118 
+      Serial.println(" try again in 60 seconds");
119 
+      // Wait 60 seconds before retrying
120 
+      delay(60000);
121 
+    }
122 
+  }
123 
+}
124 
+
125 
+void setup()
126 
+{
127 
+  Serial.begin(115200);
128 
+  //generez variabilele
129 
+  readFS();
130 
+  // The extra parameters to be configured (can be either global or just in the setup)
131 
+  // After connecting, parameter.getValue() will get you the configured value
132 
+  // id/name placeholder/prompt default length
133 
+
134 
+  WiFiManagerParameter custom_mqtt_user("user", "mqtt user", mqtt_user, 9);
135 
+  WiFiManagerParameter custom_mqtt_devid("devid", "mqtt devid", mqtt_devid, 5);
136 
+
137 
+  // ma conectez la AP via wifi
138 
+   WiFiManager wifi;
139 
+   wifi.setConfigPortalTimeout(120); // a timeout so the ESP doesn't hang waiting to be configured, for instance after a power failure
140 
+   wifi.setTimeout(180); // sta AP 3 minute apoi se reseteaza din nou
141 
+   if (!wifi.autoConnect("ClickHome")) {
142 
+     Serial.println("timeout - going to sleep");
143 
+  }
144 
+  delay(200);
145 
+
146 
+  strcpy(mqtt_user, custom_mqtt_user.getValue()); //citesc datele salvate anterior pe FS
147 
+  strcpy(mqtt_devid, custom_mqtt_devid.getValue());
148 
+  generate_vars(); //genereaza topicurile de mqtt in baza mqtt_user si mqtt_devid
149 
+  reconectez();
150 
+  client.setCallback(getMessage); //setez functia care parseaza mesajele venite prin mqtt
151 
+
152 
+  pinMode(inPin, INPUT);
153 
+  sensors.begin();
154 
+}
155 
+
156 
+void getMessage(char* topic, byte* payload, unsigned int length) {
157 
+  float t = 0;
158 
+  mqttMessage="";
159 
+  Serial.print("Message arrived in topic: ");
160 
+  Serial.println(topic);
161 
+  Serial.print("Message:");
162 
+  for (int i = 0; i < length; i++) {
163 
+    mqttMessage += (char)payload[i];
164 
+  }
165 
+  Serial.println(mqttMessage);
166 
+
167 
+  // daca a primit sendTemp trimite temperatura
168 
+  if (mqttMessage == "temp")
169 
+  {
170 
+    Serial.println("Trimit temperatura");
171 
+    sensors.setResolution(12);
172 
+    sensors.requestTemperatures(); // Send the command to get Temperatures
173 
+    t = sensors.getTempCByIndex(0);
174 
+      String json = "{\"Temp\":";
175 
+      json += String (t);
176 
+      json += "}";
177 
+      client.publish(mqttTEMP, json.c_str(),TRUE);
178 
+      Serial.println(json);
179 
+  }
180 
+
181 
+  // daca a primit valoarea in minute seteaza loopTimer si-l trimite in DB
182 
+
183 
+   if (mqttMessage == "debug")
184 
+   {
185 
+        loopTimer=30000; // setez sa trimita valori la 30 de secunde ca sa fac debug
186 
+        client.publish(mqttESP, "{\"LoopInterval\":\"30 secunde\"}",TRUE);
187 
+   }
188 
+   if (mqttMessage == "10")
189 
+   {
190 
+        loopTimer=600000; // setez sa trimita valori la 10 minute
191 
+        client.publish(mqttESP, "{\"LoopInterval\":\"10 minute\"}",TRUE);
192 
+   }
193 
+   if (mqttMessage == "15")
194 
+   {
195 
+        loopTimer=900000; // setez sa trimita valori la 15 minute
196 
+        client.publish(mqttESP, "{\"LoopInterval\":\"15 minute\"}",TRUE);
197 
+   }
198 
+   if (mqttMessage == "30")
199 
+   {
200 
+        loopTimer=1800000; // setez sa trimita valori la 30 de minute
201 
+        client.publish(mqttESP, "{\"LoopInterval\":\"30 de minute\"}",TRUE);
202 
+   }
203 
+   if (mqttMessage == "60")
204 
+   {
205 
+        loopTimer=3600000; // setez sa trimita valori la o ora
206 
+        client.publish(mqttESP, "{\"LoopInterval\":\"o ora\"}",TRUE);
207 
+   }
208 
+   if (mqttMessage == "stop")
209 
+   {
210 
+        loopTimer=3600000000; // setez sa nu trimita valori
211 
+        client.publish(mqttESP, "{\"LoopInterval\":\"oprit\"}",TRUE);
212 
+   }
213 
+}
214 
+
215 
+void readFS(){
216 
+  //read configuration from FS json
217 
+  //Serial.println("mounting FS...");
218 
+
219 
+  if (SPIFFS.begin()) {
220 
+    //Serial.println("mounted file system");
221 
+    if (SPIFFS.exists("/config.json")) {
222 
+      //file exists, reading and loading
223 
+      //Serial.println("reading config file");
224 
+      File configFile = SPIFFS.open("/config.json", "r");
225 
+      if (configFile) {
226 
+        //Serial.println("opened config file");
227 
+
228 
+        size_t size = configFile.size();
229 
+        // Allocate a buffer to store contents of the file.
230 
+        std::unique_ptr<char[]> buf(new char[size]);
231 
+
232 
+        configFile.readBytes(buf.get(), size);
233 
+        DynamicJsonBuffer jsonBuffer;
234 
+        JsonObject& json = jsonBuffer.parseObject(buf.get());
235 
+        //json.printTo(Serial);
236 
+        if (json.success()) {
237 
+          //Serial.println("\nparsed json");
238 
+          strcpy(mqtt_user, json["mqtt_user"]);
239 
+          strcpy(mqtt_devid, json["mqtt_devid"]);
240 
+        } else {
241 
+          //Serial.println("failed to load json config");
242 
+        }
243 
+      }
244 
+    }
245 
+  } else {
246 
+    //Serial.println("failed to mount FS");
247 
+  }
248 
+  //end read
249 
+}
250 
+
251 
+void loop()
252 
+{
253 
+  if (!client.connected()) {
254 
+    reconectez();
255 
+  }
256 
+  client.loop();
257 
+  long now = millis();
258 
+  if (now - lastMsg > loopTimer) {
259 
+    lastMsg = now;
260 
+    sensors.setResolution(12);
261 
+    sensors.requestTemperatures(); // Send the command to get loopTemperatures
262 
+    loopTemp = sensors.getTempCByIndex(0);
263 
+    Serial.println(loopTemp);
264 
+    if((loopTemp > -20) && (loopTemp <60))
265 
+      {
266 
+     String val = "{\"Temp\":";
267 
+      val += String (loopTemp);
268 
+      val += "}";
269 
+      client.publish(mqttESP, val.c_str(),TRUE);
270 
+      }
271 
+  }
272 
+}
arduino/nodemcu/senzor-dht.ino
History View file @ 04250b8
0 273 
deleted file mode 100644
... ... 
@@ -1,278 +0,0 @@
1 
-#include <ESP8266WiFi.h>
2 
-#include <PubSubClient.h>
3 
-#include <WiFiManager.h>
4 
-#include <WiFiClient.h>
5 
-#include <OneWire.h>
6 
-#include <PietteTech_DHT.h>
7 
-#include <ESP8266HTTPClient.h>
8 
-#include <ESP8266httpUpdate.h>
9 
-
10 
-// Modifica cu datele tale
11 
-const char* mqttUser = "qbzesh";
12 
-const char* mqttPassword = "8219CHqbzesh";
13 
-const char* mqttSUB = "cmnd/qbzesh-1250/ESP";
14 
-const char* mqttESP = "stat/qbzesh-1250/ESP";
15 
-const char* mqttTEMP = "stat/qbzesh-1250/TEMP";
16 
-const char* mqttLWT = "tele/qbzesh-1250/LWT";
17 
-const char* espName ="qbzesh-1250";
18 
-
19 
-//#######################################################################
20 
-// NU EDITA MAI JOS
21 
-//#######################################################################
22 
-const String model = "NodeMCU DHT22";
23 
-const String ver = "v1.0.6";
24 
-const char* mqttServer = "mqtt.clickhome.ro";
25 
-const int mqttPort = 1883;
26 
-long loopTimer = 900000; // miliseconds - by default trimite la 15 minute
27 
-long lastMsg = 0;
28 
-float loopTemp = 0;
29 
-float t = 0;
30 
-float loopHumi = 0;
31 
-float h = 0;
32 
-String mqttMessage;
33 
-bool bDHTstarted;
34 
-int acquireresult;
35 
-
36 
-// senzor de temperatura DHT
37 
-#define DHTPIN D4 // pinul de date (la mine am pus senzor pe D4)
38 
-#define DHTTYPE DHT22 // DHT 11
39 
-void dht_wrapper();
40 
-PietteTech_DHT DHT(DHTPIN, DHTTYPE, dht_wrapper);
41 
-void dht_wrapper()
42 
-{
43 
-  DHT.isrCallback();
44 
-}
45 
-//*********************************************************************
46 
-
47 
-WiFiClient espClient;
48 
-PubSubClient client(espClient);
49 
-
50 
-
51 
-String ipToString(IPAddress ip){
52 
-  String s="";
53 
-  for (int i=0; i<4; i++)
54 
-    s += i  ? "." + String(ip[i]) : String(ip[i]);
55 
-  return s;
56 
-}
57 
-
58 
-String getMacAddress() {
59 
-  byte mac[6];
60 
-  WiFi.macAddress(mac);
61 
-  String cMac = "";
62 
-  for (int i = 0; i < 6; ++i) {
63 
-    cMac += String(mac[i],HEX);
64 
-    if(i<5)
65 
-    cMac += "-";
66 
-  }
67 
-  cMac.toUpperCase();
68 
-  return cMac;
69 
-}
70 
-
71 
-void reconnect()
72 
-{
73 
-  while (!client.connected())
74 
-  {
75 
-    //Serial.println("Reconectare la MQTT ...");
76 
-    // Incerc sa ma reconectez cu LWT din 60 in 60 secunde
77 
-    if (client.connect(espName, mqttUser, mqttPassword, mqttLWT, 1, 1, "Offline"))
78 
-    {
79 
-      Serial.println("Senzor reconectat la MQTT.");
80 
-      client.publish(mqttLWT,"Online",TRUE);
81 
-      // trimit informatii utile cand ma conectez
82 
-        String esp_info = "{\"ESPMac\":\"";
83 
-        esp_info += getMacAddress();
84 
-        esp_info += "\", \"IPAddress\":\"";
85 
-        esp_info += ipToString(WiFi.localIP());
86 
-        esp_info += "\"}";
87 
-        String netinfo = "{\"Module\":\"";
88 
-        netinfo += String (model);
89 
-        netinfo += "\", \"Version\":\"";
90 
-        netinfo += String (ver);
91 
-        netinfo += "\"}";
92 
-
93 
-        client.publish(mqttESP, netinfo.c_str(),TRUE);
94 
-        Serial.println(netinfo);
95 
-        client.publish(mqttESP, esp_info.c_str(),TRUE);
96 
-        Serial.println(esp_info);
97 
-        client.publish(mqttESP, "15 minute",TRUE); // trimit intervalul default
98 
-        client.subscribe(mqttSUB);
99 
-    }
100 
-    else
101 
-    {
102 
-        Serial.println("Reconectare MQTT esuata: ");
103 
-        Serial.println(client.state());
104 
-        Serial.println("fac o alta incercare in 60 de secunde");
105 
-        delay(60000);
106 
-    }
107 
-  }
108 
-}
109 
-
110 
-void setup()
111 
-{
112 
-  Serial.begin(115200);
113 
-
114 
-  // ma conectez la AP via wifi
115 
-   WiFiManager wifi;
116 
-   wifi.setTimeout(180); // sta AP 3 minute apoi se reseteaza din nou
117 
-   if (!wifi.autoConnect("ClickHome")) {
118 
-     Serial.println("timeout - going to sleep");
119 
-  }
120 
-  delay(200);
121 
-
122 
-  // ma conectez la mqtt server
123 
-  client.setServer(mqttServer, mqttPort);
124 
-    while (!client.connected()) {
125 
-    Serial.println("Conectare la MQTT ...");
126 
-    // fac connect cu LWT
127 
-    if (client.connect(espName, mqttUser, mqttPassword, mqttLWT, 1, 1, "Offline")) {
128 
-      Serial.println("Senzor conectat la MQTT.");
129 
-      // trimit starea Online pe topic LWT cand ma conectez
130 
-      client.publish(mqttLWT,"Online",TRUE);
131 
-      // trimit informatii utile cand ma conectez
132 
-        String esp_info = "{\"ESPMac\":\"";
133 
-        esp_info += getMacAddress();
134 
-        esp_info += "\", \"IPAddress\":\"";
135 
-        esp_info += ipToString(WiFi.localIP());
136 
-        esp_info += "\"}";
137 
-        String netinfo = "{\"Module\":\"";
138 
-        netinfo += String (model);
139 
-        netinfo += "\", \"Version\":\"";
140 
-        netinfo += String (ver);
141 
-        netinfo += "\"}";
142 
-        client.publish(mqttESP, netinfo.c_str(),TRUE);
143 
-        Serial.println(netinfo);
144 
-        client.publish(mqttESP, esp_info.c_str(),TRUE);
145 
-        Serial.println(esp_info);
146 
-        client.publish(mqttESP, "{\"LoopInterval\":\"15 minute\"}",TRUE);
147 
-        client.subscribe(mqttSUB);
148 
-      }
149 
-      else {
150 
-        Serial.print("Conectare MQTT esuata: ");
151 
-        Serial.print(client.state());
152 
-        delay(2000);
153 
-    }
154 
-  }
155 
-  client.setCallback(getMessage);
156 
-}
157 
-
158 
-void getMessage(char* topic, byte* payload, unsigned int length) {
159 
-  mqttMessage="";
160 
-  Serial.print("Message arrived in topic: ");
161 
-  Serial.println(topic);
162 
-  Serial.print("Message:");
163 
-  for (int i = 0; i < length; i++) {
164 
-    mqttMessage += (char)payload[i];
165 
-  }
166 
-  Serial.println(mqttMessage);
167 
-
168 
-  // daca a primit temp va trimite temperatura
169 
-  if (mqttMessage == "temp")
170 
-  {
171 
-      Serial.println("Trimit temperatura si umiditatea");
172 
-      acquireresult = DHT.acquireAndWait(2000);
173 
-      if ( acquireresult == 0 )
174 
-      {
175 
-           t = DHT.getCelsius();
176 
-           h = DHT.getHumidity();
177 
-           delay(10);
178 
-           String json = "{\"Temp\":";
179 
-           json += String (t);
180 
-           json += ", \"Humi\":";
181 
-           json += String (h);
182 
-           json += "}";
183 
-           client.publish(mqttTEMP, json.c_str(),TRUE);
184 
-           Serial.println(json);
185 
-      }
186 
-      else
187 
-      {
188 
-        t = h = 0;
189 
-        Serial.println("Nu am putut citi temperatura si umiditatea");
190 
-      }
191 
-  }
192 
-
193 
-  // procedura de software update via WEB
194 
-   if (mqttMessage == "update")
195 
-   {
196 
-        String msg="Software update: ";
197 
-        t_httpUpdate_return ret;
198 
-        //ESPhttpUpdate.rebootOnUpdate(false);
199 
-        ret = ESPhttpUpdate.update("http://update.clickhome.ro/senzor/dht/arduino.bin");
200 
-        //ret = ESPhttpUpdate.update("update.clickhome.ro", 80, "/senzor/dht/arduino.bin");
201 
-        switch(ret) {
202 
-           case HTTP_UPDATE_FAILED:
203 
-               msg.concat(" eroare:");
204 
-               msg.concat(ESPhttpUpdate.getLastError());
205 
-               msg.concat(" motiv:");
206 
-               msg.concat(ESPhttpUpdate.getLastErrorString().c_str());
207 
-               break;
208 
-           case HTTP_UPDATE_NO_UPDATES:
209 
-               msg.concat(" no update.");
210 
-               break;
211 
-           case HTTP_UPDATE_OK:
212 
-               msg.concat(" success.");
213 
-               break;
214 
-        }
215 
-        Serial.println(msg);
216 
-   }
217 
-
218 
-  // daca a primit valoarea in minute seteaza loopTimer si-l trimite in DB
219 
-   if (mqttMessage == "debug")
220 
-   {
221 
-        loopTimer=30000; // setez sa trimita valori la 30 de secunde ca sa fac debug
222 
-        client.publish(mqttESP, "{\"LoopInterval\":\"30 secunde\"}",TRUE);
223 
-   }
224 
-   if (mqttMessage == "10")
225 
-   {
226 
-        loopTimer=600000; // setez sa trimita valori la 10 minute
227 
-        client.publish(mqttESP, "{\"LoopInterval\":\"10 minute\"}",TRUE);
228 
-   }
229 
-   if (mqttMessage == "15")
230 
-   {
231 
-        loopTimer=900000; // setez sa trimita valori la 15 minute
232 
-        client.publish(mqttESP, "{\"LoopInterval\":\"15 minute\"}",TRUE);
233 
-   }
234 
-   if (mqttMessage == "30")
235 
-   {
236 
-        loopTimer=1800000; // setez sa trimita valori la 30 de minute
237 
-        client.publish(mqttESP, "{\"LoopInterval\":\"30 de minute\"}",TRUE);
238 
-   }
239 
-   if (mqttMessage == "60")
240 
-   {
241 
-        loopTimer=3600000; // setez sa trimita valori la o ora
242 
-        client.publish(mqttESP, "{\"LoopInterval\":\"o ora\"}",TRUE);
243 
-   }
244 
-   if (mqttMessage == "stop")
245 
-   {
246 
-        loopTimer=3600000000; // setez sa nu trimita valori
247 
-        client.publish(mqttESP, "{\"LoopInterval\":\"oprit\"}",TRUE);
248 
-   }
249 
-}
250 
-
251 
-void loop()
252 
-{
253 
-  if (!client.connected()) {
254 
-    reconnect();
255 
-  }
256 
-  client.loop();
257 
-  long now = millis();
258 
-  if (now - lastMsg > loopTimer) {
259 
-     lastMsg = now;
260 
-     acquireresult = DHT.acquireAndWait(2000);
261 
-     if ( acquireresult == 0 )
262 
-      {
263 
-           loopTemp = DHT.getCelsius();
264 
-           loopHumi = DHT.getHumidity();
265 
-           delay(10);
266 
-           String val = "{\"Temp\":";
267 
-           val += String (loopTemp);
268 
-           val += ", \"Humi\":";
269 
-           val += String (loopHumi);
270 
-           val += "}";
271 
-           client.publish(mqttESP, val.c_str(),TRUE);
272 
-      }
273 
-      else
274 
-      {
275 
-        loopTemp = loopHumi = 0;
276 
-      }
277 
-   }
278 
-}
arduino/nodemcu/senzor-dht/senzor-dht.ino
History View file @ 04250b8
279 1 
new file mode 100644
... ... 
@@ -0,0 +1,278 @@
0 
+#include <ESP8266WiFi.h>
1 
+#include <PubSubClient.h>
2 
+#include <WiFiManager.h>
3 
+#include <WiFiClient.h>
4 
+#include <OneWire.h>
5 
+#include <PietteTech_DHT.h>
6 
+#include <ESP8266HTTPClient.h>
7 
+#include <ESP8266httpUpdate.h>
8 
+
9 
+// Modifica cu datele tale
10 
+const char* mqttUser = "qbzesh";
11 
+const char* mqttPassword = "8219CHqbzesh";
12 
+const char* mqttSUB = "cmnd/qbzesh-1250/ESP";
13 
+const char* mqttESP = "stat/qbzesh-1250/ESP";
14 
+const char* mqttTEMP = "stat/qbzesh-1250/TEMP";
15 
+const char* mqttLWT = "tele/qbzesh-1250/LWT";
16 
+const char* espName ="qbzesh-1250";
17 
+
18 
+//#######################################################################
19 
+// NU EDITA MAI JOS
20 
+//#######################################################################
21 
+const String model = "NodeMCU DHT22";
22 
+const String ver = "v1.0.6";
23 
+const char* mqttServer = "mqtt.clickhome.ro";
24 
+const int mqttPort = 1883;
25 
+long loopTimer = 900000; // miliseconds - by default trimite la 15 minute
26 
+long lastMsg = 0;
27 
+float loopTemp = 0;
28 
+float t = 0;
29 
+float loopHumi = 0;
30 
+float h = 0;
31 
+String mqttMessage;
32 
+bool bDHTstarted;
33 
+int acquireresult;
34 
+
35 
+// senzor de temperatura DHT
36 
+#define DHTPIN D4 // pinul de date (la mine am pus senzor pe D4)
37 
+#define DHTTYPE DHT22 // DHT 11
38 
+void dht_wrapper();
39 
+PietteTech_DHT DHT(DHTPIN, DHTTYPE, dht_wrapper);
40 
+void dht_wrapper()
41 
+{
42 
+  DHT.isrCallback();
43 
+}
44 
+//*********************************************************************
45 
+
46 
+WiFiClient espClient;
47 
+PubSubClient client(espClient);
48 
+
49 
+
50 
+String ipToString(IPAddress ip){
51 
+  String s="";
52 
+  for (int i=0; i<4; i++)
53 
+    s += i  ? "." + String(ip[i]) : String(ip[i]);
54 
+  return s;
55 
+}
56 
+
57 
+String getMacAddress() {
58 
+  byte mac[6];
59 
+  WiFi.macAddress(mac);
60 
+  String cMac = "";
61 
+  for (int i = 0; i < 6; ++i) {
62 
+    cMac += String(mac[i],HEX);
63 
+    if(i<5)
64 
+    cMac += "-";
65 
+  }
66 
+  cMac.toUpperCase();
67 
+  return cMac;
68 
+}
69 
+
70 
+void reconnect()
71 
+{
72 
+  while (!client.connected())
73 
+  {
74 
+    //Serial.println("Reconectare la MQTT ...");
75 
+    // Incerc sa ma reconectez cu LWT din 60 in 60 secunde
76 
+    if (client.connect(espName, mqttUser, mqttPassword, mqttLWT, 1, 1, "Offline"))
77 
+    {
78 
+      Serial.println("Senzor reconectat la MQTT.");
79 
+      client.publish(mqttLWT,"Online",TRUE);
80 
+      // trimit informatii utile cand ma conectez
81 
+        String esp_info = "{\"ESPMac\":\"";
82 
+        esp_info += getMacAddress();
83 
+        esp_info += "\", \"IPAddress\":\"";
84 
+        esp_info += ipToString(WiFi.localIP());
85 
+        esp_info += "\"}";
86 
+        String netinfo = "{\"Module\":\"";
87 
+        netinfo += String (model);
88 
+        netinfo += "\", \"Version\":\"";
89 
+        netinfo += String (ver);
90 
+        netinfo += "\"}";
91 
+
92 
+        client.publish(mqttESP, netinfo.c_str(),TRUE);
93 
+        Serial.println(netinfo);
94 
+        client.publish(mqttESP, esp_info.c_str(),TRUE);
95 
+        Serial.println(esp_info);
96 
+        client.publish(mqttESP, "15 minute",TRUE); // trimit intervalul default
97 
+        client.subscribe(mqttSUB);
98 
+    }
99 
+    else
100 
+    {
101 
+        Serial.println("Reconectare MQTT esuata: ");
102 
+        Serial.println(client.state());
103 
+        Serial.println("fac o alta incercare in 60 de secunde");
104 
+        delay(60000);
105 
+    }
106 
+  }
107 
+}
108 
+
109 
+void setup()
110 
+{
111 
+  Serial.begin(115200);
112 
+
113 
+  // ma conectez la AP via wifi
114 
+   WiFiManager wifi;
115 
+   wifi.setTimeout(180); // sta AP 3 minute apoi se reseteaza din nou
116 
+   if (!wifi.autoConnect("ClickHome")) {
117 
+     Serial.println("timeout - going to sleep");
118 
+  }
119 
+  delay(200);
120 
+
121 
+  // ma conectez la mqtt server
122 
+  client.setServer(mqttServer, mqttPort);
123 
+    while (!client.connected()) {
124 
+    Serial.println("Conectare la MQTT ...");
125 
+    // fac connect cu LWT
126 
+    if (client.connect(espName, mqttUser, mqttPassword, mqttLWT, 1, 1, "Offline")) {
127 
+      Serial.println("Senzor conectat la MQTT.");
128 
+      // trimit starea Online pe topic LWT cand ma conectez
129 
+      client.publish(mqttLWT,"Online",TRUE);
130 
+      // trimit informatii utile cand ma conectez
131 
+        String esp_info = "{\"ESPMac\":\"";
132 
+        esp_info += getMacAddress();
133 
+        esp_info += "\", \"IPAddress\":\"";
134 
+        esp_info += ipToString(WiFi.localIP());
135 
+        esp_info += "\"}";
136 
+        String netinfo = "{\"Module\":\"";
137 
+        netinfo += String (model);
138 
+        netinfo += "\", \"Version\":\"";
139 
+        netinfo += String (ver);
140 
+        netinfo += "\"}";
141 
+        client.publish(mqttESP, netinfo.c_str(),TRUE);
142 
+        Serial.println(netinfo);
143 
+        client.publish(mqttESP, esp_info.c_str(),TRUE);
144 
+        Serial.println(esp_info);
145 
+        client.publish(mqttESP, "{\"LoopInterval\":\"15 minute\"}",TRUE);
146 
+        client.subscribe(mqttSUB);
147 
+      }
148 
+      else {
149 
+        Serial.print("Conectare MQTT esuata: ");
150 
+        Serial.print(client.state());
151 
+        delay(2000);
152 
+    }
153 
+  }
154 
+  client.setCallback(getMessage);
155 
+}
156 
+
157 
+void getMessage(char* topic, byte* payload, unsigned int length) {
158 
+  mqttMessage="";
159 
+  Serial.print("Message arrived in topic: ");
160 
+  Serial.println(topic);
161 
+  Serial.print("Message:");
162 
+  for (int i = 0; i < length; i++) {
163 
+    mqttMessage += (char)payload[i];
164 
+  }
165 
+  Serial.println(mqttMessage);
166 
+
167 
+  // daca a primit temp va trimite temperatura
168 
+  if (mqttMessage == "temp")
169 
+  {
170 
+      Serial.println("Trimit temperatura si umiditatea");
171 
+      acquireresult = DHT.acquireAndWait(2000);
172 
+      if ( acquireresult == 0 )
173 
+      {
174 
+           t = DHT.getCelsius();
175 
+           h = DHT.getHumidity();
176 
+           delay(10);
177 
+           String json = "{\"Temp\":";
178 
+           json += String (t);
179 
+           json += ", \"Humi\":";
180 
+           json += String (h);
181 
+           json += "}";
182 
+           client.publish(mqttTEMP, json.c_str(),TRUE);
183 
+           Serial.println(json);
184 
+      }
185 
+      else
186 
+      {
187 
+        t = h = 0;
188 
+        Serial.println("Nu am putut citi temperatura si umiditatea");
189 
+      }
190 
+  }
191 
+
192 
+  // procedura de software update via WEB
193 
+   if (mqttMessage == "update")
194 
+   {
195 
+        String msg="Software update: ";
196 
+        t_httpUpdate_return ret;
197 
+        //ESPhttpUpdate.rebootOnUpdate(false);
198 
+        ret = ESPhttpUpdate.update("http://update.clickhome.ro/senzor/dht/arduino.bin");
199 
+        //ret = ESPhttpUpdate.update("update.clickhome.ro", 80, "/senzor/dht/arduino.bin");
200 
+        switch(ret) {
201 
+           case HTTP_UPDATE_FAILED:
202 
+               msg.concat(" eroare:");
203 
+               msg.concat(ESPhttpUpdate.getLastError());
204 
+               msg.concat(" motiv:");
205 
+               msg.concat(ESPhttpUpdate.getLastErrorString().c_str());
206 
+               break;
207 
+           case HTTP_UPDATE_NO_UPDATES:
208 
+               msg.concat(" no update.");
209 
+               break;
210 
+           case HTTP_UPDATE_OK:
211 
+               msg.concat(" success.");
212 
+               break;
213 
+        }
214 
+        Serial.println(msg);
215 
+   }
216 
+
217 
+  // daca a primit valoarea in minute seteaza loopTimer si-l trimite in DB
218 
+   if (mqttMessage == "debug")
219 
+   {
220 
+        loopTimer=30000; // setez sa trimita valori la 30 de secunde ca sa fac debug
221 
+        client.publish(mqttESP, "{\"LoopInterval\":\"30 secunde\"}",TRUE);
222 
+   }
223 
+   if (mqttMessage == "10")
224 
+   {
225 
+        loopTimer=600000; // setez sa trimita valori la 10 minute
226 
+        client.publish(mqttESP, "{\"LoopInterval\":\"10 minute\"}",TRUE);
227 
+   }
228 
+   if (mqttMessage == "15")
229 
+   {
230 
+        loopTimer=900000; // setez sa trimita valori la 15 minute
231 
+        client.publish(mqttESP, "{\"LoopInterval\":\"15 minute\"}",TRUE);
232 
+   }
233 
+   if (mqttMessage == "30")
234 
+   {
235 
+        loopTimer=1800000; // setez sa trimita valori la 30 de minute
236 
+        client.publish(mqttESP, "{\"LoopInterval\":\"30 de minute\"}",TRUE);
237 
+   }
238 
+   if (mqttMessage == "60")
239 
+   {
240 
+        loopTimer=3600000; // setez sa trimita valori la o ora
241 
+        client.publish(mqttESP, "{\"LoopInterval\":\"o ora\"}",TRUE);
242 
+   }
243 
+   if (mqttMessage == "stop")
244 
+   {
245 
+        loopTimer=3600000000; // setez sa nu trimita valori
246 
+        client.publish(mqttESP, "{\"LoopInterval\":\"oprit\"}",TRUE);
247 
+   }
248 
+}
249 
+
250 
+void loop()
251 
+{
252 
+  if (!client.connected()) {
253 
+    reconnect();
254 
+  }
255 
+  client.loop();
256 
+  long now = millis();
257 
+  if (now - lastMsg > loopTimer) {
258 
+     lastMsg = now;
259 
+     acquireresult = DHT.acquireAndWait(2000);
260 
+     if ( acquireresult == 0 )
261 
+      {
262 
+           loopTemp = DHT.getCelsius();
263 
+           loopHumi = DHT.getHumidity();
264 
+           delay(10);
265 
+           String val = "{\"Temp\":";
266 
+           val += String (loopTemp);
267 
+           val += ", \"Humi\":";
268 
+           val += String (loopHumi);
269 
+           val += "}";
270 
+           client.publish(mqttESP, val.c_str(),TRUE);
271 
+      }
272 
+      else
273 
+      {
274 
+        loopTemp = loopHumi = 0;
275 
+      }
276 
+   }
277 
+}