Nodemcu AHT10 Temp/Humidity Measuring WLAN MQQT

Place it anywhere and get correct Data everytime. Perfect for Smarthome.

Jan 28, 2022

•

3092 views

•

0 respects

nodemcu

tp4056

aht10

Components and supplies

TP4056

AHT10

Solar Panel, 2.5 W

Wire, Hook Up

Li-Ion Battery 1000mAh

NodeMCU ESP8266 Breakout Board

Tools and machines

Soldering iron (generic)

Solder Wire, Lead Free

Apps and platforms

MQTT

Arduino IDE

Project description

Code

AHT10 Measuring with Backup and Solar

c_cpp

WLAN connection is established. Connection to the MQTT broker is established. Sensor data is being collected. Sensor data is sent to the broker with the previously determined TOPIC. The NodeMCU is put to sleep for 120 seconds and then carries out a reset.

1#include <ESP8266WiFi.h>
2#include <Ticker.h>
3#include <AsyncMqttClient.h>
4#include   <Adafruit_AHTX0.h>
5
6#define WIFI_SSID "YOUR SSID"
7#define WIFI_PASSWORD   "YOUR PW"
8char wiFiHostname[ ] = "YOUR SENSORNAME";
9#define FORCE_DEEPSLEEP
10
11Adafruit_AHTX0   aht;
12Adafruit_Sensor *aht_humidity, *aht_temp;
13
14#define MQTT_HOST IPAddress(192,   168, XXX, XX)
15#define MQTT_PORT 1883
16
17// Temperature MQTT Topics
18#define   MQTT_PUB_TEMP "Bad/temperature"
19#define MQTT_PUB_HUM "Bad/humidity"
20
21
22AsyncMqttClient   mqttClient;
23Ticker mqttReconnectTimer;
24
25WiFiEventHandler wifiConnectHandler;
26WiFiEventHandler   wifiDisconnectHandler;
27Ticker wifiReconnectTimer;
28
29unsigned long previousMillis   = 0;   // Stores last time temperature was published
30const long interval = 10000;         // Interval at which to publish sensor readings
31
32void connectToWifi()   {
33  Serial.println("Connecting to Wi-Fi...");
34  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
35   wifi_station_set_hostname(wiFiHostname);
36}
37
38void onWifiConnect(const   WiFiEventStationModeGotIP& event) {
39  Serial.println("Connected to Wi-Fi.");
40   Serial.println("Ready");
41  Serial.print("IP address: ");
42  Serial.println(WiFi.localIP());
43   connectToMqtt();
44}
45
46void onWifiDisconnect(const WiFiEventStationModeDisconnected&   event) {
47  Serial.println("Disconnected from Wi-Fi.");
48  mqttReconnectTimer.detach();   // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
49  wifiReconnectTimer.once(2,   connectToWifi);
50}
51
52void connectToMqtt() {
53  Serial.println("Connecting   to MQTT...");
54  mqttClient.connect();
55}
56
57void onMqttConnect(bool sessionPresent)   {
58  Serial.println("Connected to MQTT.");
59  Serial.print("Session present:   ");
60  Serial.println(sessionPresent);
61}
62
63void onMqttDisconnect(AsyncMqttClientDisconnectReason   reason) {
64  Serial.println("Disconnected from MQTT.");
65
66  if (WiFi.isConnected())   {
67    mqttReconnectTimer.once(2, connectToMqtt);
68  }
69}
70
71void onMqttPublish(uint16_t   packetId) {
72  Serial.print("Publish acknowledged.");
73  Serial.print("  packetId:   ");
74  Serial.println(packetId);
75}
76
77void setup() {
78  Serial.begin(115200);
79   while (!Serial)
80    delay(10); // will pause Zero, Leonardo, etc until serial   console opens
81  Serial.println();
82
83  if (!aht.begin()) {
84    Serial.println("Failed   to find AHT10/AHT20 chip");
85    while (1) {
86      delay(10);
87    }
88   }
89  Serial.println("AHT10/AHT20 Found!");
90  aht_temp = aht.getTemperatureSensor();
91   aht_temp->printSensorDetails();
92
93  aht_humidity = aht.getHumiditySensor();
94   aht_humidity->printSensorDetails();
95
96  wifiConnectHandler = WiFi.onStationModeGotIP(onWifiConnect);
97   wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWifiDisconnect);
98
99   mqttClient.onConnect(onMqttConnect);
100  mqttClient.onDisconnect(onMqttDisconnect);
101
102   mqttClient.onPublish(onMqttPublish);
103  mqttClient.setServer(MQTT_HOST, MQTT_PORT);
104   // If your broker requires authentication (username and password), set them below
105   mqttClient.setCredentials("Guru", "Enterprise1");
106
107  connectToWifi();
108}
109
110void   loop() {
111  unsigned long currentMillis = millis();
112  // Every X number of   seconds (interval = 10 seconds)
113  // it publishes a new MQTT message
114  if   (currentMillis - previousMillis >= interval) {
115    // Save the last time a new   reading was published
116    previousMillis = currentMillis;
117
118    sensors_event_t   humidity;
119    sensors_event_t temp;
120    aht_humidity->getEvent(&humidity);
121     aht_temp->getEvent(&temp);
122
123    // Publish an MQTT message on topic esp/dht/temperature
124     uint16_t packetIdPub1 = mqttClient.publish(MQTT_PUB_TEMP, 1, true, String(temp.temperature).c_str());
125     Serial.printf("Publishing on topic %s at QoS 1, packetId: %i ", MQTT_PUB_TEMP,   packetIdPub1);
126    Serial.printf("Message: %.2f \
127", temp.temperature);
128
129     // Publish an MQTT message on topic esp/dht/humidity
130    uint16_t packetIdPub2   = mqttClient.publish(MQTT_PUB_HUM, 1, true, String(humidity.relative_humidity).c_str());
131     Serial.printf("Publishing on topic %s at QoS 1, packetId %i: ", MQTT_PUB_HUM,   packetIdPub2);
132    Serial.printf("Message: %.2f \
133", humidity.relative_humidity);
134     delay(200);
135    Serial.println("gleich geh ich schlafen");
136    ESP.deepSleep(120e6);
137   }
138}

#include <ESP8266WiFi.h>
#include <Ticker.h>
#include <AsyncMqttClient.h>
#include   <Adafruit_AHTX0.h>

#define WIFI_SSID "YOUR SSID"
#define WIFI_PASSWORD   "YOUR PW"
char wiFiHostname[ ] = "YOUR SENSORNAME";
#define FORCE_DEEPSLEEP

Adafruit_AHTX0   aht;
Adafruit_Sensor *aht_humidity, *aht_temp;

#define MQTT_HOST IPAddress(192,   168, XXX, XX)
#define MQTT_PORT 1883

// Temperature MQTT Topics
#define   MQTT_PUB_TEMP "Bad/temperature"
#define MQTT_PUB_HUM "Bad/humidity"


AsyncMqttClient   mqttClient;
Ticker mqttReconnectTimer;

WiFiEventHandler wifiConnectHandler;
WiFiEventHandler   wifiDisconnectHandler;
Ticker wifiReconnectTimer;

unsigned long previousMillis   = 0;   // Stores last time temperature was published
const long interval = 10000;         // Interval at which to publish sensor readings

void connectToWifi()   {
  Serial.println("Connecting to Wi-Fi...");
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
   wifi_station_set_hostname(wiFiHostname);
}

void onWifiConnect(const   WiFiEventStationModeGotIP& event) {
  Serial.println("Connected to Wi-Fi.");
   Serial.println("Ready");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
   connectToMqtt();
}

void onWifiDisconnect(const WiFiEventStationModeDisconnected&   event) {
  Serial.println("Disconnected from Wi-Fi.");
  mqttReconnectTimer.detach();   // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
  wifiReconnectTimer.once(2,   connectToWifi);
}

void connectToMqtt() {
  Serial.println("Connecting   to MQTT...");
  mqttClient.connect();
}

void onMqttConnect(bool sessionPresent)   {
  Serial.println("Connected to MQTT.");
  Serial.print("Session present:   ");
  Serial.println(sessionPresent);
}

void onMqttDisconnect(AsyncMqttClientDisconnectReason   reason) {
  Serial.println("Disconnected from MQTT.");

  if (WiFi.isConnected())   {
    mqttReconnectTimer.once(2, connectToMqtt);
  }
}

void onMqttPublish(uint16_t   packetId) {
  Serial.print("Publish acknowledged.");
  Serial.print("  packetId:   ");
  Serial.println(packetId);
}

void setup() {
  Serial.begin(115200);
   while (!Serial)
    delay(10); // will pause Zero, Leonardo, etc until serial   console opens
  Serial.println();

  if (!aht.begin()) {
    Serial.println("Failed   to find AHT10/AHT20 chip");
    while (1) {
      delay(10);
    }
   }
  Serial.println("AHT10/AHT20 Found!");
  aht_temp = aht.getTemperatureSensor();
   aht_temp->printSensorDetails();

  aht_humidity = aht.getHumiditySensor();
   aht_humidity->printSensorDetails();

  wifiConnectHandler = WiFi.onStationModeGotIP(onWifiConnect);
   wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWifiDisconnect);

   mqttClient.onConnect(onMqttConnect);
  mqttClient.onDisconnect(onMqttDisconnect);

   mqttClient.onPublish(onMqttPublish);
  mqttClient.setServer(MQTT_HOST, MQTT_PORT);
   // If your broker requires authentication (username and password), set them below
   mqttClient.setCredentials("Guru", "Enterprise1");

  connectToWifi();
}

void   loop() {
  unsigned long currentMillis = millis();
  // Every X number of   seconds (interval = 10 seconds)
  // it publishes a new MQTT message
  if   (currentMillis - previousMillis >= interval) {
    // Save the last time a new   reading was published
    previousMillis = currentMillis;

    sensors_event_t   humidity;
    sensors_event_t temp;
    aht_humidity->getEvent(&humidity);
     aht_temp->getEvent(&temp);

    // Publish an MQTT message on topic esp/dht/temperature
     uint16_t packetIdPub1 = mqttClient.publish(MQTT_PUB_TEMP, 1, true, String(temp.temperature).c_str());
     Serial.printf("Publishing on topic %s at QoS 1, packetId: %i ", MQTT_PUB_TEMP,   packetIdPub1);
    Serial.printf("Message: %.2f \
", temp.temperature);

     // Publish an MQTT message on topic esp/dht/humidity
    uint16_t packetIdPub2   = mqttClient.publish(MQTT_PUB_HUM, 1, true, String(humidity.relative_humidity).c_str());
     Serial.printf("Publishing on topic %s at QoS 1, packetId %i: ", MQTT_PUB_HUM,   packetIdPub2);
    Serial.printf("Message: %.2f \
", humidity.relative_humidity);
     delay(200);
    Serial.println("gleich geh ich schlafen");
    ESP.deepSleep(120e6);
   }
}

AHT10 Measuring with Backup and Solar

c_cpp

1#include <ESP8266WiFi.h>
2#include <Ticker.h>
3#include <AsyncMqttClient.h>
4#include
5  <Adafruit_AHTX0.h>
6
7#define WIFI_SSID "YOUR SSID"
8#define WIFI_PASSWORD
9  "YOUR PW"
10char wiFiHostname[ ] = "YOUR SENSORNAME";
11#define FORCE_DEEPSLEEP
12
13Adafruit_AHTX0
14  aht;
15Adafruit_Sensor *aht_humidity, *aht_temp;
16
17#define MQTT_HOST IPAddress(192,
18  168, XXX, XX)
19#define MQTT_PORT 1883
20
21// Temperature MQTT Topics
22#define
23  MQTT_PUB_TEMP "Bad/temperature"
24#define MQTT_PUB_HUM "Bad/humidity"
25
26
27AsyncMqttClient
28  mqttClient;
29Ticker mqttReconnectTimer;
30
31WiFiEventHandler wifiConnectHandler;
32WiFiEventHandler
33  wifiDisconnectHandler;
34Ticker wifiReconnectTimer;
35
36unsigned long previousMillis
37  = 0;   // Stores last time temperature was published
38const long interval = 10000;
39        // Interval at which to publish sensor readings
40
41void connectToWifi()
42  {
43  Serial.println("Connecting to Wi-Fi...");
44  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
45
46  wifi_station_set_hostname(wiFiHostname);
47}
48
49void onWifiConnect(const
50  WiFiEventStationModeGotIP& event) {
51  Serial.println("Connected to Wi-Fi.");
52
53  Serial.println("Ready");
54  Serial.print("IP address: ");
55  Serial.println(WiFi.localIP());
56
57  connectToMqtt();
58}
59
60void onWifiDisconnect(const WiFiEventStationModeDisconnected&
61  event) {
62  Serial.println("Disconnected from Wi-Fi.");
63  mqttReconnectTimer.detach();
64  // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
65  wifiReconnectTimer.once(2,
66  connectToWifi);
67}
68
69void connectToMqtt() {
70  Serial.println("Connecting
71  to MQTT...");
72  mqttClient.connect();
73}
74
75void onMqttConnect(bool sessionPresent)
76  {
77  Serial.println("Connected to MQTT.");
78  Serial.print("Session present:
79  ");
80  Serial.println(sessionPresent);
81}
82
83void onMqttDisconnect(AsyncMqttClientDisconnectReason
84  reason) {
85  Serial.println("Disconnected from MQTT.");
86
87  if (WiFi.isConnected())
88  {
89    mqttReconnectTimer.once(2, connectToMqtt);
90  }
91}
92
93void onMqttPublish(uint16_t
94  packetId) {
95  Serial.print("Publish acknowledged.");
96  Serial.print("  packetId:
97  ");
98  Serial.println(packetId);
99}
100
101void setup() {
102  Serial.begin(115200);
103
104  while (!Serial)
105    delay(10); // will pause Zero, Leonardo, etc until serial
106  console opens
107  Serial.println();
108
109  if (!aht.begin()) {
110    Serial.println("Failed
111  to find AHT10/AHT20 chip");
112    while (1) {
113      delay(10);
114    }
115
116  }
117  Serial.println("AHT10/AHT20 Found!");
118  aht_temp = aht.getTemperatureSensor();
119
120  aht_temp->printSensorDetails();
121
122  aht_humidity = aht.getHumiditySensor();
123
124  aht_humidity->printSensorDetails();
125
126  wifiConnectHandler = WiFi.onStationModeGotIP(onWifiConnect);
127
128  wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWifiDisconnect);
129
130
131  mqttClient.onConnect(onMqttConnect);
132  mqttClient.onDisconnect(onMqttDisconnect);
133
134
135  mqttClient.onPublish(onMqttPublish);
136  mqttClient.setServer(MQTT_HOST, MQTT_PORT);
137
138  // If your broker requires authentication (username and password), set them below
139
140  mqttClient.setCredentials("Guru", "Enterprise1");
141
142  connectToWifi();
143}
144
145void
146  loop() {
147  unsigned long currentMillis = millis();
148  // Every X number of
149  seconds (interval = 10 seconds)
150  // it publishes a new MQTT message
151  if
152  (currentMillis - previousMillis >= interval) {
153    // Save the last time a new
154  reading was published
155    previousMillis = currentMillis;
156
157    sensors_event_t
158  humidity;
159    sensors_event_t temp;
160    aht_humidity->getEvent(&humidity);
161
162    aht_temp->getEvent(&temp);
163
164    // Publish an MQTT message on topic esp/dht/temperature
165
166    uint16_t packetIdPub1 = mqttClient.publish(MQTT_PUB_TEMP, 1, true, String(temp.temperature).c_str());
167
168    Serial.printf("Publishing on topic %s at QoS 1, packetId: %i ", MQTT_PUB_TEMP,
169  packetIdPub1);
170    Serial.printf("Message: %.2f \
171", temp.temperature);
172
173
174    // Publish an MQTT message on topic esp/dht/humidity
175    uint16_t packetIdPub2
176  = mqttClient.publish(MQTT_PUB_HUM, 1, true, String(humidity.relative_humidity).c_str());
177
178    Serial.printf("Publishing on topic %s at QoS 1, packetId %i: ", MQTT_PUB_HUM,
179  packetIdPub2);
180    Serial.printf("Message: %.2f \
181", humidity.relative_humidity);
182
183    delay(200);
184    Serial.println("gleich geh ich schlafen");
185    ESP.deepSleep(120e6);
186
187  }
188}

#include <ESP8266WiFi.h>
#include <Ticker.h>
#include <AsyncMqttClient.h>
#include
  <Adafruit_AHTX0.h>

#define WIFI_SSID "YOUR SSID"
#define WIFI_PASSWORD
  "YOUR PW"
char wiFiHostname[ ] = "YOUR SENSORNAME";
#define FORCE_DEEPSLEEP

Adafruit_AHTX0
  aht;
Adafruit_Sensor *aht_humidity, *aht_temp;

#define MQTT_HOST IPAddress(192,
  168, XXX, XX)
#define MQTT_PORT 1883

// Temperature MQTT Topics
#define
  MQTT_PUB_TEMP "Bad/temperature"
#define MQTT_PUB_HUM "Bad/humidity"


AsyncMqttClient
  mqttClient;
Ticker mqttReconnectTimer;

WiFiEventHandler wifiConnectHandler;
WiFiEventHandler
  wifiDisconnectHandler;
Ticker wifiReconnectTimer;

unsigned long previousMillis
  = 0;   // Stores last time temperature was published
const long interval = 10000;
        // Interval at which to publish sensor readings

void connectToWifi()
  {
  Serial.println("Connecting to Wi-Fi...");
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

  wifi_station_set_hostname(wiFiHostname);
}

void onWifiConnect(const
  WiFiEventStationModeGotIP& event) {
  Serial.println("Connected to Wi-Fi.");

  Serial.println("Ready");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());

  connectToMqtt();
}

void onWifiDisconnect(const WiFiEventStationModeDisconnected&
  event) {
  Serial.println("Disconnected from Wi-Fi.");
  mqttReconnectTimer.detach();
  // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
  wifiReconnectTimer.once(2,
  connectToWifi);
}

void connectToMqtt() {
  Serial.println("Connecting
  to MQTT...");
  mqttClient.connect();
}

void onMqttConnect(bool sessionPresent)
  {
  Serial.println("Connected to MQTT.");
  Serial.print("Session present:
  ");
  Serial.println(sessionPresent);
}

void onMqttDisconnect(AsyncMqttClientDisconnectReason
  reason) {
  Serial.println("Disconnected from MQTT.");

  if (WiFi.isConnected())
  {
    mqttReconnectTimer.once(2, connectToMqtt);
  }
}

void onMqttPublish(uint16_t
  packetId) {
  Serial.print("Publish acknowledged.");
  Serial.print("  packetId:
  ");
  Serial.println(packetId);
}

void setup() {
  Serial.begin(115200);

  while (!Serial)
    delay(10); // will pause Zero, Leonardo, etc until serial
  console opens
  Serial.println();

  if (!aht.begin()) {
    Serial.println("Failed
  to find AHT10/AHT20 chip");
    while (1) {
      delay(10);
    }

  }
  Serial.println("AHT10/AHT20 Found!");
  aht_temp = aht.getTemperatureSensor();

  aht_temp->printSensorDetails();

  aht_humidity = aht.getHumiditySensor();

  aht_humidity->printSensorDetails();

  wifiConnectHandler = WiFi.onStationModeGotIP(onWifiConnect);

  wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWifiDisconnect);


  mqttClient.onConnect(onMqttConnect);
  mqttClient.onDisconnect(onMqttDisconnect);


  mqttClient.onPublish(onMqttPublish);
  mqttClient.setServer(MQTT_HOST, MQTT_PORT);

  // If your broker requires authentication (username and password), set them below

  mqttClient.setCredentials("Guru", "Enterprise1");

  connectToWifi();
}

void
  loop() {
  unsigned long currentMillis = millis();
  // Every X number of
  seconds (interval = 10 seconds)
  // it publishes a new MQTT message
  if
  (currentMillis - previousMillis >= interval) {
    // Save the last time a new
  reading was published
    previousMillis = currentMillis;

    sensors_event_t
  humidity;
    sensors_event_t temp;
    aht_humidity->getEvent(&humidity);

    aht_temp->getEvent(&temp);

    // Publish an MQTT message on topic esp/dht/temperature

    uint16_t packetIdPub1 = mqttClient.publish(MQTT_PUB_TEMP, 1, true, String(temp.temperature).c_str());

    Serial.printf("Publishing on topic %s at QoS 1, packetId: %i ", MQTT_PUB_TEMP,
  packetIdPub1);
    Serial.printf("Message: %.2f \
", temp.temperature);


    // Publish an MQTT message on topic esp/dht/humidity
    uint16_t packetIdPub2
  = mqttClient.publish(MQTT_PUB_HUM, 1, true, String(humidity.relative_humidity).c_str());

    Serial.printf("Publishing on topic %s at QoS 1, packetId %i: ", MQTT_PUB_HUM,
  packetIdPub2);
    Serial.printf("Message: %.2f \
", humidity.relative_humidity);

    delay(200);
    Serial.println("gleich geh ich schlafen");
    ESP.deepSleep(120e6);

  }
}

AHT10 Measuring with Backup and Solar

c_cpp

1#include <ESP8266WiFi.h>
2#include <Ticker.h>
3#include <AsyncMqttClient.h>
4#include  <Adafruit_AHTX0.h>
5
6#define WIFI_SSID "YOUR SSID"
7#define WIFI_PASSWORD  "YOUR PW"
8char wiFiHostname[ ] = "YOUR SENSORNAME";
9#define FORCE_DEEPSLEEP
10
11Adafruit_AHTX0  aht;
12Adafruit_Sensor *aht_humidity, *aht_temp;
13
14#define MQTT_HOST IPAddress(192,  168, XXX, XX)
15#define MQTT_PORT 1883
16
17// Temperature MQTT Topics
18#define  MQTT_PUB_TEMP "Bad/temperature"
19#define MQTT_PUB_HUM "Bad/humidity"
20
21
22AsyncMqttClient  mqttClient;
23Ticker mqttReconnectTimer;
24
25WiFiEventHandler wifiConnectHandler;
26WiFiEventHandler  wifiDisconnectHandler;
27Ticker wifiReconnectTimer;
28
29unsigned long previousMillis  = 0;   // Stores last time temperature was published
30const long interval = 10000;        // Interval at which to publish sensor readings
31
32void connectToWifi()  {
33  Serial.println("Connecting to Wi-Fi...");
34  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
35  wifi_station_set_hostname(wiFiHostname);
36}
37
38void onWifiConnect(const  WiFiEventStationModeGotIP& event) {
39  Serial.println("Connected to Wi-Fi.");
40  Serial.println("Ready");
41  Serial.print("IP address: ");
42  Serial.println(WiFi.localIP());
43  connectToMqtt();
44}
45
46void onWifiDisconnect(const WiFiEventStationModeDisconnected&  event) {
47  Serial.println("Disconnected from Wi-Fi.");
48  mqttReconnectTimer.detach();  // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
49  wifiReconnectTimer.once(2,  connectToWifi);
50}
51
52void connectToMqtt() {
53  Serial.println("Connecting  to MQTT...");
54  mqttClient.connect();
55}
56
57void onMqttConnect(bool sessionPresent)  {
58  Serial.println("Connected to MQTT.");
59  Serial.print("Session present:  ");
60  Serial.println(sessionPresent);
61}
62
63void onMqttDisconnect(AsyncMqttClientDisconnectReason  reason) {
64  Serial.println("Disconnected from MQTT.");
65
66  if (WiFi.isConnected())  {
67    mqttReconnectTimer.once(2, connectToMqtt);
68  }
69}
70
71void onMqttPublish(uint16_t  packetId) {
72  Serial.print("Publish acknowledged.");
73  Serial.print("  packetId:  ");
74  Serial.println(packetId);
75}
76
77void setup() {
78  Serial.begin(115200);
79  while (!Serial)
80    delay(10); // will pause Zero, Leonardo, etc until serial  console opens
81  Serial.println();
82
83  if (!aht.begin()) {
84    Serial.println("Failed  to find AHT10/AHT20 chip");
85    while (1) {
86      delay(10);
87    }
88  }
89  Serial.println("AHT10/AHT20 Found!");
90  aht_temp = aht.getTemperatureSensor();
91  aht_temp->printSensorDetails();
92
93  aht_humidity = aht.getHumiditySensor();
94  aht_humidity->printSensorDetails();
95
96  wifiConnectHandler = WiFi.onStationModeGotIP(onWifiConnect);
97  wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWifiDisconnect);
98
99  mqttClient.onConnect(onMqttConnect);
100  mqttClient.onDisconnect(onMqttDisconnect);
101
102  mqttClient.onPublish(onMqttPublish);
103  mqttClient.setServer(MQTT_HOST, MQTT_PORT);
104  // If your broker requires authentication (username and password), set them below
105  mqttClient.setCredentials("Guru", "Enterprise1");
106
107  connectToWifi();
108}
109
110void  loop() {
111  unsigned long currentMillis = millis();
112  // Every X number of  seconds (interval = 10 seconds)
113  // it publishes a new MQTT message
114  if  (currentMillis - previousMillis >= interval) {
115    // Save the last time a new  reading was published
116    previousMillis = currentMillis;
117
118    sensors_event_t  humidity;
119    sensors_event_t temp;
120    aht_humidity->getEvent(&humidity);
121    aht_temp->getEvent(&temp);
122
123    // Publish an MQTT message on topic esp/dht/temperature
124    uint16_t packetIdPub1 = mqttClient.publish(MQTT_PUB_TEMP, 1, true, String(temp.temperature).c_str());
125    Serial.printf("Publishing on topic %s at QoS 1, packetId: %i ", MQTT_PUB_TEMP,  packetIdPub1);
126    Serial.printf("Message: %.2f \
127", temp.temperature);
128
129    // Publish an MQTT message on topic esp/dht/humidity
130    uint16_t packetIdPub2  = mqttClient.publish(MQTT_PUB_HUM, 1, true, String(humidity.relative_humidity).c_str());
131    Serial.printf("Publishing on topic %s at QoS 1, packetId %i: ", MQTT_PUB_HUM,  packetIdPub2);
132    Serial.printf("Message: %.2f \
133", humidity.relative_humidity);
134    delay(200);
135    Serial.println("gleich geh ich schlafen");
136    ESP.deepSleep(120e6);
137  }
138}

#include <ESP8266WiFi.h>
#include <Ticker.h>
#include <AsyncMqttClient.h>
#include  <Adafruit_AHTX0.h>

#define WIFI_SSID "YOUR SSID"
#define WIFI_PASSWORD  "YOUR PW"
char wiFiHostname[ ] = "YOUR SENSORNAME";
#define FORCE_DEEPSLEEP

Adafruit_AHTX0  aht;
Adafruit_Sensor *aht_humidity, *aht_temp;

#define MQTT_HOST IPAddress(192,  168, XXX, XX)
#define MQTT_PORT 1883

// Temperature MQTT Topics
#define  MQTT_PUB_TEMP "Bad/temperature"
#define MQTT_PUB_HUM "Bad/humidity"


AsyncMqttClient  mqttClient;
Ticker mqttReconnectTimer;

WiFiEventHandler wifiConnectHandler;
WiFiEventHandler  wifiDisconnectHandler;
Ticker wifiReconnectTimer;

unsigned long previousMillis  = 0;   // Stores last time temperature was published
const long interval = 10000;        // Interval at which to publish sensor readings

void connectToWifi()  {
  Serial.println("Connecting to Wi-Fi...");
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  wifi_station_set_hostname(wiFiHostname);
}

void onWifiConnect(const  WiFiEventStationModeGotIP& event) {
  Serial.println("Connected to Wi-Fi.");
  Serial.println("Ready");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
  connectToMqtt();
}

void onWifiDisconnect(const WiFiEventStationModeDisconnected&  event) {
  Serial.println("Disconnected from Wi-Fi.");
  mqttReconnectTimer.detach();  // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
  wifiReconnectTimer.once(2,  connectToWifi);
}

void connectToMqtt() {
  Serial.println("Connecting  to MQTT...");
  mqttClient.connect();
}

void onMqttConnect(bool sessionPresent)  {
  Serial.println("Connected to MQTT.");
  Serial.print("Session present:  ");
  Serial.println(sessionPresent);
}

void onMqttDisconnect(AsyncMqttClientDisconnectReason  reason) {
  Serial.println("Disconnected from MQTT.");

  if (WiFi.isConnected())  {
    mqttReconnectTimer.once(2, connectToMqtt);
  }
}

void onMqttPublish(uint16_t  packetId) {
  Serial.print("Publish acknowledged.");
  Serial.print("  packetId:  ");
  Serial.println(packetId);
}

void setup() {
  Serial.begin(115200);
  while (!Serial)
    delay(10); // will pause Zero, Leonardo, etc until serial  console opens
  Serial.println();

  if (!aht.begin()) {
    Serial.println("Failed  to find AHT10/AHT20 chip");
    while (1) {
      delay(10);
    }
  }
  Serial.println("AHT10/AHT20 Found!");
  aht_temp = aht.getTemperatureSensor();
  aht_temp->printSensorDetails();

  aht_humidity = aht.getHumiditySensor();
  aht_humidity->printSensorDetails();

  wifiConnectHandler = WiFi.onStationModeGotIP(onWifiConnect);
  wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWifiDisconnect);

  mqttClient.onConnect(onMqttConnect);
  mqttClient.onDisconnect(onMqttDisconnect);

  mqttClient.onPublish(onMqttPublish);
  mqttClient.setServer(MQTT_HOST, MQTT_PORT);
  // If your broker requires authentication (username and password), set them below
  mqttClient.setCredentials("Guru", "Enterprise1");

  connectToWifi();
}

void  loop() {
  unsigned long currentMillis = millis();
  // Every X number of  seconds (interval = 10 seconds)
  // it publishes a new MQTT message
  if  (currentMillis - previousMillis >= interval) {
    // Save the last time a new  reading was published
    previousMillis = currentMillis;

    sensors_event_t  humidity;
    sensors_event_t temp;
    aht_humidity->getEvent(&humidity);
    aht_temp->getEvent(&temp);

    // Publish an MQTT message on topic esp/dht/temperature
    uint16_t packetIdPub1 = mqttClient.publish(MQTT_PUB_TEMP, 1, true, String(temp.temperature).c_str());
    Serial.printf("Publishing on topic %s at QoS 1, packetId: %i ", MQTT_PUB_TEMP,  packetIdPub1);
    Serial.printf("Message: %.2f \
", temp.temperature);

    // Publish an MQTT message on topic esp/dht/humidity
    uint16_t packetIdPub2  = mqttClient.publish(MQTT_PUB_HUM, 1, true, String(humidity.relative_humidity).c_str());
    Serial.printf("Publishing on topic %s at QoS 1, packetId %i: ", MQTT_PUB_HUM,  packetIdPub2);
    Serial.printf("Message: %.2f \
", humidity.relative_humidity);
    delay(200);
    Serial.println("gleich geh ich schlafen");
    ESP.deepSleep(120e6);
  }
}

Downloadable files

AHT10 Measuring with Backup and Solar

untitled

Comments

Only logged in users can leave comments

maximus1

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content