/**
 * @file ci74hc595.c
 * @author Jaime Albuquerque (jaime.albq@gmail.com)
 * @brief 
 * @version 0.1
 * @date 2022-09-27
 * 
 * @copyright Copyright (c) 2022
 * 
 */

#include "ci74hc595.h"

signed char ci74hc595_init(ci74hc595_t *shft)
{
#if defined(IDF_VER)

        gpio_config_t *io_conf = (gpio_config_t *) malloc(sizeof(gpio_config_t));

        //disable interrupt
        io_conf->intr_type = GPIO_INTR_DISABLE;
        //set as output mode
        io_conf->mode = GPIO_MODE_OUTPUT;
        //bit mask of the pins that you want to set,e.g.GPIO18/19
        {
                uint32_t buf32_0 = 0;
                uint32_t buf32_1 = 0;
                uint64_t result = 0;

                if (shft->pin.clk >= 32)
                        buf32_1 |= 1 << (shft->pin.clk - 32);
                else
                        buf32_0 |= 1 << shft->pin.clk;

                if (shft->pin.latch >= 32)
                        buf32_1 |= 1 << (shft->pin.latch - 32);
                else
                        buf32_0 |= 1 << shft->pin.latch;

                if (shft->pin.signal >= 32)
                        buf32_1 |= 1 << (shft->pin.signal - 32);
                else
                        buf32_0 |= 1 << shft->pin.signal;

                result = ((uint64_t)buf32_1 << 32) | ((uint64_t)buf32_0 << 0);

                io_conf->pin_bit_mask = result;
        }
        //disable pull-down mode
        io_conf->pull_down_en = 0;
        //disable pull-up mode
        io_conf->pull_up_en = 0;
        //configure GPIO with the given settings
        gpio_config(io_conf);

        free(io_conf);

        return 1;

#endif // __ESP_IDF__

        return -1;
}

signed char ci74hc595_send(char *data, unsigned char len, ci74hc595_t *shft)
{
        for (unsigned char i = 0; i < len; i++) {
                ci74hc595_send8bits(data[i], shft);
        }

        return 1;
}

signed char ci74hc595_send8bits(char data, ci74hc595_t *shft)
{
        for (signed char i = 7; i >= 0; i--) {
                if ((data >> i) & 1) {
                        SETPIN(shft->pin.signal);
                } else {
                        CLRPIN(shft->pin.signal);
                }

                SETPIN(shft->pin.clk);
                _DELAY_US(1);
                CLRPIN(shft->pin.clk);
                _DELAY_US(1);
        }

        return 1;
}

signed char ci74hc595_latch(ci74hc595_t *shft)
{
        SETPIN(shft->pin.latch);
        _DELAY_US(1);
        CLRPIN(shft->pin.latch);
        _DELAY_US(1);

        return 1;
}

ci74hc595.c

/**
 * @file ci74hc595.h
 * @author Jaime Albuquerque (jaime.albq@gmail.com)
 * @brief Output serializer
 * @version 0.1
 * @date 2022-09-27
 * 
 * @copyright Copyright (c) 2022
 * 
 */

#if !defined(_CI74HC595_H_)
#define _CI74HC595_H_

#if defined(IDF_VER) // Settings for ESP-IDF

#include <stdlib.h>

#include "driver/gpio.h"
#include "esp32/rom/ets_sys.h"

#define SETPIN(PIN)     gpio_set_level(PIN, 1)
#define CLRPIN(PIN)     gpio_set_level(PIN, 0)
#define _DELAY_US(x)    ets_delay_us(x)

#endif // IDF_VER

typedef struct {
        unsigned char num_shft; // Number of shift registers
        
        // GPIO
        struct pin {
                
#if defined(IDF_VER)
                gpio_num_t clk;
                gpio_num_t signal;
                gpio_num_t latch;
#endif // IDF_VER

        } pin;
} ci74hc595_t;

/**
 * @brief Initialize the microcontroller to do the output
 * 
 * @param shft 
 * @return < 0 means error
 */
signed char ci74hc595_init(ci74hc595_t *shft);

/**
 * @brief Send the whole data
 * 
 * @param data 
 * @param len 
 * @param shft 
 * @return signed char 
 */
signed char ci74hc595_send(char *data, unsigned char len, ci74hc595_t *shft);

/**
 * @brief Send 1 byte at a time
 * 
 * @param data 
 * @param shft 
 * @return signed char 
 */
signed char ci74hc595_send8bits(char data, ci74hc595_t *shft);

/**
 * @brief Latch the registers
 * 
 * @param shft 
 * @return signed char 
 */
signed char ci74hc595_latch(ci74hc595_t *shft);

#endif // _CI74HC595_H_


ci74hc595.h

diagram.json

/*
 * Copyright (c) 2019 Tomoyuki Sakurai <y@trombik.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#if !defined(__ESP_IDF_LIB_HELPERS__H__)
#define __ESP_IDF_LIB_HELPERS__H__

/* XXX this header file does not need to include freertos/FreeRTOS.h.
 * but without it, ESP8266 RTOS SDK does not include `sdkconfig.h` in correct
 * order. as this header depends on sdkconfig.h, sdkconfig.h must be included
 * first. however, the SDK includes this header first, then includes
 * `sdkconfig.h` when freertos/FreeRTOS.h is not explicitly included. an
 * evidence can be found in `build/${COMPONENT}/${COMPONENT}.d` in a failed
 * build.
 */
#include <freertos/FreeRTOS.h>
#include <esp_idf_version.h>

#if !defined(ESP_IDF_VERSION) || !defined(ESP_IDF_VERSION_VAL)
#error Unknown ESP-IDF/ESP8266 RTOS SDK version
#endif

/* Minimal supported version for ESP32, ESP32S2 */
#define HELPER_ESP32_MIN_VER    ESP_IDF_VERSION_VAL(3, 3, 5)
/* Minimal supported version for ESP8266 */
#define HELPER_ESP8266_MIN_VER  ESP_IDF_VERSION_VAL(3, 3, 0)

/* HELPER_TARGET_IS_ESP32
 * 1 when the target is esp32
 */
#if defined(CONFIG_IDF_TARGET_ESP32) \
        || defined(CONFIG_IDF_TARGET_ESP32S2) \
        || defined(CONFIG_IDF_TARGET_ESP32S3) \
        || defined(CONFIG_IDF_TARGET_ESP32C3)
#define HELPER_TARGET_IS_ESP32     (1)
#define HELPER_TARGET_IS_ESP8266   (0)

/* HELPER_TARGET_IS_ESP8266
 * 1 when the target is esp8266
 */
#elif defined(CONFIG_IDF_TARGET_ESP8266)
#define HELPER_TARGET_IS_ESP32     (0)
#define HELPER_TARGET_IS_ESP8266   (1)
#else
#error BUG: cannot determine the target
#endif

#if HELPER_TARGET_IS_ESP32 && ESP_IDF_VERSION < HELPER_ESP32_MIN_VER
#error Unsupported ESP-IDF version. Please update!
#endif

#if HELPER_TARGET_IS_ESP8266 && ESP_IDF_VERSION < HELPER_ESP8266_MIN_VER
#error Unsupported ESP8266 RTOS SDK version. Please update!
#endif

/* show the actual values for debugging */
#if DEBUG
#define VALUE_TO_STRING(x) #x
#define VALUE(x) VALUE_TO_STRING(x)
#define VAR_NAME_VALUE(var) #var "="  VALUE(var)
#pragma message(VAR_NAME_VALUE(CONFIG_IDF_TARGET_ESP32C3))
#pragma message(VAR_NAME_VALUE(CONFIG_IDF_TARGET_ESP32S2))
#pragma message(VAR_NAME_VALUE(CONFIG_IDF_TARGET_ESP32))
#pragma message(VAR_NAME_VALUE(CONFIG_IDF_TARGET_ESP8266))
#pragma message(VAR_NAME_VALUE(ESP_IDF_VERSION_MAJOR))
#endif

#endif


esp_idf_lib_helpers.h

#if CONFIG_IDF_TARGET_ESP32
#include <esp32/rom/ets_sys.h>
#elif CONFIG_IDF_TARGET_ESP32S2
#include <esp32s2/rom/ets_sys.h>
#elif CONFIG_IDF_TARGET_ESP32S3
#include <esp32s3/rom/ets_sys.h>
#elif CONFIG_IDF_TARGET_ESP32C3
#include <esp32c3/rom/ets_sys.h>
#elif CONFIG_IDF_TARGET_ESP32H2
#include <esp32h2/rom/ets_sys.h>
#elif CONFIG_IDF_TARGET_ESP32C2
#include <esp32c2/rom/ets_sys.h>
#endif

ets_sys.h

/*
 * Copyright (c) 2016 Ruslan V. Uss <unclerus@gmail.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holder nor the names of itscontributors
 *    may be used to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/**
 * @file hd44780.c
 *
 * ESP-IDF driver for HD44780 compatible LCD text displays
 *
 * Ported from esp-open-rtos
 *
 * Copyright (c) 2016 Ruslan V. Uss <unclerus@gmail.com>
 *
 * BSD Licensed as described in the file LICENSE
 */
#include <string.h>
#include <esp_system.h>
#include "esp_idf_lib_helpers.h"
#include "ets_sys.h"
#include "hd44780.h"

#define MS 1000

#define BV(x) (1 << (x))
#define GPIO_BIT(x) (1ULL << (x))

#define DELAY_CMD_LONG  (3 * MS) // >1.53ms according to datasheet
#define DELAY_CMD_SHORT (60)     // >39us according to datasheet
#define DELAY_TOGGLE    (1)      // E cycle time >= 1μs, E pulse width >= 450ns, Data set-up time >= 195ns
#define DELAY_INIT      (5 * MS)

#define CMD_CLEAR        0x01
#define CMD_RETURN_HOME  0x02
#define CMD_ENTRY_MODE   0x04
#define CMD_DISPLAY_CTRL 0x08
#define CMD_SHIFT        0x10
#define CMD_FUNC_SET     0x20
#define CMD_CGRAM_ADDR   0x40
#define CMD_DDRAM_ADDR   0x80

#define ARG_MOVE_RIGHT 0x04
#define ARG_MOVE_LEFT 0x00
#define CMD_SHIFT_LEFT  (CMD_SHIFT | CMD_DISPLAY_CTRL | ARG_MOVE_LEFT)
#define CMD_SHIFT_RIGHT (CMD_SHIFT | CMD_DISPLAY_CTRL | ARG_MOVE_RIGHT)

// CMD_ENTRY_MODE
#define ARG_EM_INCREMENT    BV(1)
#define ARG_EM_SHIFT        (1)

// CMD_DISPLAY_CTRL
#define ARG_DC_DISPLAY_ON   BV(2)
#define ARG_DC_CURSOR_ON    BV(1)
#define ARG_DC_CURSOR_BLINK (1)

// CMD_FUNC_SET
#define ARG_FS_8_BIT        BV(4)
#define ARG_FS_2_LINES      BV(3)
#define ARG_FS_FONT_5X10    BV(2)

#define init_delay()   do { ets_delay_us(DELAY_INIT); } while (0)
#define short_delay()  do { ets_delay_us(DELAY_CMD_SHORT); } while (0)
#define long_delay()   do { ets_delay_us(DELAY_CMD_LONG); } while (0)
#define toggle_delay() do { ets_delay_us(DELAY_TOGGLE); } while (0)

#define CHECK_ARG(VAL) do { if (!(VAL)) return ESP_ERR_INVALID_ARG; } while (0)
#define CHECK(x) do { esp_err_t __; if ((__ = x) != ESP_OK) return __; } while (0)

static const uint8_t line_addr[] = { 0x00, 0x40, 0x14, 0x54 };

static esp_err_t write_nibble(const hd44780_t *lcd, uint8_t b, bool rs)
{
    if (lcd->write_cb)
    {
        uint8_t data = (((b >> 3) & 1) << lcd->pins.d7)
                     | (((b >> 2) & 1) << lcd->pins.d6)
                     | (((b >> 1) & 1) << lcd->pins.d5)
                     | ((b & 1) << lcd->pins.d4)
                     | (rs ? 1 << lcd->pins.rs : 0)
                     | (lcd->backlight ? 1 << lcd->pins.bl : 0);
        CHECK(lcd->write_cb(lcd, data | (1 << lcd->pins.e)));
        toggle_delay();
        CHECK(lcd->write_cb(lcd, data));
    }
    else
    {
        /* Jaime - Start */

      /* 
        CHECK(gpio_set_level(lcd->pins.rs, rs));
        ets_delay_us(1); // Address Setup time >= 60ns.
        CHECK(gpio_set_level(lcd->pins.e, true));
        CHECK(gpio_set_level(lcd->pins.d7, (b >> 3) & 1));
        CHECK(gpio_set_level(lcd->pins.d6, (b >> 2) & 1));
        CHECK(gpio_set_level(lcd->pins.d5, (b >> 1) & 1));
        CHECK(gpio_set_level(lcd->pins.d4, b & 1));
        toggle_delay();
        CHECK(gpio_set_level(lcd->pins.e, false));
 */
        // With shift register
        TESTBIT(rs, shifter_register_value, lcd->pins.rs);
        ets_delay_us(1); // Address Setup time >= 60ns.
        SETBIT(shifter_register_value, lcd->pins.e); //CHECK(gpio_set_level(lcd->pins.e, true));
        //TESTBIT((b >> 3) & 1, shifter_register_value, lcd->pins.d7); //CHECK(gpio_set_level(lcd->pins.d7, (b >> 3) & 1));
        //TESTBIT((b >> 2) & 1, shifter_register_value, lcd->pins.d6); //CHECK(gpio_set_level(lcd->pins.d6, (b >> 2) & 1));
        //TESTBIT((b >> 1) & 1, shifter_register_value, lcd->pins.d5); //CHECK(gpio_set_level(lcd->pins.d5, (b >> 1) & 1));
        //TESTBIT(b & 1, shifter_register_value, lcd->pins.d4); //CHECK(gpio_set_level(lcd->pins.d4, b & 1));
        shifter_register_value &= 0x0F;
        shifter_register_value |= (b << 4) | 0x0F;
        printf("Data: 0x%02X\tRegister status: 0x%02X\n", b, shifter_register_value);
        ci74hc595_send8bits(shifter_register_value, _hd_shft);
        ci74hc595_latch(_hd_shft);
        toggle_delay();
        CLRBIT(shifter_register_value, lcd->pins.e); //CHECK(gpio_set_level(lcd->pins.e, false));
        /* Jaime - END */
    }

    return ESP_OK;
}

static esp_err_t write_byte(const hd44780_t *lcd, uint8_t b, bool rs)
{
    CHECK(write_nibble(lcd, b >> 4, rs));
    CHECK(write_nibble(lcd, b, rs));

    return ESP_OK;
}

esp_err_t hd44780_init(const hd44780_t *lcd, const ci74hc595_t *shft)
{
    _hd_shft = shft;
    ci74hc595_init(_hd_shft);

    CHECK_ARG(lcd && lcd->lines > 0 && lcd->lines < 5);

    if (!lcd->write_cb)
    {
        gpio_config_t io_conf;
        memset(&io_conf, 0, sizeof(gpio_config_t));
        io_conf.mode = GPIO_MODE_OUTPUT;
        io_conf.pin_bit_mask =
                GPIO_BIT(lcd->pins.rs) |
                GPIO_BIT(lcd->pins.e) |
                GPIO_BIT(lcd->pins.d4) |
                GPIO_BIT(lcd->pins.d5) |
                GPIO_BIT(lcd->pins.d6) |
                GPIO_BIT(lcd->pins.d7);
        if (lcd->pins.bl != HD44780_NOT_USED)
            io_conf.pin_bit_mask |= GPIO_BIT(lcd->pins.bl);
        CHECK(gpio_config(&io_conf));
    }

    // switch to 4 bit mode
    for (uint8_t i = 0; i < 3; i ++)
    {
        CHECK(write_nibble(lcd, (CMD_FUNC_SET | ARG_FS_8_BIT) >> 4, false));
        init_delay();
    }
    CHECK(write_nibble(lcd, CMD_FUNC_SET >> 4, false));
    short_delay();

    // Specify the number of display lines and character font
    CHECK(write_byte(lcd,
        CMD_FUNC_SET
            | (lcd->lines > 1 ? ARG_FS_2_LINES : 0)
            | (lcd->font == HD44780_FONT_5X10 ? ARG_FS_FONT_5X10 : 0),
        false));
    short_delay();
    // Display off
    CHECK(hd44780_control(lcd, false, false, false));
    // Clear
    CHECK(hd44780_clear(lcd));
    // Entry mode set
    CHECK(write_byte(lcd, CMD_ENTRY_MODE | ARG_EM_INCREMENT, false));
    short_delay();
    // Display on
    CHECK(hd44780_control(lcd, true, false, false));

    return ESP_OK;
}

esp_err_t hd44780_control(const hd44780_t *lcd, bool on, bool cursor, bool cursor_blink)
{
    CHECK_ARG(lcd);

    CHECK(write_byte(lcd,
        CMD_DISPLAY_CTRL
            | (on ? ARG_DC_DISPLAY_ON : 0)
            | (cursor ? ARG_DC_CURSOR_ON : 0)
            | (cursor_blink ? ARG_DC_CURSOR_BLINK : 0),
        false));
    short_delay();

    return ESP_OK;
}

esp_err_t hd44780_clear(const hd44780_t *lcd)
{
    CHECK_ARG(lcd);

    CHECK(write_byte(lcd, CMD_CLEAR, false));
    long_delay();

    return ESP_OK;
}

esp_err_t hd44780_gotoxy(const hd44780_t *lcd, uint8_t col, uint8_t line)
{
    CHECK_ARG(lcd && line < lcd->lines && line < sizeof(line_addr));

    CHECK(write_byte(lcd, CMD_DDRAM_ADDR + line_addr[line] + col, false));
    short_delay();

    return ESP_OK;
}

esp_err_t hd44780_putc(const hd44780_t *lcd, char c)
{
    CHECK_ARG(lcd);

    CHECK(write_byte(lcd, c, true));
    short_delay();

    return ESP_OK;
}

esp_err_t hd44780_puts(const hd44780_t *lcd, const char *s)
{
    CHECK_ARG(lcd && s);

    while (*s)
    {
        CHECK(hd44780_putc(lcd, *s));
        s++;
    }

    return ESP_OK;
}

esp_err_t hd44780_switch_backlight(hd44780_t *lcd, bool on)
{
    CHECK_ARG(lcd);
    if (lcd->pins.bl == HD44780_NOT_USED)
        return ESP_ERR_NOT_SUPPORTED;

    if (!lcd->write_cb)
        CHECK(gpio_set_level(lcd->pins.bl, on));
    else
        CHECK(lcd->write_cb(lcd, on ? BV(lcd->pins.bl) : 0));

    lcd->backlight = on;

    return ESP_OK;
}

esp_err_t hd44780_upload_character(const hd44780_t *lcd, uint8_t num, const uint8_t *data)
{
    CHECK_ARG(lcd && data && num < 8);

    uint8_t bytes = lcd->font == HD44780_FONT_5X8 ? 8 : 10;
    CHECK(write_byte(lcd, CMD_CGRAM_ADDR + num * bytes, false));
    short_delay();
    for (uint8_t i = 0; i < bytes; i ++)
    {
        CHECK(write_byte(lcd, data[i], true));
        short_delay();
    }

    CHECK(hd44780_gotoxy(lcd, 0, 0));

    return ESP_OK;
}

esp_err_t hd44780_scroll_left(const hd44780_t *lcd)
{
    CHECK_ARG(lcd);

    CHECK(write_byte(lcd, CMD_SHIFT_LEFT, false));
    short_delay();

    return ESP_OK;
}

esp_err_t hd44780_scroll_right(const hd44780_t *lcd)
{
    CHECK_ARG(lcd);

    CHECK(write_byte(lcd, CMD_SHIFT_RIGHT, false));
    short_delay();

    return ESP_OK;
}


hd44780.c

/*
 * Copyright (c) 2016 Ruslan V. Uss <unclerus@gmail.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holder nor the names of itscontributors
 *    may be used to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/**
 * @file hd44780.h
 * @defgroup hd44780 hd44780
 * @{
 *
 * ESP-IDF driver for HD44780 compatible LCD text displays
 *
 * Ported from esp-open-rtos
 *
 * Copyright (c) 2016 Ruslan V. Uss <unclerus@gmail.com>
 *
 * BSD Licensed as described in the file LICENSE
 */
#ifndef __HD44780_H__
#define __HD44780_H__

#include <stdint.h>
#include <stdbool.h>
#include <driver/gpio.h>
#include <esp_err.h>
#include "ci74hc595.h"

#ifdef __cplusplus
extern "C" {
#endif

#define HD44780_NOT_USED 0xff

/* Jaime - Start */
static uint8_t shifter_register_value = 0;
ci74hc595_t *_hd_shft;
#define SETBIT(REG, BIT)  {REG |= (1 << BIT); ci74hc595_send8bits(REG, _hd_shft); ci74hc595_latch(_hd_shft);}
#define CLRBIT(REG, BIT)  {REG &= ~(1 << BIT); ci74hc595_send8bits(REG, _hd_shft); ci74hc595_latch(_hd_shft);}
#define TESTBIT(x, REG, BIT) {if (x) {SETBIT(shifter_register_value, lcd->pins.rs);} else {CLRBIT(shifter_register_value, lcd->pins.rs);}}
/* Jaime - END */
/**
 * LCD font type. Please refer to the datasheet
 * of your module.
 */
typedef enum
{
    HD44780_FONT_5X8 = 0,
    HD44780_FONT_5X10
} hd44780_font_t;

typedef struct hd44780 hd44780_t;

typedef esp_err_t (*hd44780_write_cb_t)(const hd44780_t *lcd, uint8_t data);

/**
 * LCD descriptor. Fill it before use.
 */
struct hd44780
{
    hd44780_write_cb_t write_cb; //!< Data write callback. Set it to NULL in case of direct LCD connection to GPIO
    struct
    {
        uint8_t rs;        //!< GPIO/register bit used for RS pin
        uint8_t e;         //!< GPIO/register bit used for E pin
        uint8_t d4;        //!< GPIO/register bit used for D4 pin
        uint8_t d5;        //!< GPIO/register bit used for D5 pin
        uint8_t d6;        //!< GPIO/register bit used for D5 pin
        uint8_t d7;        //!< GPIO/register bit used for D5 pin
        uint8_t bl;        //!< GPIO/register bit used for backlight. Set it `HD44780_NOT_USED` if no backlight used
    } pins;
    hd44780_font_t font;   //!< LCD Font type
    uint8_t lines;         //!< Number of lines for LCD. Many 16x1 LCD has two lines (like 8x2)
    bool backlight;        //!< Current backlight state
};

/**
 * @brief Init LCD
 *
 * Set cursor position to (0, 0)
 *
 * @param lcd LCD descriptor
 * @return `ESP_OK` on success
 */
esp_err_t hd44780_init(const hd44780_t *lcd, const ci74hc595_t *shft);

/**
 * @brief Control LCD
 *
 * On/off LCD, show/hide cursor, set cursor blink
 *
 * @param lcd LCD descriptor
 * @param on Switch LCD on if true
 * @param cursor Show cursor if true
 * @param cursor_blink Enable cursor blinking if true
 * @return `ESP_OK` on success
 */
esp_err_t hd44780_control(const hd44780_t *lcd, bool on, bool cursor, bool cursor_blink);

/**
 * @brief Clear LCD
 *
 * Clear memory and move cursor to (0, 0)
 *
 * @param lcd LCD descriptor
 * @return `ESP_OK` on success
 */
esp_err_t hd44780_clear(const hd44780_t *lcd);

/**
 * @brief Move cursor
 *
 * @param lcd LCD descriptor
 * @param col Column
 * @param line Line
 * @return `ESP_OK` on success
 */
esp_err_t hd44780_gotoxy(const hd44780_t *lcd, uint8_t col, uint8_t line);

/**
 * @brief Write character at cursor position
 *
 * @param lcd LCD descriptor
 * @param c Character to write
 * @return `ESP_OK` on success
 */
esp_err_t hd44780_putc(const hd44780_t *lcd, char c);

/**
 * @brief Write NULL-terminated string at cursor position
 *
 * @param lcd LCD descriptor
 * @param s String to write
 * @return `ESP_OK` on success
 */
esp_err_t hd44780_puts(const hd44780_t *lcd, const char *s);

/**
 * @brief Switch backlight
 *
 * @param lcd LCD descriptor
 * @param on Turn backlight on if true
 * @return `ESP_OK` on success
 */
esp_err_t hd44780_switch_backlight(hd44780_t *lcd, bool on);

/**
 * @brief Upload character data to the CGRAM
 *
 * After upload cursor will be moved to (0, 0).
 *
 * @param lcd LCD descriptor
 * @param num Character number (0..7)
 * @param data Character data: 8 or 10 bytes depending on the font
 * @return `ESP_OK` on success
 */
esp_err_t hd44780_upload_character(const hd44780_t *lcd, uint8_t num, const uint8_t *data);

/**
 * @brief Scroll the display content to left by one character
 *
 * @param lcd LCD descriptor
 * @return `ESP_OK` on success
 */
esp_err_t hd44780_scroll_left(const hd44780_t *lcd);

/**
 * @brief Scroll the display content to right by one character
 *
 * @param lcd LCD descriptor
 * @return `ESP_OK` on success
 */
esp_err_t hd44780_scroll_right(const hd44780_t *lcd);

#ifdef __cplusplus
}
#endif

/**@}*/

#endif /* __HD44780_H__ */


hd44780.h

#include <inttypes.h>
#include <stdio.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <sys/time.h>
/* Jaime - Start */
#include "ci74hc595.h"
/* Jaime - END */
#include "hd44780.h"
#include "esp_idf_lib_helpers.h"

static uint32_t get_time_sec()
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return tv.tv_sec;
}

static const uint8_t char_data[] = {
    0x04, 0x0e, 0x0e, 0x0e, 0x1f, 0x00, 0x04, 0x00,
    0x1f, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x1f, 0x00
};

void lcd_test(void *pvParameters)
{
    hd44780_t lcd = {
        .write_cb = NULL,
        .pins = {
#if HELPER_TARGET_IS_ESP8266
            .rs = GPIO_NUM_12,
            .e  = GPIO_NUM_14,
            .d4 = GPIO_NUM_5,
            .d5 = GPIO_NUM_13,
            .d6 = GPIO_NUM_16,
            .d7 = GPIO_NUM_4,
            .bl = HD44780_NOT_USED
#else
            .rs = 1,
            .e  = 3,
            .d4 = 4,
            .d5 = 5,
            .d6 = 6,
            .d7 = 7,
            .bl = HD44780_NOT_USED
#endif
        },
        .font = HD44780_FONT_5X8,
        .lines = 2,
    };

/* Jaime - Start */
    static ci74hc595_t shifter = {
        .num_shft = 1,
        .pin = {
            .clk = GPIO_NUM_12,
            .signal = GPIO_NUM_13,
            .latch = GPIO_NUM_14,
        },
    };


    ESP_ERROR_CHECK(hd44780_init(&lcd, &shifter));
/* Jaime - END */

    hd44780_upload_character(&lcd, 0, char_data);
    hd44780_upload_character(&lcd, 1, char_data + 8);

    hd44780_gotoxy(&lcd, 0, 0);
    hd44780_puts(&lcd, "\x08 Hello world!");
    hd44780_gotoxy(&lcd, 0, 1);
    hd44780_puts(&lcd, "\x09 ");

    char time[16];

    while (1)
    {
        hd44780_gotoxy(&lcd, 2, 1);

        snprintf(time, 7, "%" PRIu32 "  ", get_time_sec());
        time[sizeof(time) - 1] = 0;

        hd44780_puts(&lcd, time);

        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

extern "C" void app_main()
{
    xTaskCreate(lcd_test, "lcd_test", configMINIMAL_STACK_SIZE * 3, NULL, 5, NULL);
}