784 lines
29 KiB
C
784 lines
29 KiB
C
/** library to communication with Hitacho HD44780 LCD controller
|
|
* @file
|
|
* @author King Kévin <kingkevin@cuvoodoo.info>
|
|
* @copyright SPDX-License-Identifier: GPL-3.0-or-later
|
|
* @date 2019-2020
|
|
* @note peripherals used: GPIO @ref lcd_hd44780_gpio
|
|
*/
|
|
/* standard libraries */
|
|
#include <stdint.h> // standard integer types
|
|
#include <stdlib.h> // general utilities
|
|
#include <stdbool.h> // boolean utilities
|
|
|
|
/* STM32 (including CM3) libraries */
|
|
#include <libopencmsis/core_cm3.h> // Cortex M3 utilities
|
|
#include <libopencm3/stm32/rcc.h> // real-time control clock library
|
|
#include <libopencm3/stm32/gpio.h> // general purpose input output library
|
|
|
|
/* own libraries */
|
|
#include "global.h" // common methods
|
|
#include "lcd_hd44780.h" // own definitions
|
|
#if defined(LCD_HD44780_I2C) && LCD_HD44780_I2C
|
|
#include "i2c_master.h" // I²C utilities
|
|
#endif
|
|
|
|
/** include busy time waiting in writes
|
|
* @note this removes the need to call lcd_hd44780_wait_busy but prevents you to do something else meanwhile, particularly when reading is enabled
|
|
* @note because I²C is already slow enough, there is no need to wait further
|
|
*/
|
|
#if defined(LCD_HD44780_I2C) && LCD_HD44780_I2C
|
|
#define LCD_HD44780_BUSY_WAIT_INCLUDE 1 // lcd_hd44780_wait_busy works, but the I²C bus is often slower
|
|
#else // LCD_HD44780_I2C
|
|
#define LCD_HD44780_BUSY_WAIT_INCLUDE 1 // you can change this value
|
|
#endif // LCD_HD44780_I2C
|
|
/** busy wait time for most short writes (37 us with margin) */
|
|
#define LCD_HD44780_BUSY_WAIT_SHORT (37 + 5)
|
|
/** busy wait time for some long writes (1520 us, but experience shows it's more)
|
|
* @note I have no idea why, but longer times increase the contrast darkness
|
|
*/
|
|
#define LCD_HD44780_BUSY_WAIT_LONG (1520 + 500)
|
|
|
|
/* usual HD44780 pinout:
|
|
* - 1 GND: ground
|
|
* - 2 VCC: 5V (3.3V versions also exist, but a less common)
|
|
* - 3 V0 : LCD bias voltage, connect to 10-20k potentiometer (VCC to GND)
|
|
* - 4 RS : Register Select (high = data, low = instruction)
|
|
* - 5 R/W: Read/Write (high = read, low = write)
|
|
* - 6 E : enable (falling edge to latch data, high to output register)
|
|
* - 7 DB0: Data Bit 0 (for 8-bit transfer)
|
|
* - 8 DB1: Data Bit 1 (for 8-bit transfer)
|
|
* - 9 DB2: Data Bit 2 (for 8-bit transfer)
|
|
* - 10 DB3: Data Bit 3 (for 8-bit transfer)
|
|
* - 11 DB4: Data Bit 4 (for 4-bit transfer)
|
|
* - 12 DB5: Data Bit 5 (for 4-bit transfer)
|
|
* - 13 DB6: Data Bit 6 (for 4-bit transfer)
|
|
* - 14 DB7: Data Bit 7 (for 4-bit transfer)
|
|
* - 15 BLA: Backlight Anode
|
|
* - 16 BLK: Backlight Cathode
|
|
*/
|
|
|
|
/** @defgroup lcd_hd44780_signals HD44780 signals
|
|
* @note can be combined using OR
|
|
* @{
|
|
*/
|
|
#define LCD_HD44780_RS (1 << 0) /**< RS : Register Select (high = data, low = instruction) */
|
|
#define LCD_HD44780_RnW (1 << 1) /**< R/W: Read/Write (high = read, low = write) */
|
|
#define LCD_HD44780_E (1 << 2) /**< enable (falling edge to latch data, high to output register) */
|
|
#define LCD_HD44780_DB0 (1 << 3) /**< Data Bit 0 */
|
|
#define LCD_HD44780_DB1 (1 << 4) /**< Data Bit 1 */
|
|
#define LCD_HD44780_DB2 (1 << 5) /**< Data Bit 2 */
|
|
#define LCD_HD44780_DB3 (1 << 6) /**< Data Bit 3 */
|
|
#define LCD_HD44780_DB4 (1 << 7) /**< Data Bit 4 */
|
|
#define LCD_HD44780_DB5 (1 << 8) /**< Data Bit 5 */
|
|
#define LCD_HD44780_DB6 (1 << 9) /**< Data Bit 6 */
|
|
#define LCD_HD44780_DB7 (1 << 10) /**< Data Bit 7 */
|
|
#define LCD_HD44780_LED (1 << 11) /**< Backlight Cathode */
|
|
/** @} */
|
|
|
|
#if defined(LCD_HD44780_I2C) && LCD_HD44780_I2C
|
|
/* I²C backpack PCF8574 GPIO expander pinout:
|
|
* - P0: RS
|
|
* - P1: RnW
|
|
* - P2: E
|
|
* - P3: LED
|
|
* - P4: D4
|
|
* - P5: D5
|
|
* - P6: D6
|
|
* - P7: D7
|
|
*/
|
|
/** register select */
|
|
#define LCD_HD44780_I2C_RS (1 << 0)
|
|
/** select read or write */
|
|
#define LCD_HD44780_I2C_RnW (1 << 1)
|
|
/** enable pin */
|
|
#define LCD_HD44780_I2C_E (1 << 2)
|
|
/** enable LED backlight */
|
|
#define LCD_HD44780_I2C_LED (1 << 3)
|
|
/** data bit 4 */
|
|
#define LCD_HD44780_I2C_DB4 (1 << 4)
|
|
/** data bit 5 */
|
|
#define LCD_HD44780_I2C_DB5 (1 << 5)
|
|
/** data bit 6 */
|
|
#define LCD_HD44780_I2C_DB6 (1 << 6)
|
|
/** data bit 7 */
|
|
#define LCD_HD44780_I2C_DB7 (1 << 7)
|
|
/** I²C peripheral base address */
|
|
#define LCD_HD44780_I2C_PERIPH I2C1
|
|
/** I2C address of I²C backpack adapter (7 bits are LSB) */
|
|
uint8_t lcd_hd44780_i2c_addr = 0x3f; // default PCF8574A I²C backpack slave address
|
|
/** I2C GPIO output state */
|
|
static uint8_t lcd_hd44780_i2c_output = 0xff;
|
|
#else // LCD_HD44780_I2C
|
|
/** @defgroup lcd_hd44780_gpio GPIO used to control the HD44780
|
|
* @{
|
|
*/
|
|
/** register select
|
|
* @note pulled up by HD44780
|
|
*/
|
|
#define LCD_HD44780_GPIO_RS PB9
|
|
/** pin allowing writing data bits (on low) or reading them (on high)
|
|
* @note remove definition if tied to ground
|
|
* @note this enables read back data, but more importantly read the busy flag to know when the controller finished processing the command. Tying R/nW to ground instead of a GPIO saves a pin, but no data can be read back. Also every command needs to wait a minimum time before being able to send the next one, even if the controlled might actually already have processed it and is not busy anymore.
|
|
* @note is pulled up by HD44780
|
|
*/
|
|
#define LCD_HD44780_GPIO_RnW PB10
|
|
/** enable pin
|
|
* @warning needs an external 10k pull-up resistor
|
|
*/
|
|
#define LCD_HD44780_GPIO_E PB11
|
|
/** data bit 7
|
|
* @note pulled up by HD44780
|
|
*/
|
|
#define LCD_HD44780_GPIO_DB7 PB12
|
|
/** data bit 6
|
|
* @note pulled up by HD44780
|
|
*/
|
|
#define LCD_HD44780_GPIO_DB6 PB13
|
|
/** data bit 5
|
|
* @note pulled up by HD44780
|
|
*/
|
|
#define LCD_HD44780_GPIO_DB5 PB14
|
|
/** data bit 4
|
|
* @note pulled up by HD44780
|
|
*/
|
|
#define LCD_HD44780_GPIO_DB4 PB15
|
|
/** data bit 3
|
|
* @note pulled up by HD44780
|
|
* @note leave undefined when only 4-bit mode is used
|
|
*/
|
|
//#define LCD_HD44780_GPIO_DB3 P
|
|
/** data bit 2
|
|
* @note pulled up by HD44780
|
|
* @note leave undefined when only 4-bit mode is used
|
|
*/
|
|
//#define LCD_HD44780_GPIO_DB2 P
|
|
/** data bit 1
|
|
* @note pulled up by HD44780
|
|
* @note leave undefined when only 4-bit mode is used
|
|
*/
|
|
//#define LCD_HD44780_GPIO_DB1 P
|
|
/** data bit 0
|
|
* @note pulled up by HD44780
|
|
* @note leave undefined when only 4-bit mode is used
|
|
*/
|
|
//#define LCD_HD44780_GPIO_DB0 P
|
|
/** @} */
|
|
#endif // LCD_HD44780_I2C
|
|
|
|
/** set for 8-bit interface data
|
|
* @note I²C implies 4-bit
|
|
*/
|
|
#if defined(LCD_HD44780_I2C) && LCD_HD44780_I2C
|
|
#define LCD_HD44780_INTERFACE_DL 0
|
|
#elif defined(LCD_HD44780_GPIO_DB3) && defined(LCD_HD44780_GPIO_DB2) && defined(LCD_HD44780_GPIO_DB1) && defined(LCD_HD44780_GPIO_DB0)
|
|
#define LCD_HD44780_INTERFACE_DL 1
|
|
#else
|
|
#define LCD_HD44780_INTERFACE_DL 0
|
|
#endif
|
|
|
|
/** if the display is configured having 2 lines */
|
|
static bool lcd_hd44780_n_2lines = true;
|
|
|
|
/** set signals
|
|
* @param[in] signals
|
|
*/
|
|
static void lcd_hd44780_set_signal(uint16_t signals)
|
|
{
|
|
#if defined(LCD_HD44780_I2C) && LCD_HD44780_I2C
|
|
if (signals & LCD_HD44780_RS) {
|
|
lcd_hd44780_i2c_output |= LCD_HD44780_I2C_RS;
|
|
}
|
|
if (signals & LCD_HD44780_RnW) {
|
|
lcd_hd44780_i2c_output |= LCD_HD44780_I2C_RnW;
|
|
}
|
|
if (signals & LCD_HD44780_E) {
|
|
lcd_hd44780_i2c_output |= LCD_HD44780_I2C_E;
|
|
}
|
|
if (signals & LCD_HD44780_DB4) {
|
|
lcd_hd44780_i2c_output |= LCD_HD44780_I2C_DB4;
|
|
}
|
|
if (signals & LCD_HD44780_DB5) {
|
|
lcd_hd44780_i2c_output |= LCD_HD44780_I2C_DB5;
|
|
}
|
|
if (signals & LCD_HD44780_DB6) {
|
|
lcd_hd44780_i2c_output |= LCD_HD44780_I2C_DB6;
|
|
}
|
|
if (signals & LCD_HD44780_DB7) {
|
|
lcd_hd44780_i2c_output |= LCD_HD44780_I2C_DB7;
|
|
}
|
|
if (signals & LCD_HD44780_LED) {
|
|
lcd_hd44780_i2c_output |= LCD_HD44780_I2C_LED;
|
|
}
|
|
#else // LCD_HD44780_I2C
|
|
if (signals & LCD_HD44780_RS) {
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_RS), GPIO_PIN(LCD_HD44780_GPIO_RS));
|
|
}
|
|
#ifdef LCD_HD44780_GPIO_RnW
|
|
if (signals & LCD_HD44780_RnW) {
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_RnW), GPIO_PIN(LCD_HD44780_GPIO_RnW));
|
|
}
|
|
#endif // LCD_HD44780_GPIO_RnW
|
|
if (signals & LCD_HD44780_E) {
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_E), GPIO_PIN(LCD_HD44780_GPIO_E));
|
|
}
|
|
#if defined(LCD_HD44780_INTERFACE_DL) && LCD_HD44780_INTERFACE_DL
|
|
if (signals & LCD_HD44780_DB0) {
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_DB0), GPIO_PIN(LCD_HD44780_GPIO_DB0));
|
|
}
|
|
if (signals & LCD_HD44780_DB1) {
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_DB1), GPIO_PIN(LCD_HD44780_GPIO_DB1));
|
|
}
|
|
if (signals & LCD_HD44780_DB2) {
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_DB2), GPIO_PIN(LCD_HD44780_GPIO_DB2));
|
|
}
|
|
if (signals & LCD_HD44780_DB3) {
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_DB3), GPIO_PIN(LCD_HD44780_GPIO_DB3));
|
|
}
|
|
#endif // LCD_HD44780_INTERFACE_DL
|
|
if (signals & LCD_HD44780_DB4) {
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_DB4), GPIO_PIN(LCD_HD44780_GPIO_DB4));
|
|
}
|
|
if (signals & LCD_HD44780_DB5) {
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_DB5), GPIO_PIN(LCD_HD44780_GPIO_DB5));
|
|
}
|
|
if (signals & LCD_HD44780_DB6) {
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_DB6), GPIO_PIN(LCD_HD44780_GPIO_DB6));
|
|
}
|
|
if (signals & LCD_HD44780_DB7) {
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_DB7), GPIO_PIN(LCD_HD44780_GPIO_DB7));
|
|
}
|
|
if (signals & LCD_HD44780_LED) {
|
|
// no LED GPIO defined
|
|
}
|
|
#endif // LCD_HD44780_I2C
|
|
}
|
|
/** clear signals
|
|
* @param[in] signals
|
|
*/
|
|
static void lcd_hd44780_clear_signal(uint16_t signals)
|
|
{
|
|
#if defined(LCD_HD44780_I2C) && LCD_HD44780_I2C
|
|
if (signals & LCD_HD44780_RS) {
|
|
lcd_hd44780_i2c_output &= ~LCD_HD44780_I2C_RS;
|
|
}
|
|
if (signals & LCD_HD44780_RnW) {
|
|
lcd_hd44780_i2c_output &= ~LCD_HD44780_I2C_RnW;
|
|
}
|
|
if (signals & LCD_HD44780_E) {
|
|
lcd_hd44780_i2c_output &= ~LCD_HD44780_I2C_E;
|
|
}
|
|
if (signals & LCD_HD44780_DB4) {
|
|
lcd_hd44780_i2c_output &= ~LCD_HD44780_I2C_DB4;
|
|
}
|
|
if (signals & LCD_HD44780_DB5) {
|
|
lcd_hd44780_i2c_output &= ~LCD_HD44780_I2C_DB5;
|
|
}
|
|
if (signals & LCD_HD44780_DB6) {
|
|
lcd_hd44780_i2c_output &= ~LCD_HD44780_I2C_DB6;
|
|
}
|
|
if (signals & LCD_HD44780_DB7) {
|
|
lcd_hd44780_i2c_output &= ~LCD_HD44780_I2C_DB7;
|
|
}
|
|
if (signals & LCD_HD44780_LED) {
|
|
lcd_hd44780_i2c_output &= ~LCD_HD44780_I2C_LED;
|
|
}
|
|
#else // LCD_HD44780_I2C
|
|
if (signals & LCD_HD44780_RS) {
|
|
gpio_clear(GPIO_PORT(LCD_HD44780_GPIO_RS), GPIO_PIN(LCD_HD44780_GPIO_RS));
|
|
}
|
|
#ifdef LCD_HD44780_GPIO_RnW
|
|
if (signals & LCD_HD44780_RnW) {
|
|
gpio_clear(GPIO_PORT(LCD_HD44780_GPIO_RnW), GPIO_PIN(LCD_HD44780_GPIO_RnW));
|
|
}
|
|
#endif // LCD_HD44780_GPIO_RnW
|
|
if (signals & LCD_HD44780_E) {
|
|
gpio_clear(GPIO_PORT(LCD_HD44780_GPIO_E), GPIO_PIN(LCD_HD44780_GPIO_E));
|
|
}
|
|
#if defined(LCD_HD44780_INTERFACE_DL) && LCD_HD44780_INTERFACE_DL
|
|
if (signals & LCD_HD44780_DB0) {
|
|
gpio_clear(GPIO_PORT(LCD_HD44780_GPIO_DB0), GPIO_PIN(LCD_HD44780_GPIO_DB0));
|
|
}
|
|
if (signals & LCD_HD44780_DB1) {
|
|
gpio_clear(GPIO_PORT(LCD_HD44780_GPIO_DB1), GPIO_PIN(LCD_HD44780_GPIO_DB1));
|
|
}
|
|
if (signals & LCD_HD44780_DB2) {
|
|
gpio_clear(GPIO_PORT(LCD_HD44780_GPIO_DB2), GPIO_PIN(LCD_HD44780_GPIO_DB2));
|
|
}
|
|
if (signals & LCD_HD44780_DB3) {
|
|
gpio_clear(GPIO_PORT(LCD_HD44780_GPIO_DB3), GPIO_PIN(LCD_HD44780_GPIO_DB3));
|
|
}
|
|
#endif // LCD_HD44780_INTERFACE_DL
|
|
if (signals & LCD_HD44780_DB4) {
|
|
gpio_clear(GPIO_PORT(LCD_HD44780_GPIO_DB4), GPIO_PIN(LCD_HD44780_GPIO_DB4));
|
|
}
|
|
if (signals & LCD_HD44780_DB5) {
|
|
gpio_clear(GPIO_PORT(LCD_HD44780_GPIO_DB5), GPIO_PIN(LCD_HD44780_GPIO_DB5));
|
|
}
|
|
if (signals & LCD_HD44780_DB6) {
|
|
gpio_clear(GPIO_PORT(LCD_HD44780_GPIO_DB6), GPIO_PIN(LCD_HD44780_GPIO_DB6));
|
|
}
|
|
if (signals & LCD_HD44780_DB7) {
|
|
gpio_clear(GPIO_PORT(LCD_HD44780_GPIO_DB7), GPIO_PIN(LCD_HD44780_GPIO_DB7));
|
|
}
|
|
if (signals & LCD_HD44780_LED) {
|
|
// no LED GPIO defined
|
|
}
|
|
#endif // LCD_HD44780_I2C
|
|
}
|
|
|
|
/** flush the set and cleared signals
|
|
* @note this only applies to I²C and helps gain time
|
|
*/
|
|
static void lcd_hd44780_flush_signal(void)
|
|
{
|
|
#if defined(LCD_HD44780_I2C) && LCD_HD44780_I2C
|
|
i2c_master_slave_write(LCD_HD44780_I2C_PERIPH, lcd_hd44780_i2c_addr, false, &lcd_hd44780_i2c_output, 1); // write the set signals
|
|
#endif
|
|
}
|
|
|
|
/** read from controller
|
|
* @param[in] data read data (true) or busy flag and address counter (false)
|
|
* @return data/AC read
|
|
*/
|
|
static uint8_t lcd_hd44780_read(bool data)
|
|
{
|
|
#if defined(LCD_HD44780_GPIO_RnW) || defined(LCD_HD44780_I2C)
|
|
lcd_hd44780_set_signal(LCD_HD44780_RnW | LCD_HD44780_DB7 | LCD_HD44780_DB6 | LCD_HD44780_DB5 | LCD_HD44780_DB4); // switch DB direction to input to read data
|
|
|
|
if (data) {
|
|
lcd_hd44780_set_signal(LCD_HD44780_RS); // set high to read data
|
|
} else {
|
|
lcd_hd44780_clear_signal(LCD_HD44780_RS); // set low to read busy flag and AC
|
|
}
|
|
lcd_hd44780_flush_signal();
|
|
// no need to wait tAS = 40 ns before next step since the instructions are slower
|
|
|
|
lcd_hd44780_set_signal(LCD_HD44780_E); // set high to have data output
|
|
lcd_hd44780_flush_signal();
|
|
sleep_us(0); // wait t_DDR = 160 ns before reading
|
|
// read data bits
|
|
uint8_t input = 0; // to store read data
|
|
#if defined(LCD_HD44780_I2C)
|
|
uint8_t i2c_data;
|
|
if (I2C_MASTER_RC_NONE == i2c_master_slave_read(LCD_HD44780_I2C_PERIPH, lcd_hd44780_i2c_addr, false, &i2c_data, 1)) {
|
|
if (i2c_data & LCD_HD44780_I2C_DB7) {
|
|
input |= 0x80;
|
|
}
|
|
if (i2c_data & LCD_HD44780_I2C_DB6) {
|
|
input |= 0x40;
|
|
}
|
|
if (i2c_data & LCD_HD44780_I2C_DB5) {
|
|
input |= 0x20;
|
|
}
|
|
if (i2c_data & LCD_HD44780_I2C_DB4) {
|
|
input |= 0x10;
|
|
}
|
|
}
|
|
#else // LCD_HD44780_I2C
|
|
if (gpio_get(GPIO_PORT(LCD_HD44780_GPIO_DB7), GPIO_PIN(LCD_HD44780_GPIO_DB7))) {
|
|
input |= 0x80;
|
|
}
|
|
if (gpio_get(GPIO_PORT(LCD_HD44780_GPIO_DB6), GPIO_PIN(LCD_HD44780_GPIO_DB6))) {
|
|
input |= 0x40;
|
|
}
|
|
if (gpio_get(GPIO_PORT(LCD_HD44780_GPIO_DB5), GPIO_PIN(LCD_HD44780_GPIO_DB5))) {
|
|
input |= 0x20;
|
|
}
|
|
if (gpio_get(GPIO_PORT(LCD_HD44780_GPIO_DB4), GPIO_PIN(LCD_HD44780_GPIO_DB4))) {
|
|
input |= 0x10;
|
|
}
|
|
#endif // LCD_HD44780_I2C
|
|
#if defined(LCD_HD44780_INTERFACE_DL) && LCD_HD44780_INTERFACE_DL
|
|
if (gpio_get(GPIO_PORT(LCD_HD44780_GPIO_DB3), GPIO_PIN(LCD_HD44780_GPIO_DB3))) {
|
|
input |= 0x08;
|
|
}
|
|
if (gpio_get(GPIO_PORT(LCD_HD44780_GPIO_DB2), GPIO_PIN(LCD_HD44780_GPIO_DB2))) {
|
|
input |= 0x04;
|
|
}
|
|
if (gpio_get(GPIO_PORT(LCD_HD44780_GPIO_DB1), GPIO_PIN(LCD_HD44780_GPIO_DB1))) {
|
|
input |= 0x02;
|
|
}
|
|
if (gpio_get(GPIO_PORT(LCD_HD44780_GPIO_DB0), GPIO_PIN(LCD_HD44780_GPIO_DB0))) {
|
|
input |= 0x01;
|
|
}
|
|
#else // LCD_HD44780_INTERFACE_DL
|
|
// get second nibble
|
|
// don't wait PW_EH = 230 ns since reading took longer
|
|
lcd_hd44780_clear_signal(LCD_HD44780_E); // end current data read
|
|
lcd_hd44780_flush_signal();
|
|
sleep_us(1); // wait t_cycE = 500 ns
|
|
lcd_hd44780_set_signal(LCD_HD44780_E); // have next data output
|
|
lcd_hd44780_flush_signal();
|
|
sleep_us(0); // wait t_DDR = 160 ns before reading
|
|
|
|
// read second nibble
|
|
#if defined(LCD_HD44780_I2C)
|
|
if (I2C_MASTER_RC_NONE == i2c_master_slave_read(LCD_HD44780_I2C_PERIPH, lcd_hd44780_i2c_addr, false, &i2c_data, 1)) {
|
|
if (i2c_data & LCD_HD44780_I2C_DB7) {
|
|
input |= 0x08;
|
|
}
|
|
if (i2c_data & LCD_HD44780_I2C_DB6) {
|
|
input |= 0x04;
|
|
}
|
|
if (i2c_data & LCD_HD44780_I2C_DB5) {
|
|
input |= 0x02;
|
|
}
|
|
if (i2c_data & LCD_HD44780_I2C_DB4) {
|
|
input |= 0x01;
|
|
}
|
|
}
|
|
#else // LCD_HD44780_I2C
|
|
if (gpio_get(GPIO_PORT(LCD_HD44780_GPIO_DB7), GPIO_PIN(LCD_HD44780_GPIO_DB7))) {
|
|
input |= 0x80;
|
|
}
|
|
if (gpio_get(GPIO_PORT(LCD_HD44780_GPIO_DB6), GPIO_PIN(LCD_HD44780_GPIO_DB6))) {
|
|
input |= 0x40;
|
|
}
|
|
if (gpio_get(GPIO_PORT(LCD_HD44780_GPIO_DB5), GPIO_PIN(LCD_HD44780_GPIO_DB5))) {
|
|
input |= 0x20;
|
|
}
|
|
if (gpio_get(GPIO_PORT(LCD_HD44780_GPIO_DB4), GPIO_PIN(LCD_HD44780_GPIO_DB4))) {
|
|
input |= 0x10;
|
|
}
|
|
#endif // LCD_HD44780_I2C
|
|
#endif // LCD_HD44780_INTERFACE_DL
|
|
// don't wait PW_EH = 230 ns since reading took longer
|
|
lcd_hd44780_clear_signal(LCD_HD44780_E); // end data read
|
|
lcd_hd44780_flush_signal();
|
|
|
|
return input;
|
|
#else // LCD_HD44780_GPIO_RnW || LCD_HD44780_I2C
|
|
return 0; // read is not supported
|
|
#endif
|
|
}
|
|
|
|
uint8_t lcd_hd44780_read_data(void)
|
|
{
|
|
return lcd_hd44780_read(true);
|
|
}
|
|
|
|
/** write to controller
|
|
* @param[in] command true if it is an command, false if it is data
|
|
* @param[in] data data bit to write
|
|
* @param[in] first_nibble_only if only the first nibble of the data should be written (only applies to 4-bit mode)
|
|
*/
|
|
static void lcd_hd44780_write(bool command, uint8_t data, bool first_nibble_only)
|
|
{
|
|
lcd_hd44780_clear_signal(LCD_HD44780_RnW); // switch DB direction to output to write data
|
|
if (command) {
|
|
lcd_hd44780_clear_signal(LCD_HD44780_RS);
|
|
} else {
|
|
lcd_hd44780_set_signal(LCD_HD44780_RS);
|
|
}
|
|
lcd_hd44780_flush_signal();
|
|
// no need to wait tAS = 40 ns before next step since the instructions are slower
|
|
|
|
// write data
|
|
if (data & 0x80) {
|
|
lcd_hd44780_set_signal(LCD_HD44780_DB7);
|
|
} else {
|
|
lcd_hd44780_clear_signal(LCD_HD44780_DB7);
|
|
}
|
|
if (data & 0x40) {
|
|
lcd_hd44780_set_signal(LCD_HD44780_DB6);
|
|
} else {
|
|
lcd_hd44780_clear_signal(LCD_HD44780_DB6);
|
|
}
|
|
if (data & 0x20) {
|
|
lcd_hd44780_set_signal(LCD_HD44780_DB5);
|
|
} else {
|
|
lcd_hd44780_clear_signal(LCD_HD44780_DB5);
|
|
}
|
|
if (data & 0x10) {
|
|
lcd_hd44780_set_signal(LCD_HD44780_DB4);
|
|
} else {
|
|
lcd_hd44780_clear_signal(LCD_HD44780_DB4);
|
|
}
|
|
#if defined(LCD_HD44780_INTERFACE_DL) && LCD_HD44780_INTERFACE_DL
|
|
if (data & 0x08) {
|
|
lcd_hd44780_set_signal(LCD_HD44780_DB3);
|
|
} else {
|
|
lcd_hd44780_clear_signal(LCD_HD44780_DB3);
|
|
}
|
|
if (data & 0x04) {
|
|
lcd_hd44780_set_signal(LCD_HD44780_DB2);
|
|
} else {
|
|
lcd_hd44780_clear_signal(LCD_HD44780_DB2);
|
|
}
|
|
if (data & 0x02) {
|
|
lcd_hd44780_set_signal(LCD_HD44780_DB1);
|
|
} else {
|
|
lcd_hd44780_clear_signal(LCD_HD44780_DB1);
|
|
}
|
|
if (data & 0x01) {
|
|
lcd_hd44780_set_signal(LCD_HD44780_DB0);
|
|
} else {
|
|
lcd_hd44780_clear_signal(LCD_HD44780_DB0);
|
|
}
|
|
#else // LCD_HD44780_INTERFACE_DL
|
|
if (!first_nibble_only) { // write second nibble
|
|
// pulse E to send data
|
|
sleep_us(1); // wait t_cycE = 500 ns
|
|
lcd_hd44780_set_signal(LCD_HD44780_E); // set high change output data
|
|
lcd_hd44780_flush_signal();
|
|
sleep_us(1); // wait PW_EH = 230 ns
|
|
lcd_hd44780_clear_signal(LCD_HD44780_E); // set low to latch data
|
|
lcd_hd44780_flush_signal();
|
|
// no need to wait t_H = 10 ns before next step since next instructions are slower
|
|
|
|
// send second nibble
|
|
if (data & 0x08) {
|
|
lcd_hd44780_set_signal(LCD_HD44780_DB7);
|
|
} else {
|
|
lcd_hd44780_clear_signal(LCD_HD44780_DB7);
|
|
}
|
|
if (data & 0x04) {
|
|
lcd_hd44780_set_signal(LCD_HD44780_DB6);
|
|
} else {
|
|
lcd_hd44780_clear_signal(LCD_HD44780_DB6);
|
|
}
|
|
if (data & 0x02) {
|
|
lcd_hd44780_set_signal(LCD_HD44780_DB5);
|
|
} else {
|
|
lcd_hd44780_clear_signal(LCD_HD44780_DB5);
|
|
}
|
|
if (data & 0x01) {
|
|
lcd_hd44780_set_signal(LCD_HD44780_DB4);
|
|
} else {
|
|
lcd_hd44780_clear_signal(LCD_HD44780_DB4);
|
|
}
|
|
}
|
|
#endif // LCD_HD44780_INTERFACE_DL
|
|
// pulse E to send data
|
|
sleep_us(1); // wait t_cycE = 500 ns
|
|
lcd_hd44780_set_signal(LCD_HD44780_E); // set high change output data
|
|
lcd_hd44780_flush_signal();
|
|
sleep_us(1); // wait PW_EH = 230 ns
|
|
lcd_hd44780_clear_signal(LCD_HD44780_E); // set low to latch data
|
|
lcd_hd44780_flush_signal();
|
|
// no need to wait t_H = 10 ns before next step since next instructions are slower
|
|
// no need to wait t_AH = 10 ns before next step since next instructions are slower
|
|
}
|
|
|
|
/** wait until controller is not busy anymore
|
|
* @param[in] timeout maximum time to wait in us
|
|
* @return address count, or >= 0x80 if timeout expired
|
|
*/
|
|
static uint8_t lcd_hd44780_wait_busy(uint16_t timeout)
|
|
{
|
|
#if defined(LCD_HD44780_GPIO_RnW)
|
|
uint8_t ac = 0x80; // address counter to return
|
|
while (timeout && ((ac = lcd_hd44780_read(false)) >= 0x80)) { // wait until busy flag is low or timeout
|
|
// wait a bit
|
|
sleep_us(100);
|
|
if (timeout > 100) {
|
|
timeout -= 100;
|
|
} else {
|
|
timeout = 0;
|
|
}
|
|
}
|
|
return ac;
|
|
#else // I²C is also to slow to read (at least 6400 us per read)
|
|
sleep_us(timeout); // just wait
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
/** write function set command
|
|
* @param[in] dl_8bit 8-bit (true) or 4-bit (false) data length
|
|
* @param[in] n_2lines 2 (true) or 1 (false) lines
|
|
* @param[in] f_5x10 5x10 (true) or 5x8 (false) dots font
|
|
*/
|
|
static void lcd_hd44780_function_set(bool dl_8bit, bool n_2lines, bool f_5x10)
|
|
{
|
|
uint8_t data = 0x20;
|
|
if (dl_8bit) {
|
|
data |= 0x10;
|
|
}
|
|
if (n_2lines) {
|
|
data |= 0x08;
|
|
}
|
|
if (f_5x10) {
|
|
data |= 0x04;
|
|
}
|
|
lcd_hd44780_write(true, data, false);
|
|
lcd_hd44780_wait_busy(LCD_HD44780_BUSY_WAIT_SHORT);
|
|
}
|
|
|
|
bool lcd_hd44780_setup(bool n_2lines, bool f_5x10)
|
|
{
|
|
sleep_ms(40 + 2); // wait for display to initialise after power on: 15 ms for VCC > 4.5 V, 40 ms for VCC > 2.7 V
|
|
#if defined(LCD_HD44780_I2C) && LCD_HD44780_I2C
|
|
// configure I²C peripheral
|
|
if (!i2c_master_check_signals(LCD_HD44780_I2C_PERIPH)) { // check if there are pull-ups to operator I²C
|
|
return false;
|
|
}
|
|
i2c_master_setup(LCD_HD44780_I2C_PERIPH, 100); // setup I²C bus (PCF8574 supports an I²C clock up to 100 kHz)
|
|
lcd_hd44780_i2c_output = 0xff; // put GPIO to input (sort of open drain output)
|
|
if (I2C_MASTER_RC_NONE != i2c_master_slave_write(LCD_HD44780_I2C_PERIPH, lcd_hd44780_i2c_addr, false, &lcd_hd44780_i2c_output, 1)) { // check if the device is present and set inputs
|
|
return false;
|
|
}
|
|
#else // LCD_HD44780_I2C
|
|
// enable all GPIO
|
|
rcc_periph_clock_enable(GPIO_RCC(LCD_HD44780_GPIO_E)); // enable clock for GPIO port
|
|
gpio_clear(GPIO_PORT(LCD_HD44780_GPIO_E), GPIO_PIN(LCD_HD44780_GPIO_E)); // start idle low
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_E), GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(LCD_HD44780_GPIO_E)); // set GPIO as output
|
|
rcc_periph_clock_enable(GPIO_RCC(LCD_HD44780_GPIO_DB7)); // enable clock for GPIO port
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_DB7), GPIO_PIN(LCD_HD44780_GPIO_DB7)); // idle high
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_DB7), GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(LCD_HD44780_GPIO_DB7)); // open drain allows to read and write
|
|
rcc_periph_clock_enable(GPIO_RCC(LCD_HD44780_GPIO_DB6)); // enable clock for GPIO port
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_DB6), GPIO_PIN(LCD_HD44780_GPIO_DB6)); // idle high
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_DB6), GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(LCD_HD44780_GPIO_DB6)); // open drain allows to read and write
|
|
rcc_periph_clock_enable(GPIO_RCC(LCD_HD44780_GPIO_DB5)); // enable clock for GPIO port
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_DB5), GPIO_PIN(LCD_HD44780_GPIO_DB5)); // idle high
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_DB5), GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(LCD_HD44780_GPIO_DB5)); // open drain allows to read and write
|
|
rcc_periph_clock_enable(GPIO_RCC(LCD_HD44780_GPIO_DB4)); // enable clock for GPIO port
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_DB4), GPIO_PIN(LCD_HD44780_GPIO_DB4)); // idle high
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_DB4), GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(LCD_HD44780_GPIO_DB4)); // open drain allows to read and write
|
|
#if defined(LCD_HD44780_INTERFACE_DL) && LCD_HD44780_INTERFACE_DL
|
|
rcc_periph_clock_enable(GPIO_RCC(LCD_HD44780_GPIO_DB3)); // enable clock for GPIO port
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_DB3), GPIO_PIN(LCD_HD44780_GPIO_DB3)); // idle high
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_DB3), GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(LCD_HD44780_GPIO_DB3)); // open drain allows to read and write
|
|
rcc_periph_clock_enable(GPIO_RCC(LCD_HD44780_GPIO_DB2)); // enable clock for GPIO port
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_DB2), GPIO_PIN(LCD_HD44780_GPIO_DB2)); // idle high
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_DB2), GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(LCD_HD44780_GPIO_DB2)); // open drain allows to read and write
|
|
rcc_periph_clock_enable(GPIO_RCC(LCD_HD44780_GPIO_DB1)); // enable clock for GPIO port
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_DB1), GPIO_PIN(LCD_HD44780_GPIO_DB1)); // idle high
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_DB1), GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(LCD_HD44780_GPIO_DB1)); // open drain allows to read and write
|
|
rcc_periph_clock_enable(GPIO_RCC(LCD_HD44780_GPIO_DB0)); // enable clock for GPIO port
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_DB0), GPIO_PIN(LCD_HD44780_GPIO_DB0)); // idle high
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_DB0), GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(LCD_HD44780_GPIO_DB0)); // open drain allows to read and write
|
|
#endif // LCD_HD44780_INTERFACE_DL
|
|
rcc_periph_clock_enable(GPIO_RCC(LCD_HD44780_GPIO_RS)); // enable clock for GPIO port
|
|
gpio_clear(GPIO_PORT(LCD_HD44780_GPIO_RS), GPIO_PIN(LCD_HD44780_GPIO_RS)); // set low to read busy flag
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_RS), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(LCD_HD44780_GPIO_RS)); // set GPIO as output
|
|
#ifdef LCD_HD44780_GPIO_RnW
|
|
rcc_periph_clock_enable(GPIO_RCC(LCD_HD44780_GPIO_RnW)); // enable clock for GPIO port
|
|
gpio_set(GPIO_PORT(LCD_HD44780_GPIO_RnW), GPIO_PIN(LCD_HD44780_GPIO_RnW)); // set high to read
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_RnW), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(LCD_HD44780_GPIO_RnW)); // set GPIO as output
|
|
#endif // LCD_HD44780_GPIO_RnW
|
|
#endif // LCD_HD44780_I2C
|
|
// initialize device
|
|
lcd_hd44780_write(true, 0x30, true); // 1st function write set to go to state 1 (8-bit) or 2 (4-bit first nibble) (BF cannot be checked)
|
|
sleep_ms(4 + 1); // wait 4.1 ms
|
|
lcd_hd44780_write(true, 0x30, true); // 2st function write set to go to state 1 (8-bit) or 3 (4-bit second nibble) (BF cannot be checked)
|
|
sleep_us(100 + 10); // wait 100 us
|
|
lcd_hd44780_write(true, 0x30, true); // 3rd function write set to go to state 1 (8-bit) (BF cannot be checked)
|
|
sleep_us(LCD_HD44780_BUSY_WAIT_SHORT); // wait 37 us
|
|
#if defined(LCD_HD44780_INTERFACE_DL) && LCD_HD44780_INTERFACE_DL
|
|
lcd_hd44780_function_set(1, n_2lines, f_5x10); // function set
|
|
#else
|
|
lcd_hd44780_write(true, 0x20, true); // switch to 4-bit mode
|
|
sleep_us(LCD_HD44780_BUSY_WAIT_SHORT); // wait 37 us
|
|
lcd_hd44780_function_set(0, n_2lines, f_5x10); // function set
|
|
#endif
|
|
lcd_hd44780_n_2lines = n_2lines; // remember number of lines
|
|
lcd_hd44780_wait_busy(LCD_HD44780_BUSY_WAIT_SHORT);
|
|
lcd_hd44780_display_control(false, false, false); // display off
|
|
lcd_hd44780_wait_busy(LCD_HD44780_BUSY_WAIT_SHORT);
|
|
lcd_hd44780_clear_display(); // display clear
|
|
lcd_hd44780_wait_busy(LCD_HD44780_BUSY_WAIT_LONG);
|
|
lcd_hd44780_entry_mode_set(true, false); // entry mode set
|
|
lcd_hd44780_wait_busy(LCD_HD44780_BUSY_WAIT_SHORT);
|
|
|
|
return true; // I²C configuration succeeded
|
|
}
|
|
|
|
void lcd_hd44780_release(void)
|
|
{
|
|
#if defined(LCD_HD44780_I2C) && LCD_HD44780_I2C
|
|
i2c_master_release(LCD_HD44780_I2C_PERIPH); // release I²C peripheral
|
|
#else // LCD_HD44780_I2C
|
|
// switch back GPIO back to input
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_DB7), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO_PIN(LCD_HD44780_GPIO_DB7));
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_DB6), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO_PIN(LCD_HD44780_GPIO_DB6));
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_DB5), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO_PIN(LCD_HD44780_GPIO_DB5));
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_DB4), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO_PIN(LCD_HD44780_GPIO_DB4));
|
|
#if defined(LCD_HD44780_INTERFACE_DL) && LCD_HD44780_INTERFACE_DL
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_DB3), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO_PIN(LCD_HD44780_GPIO_DB3));
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_DB2), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO_PIN(LCD_HD44780_GPIO_DB2));
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_DB1), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO_PIN(LCD_HD44780_GPIO_DB1));
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_DB0), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO_PIN(LCD_HD44780_GPIO_DB0));
|
|
#endif // LCD_HD44780_INTERFACE_DL
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_RS), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO_PIN(LCD_HD44780_GPIO_RS));
|
|
#ifdef LCD_HD44780_GPIO_RnW
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_RnW), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO_PIN(LCD_HD44780_GPIO_RnW));
|
|
#endif // LCD_HD44780_GPIO_RnW
|
|
gpio_set_mode(GPIO_PORT(LCD_HD44780_GPIO_E), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO_PIN(LCD_HD44780_GPIO_E));
|
|
#endif // LCD_HD44780_I2C:
|
|
}
|
|
|
|
void lcd_hd44780_write_data(uint8_t data)
|
|
{
|
|
lcd_hd44780_write(false, data, false);
|
|
lcd_hd44780_wait_busy(LCD_HD44780_BUSY_WAIT_SHORT);
|
|
}
|
|
|
|
void lcd_hd44780_write_command(uint8_t data)
|
|
{
|
|
lcd_hd44780_write(true, data, false);
|
|
lcd_hd44780_wait_busy(LCD_HD44780_BUSY_WAIT_SHORT);
|
|
}
|
|
|
|
void lcd_hd44780_clear_display(void)
|
|
{
|
|
lcd_hd44780_write_command(0x01);
|
|
lcd_hd44780_wait_busy(LCD_HD44780_BUSY_WAIT_LONG);
|
|
}
|
|
|
|
void lcd_hd44780_return_home(void)
|
|
{
|
|
lcd_hd44780_write_command(0x02);
|
|
lcd_hd44780_wait_busy(LCD_HD44780_BUSY_WAIT_LONG);
|
|
}
|
|
|
|
void lcd_hd44780_entry_mode_set(bool increment, bool shift)
|
|
{
|
|
uint8_t command = 0x04;
|
|
if (increment) {
|
|
command |= 0x02;
|
|
}
|
|
if (shift) {
|
|
command |= 0x01;
|
|
}
|
|
lcd_hd44780_write_command(command);
|
|
}
|
|
|
|
void lcd_hd44780_display_control(bool d, bool c, bool b)
|
|
{
|
|
uint8_t command = 0x08;
|
|
if (d) {
|
|
command |= 0x04;
|
|
}
|
|
if (c) {
|
|
command |= 0x02;
|
|
}
|
|
if (b) {
|
|
command |= 0x01;
|
|
}
|
|
lcd_hd44780_write_command(command);
|
|
}
|
|
|
|
void lcd_hd44780_set_cgram_address(uint8_t acg)
|
|
{
|
|
lcd_hd44780_write_command(0x40 | (acg & 0x3f));
|
|
}
|
|
|
|
void lcd_hd44780_set_ddram_address(uint8_t add)
|
|
{
|
|
lcd_hd44780_write_command(0x80 | (add & 0x7f));
|
|
}
|
|
|
|
void lcd_hd44780_write_line(bool line2, const char* data, uint8_t length)
|
|
{
|
|
if (line2 && !lcd_hd44780_n_2lines) { // writing line 2 when it does not exists is not possible
|
|
return;
|
|
}
|
|
lcd_hd44780_set_ddram_address(line2 ? 0x40 : 0x00); // set start of line
|
|
lcd_hd44780_wait_busy(LCD_HD44780_BUSY_WAIT_SHORT);
|
|
for (uint8_t i = 0; i < length && i < (lcd_hd44780_n_2lines ? 0x27 : 0x4f); i++) { // write line
|
|
lcd_hd44780_write_data(data[i]); // write character
|
|
lcd_hd44780_wait_busy(LCD_HD44780_BUSY_WAIT_SHORT);
|
|
}
|
|
}
|