#include "lcd_driver.h"
#include <dht_driver.h>



// first init the I2C bus
static esp_err_t i2c_master_init();


void app_main(void)
{
  ESP_ERROR_CHECK(i2c_master_init());               // if the I2C was initialized
  ESP_LOGI(TAG, "I2C initialized successfully");
  gpio_reset_pin(LED);                             // reset the led Pin for good practice
  gpio_reset_pin(SW1);                             // reset the led Pin for good practice
  gpio_set_direction(LED, GPIO_MODE_OUTPUT);      // Set the direction LED to output
  gpio_set_direction(SW1, GPIO_MODE_INPUT);      // Set the direction LED to output
  lcd_init();                                    // Init the LCD
  ESP_LOGI(TAG, "LCD initialized successfully");
  DHT11_init(DHT_Pin);

  while (true) {
    if (gpio_get_level(SW1)) {
      lcd_send_cmd(LCD_CLEARDISPLAY);
      lcd_print((char)(12));
      printf("The temperature is %d \n", DHT11_read().temperature);
      vTaskDelay(100 / portTICK_PERIOD_MS);
      gpio_set_level(LED, 1);
      ESP_LOGI(TAG, "Message printed on LCD");

    }
    else {
      lcd_send_cmd(LCD_CLEARDISPLAY);
      lcd_setCursor(0, 0);
      lcd_print("LED: ");
      lcd_setCursor(0, 4);
      lcd_print("OFF");
      vTaskDelay(50 / portTICK_PERIOD_MS);
      gpio_set_level(LED, 0);
      ESP_LOGI(TAG, "Message printed on LCD");
    }
  }


}

main.c

diagram.json

/*=================================================================================
  Header file for the lcdI2C.c
  ===============================================================================*/

#ifndef __LCD_DRIVER_H__
#define __LCD_DRIVER_H__

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "driver/gpio.h"
#include "driver/i2c.h"
#include "esp_log.h"

#define I2C_MASTER_SCL_IO 9         // SCL pin
#define I2C_MASTER_SDA_IO 8         // SDA pin
#define LED GPIO_NUM_2              // LED  pin
#define SW1 GPIO_NUM_4
#define I2C_MASTER_NUM I2C_NUM_0    // I2C port number
#define I2C_MASTER_FREQ_HZ 100000   // I2C master clock frequency
#define LCD_ADDR 0x27               // I2C address of the LCD

static const char *TAG = "LCD_EXAMPLE";

// LCD commands
#define LCD_CLEARDISPLAY 0x01
#define LCD_RETURNHOME 0x02
#define LCD_ENTRYMODESET 0x04
#define LCD_DISPLAYCONTROL 0x08
#define LCD_CURSORSHIFT 0x10
#define LCD_FUNCTIONSET 0x20
#define LCD_SETCGRAMADDR 0x40
#define LCD_SETDDRAMADDR 0x80

// Flags for display entry mode
#define LCD_ENTRYRIGHT 0x00
#define LCD_ENTRYLEFT 0x02
#define LCD_ENTRYSHIFTINCREMENT 0x01
#define LCD_ENTRYSHIFTDECREMENT 0x00

// Flags for display on/off control
#define LCD_DISPLAYON 0x04
#define LCD_DISPLAYOFF 0x00
#define LCD_CURSORON 0x02
#define LCD_CURSOROFF 0x00
#define LCD_BLINKON 0x01
#define LCD_BLINKOFF 0x00

// Flags for function set
#define LCD_8BITMODE 0x10
#define LCD_4BITMODE 0x00
#define LCD_2LINE 0x08
#define LCD_1LINE 0x00
#define LCD_5x10DOTS 0x04
#define LCD_5x8DOTS 0x00
// I2C initialization
static esp_err_t i2c_master_init(void)
{
  i2c_config_t conf = {
    .mode = I2C_MODE_MASTER,
    .sda_io_num = I2C_MASTER_SDA_IO,
    .scl_io_num = I2C_MASTER_SCL_IO,
    .sda_pullup_en = GPIO_PULLUP_ENABLE,
    .scl_pullup_en = GPIO_PULLUP_ENABLE,
    .master.clk_speed = I2C_MASTER_FREQ_HZ,
  };

  i2c_param_config(I2C_MASTER_NUM, &conf);

  return i2c_driver_install(I2C_MASTER_NUM, conf.mode, 0, 0, 0);
}

// Function to send command to LCD
static esp_err_t lcd_send_cmd(uint8_t cmd)
{
  uint8_t data_u, data_l;
  uint8_t data_t[4];
  data_u = (cmd & 0xf0);
  data_l = ((cmd << 4) & 0xf0);
  data_t[0] = data_u | 0x0C;  // en=1, rs=0
  data_t[1] = data_u | 0x08;  // en=0, rs=0
  data_t[2] = data_l | 0x0C;  // en=1, rs=0
  data_t[3] = data_l | 0x08;  // en=0, rs=0
  return i2c_master_write_to_device(I2C_MASTER_NUM, LCD_ADDR, data_t, 4, 1000 / portTICK_PERIOD_MS);
}

// Function to send data to LCD
static esp_err_t lcd_send_data(uint8_t data)
{
  uint8_t data_u, data_l;
  uint8_t data_t[4];
  data_u = (data & 0xf0);
  data_l = ((data << 4) & 0xf0);
  data_t[0] = data_u | 0x0D;  // en=1, rs=1
  data_t[1] = data_u | 0x09;  // en=0, rs=1
  data_t[2] = data_l | 0x0D;  // en=1, rs=1
  data_t[3] = data_l | 0x09;  // en=0, rs=1
  return i2c_master_write_to_device(I2C_MASTER_NUM, LCD_ADDR, data_t, 4, 1000 / portTICK_PERIOD_MS);
}


// Function to print string on LCD
static void lcd_print(const char *str)
{
  while (*str) {
    lcd_send_data(*str++);
  }
}

// Function to initialize LCD
static void lcd_init(void)
{
  vTaskDelay(100 / portTICK_PERIOD_MS);         // a delay after the LCD is ON
  lcd_send_cmd(0x33);                          //
  vTaskDelay(5 / portTICK_PERIOD_MS);
  lcd_send_cmd(0x32);                          //
  vTaskDelay(5 / portTICK_PERIOD_MS);
  lcd_send_cmd(LCD_FUNCTIONSET | LCD_2LINE);   // 2 rows or line functionset
  vTaskDelay(5 / portTICK_PERIOD_MS);
  lcd_send_cmd(LCD_DISPLAYCONTROL | LCD_DISPLAYON);  // DisplayON control
  vTaskDelay(5 / portTICK_PERIOD_MS);
  lcd_send_cmd(LCD_CLEARDISPLAY);                    // Clear the screen
  vTaskDelay(5 / portTICK_PERIOD_MS);
  lcd_send_cmd(LCD_ENTRYMODESET | LCD_ENTRYLEFT);    // Entry mode set left or right
}

void lcd_setCursor(int row, int col) {
  switch (row)
  {
    case 0:
      col |= 0x80;
      break;
    case 1:
      col |= 0xC0;
      break;
  }
  lcd_send_cmd(col);
}
#endif

lcd_driver.h

#include "esp_timer.h"
#include "driver/gpio.h"
#include "rom/ets_sys.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"


enum dht11_status {
    DHT11_CRC_ERROR = -2,
    DHT11_TIMEOUT_ERROR,
    DHT11_OK
};

struct dht11_reading {
    int status;
    int temperature;
    int humidity;
};
#define DHT_Pin GPIO_NUM_20

static gpio_num_t dht_gpio;
static int64_t last_read_time = -2000000;
static struct dht11_reading last_read;

static int _waitOrTimeout(uint16_t microSeconds, int level) {
    int micros_ticks = 0;
    while(gpio_get_level(dht_gpio) == level) { 
        if(micros_ticks++ > microSeconds) 
            return DHT11_TIMEOUT_ERROR;
        ets_delay_us(1);
    }
    return micros_ticks;
}

static int _checkCRC(uint8_t data[]) {
    if(data[4] == (data[0] + data[1] + data[2] + data[3]))
        return DHT11_OK;
    else
        return DHT11_CRC_ERROR;
}

static void _sendStartSignal() {
    gpio_set_direction(dht_gpio, GPIO_MODE_OUTPUT);
    gpio_set_level(dht_gpio, 0);
    ets_delay_us(20 * 1000);
    gpio_set_level(dht_gpio, 1);
    ets_delay_us(40);
    gpio_set_direction(dht_gpio, GPIO_MODE_INPUT);
}

static int _checkResponse() {
    /* Wait for next step ~80us*/
    if(_waitOrTimeout(80, 0) == DHT11_TIMEOUT_ERROR)
        return DHT11_TIMEOUT_ERROR;

    /* Wait for next step ~80us*/
    if(_waitOrTimeout(80, 1) == DHT11_TIMEOUT_ERROR) 
        return DHT11_TIMEOUT_ERROR;

    return DHT11_OK;
}

static struct dht11_reading _timeoutError() {
    struct dht11_reading timeoutError = {DHT11_TIMEOUT_ERROR, -1, -1};
    return timeoutError;
}

static struct dht11_reading _crcError() {
    struct dht11_reading crcError = {DHT11_CRC_ERROR, -1, -1};
    return crcError;
}

void DHT11_init(gpio_num_t gpio_num) {
    /* Wait 1 seconds to make the device pass its initial unstable status */
    vTaskDelay(1000 / portTICK_PERIOD_MS);
    dht_gpio = gpio_num;
}

struct dht11_reading DHT11_read() {
    /* Tried to sense too son since last read (dht11 needs ~2 seconds to make a new read) */
    if(esp_timer_get_time() - 2000000 < last_read_time) {
        return last_read;
    }

    last_read_time = esp_timer_get_time();

    uint8_t data[5] = {0,0,0,0,0};

    _sendStartSignal();

    if(_checkResponse() == DHT11_TIMEOUT_ERROR)
        return last_read = _timeoutError();
    
    /* Read response */
    for(int i = 0; i < 40; i++) {
        /* Initial data */
        if(_waitOrTimeout(50, 0) == DHT11_TIMEOUT_ERROR)
            return last_read = _timeoutError();
                
        if(_waitOrTimeout(70, 1) > 28) {
            /* Bit received was a 1 */
            data[i/8] |= (1 << (7-(i%8)));
        }
    }

    if(_checkCRC(data) != DHT11_CRC_ERROR) {
        last_read.status = DHT11_OK;
        last_read.temperature = data[2];
        last_read.humidity = data[0];
        return last_read;
    } else {
        return last_read = _crcError();
    }
}