/*******02-INTROCUÇÃO DE TAREFA PARA PISCAR O LED DA PLACA******/
/*******transferindo para arquivos auxiliares*******************/
/****************DHT, LCD_I2C e LED****************************/
/**********inic_01.h, setup_01.h, loop_01.h e tarLED*********/

#include <LiquidCrystal_I2C.h>
/*******************************************************************************/
#include "DHTesp.h" // Clique aqui para obter a biblioteca: http://librarymanager/All#DHTesp
#include <Ticker.h>

#ifndef ESP32
#pragma message(ESTE EXEMPLO É APENAS PARA ESP32!)
#error Selecione a placa ESP32.
#endif

#include "inic_01.h"
#include "tarLED.h"
#include "includ_02.h"
#include "inic_02.h"





void setup()
{
#include "setup_01.h"

#include "setup_02.h"

}

void loop() {
#include "loop_01.h"
#include "loop_02.h"

}





sketch.ino

diagram.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

Firebase Arduino Client Library for ESP8266 and ESP32
DHT sensor library for ESPx
LiquidCrystal I2C
Time

libraries.txt

#define led1 LED_BUILTIN
/**************************************************************/
/* Exemplo de como ler sensores DHT de um ESP32 usando multi-*/
/* tarefa.                                                   */
/* Este exemplo depende da biblioteca Ticker para acordar */
/* a tarefa a cada x segundos, conforme */
/*tempTicker.attach(4, triggerGetTemp);  4 é o tempo */  
/*Neste após publicar no LCD, iremos publicar no FIREBASE*/                  
/**************************************************************/

DHTesp dht;

void tempTask(void *pvParameters);
bool getTemperature();
void triggerGetTemp();

/** Task handle for the light value read task */
TaskHandle_t tempTaskHandle = NULL;
/** Ticker para leitura de temperatura */ 
Ticker tempTicker;
/** Perfil de conforto */
ComfortState cf;
/** Flag se a tarefa deve executar */
bool tasksEnabled = false;
/** Número do pino para pino de dados DHT22 */
int dhtPin = 15;

LiquidCrystal_I2C lcd= LiquidCrystal_I2C(0x27, 16, 2);
const float t1 = 600;
const float t2 = 1200;
/******************led*********************************/
TaskHandle_t task_LED_H;
/**
 * initTemp
 * Setup DHT library
 * Setup task and timer for repeated measurement
 * @return bool
 *    true if task and timer are started
 *    false if task or timer couldn't be started
 */
bool initTemp() {
  byte resultValue = 0;
  // Inicializa o Sensor de temperatura
	dht.setup(dhtPin, DHTesp::DHT22);
	Serial.println("DHT inicializado e tarefa tempTask no núcleo 1!!!");

  // Inicie a tarefa para obter temperatura
	xTaskCreatePinnedToCore(
			tempTask,                       /* Function to implement the task */
			"tempTask ",                    /* Name of the task */
			4000,                           /* Stack size in words */
			NULL,                           /* Task input parameter */
			5,                              /* Priority of the task */
			&tempTaskHandle,                /* Task handle. */
			1);                             /* Core where the task should run */

  if (tempTaskHandle == NULL) {
    Serial.println("Falha ao iniciar a tarefa para atualização de temperatura");
    return false;
  } else {
    //  Iniciar a atualização dos dados do ambiente a cada 20 segundos
    tempTicker.attach(4, triggerGetTemp);
    Serial.print("tempTask correndo no: core ");
    Serial.println( xPortGetCoreID() );
    Serial.println("Chama a função getTemperature para iniciar a leitura do sensor");
  }
  return true;
}

/**
 * triggerGetTemp
 * Define o flag dhtUpdated para verdadeiro para manuseio em loop()
 * chamado porTicker getTempTimer
 */
void triggerGetTemp() {
  if (tempTaskHandle != NULL) {
	   xTaskResumeFromISR(tempTaskHandle);
  }
}

/**
 * Tarefa para ler a temperatura do sensor DHT22
 * @param pvParameters
 *    ponteiro para parâmetros de tarefa
 */
void tempTask(void *pvParameters) {
	Serial.println("Loop de execução das tarefas inicializado via tempTask");
	while (1) // tempTask loop
  {
    if (tasksEnabled) {
      // Get temperature values
			getTemperature();
		}
    // Got sleep again
		vTaskSuspend(NULL);
	}
}

/**
 * getTemperature
 * Leitura da temperatura do sensor DHT22
 * @return bool
 *    true if temperature could be aquired
 *    false if aquisition failed
*/
bool getTemperature() {
	// Reading temperature for humidity takes about 250 milliseconds!
	// Sensor readings may also be up to 2 seconds 'old' (it's a very slow sensor)
  TempAndHumidity newValues = dht.getTempAndHumidity();
	// Check if any reads failed and exit early (to try again).
	if (dht.getStatus() != 0) {
		Serial.println("DHT11 error status: " + String(dht.getStatusString()));
		return false;
	}
 //DÚVIDAS: https://github.com/beegee-tokyo/DHTesp
	float heatIndex = dht.computeHeatIndex(newValues.temperature, newValues.humidity);
  float dewPoint = dht.computeDewPoint(newValues.temperature, newValues.humidity);
  float cr = dht.getComfortRatio(cf, newValues.temperature, newValues.humidity);

  String comfortStatus;
  switch(cf) {
    case Comfort_OK:
      comfortStatus = "Comforto OK";
      break;
    case Comfort_TooHot:
      comfortStatus = "Muito quente";
      break;
    case Comfort_TooCold:
      comfortStatus = "Muito Frio";
      break;
    case Comfort_TooDry:
      comfortStatus = "Muito seco";
      break;
    case Comfort_TooHumid:
      comfortStatus = "Muito Umido";
      break;
    case Comfort_HotAndHumid:
      comfortStatus = "Quente e Umido";
      break;
    case Comfort_HotAndDry:
      comfortStatus = "Quente e Seco";
      break;
    case Comfort_ColdAndHumid:
      comfortStatus = "Frio e Umido";
      break;
    case Comfort_ColdAndDry:
      comfortStatus = "Frio e seco";
      break;
    default:
      comfortStatus = "Desconhecido:";
      break;
  };

  Serial.println(" T:" + String(newValues.temperature) + " H:" + String(newValues.humidity) + " I:" + String(heatIndex) + " D:" + String(dewPoint) + " " + comfortStatus);
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print(String(comfortStatus));
  lcd.setCursor(0,1);
  lcd.print("T: ");
  lcd.setCursor(2,1);
  lcd.print(String(newValues.temperature));
  lcd.setCursor(8,1);
  lcd.print("U: ");
  lcd.setCursor(10,1);
  lcd.print(String(newValues.humidity));
  lcd.setCursor(15,1);
  lcd.print("%");
  
  return true;
}

inic_01.h

  Serial.begin(115200);
  
  lcd.init(); // initialize the lcd
  Serial.println();
  Serial.println("Exemplo DHT ESP32 com tarefas (tasks)");
  initTemp();
  // Fim do sinal de configuração() para tarefas
  tasksEnabled = true;

  /*************TAREFA LED**************/
  xTaskCreatePinnedToCore(task_LED,
"LED", // name of task.
10000, // Stack size of task
NULL, // parameter of the task
1, // priority of the task
&task_LED_H, // Task handle to keep track of created task
1); // pin task to core 1

  /*************************LCD I2C**********************************/
lcd.backlight();
  /**************************LED*************************************/
  pinMode( led1, OUTPUT );


  initWiFi();
  

setup_01.h

  if (!tasksEnabled) {
    // Espere 2 segundos para deixar o sistema se estabilizar
    delay(2000);
    // Habilite a tarefa que lerá valores do sensor DHT
    tasksEnabled = true;
    if (tempTaskHandle != NULL) {
			vTaskResume(tempTaskHandle);
		}
  }
  yield();//chamando para execução as tarefas em background nas temporizações

loop_01.h

void task_LED( void * pvParameters )
{
Serial.println( "parte de task_LED rodando uma única vez na inicialização: " );
Serial.print("task_LED correndo no: core ");
Serial.println( xPortGetCoreID() );
Serial.print( " LED_BUILTIN: " );
Serial.print(t2/1000);
Serial.println('s');

for(;;)
  {
  digitalWrite(led1, HIGH);
  vTaskDelay(t2);
  digitalWrite(led1, LOW);
  vTaskDelay(t1);
  }
}

tarLED.h

/***********************parametrização firebase*****************************/
// Provide the token generation process info.
#include "addons/TokenHelper.h"
// Provide the RTDB payload printing info and other helper functions.
#include "addons/RTDBHelper.h"

// Insert Firebase project API Key
#define API_KEY "AIzaSyDq7b5j3eSDebXFUMePpvXhG7NlVa0I_Xs"

// Insert Authorized Email and Corresponding Password
#define USER_EMAIL "remaziero.esp32@gmail.com"
#define USER_PASSWORD "camila12"

// Insert RTDB URLefine the RTDB URL
#define DATABASE_URL "https://esp32proj1-default-rtdb.firebaseio.com/"

// Define Firebase objects
FirebaseData fbdo;
FirebaseAuth auth;
FirebaseConfig config;

// Variable to save USER UID
String uid;

// Database main path (to be updated in setup with the user UID)
String databasePath;
// Database child nodes
String tempPath = "/temperature";
String humPath = "/humidity";
String presPath = "/pressure";
String timePath = "/timestamp";

// Parent Node (to be updated in every loop)
String parentPath;

int timestamp;
FirebaseJson json;

const char* ntpServer = "pool.ntp.org";

// Timer variables (send new readings every three minutes)
unsigned long sendDataPrevMillis = 0;
unsigned long timerDelay = 180000;
/***************************fim da parametrização firebase**************************/
// Initialize WiFi
void initWiFi() {
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }
  Serial.println(WiFi.localIP());
  Serial.println();
}

// 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);
  return now;
}


inic_02.h


  /*********************conexão setup**************************************/
  configTime(0, 0, ntpServer);

  // Assign the api key (required)
  config.api_key = API_KEY;

  // Assign the user sign in credentials
  auth.user.email = USER_EMAIL;
  auth.user.password = USER_PASSWORD;

  // Assign the RTDB URL (required)
  config.database_url = DATABASE_URL;

  Firebase.reconnectWiFi(true);
  fbdo.setResponseSize(4096);

  // Assign the callback function for the long running token generation task */
  config.token_status_callback = tokenStatusCallback; //see addons/TokenHelper.h

  // Assign the maximum retry of token generation
  config.max_token_generation_retry = 5;

  // Initialize the library with the Firebase authen and config
  Firebase.begin(&config, &auth);

  // Getting the user UID might take a few seconds
  Serial.println("Getting User UID");
  while ((auth.token.uid) == "") {
    Serial.print('.');
    delay(1000);
  }
  // Print user UID
  uid = auth.token.uid.c_str();
  Serial.print("User UID: ");
  Serial.println(uid);

  // Update database path
  databasePath = "/UsersData/" + uid + "/readings";
  /*********************fim conexão setup**************************************/

setup_02.h

/**************************conexão loop******************************************/
  // Send new readings to database
  if (Firebase.ready() && (millis() - sendDataPrevMillis > timerDelay || sendDataPrevMillis == 0)){
    sendDataPrevMillis = millis();

    //Get current timestamp
    timestamp = getTime();
    Serial.print ("time: ");
    Serial.println (timestamp);

    parentPath= databasePath + "/" + String(timestamp);


    json.set(tempPath.c_str(), String(45*2));
    json.set(humPath.c_str(), String(45));
    json.set(presPath.c_str(), String(10/100.0F));
    json.set(timePath, String(timestamp));
    Serial.printf("Set json... %s\n", Firebase.RTDB.setJSON(&fbdo, parentPath.c_str(), &json) ? "ok" : fbdo.errorReason().c_str());
  }
 /**************************fim conexão loop******************************************/

loop_02.h

#include <Firebase_ESP_Client.h>
#include <Wire.h>
#include "time.h"

// Insert your network credentials
//#define WIFI_SSID "Maziero 2.4G"
//#define WIFI_PASSWORD "camila12"

#define WIFI_SSID "Wokwi-GUEST"
#define WIFI_PASSWORD ""