397 lines
11 KiB
C++
397 lines
11 KiB
C++
#include "main.h"
|
|
#include "NTPClient.h"
|
|
//#include "Effortless_SPIFFS.h"
|
|
//#include "driver/"
|
|
#include <sys/time.h>
|
|
#include <nvs_flash.h>
|
|
#include <ctime>
|
|
#include <iostream>
|
|
#include <chrono>
|
|
|
|
#define STORAGE_NAMESPACE "storage"
|
|
#define RESTART 1
|
|
#define REFRESHMEMBOOT 0
|
|
|
|
using namespace std;
|
|
|
|
DHT sensors[SENSORS_NUMBER] = {DHT(04, DHT22), DHT(18, DHT22), DHT(05, DHT22), DHT(17, DHT22), DHT(16, DHT22)};
|
|
float temp[SENSORS_NUMBER];
|
|
float hum[SENSORS_NUMBER];
|
|
|
|
Pangodream_18650_CL Battery(ADC_PIN, CONV_FACTOR, READS);
|
|
WiFiClient WifiClient;
|
|
PubSubClient MqttClient(WifiClient);
|
|
WiFiUDP NtpUDP;
|
|
|
|
/**
|
|
* @brief create NTP profile for frenchs users
|
|
*
|
|
* @param NtpUDP: Protocole use
|
|
*
|
|
* @param "europe.pool.ntp.org": serve target
|
|
*
|
|
* @param 7200: jet lag europe time from France (2 * 3600 sec)
|
|
*/
|
|
NTPClient TimeClient(NtpUDP, "europe.pool.ntp.org", 7200, 60000);
|
|
|
|
//-------------------- CONDITION --------------------//
|
|
|
|
/**
|
|
* @brief Time hour for restart or time for refresh restart persistant mem
|
|
*
|
|
* @param hours
|
|
* @param restart bool at true for restart or at false for resfresh memory
|
|
* @return true right hour for restart or refresh
|
|
* @return false bad hour for restart or refresh
|
|
*/
|
|
bool ishour(int hours, bool restart){
|
|
if (restart){
|
|
return hours <= (2 * TIME_TO_SLEEP) / 3600;
|
|
}
|
|
// Then refresh time
|
|
return (hours > (2 * TIME_TO_SLEEP) / 3600) && (hours <= (4 * TIME_TO_SLEEP) / 3600);
|
|
}
|
|
|
|
/**
|
|
* @brief Time minute for restart or time for refresh restart persistant mem
|
|
*
|
|
* @param minutes
|
|
* @param restart bool at true for restart or at false for resfresh memory
|
|
* @return true right minute for restart or refresh
|
|
* @return false bad minute for restart or refresh
|
|
*/
|
|
bool isminute(int minutes, bool restart){
|
|
if (restart){
|
|
return minutes <= ((2 * TIME_TO_SLEEP) % 3600) / 60;
|
|
}
|
|
// Then refresh time
|
|
return (minutes > ((2 * TIME_TO_SLEEP) % 3600)) / 60 && (minutes <= ((4 * TIME_TO_SLEEP) % 3600) / 60);
|
|
}
|
|
|
|
/**
|
|
* @brief Time seconde for restart or time for refresh restart persistant mem
|
|
*
|
|
* @param secondes
|
|
* @param restart bool at true for restart or at false for resfresh memory
|
|
* @return true right secondes for restart or refresh
|
|
* @return false bad secondes for restart or refresh
|
|
*/
|
|
bool issecond(int secondes, bool restart){
|
|
if (restart){
|
|
return secondes <= ((2 * TIME_TO_SLEEP) - 1 ) % 60;
|
|
}
|
|
// Then refresh time
|
|
return (secondes > ((2 * TIME_TO_SLEEP) - 1 ) % 60) && (secondes <= ((4 * TIME_TO_SLEEP) - 1 ) % 60);
|
|
}
|
|
|
|
//-------------------- FONCTIONS --------------------//
|
|
|
|
//-------------- Connexion MQTT --------------//
|
|
|
|
void setupMQTT(const char *address, int port)
|
|
{
|
|
MqttClient.setServer(address, port);
|
|
}
|
|
|
|
|
|
void setupWIFI(const char *wifi_name, const char *password)
|
|
{
|
|
Serial.println('\n');
|
|
|
|
WiFi.begin(wifi_name, password);
|
|
Serial.print("Connecting to ");
|
|
Serial.print(wifi_name);
|
|
|
|
int cpttry = 10;
|
|
while (WiFi.status() != WL_CONNECTED)
|
|
{
|
|
delay(500);
|
|
Serial.print('.');
|
|
|
|
/* stop trying wifi connexion */
|
|
cpttry--;
|
|
if(cpttry == 0){
|
|
Serial.print("wifi: 10 try go to sleep");
|
|
sleep();
|
|
}
|
|
}
|
|
Serial.println('\n');
|
|
Serial.println("Connection established!");
|
|
Serial.print("IP address:\t");
|
|
Serial.println(WiFi.localIP());
|
|
}
|
|
|
|
void reconnect(void)
|
|
{
|
|
Serial.println("Connecting to MQTT Broker...");
|
|
int cpttry = 10;
|
|
while (!MqttClient.connected())
|
|
{
|
|
/* stop trying mqtt connexion */
|
|
cpttry--;
|
|
if(cpttry == 0){
|
|
Serial.print("Mqtt: 10 try go to sleep");
|
|
sleep();
|
|
}
|
|
|
|
Serial.print(".");
|
|
if (MqttClient.connect(ESPNAME, MQTT_USER, MQTT_MDP)) // MQTT_MDP (mot de passe)
|
|
{
|
|
Serial.println("Connected.");
|
|
}
|
|
}
|
|
}
|
|
|
|
//-------------- Initialisation et lecture des capteurs --------------//
|
|
|
|
void initSensors(DHT *sensors, int number)
|
|
{
|
|
int i;
|
|
for (i = 0; i < number; i++)
|
|
{
|
|
sensors[i].begin();
|
|
}
|
|
}
|
|
|
|
void readSensors(DHT sensors[], float temp[], float hum[], int number)
|
|
{
|
|
int i;
|
|
for (i = 0; i < number; i++)
|
|
{
|
|
*(temp + i) = sensors[i].readTemperature();
|
|
*(hum + i) = sensors[i].readHumidity();
|
|
}
|
|
}
|
|
|
|
//-------------------- Sleep de l'ESP --------------------//
|
|
|
|
void sleep()
|
|
{
|
|
esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * US_TO_S_FACTOR);
|
|
esp_deep_sleep_start();
|
|
}
|
|
|
|
//exemple d'une triple utilisation de valeur pour une fonction utilise pour la date
|
|
std::tuple<int, int, int> getDate()
|
|
{
|
|
struct timeval synctime;
|
|
TimeClient.forceUpdate();
|
|
time_t rawtime = TimeClient.getEpochTime();
|
|
synctime.tv_sec = rawtime;
|
|
synctime.tv_usec = 0;
|
|
if(settimeofday(&synctime,NULL) != 0) std::cout << "error\n" ;
|
|
setenv("TZ", "CEST+2", 1);
|
|
tzset();
|
|
|
|
struct tm *ti;
|
|
ti = localtime(&rawtime);
|
|
int year = ti->tm_year + 1900;
|
|
int month = (ti->tm_mon + 1) < 10 ? 0 + (ti->tm_mon + 1) : (ti->tm_mon + 1);
|
|
int day = (ti->tm_mday) < 10 ? 0 + (ti->tm_mday) : (ti->tm_mday);
|
|
return std::make_tuple(year, month, day);
|
|
}
|
|
|
|
// Function that gets current epoch time
|
|
unsigned long getTime() {
|
|
time_t now;
|
|
struct tm timeinfo;
|
|
if (!getLocalTime(&timeinfo)) {
|
|
Serial.println("Failed to obtain time");
|
|
return(0);
|
|
}
|
|
time(&now);
|
|
Serial.println(now);
|
|
return now;
|
|
}
|
|
//-------------------- Création de trames --------------------//
|
|
|
|
|
|
void writeMessage(char *txt, float *temp, float *hum, int number)
|
|
{
|
|
int chargelvl = Battery.getBatteryChargeLevel();
|
|
//time_t rawtime = TimeClient.getEpochTime();
|
|
|
|
|
|
switch (number)
|
|
{
|
|
case 1:
|
|
sprintf(txt, "|%s|%0.2f|%0.2f", CLUSTER, temp[0], hum[0]);
|
|
break;
|
|
case 2:
|
|
sprintf(txt, "|%s|%0.2f %0.2f|%0.2f %0.2f", CLUSTER, temp[0], temp[1], hum[0], hum[1]);
|
|
break;
|
|
case 3:
|
|
sprintf(txt, "|%s|%0.2f %0.2f %0.2f|%0.2f %0.2f %0.2f", CLUSTER, temp[0], temp[1], temp[2], hum[0], hum[1], hum[2]);
|
|
break;
|
|
case 4:
|
|
sprintf(txt, "|%s|%0.2f %0.2f %0.2f %0.2f|%0.2f %0.2f %0.2f %0.2f", CLUSTER, temp[0], temp[1], temp[2], temp[3], hum[0], hum[1], hum[2], hum[3]);
|
|
break;
|
|
case 5:
|
|
sprintf(txt, "|%s|%0.2f %0.2f %0.2f %0.2f %0.2f|%0.2f %0.2f %0.2f %0.2f %0.2f|%d", CLUSTER, temp[0], temp[1], temp[2], temp[3], temp[4], hum[0], hum[1], hum[2], hum[3], hum[4], chargelvl);
|
|
break;
|
|
case 6:
|
|
sprintf(txt, "|%s|%0.2f %0.2f %0.2f %0.2f %0.2f %0.2f|%0.2f %0.2f %0.2f %0.2f %0.2f %0.2f", CLUSTER, temp[0], temp[1], temp[2], temp[3], temp[4], temp[5], hum[0], hum[1], hum[2], hum[3], hum[4], hum[5]);
|
|
break;
|
|
default:
|
|
Serial.println("Erreur, temp et hum sont trop longs : trop de capteurs");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief read, refresh and return the day boot state
|
|
*
|
|
* @return bool at true if the esp was restarted or false if error or not restarted
|
|
* @inspired of https://github.com/espressif/esp-idf/blob/master/examples/storage/nvs_rw_blob/main/nvs_blob_example_main.c
|
|
*/
|
|
bool TestBoot(bool resOrRfsh)
|
|
{
|
|
nvs_handle_t my_handle;
|
|
esp_err_t err;
|
|
bool booted = false;
|
|
|
|
// Open
|
|
err = nvs_open(STORAGE_NAMESPACE, NVS_READWRITE, &my_handle);
|
|
if (err != ESP_OK){
|
|
Serial.println("Erreur open nvs persistant storage");
|
|
return false;
|
|
}
|
|
|
|
/******** Refresh part ********/
|
|
|
|
if(resOrRfsh == REFRESHMEMBOOT){
|
|
int32_t restart = REFRESHMEMBOOT;
|
|
err = nvs_set_i32(my_handle, "restart", restart);
|
|
if (err != ESP_OK) {
|
|
Serial.println("Erreur write nvs persistant storage");
|
|
return false;
|
|
}
|
|
// Commit written value.
|
|
// After setting any values, nvs_commit() must be called to ensure changes are written
|
|
// to flash storage. Implementations may write to storage at other times,
|
|
// but this is not guaranteed.
|
|
err = nvs_commit(my_handle);
|
|
if (err != ESP_OK) return err;
|
|
// Close
|
|
nvs_close(my_handle);
|
|
Serial.println("Refresh memory restart state ");
|
|
return false;
|
|
}
|
|
|
|
/******** ********/
|
|
|
|
// Read
|
|
int32_t restart = 0; // value will default to 0, if not set yet in NVS
|
|
err = nvs_get_i32(my_handle, "restart", &restart);
|
|
if (err != ESP_OK && err != ESP_ERR_NVS_NOT_FOUND){
|
|
Serial.println("Erreur read nvs persistant storage");
|
|
return false;
|
|
}
|
|
|
|
if(!restart){
|
|
// Write
|
|
restart = 1;
|
|
err = nvs_set_i32(my_handle, "restart", restart);
|
|
if (err != ESP_OK) {
|
|
Serial.println("Erreur write nvs persistant storage");
|
|
return false;
|
|
}
|
|
// Commit written value.
|
|
// After setting any values, nvs_commit() must be called to ensure changes are written
|
|
// to flash storage. Implementations may write to storage at other times,
|
|
// but this is not guaranteed.
|
|
err = nvs_commit(my_handle);
|
|
if (err != ESP_OK) return err;
|
|
// Close
|
|
nvs_close(my_handle);
|
|
Serial.println("not restart");
|
|
return false;
|
|
|
|
} else {
|
|
// Close
|
|
nvs_close(my_handle);
|
|
Serial.println("already restart");
|
|
return true;
|
|
}
|
|
|
|
/* Not needed but finish properly the function */
|
|
// Close
|
|
nvs_close(my_handle);
|
|
return false;
|
|
}
|
|
|
|
|
|
//-------------------- Initialisation --------------------//
|
|
|
|
void setup()
|
|
{
|
|
Serial.begin(9600);
|
|
|
|
setupWIFI(SSID, PWD);
|
|
setupMQTT(MQTT_ADDRESS, MQTT_PORT);
|
|
initSensors(sensors, SENSORS_NUMBER);
|
|
|
|
|
|
TimeClient.begin();
|
|
TimeClient.forceUpdate();
|
|
|
|
int rawtime = (TimeClient.getEpochTime()) % 86400; // 86400 = 60sec*60minutes*24heures
|
|
int hours = rawtime / 3600, minutes = (rawtime % 3600) / 60 , secondes = rawtime % 60;
|
|
|
|
if (nvs_flash_init() != ESP_OK){
|
|
Serial.println("Erreur flash init");
|
|
}
|
|
/**
|
|
* @brief restart the ESP if there is the time restart
|
|
*
|
|
*/
|
|
if(ishour(hours,RESTART) && isminute(minutes,RESTART) && issecond(secondes,RESTART) && TestBoot(RESTART)){
|
|
ESP.restart();
|
|
} else if(ishour(hours,REFRESHMEMBOOT) && isminute(minutes,REFRESHMEMBOOT) && issecond(secondes,REFRESHMEMBOOT)){
|
|
TestBoot(REFRESHMEMBOOT);
|
|
}
|
|
/* ######### test time part #########
|
|
Serial.println('\n');
|
|
Serial.println(hours,DEC);
|
|
Serial.println(':');
|
|
Serial.println(minutes,DEC);
|
|
Serial.println(':');
|
|
Serial.println(secondes,DEC);
|
|
Serial.println('\n');
|
|
*/
|
|
}
|
|
|
|
|
|
|
|
//-------------------- Boucle principale --------------------//
|
|
|
|
void loop()
|
|
{
|
|
int year, month, day;
|
|
int lenght;
|
|
char time[30];
|
|
char date[30];
|
|
char msg[70];
|
|
|
|
MqttClient.loop();
|
|
if (!MqttClient.connected())
|
|
{
|
|
reconnect();
|
|
}
|
|
|
|
readSensors(sensors, temp, hum, SENSORS_NUMBER);
|
|
writeMessage(msg, temp, hum, SENSORS_NUMBER);
|
|
|
|
TimeClient.update();
|
|
TimeClient.getFormattedTime().toCharArray(time, 30);
|
|
|
|
tie(year, month, day) = getDate();
|
|
lenght = sprintf(date, "%d-%d-%d ", year, month, day);
|
|
sprintf(date + lenght, time);
|
|
sprintf(date + strlen(date), msg);
|
|
MqttClient.publish(TOPIC, date);
|
|
|
|
delay(2000);
|
|
|
|
sleep();
|
|
} |