// STM32 Nucleo-C031C6 I2C Example
// Simulation: https://wokwi.com/projects/365421666018061313

int led_port = 13;

void setup() {
  Serial.begin(115200);

  Serial.println("Hello, STM32!");
}
uint16_t x=800;
uint16_t y=1200;
void loop() {
  //Serial.println(GPIOB->IDR & (1 << 1)); // 0b10
  //GPIOC->ODR = (1 << 6); // 0b1000000
  if(abs(x-y) >= 100)     Serial.println(1);
  //Serial.println(abs(x-y));
  delay(1000);
  if(abs(y-x) >= 100)     Serial.println(0);
  //Serial.println(abs(y-x));
  delay(1000);
  }


sketch.ino

diagram.json

#include <Wire.h>
#include "LiquidCrystal_I2C.h"

TwoWire Wire2(PA10, PA9);

// When the display powers up, it is configured as follows:
//
// 1. Display clear
// 2. Function set: 
//    DL = 1; 8-bit interface data 
//    N = 0; 1-line display 
//    F = 0; 5x8 dot character font 
// 3. Display on/off control: 
//    D = 0; Display off 
//    C = 0; Cursor off 
//    B = 0; Blinking off 
// 4. Entry mode set: 
//    I/D = 1; Increment by 1
//    S = 0; No shift 
//
// Note, however, that resetting the Arduino doesn't reset the LCD, so we
// can't assume that its in that state when a sketch starts (and the
// LiquidCrystal constructor is called).
LiquidCrystal_I2C::LiquidCrystal_I2C(uint8_t addr, uint8_t cols, uint8_t rows)
{
  _Addr = addr;
  _cols = cols;
  _rows = rows;
  _backlightval = LCD_NOBACKLIGHT;
}

void LiquidCrystal_I2C::init(){
	init_priv();
}

void LiquidCrystal_I2C::init_priv()
{
	Wire2.begin();
	_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
	begin(_cols, _rows);  
}

void LiquidCrystal_I2C::begin(uint8_t cols, uint8_t lines, uint8_t charsize) {
	if (lines > 1) {
		_displayfunction |= LCD_2LINE;
	}
	_numlines = lines;

	// for some 1 line displays you can select a 10 pixel high font
	if ((charsize != 0) && (lines == 1)) {
		_displayfunction |= LCD_5x10DOTS;
	}

	// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
	// according to datasheet, we need at least 40ms after power rises above 2.7V
	// before sending commands. Arduino can turn on way before 4.5V so we'll wait 50
	delayMicroseconds(50000); 
  
	// Now we pull both RS and R/W low to begin commands
	expanderWrite(_backlightval);	// reset expanderand turn backlight off (Bit 8 =1)
	delay(100);

  // put the LCD into 4 bit mode
	// this is according to the hitachi HD44780 datasheet
	// figure 24, pg 46
	
	// we start in 8bit mode, try to set 4 bit mode
	write4bits(0x30);
	delayMicroseconds(4500); // wait min 4.1ms
	
	// second try
	write4bits(0x30);
	delayMicroseconds(4500); // wait min 4.1ms
	
	// third go!
	write4bits(0x30); 
	delayMicroseconds(150);
	
	// finally, set to 4-bit interface
	write4bits(0x20); 


	// set # lines, font size, etc.
	command(LCD_FUNCTIONSET | _displayfunction);  
	
	// turn the display on with no cursor or blinking default
	_displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
	display();
	
	// clear it off
	clear();
	
	// Initialize to default text direction (for roman languages)
	_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
	
	// set the entry mode
	command(LCD_ENTRYMODESET | _displaymode);
	
	home();
  
}



/********** high level commands, for the user! */
void LiquidCrystal_I2C::clear(){
	command(LCD_CLEARDISPLAY);  // clear display, set cursor position to zero
	delayMicroseconds(2000);    // this command takes a long time!
}

// Clear particular segment of a row
void LiquidCrystal_I2C::clear(uint8_t rowStart, uint8_t colStart, uint8_t colCnt) {
  // Maintain input parameters
  rowStart = constrain(rowStart, 0, _rows - 1);
  colStart = constrain(colStart, 0, _cols - 1);
  colCnt   = constrain(colCnt,   0, _cols - colStart);
  // Clear segment
  setCursor(colStart, rowStart);
  for (uint8_t i = 0; i < colCnt; i++) write(' ');
  // Go to segment start
  setCursor(colStart, rowStart);
}


void LiquidCrystal_I2C::home(){
	command(LCD_RETURNHOME);  // set cursor position to zero
	delayMicroseconds(2000);  // this command takes a long time!
}

void LiquidCrystal_I2C::setCursor(uint8_t col, uint8_t row){
	int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
	if ( row > _numlines ) {
		row = _numlines-1;    // we count rows starting w/0
	}
	command(LCD_SETDDRAMADDR | (col + row_offsets[row]));
}

// Turn the display on/off (quickly)
void LiquidCrystal_I2C::noDisplay() {
	_displaycontrol &= ~LCD_DISPLAYON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::display() {
	_displaycontrol |= LCD_DISPLAYON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// Turns the underline cursor on/off
void LiquidCrystal_I2C::noCursor() {
	_displaycontrol &= ~LCD_CURSORON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::cursor() {
	_displaycontrol |= LCD_CURSORON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// Turn on and off the blinking cursor
void LiquidCrystal_I2C::noBlink() {
	_displaycontrol &= ~LCD_BLINKON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::blink() {
	_displaycontrol |= LCD_BLINKON;
	command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// These commands scroll the display without changing the RAM
void LiquidCrystal_I2C::scrollDisplayLeft(void) {
	command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
}
void LiquidCrystal_I2C::scrollDisplayRight(void) {
	command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
}

// This is for text that flows Left to Right
void LiquidCrystal_I2C::leftToRight(void) {
	_displaymode |= LCD_ENTRYLEFT;
	command(LCD_ENTRYMODESET | _displaymode);
}

// This is for text that flows Right to Left
void LiquidCrystal_I2C::rightToLeft(void) {
	_displaymode &= ~LCD_ENTRYLEFT;
	command(LCD_ENTRYMODESET | _displaymode);
}

// This will 'right justify' text from the cursor
void LiquidCrystal_I2C::autoscroll(void) {
	_displaymode |= LCD_ENTRYSHIFTINCREMENT;
	command(LCD_ENTRYMODESET | _displaymode);
}

// This will 'left justify' text from the cursor
void LiquidCrystal_I2C::noAutoscroll(void) {
	_displaymode &= ~LCD_ENTRYSHIFTINCREMENT;
	command(LCD_ENTRYMODESET | _displaymode);
}

// Allows us to fill the first 8 CGRAM locations
// with custom characters
void LiquidCrystal_I2C::createChar(uint8_t location, uint8_t charmap[]) {
	location &= 0x7; // we only have 8 locations 0-7
	command(LCD_SETCGRAMADDR | (location << 3));
	for (int i=0; i<8; i++) {
		write(charmap[i]);
	}
}

// Turn the (optional) backlight off/on
void LiquidCrystal_I2C::noBacklight(void) {
	_backlightval=LCD_NOBACKLIGHT;
	expanderWrite(0);
}

void LiquidCrystal_I2C::backlight(void) {
	_backlightval=LCD_BACKLIGHT;
	expanderWrite(0);
}



/*********** mid level commands, for sending data/cmds */

inline void LiquidCrystal_I2C::command(uint8_t value) {
	send(value, 0);
}

inline size_t LiquidCrystal_I2C::write(uint8_t value) {
	send(value, Rs);
	return 1; // Number of processed bytes
}



/************ low level data pushing commands **********/

// write either command or data
void LiquidCrystal_I2C::send(uint8_t value, uint8_t mode) {
	uint8_t highnib = value & 0xF0;
	uint8_t lownib = value << 4;
	write4bits((highnib)|mode);
	write4bits((lownib)|mode);
}

void LiquidCrystal_I2C::write4bits(uint8_t value) {
	expanderWrite(value);
	pulseEnable(value);
}

void LiquidCrystal_I2C::expanderWrite(uint8_t _data){                                        
	Wire2.beginTransmission(_Addr);
	Wire2.write((int)(_data) | _backlightval);
	Wire2.endTransmission();   
}

void LiquidCrystal_I2C::pulseEnable(uint8_t _data){
	expanderWrite(_data | En);	// En high
	delayMicroseconds(1);		// enable pulse must be >450ns
	
	expanderWrite(_data & ~En);	// En low
	delayMicroseconds(50);		// commands need > 37us to settle
} 

// Create custom characters for horizontal graphs
uint8_t LiquidCrystal_I2C::graphHorizontalChars(uint8_t rowPattern) {
  uint8_t cc[LCD_CHARACTER_VERTICAL_DOTS];
  for (uint8_t idxCol = 0; idxCol < LCD_CHARACTER_HORIZONTAL_DOTS; idxCol++) {
    for (uint8_t idxRow = 0; idxRow < LCD_CHARACTER_VERTICAL_DOTS; idxRow++) {
      cc[idxRow] = rowPattern << (LCD_CHARACTER_HORIZONTAL_DOTS - 1 - idxCol);
    }
    createChar(idxCol, cc);
  }
  return LCD_CHARACTER_HORIZONTAL_DOTS;
}

// Create custom characters for vertical graphs
uint8_t LiquidCrystal_I2C::graphVerticalChars(uint8_t rowPattern) {
  uint8_t cc[LCD_CHARACTER_VERTICAL_DOTS];
  for (uint8_t idxChr = 0; idxChr < LCD_CHARACTER_VERTICAL_DOTS; idxChr++) {
    for (uint8_t idxRow = 0; idxRow < LCD_CHARACTER_VERTICAL_DOTS; idxRow++) {
      cc[LCD_CHARACTER_VERTICAL_DOTS - idxRow - 1] = idxRow > idxChr ? B00000 : rowPattern;
    }
    createChar(idxChr, cc);
  }
  return LCD_CHARACTER_VERTICAL_DOTS;
}

// Initializes custom characters for input graph type
uint8_t LiquidCrystal_I2C::init_bargraph(uint8_t graphtype) {
  // Initialize row state vector
  for(byte i = 0; i < _rows; i++) {
    _graphstate[i] = 255;
  }
	switch (graphtype) {
		case LCDI2C_VERTICAL_BAR_GRAPH:
      graphVerticalChars(B11111);
      // Initialize column state vector
      for(byte i = _rows; i < _cols; i++) {
        _graphstate[i] = 255;
      }
			break;
		case LCDI2C_HORIZONTAL_BAR_GRAPH:
      graphHorizontalChars(B11111);
			break;
		case LCDI2C_HORIZONTAL_LINE_GRAPH:
      graphHorizontalChars(B00001);
			break;
		default:
			return 1;
	}
  _graphtype = graphtype;
	return 0;
}

// Display horizontal graph from desired cursor position with input value
void LiquidCrystal_I2C::draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len, uint8_t pixel_col_end) {
  // Maintain input parameters
  row = constrain(row, 0, _rows - 1);
  column = constrain(column, 0, _cols - 1);
  len = constrain(len, 0, _cols - column);
  pixel_col_end = constrain(pixel_col_end, 0, (len * LCD_CHARACTER_HORIZONTAL_DOTS) - 1);
  _graphstate[row] = constrain(_graphstate[row], column, column + len - 1);
  // Display graph
  switch (_graphtype) {
    case LCDI2C_HORIZONTAL_BAR_GRAPH:
      setCursor(column, row);
      // Display full characters
      for (uint8_t i = 0; i < pixel_col_end / LCD_CHARACTER_HORIZONTAL_DOTS; i++) {
        write(LCD_CHARACTER_HORIZONTAL_DOTS - 1);
        column++;
      }
      // Display last character
      write(pixel_col_end % LCD_CHARACTER_HORIZONTAL_DOTS);
      // Clear remaining chars in segment
      for (uint8_t i = column; i < _graphstate[row]; i++) write(' ');
      // Last drawn column as graph state
      _graphstate[row] = column;
      break;
    case LCDI2C_HORIZONTAL_LINE_GRAPH:
      // Drawn column as graph state
      column += pixel_col_end / LCD_CHARACTER_HORIZONTAL_DOTS;
      // Clear previous drawn character if differs from new one
      if (_graphstate[row] != column) {
        setCursor(_graphstate[row], row);
        write(' ');
        _graphstate[row] = column;
      }
      // Display graph character
      setCursor(column, row);
      write(pixel_col_end % LCD_CHARACTER_HORIZONTAL_DOTS);
      break;
		default:
			return;
  }
}
// Display horizontal graph from desired cursor position with input value
void LiquidCrystal_I2C::draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_row_end) {
  // Maintain input parameters
  row = constrain(row, 0, _rows - 1);
  column = constrain(column, 0, _cols - 1);
  len = constrain(len, 0, row + 1);
  pixel_row_end = constrain(pixel_row_end, 0, (len * LCD_CHARACTER_VERTICAL_DOTS) - 1);
  _graphstate[column] = constrain(_graphstate[column], row - len + 1, row);
  // Display graph
	switch (_graphtype) {
    case LCDI2C_VERTICAL_BAR_GRAPH:
      // Display full characters
      for (uint8_t i = 0; i < pixel_row_end / LCD_CHARACTER_VERTICAL_DOTS; i++) {
        setCursor(column, row--);
        write(LCD_CHARACTER_VERTICAL_DOTS - 1);
      }
      // Display the highest character
      setCursor(column, row);
      write(pixel_row_end % LCD_CHARACTER_VERTICAL_DOTS);
      // Clear remaining top chars in column
      for (uint8_t i = _graphstate[column]; i < row; i++) {
        setCursor(column, i);
        write(' ');
      }
      _graphstate[column] = row; // Last drawn row as its state
      break;
		default:
			return;
  }
}
// Overloaded methods
void LiquidCrystal_I2C::draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len, uint16_t percentage) {
  percentage = (percentage * len * LCD_CHARACTER_HORIZONTAL_DOTS / 100) - 1;
  draw_horizontal_graph(row, column, len, (uint8_t) percentage);
}
void LiquidCrystal_I2C::draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len, float ratio) {
  ratio = (ratio * len * LCD_CHARACTER_HORIZONTAL_DOTS) - 1;
  draw_horizontal_graph(row, column, len, (uint8_t) ratio);
}
void LiquidCrystal_I2C::draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint16_t percentage) {
  percentage = (percentage * len * LCD_CHARACTER_VERTICAL_DOTS / 100) - 1;
  draw_vertical_graph(row, column, len, (uint8_t) percentage);
}
void LiquidCrystal_I2C::draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  float ratio) {
  ratio = (ratio * len * LCD_CHARACTER_VERTICAL_DOTS) - 1;
  draw_vertical_graph(row, column, len, (uint8_t) ratio);
}

// Alias functions

void LiquidCrystal_I2C::on(){
	display();
}

void LiquidCrystal_I2C::off(){
	noDisplay();
}

void LiquidCrystal_I2C::cursor_on(){
	cursor();
}

void LiquidCrystal_I2C::cursor_off(){
	noCursor();
}

void LiquidCrystal_I2C::blink_on(){
	blink();
}

void LiquidCrystal_I2C::blink_off(){
	noBlink();
}

void LiquidCrystal_I2C::load_custom_character(uint8_t char_num, uint8_t *rows){
		createChar(char_num, rows);
}

void LiquidCrystal_I2C::setBacklight(uint8_t new_val){
	if(new_val){
		backlight();		// turn backlight on
	}else{
		noBacklight();		// turn backlight off
	}
}

void LiquidCrystal_I2C::printstr(const char c[]){
	//This function is not identical to the function used for "real" I2C displays
	//it's here so the user sketch doesn't have to be changed 
	print(c);
}

LiquidCrystal_I2C.cpp

/*
  NAME:
  LiquidCrystal_I2C

  DESCRIPTION:
  Library for parallel HD44780 compatible LCDs interfaced via a Chinese
  PCF8574 I2C serial extender.
  - Library implements LCD API 1.0 to the extend the appropriate LCDs
    support functionality expected by the API.
  - Library adds overloaded clear() function for clearing particular
    segment of an input row.
  - Library implements extended graph functions with help of custom 
    characters, so that do not use your custom characters concurrently
    with graph function. Your custom characters will be overwritten by
    graph initialization.
  - Library adds overloaded graph functions for expression graph value
    in percentage instead of pixels.

  LICENSE:
  This program is free software; you can redistribute it and/or modify
  it under the terms of the MIT License (MIT).
    
  CREDENTIALS:
  Author: Libor Gabaj
  GitHub: https://github.com/mrkaleArduinoLib/LiquidCrystal_I2C.git
  
  CREDITS:
  Mario H. atmega@xs4all.nl - LiquidCrystal_I2C V2.0
  Murray R. Van Luyn. vanluynm@iinet.net.au - Mods for Chinese I2C converter board
 */
#ifndef LIQUIDCRYSTAL_I2C_H
#define LIQUIDCRYSTAL_I2C_H
#define LIQUIDCRYSTAL_I2C_VERSION "LiquidCrystal_I2C 2.6.1"

#include "Arduino.h"

// 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 display/cursor shift
#define LCD_DISPLAYMOVE 0x08
#define LCD_CURSORMOVE 0x00
#define LCD_MOVERIGHT 0x04
#define LCD_MOVELEFT 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

// flags for backlight control
#define LCD_BACKLIGHT   B00001000
#define LCD_NOBACKLIGHT B00000000

// values for graphtype in calls to init_bargraph and character geometry
#define LCDI2C_VERTICAL_BAR_GRAPH    1
#define LCDI2C_HORIZONTAL_BAR_GRAPH  2
#define LCDI2C_HORIZONTAL_LINE_GRAPH 3
#define LCD_CHARACTER_HORIZONTAL_DOTS 5
#define LCD_CHARACTER_VERTICAL_DOTS   8

#define En B00000100  // Enable bit
#define Rw B00000010  // Read/Write bit
#define Rs B00000001  // Register select bit

class LiquidCrystal_I2C : public Print {
public:
  LiquidCrystal_I2C(uint8_t addr, uint8_t cols, uint8_t rows);
  void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS);
  void init();
/*
  Clear particular segment of a row
  
  DESCRIPTION:
  Overloaded original function clear().
  * Thanks to default  parameters, for clearing the entire row
    use just clear(rowStart).
  * The functions sets the cursor to start column and row after clearing.
  
  PARAMETERS:
  rowStart  - row number to be cleared counting from 0.
              Limited to the last row.
  colStart  - column number of the cleared segment counting from 0.
              Defaulted to the very begining of the row.
              Limited to the last character.
  colCnt    - number of cleared characters.
              Defaulted to 255.
              Limited to remaining characters on the row.
  
  RETURN:	none
*/
  void clear();
  void clear(uint8_t rowStart, uint8_t colStart = 0, uint8_t colCnt = 255);
  void home();
  void noDisplay();
  void display();
  void noBlink();
  void blink();
  void noCursor();
  void cursor();
  void scrollDisplayLeft();
  void scrollDisplayRight();
  void leftToRight();
  void rightToLeft();
  void noBacklight();
  void backlight();
  void noAutoscroll(); 
  void autoscroll();
  void createChar(uint8_t location, uint8_t charmap[]);
  void setCursor(uint8_t col, uint8_t row); 
  virtual size_t write(uint8_t value);
  void command(uint8_t value);

/*
  Initialize particular bar graph
  
  DESCRIPTION:
  Creates a set of custom characters for displaying bar graphs.
  Some number of first current custom characters will be overwritten
  according to the type of graph.

  PARAMETERS:
  uint8_t graphtype - type of graph
    LCDI2C_VERTICAL_BAR_GRAPH    - rewrites all 8 custom characters
    LCDI2C_HORIZONTAL_BAR_GRAPH  - rewrites first 5 custom characters
    LCDI2C_HORIZONTAL_LINE_GRAPH - rewrites first 5 custom characters

  RETURN:	error code
          0 - at success
          1 - at failure, e.g., graph type not recognized
*/
uint8_t init_bargraph(uint8_t graphtype);

/*
  Display horizontal graph from desired cursor position with input value
  
  DESCRIPTION:
  Displays horizontal bar or running pipe starting at input cursor position
  composed of custom characters.
  * For graph is reserved "len" characters long segment on the "row" starting
    on "column".
  * Current value of the bar graph is displayed as "pixel_col_end" pipes
    in the graph segment.
  * Current value of the line graph is displayed as pipe on "pixel_col_end"
    dot position in the graph segment.
  * Zero value of the graph is displayed as the very left pipe in the
    graph segment, so that the graph always displays something.
  
  PARAMETERS:
  uint8_t row           - row position of graph segment counting from 0
                          Limited to physical rows.
  uint8_t column        - column position of graph segment counting from 0
                          Limited to physical columns.
  uint8_t len           - length of graph segment in characters
                          Limited to remaining physical columns from col position.
  uint8_t pixel_col_end - value of graph in pipes counting from 0
                          Limited to physical horizontal dots of graph segment.
  
  RETURN:	none
*/
void draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len, uint8_t pixel_col_end);

/*
  Display vertical graph from desired cursor position with input value
  
  DESCRIPTION:
  Displays vertical bar starting at "row", "column" position composed
  of custom characters.
  For bar is reserved "len" rows long segment on the "column" starting on
  "row".
  Current value of the bar graph is displayed as "pixel_row_end" dashes
  from bottom to top of the graph segment.
  
  PARAMETERS:
  uint8_t row           - row positon of the bottom of a graph segment
													counting from 0
                          Limited to physical rows.
  uint8_t column        - column position of graph segment counting from 0
                          Limited to physical columns.
  uint8_t len           - length of graph segment in rows
                          Limited to remaining physical rows from row position.
  uint8_t pixel_row_end - value of graph in dashes counting from 0
                          Limited to physical vertical dots of graph segment.
  
  RETURN:	none
*/
void draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_row_end);

/*
  Overloaded methods with type difference of graph value
  
  PARAMETERS:
  uint16_t percentage - percentage of graph segment as graph value
    Although expected range is 0 to 100, uint8_t has been reserved
    by official API already.
  float ratio - fraction of graph segment as graph value
    Expected range is 0.0 to 1.0
*/
void draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len, uint16_t percentage);
void draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len, float ratio);
void draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint16_t percentage);
void draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  float ratio);

////compatibility API function aliases
void on();                          // alias for display()
void off();                         // alias for noDisplay()
void blink_on();						        // alias for blink()
void blink_off();       					  // alias for noBlink()
void cursor_on();      	 					  // alias for cursor()
void cursor_off();      					  // alias for noCursor()
void setBacklight(uint8_t new_val);	// alias for backlight() and nobacklight()
void load_custom_character(uint8_t char_num, uint8_t *rows);	// alias for createChar()
void printstr(const char[]);

/* Unsupported API functions (not implemented in this library)
uint8_t status();
void setContrast(uint8_t new_val);
uint8_t keypad();
void setDelay(int, int);
*/

private:
  void init_priv();
  void send(uint8_t, uint8_t);
  void write4bits(uint8_t);
  void expanderWrite(uint8_t);
  void pulseEnable(uint8_t);

/*
  Create custom characters for horizontal graphs
  
  DESCRIPTION:
  Creates the set of custom characters for displaying horizontal graphs.
  The first 5 current custom characters will be overwritten.
  Particular custom characters are filled by bit shifting fullCharRowPattern
  from the right to the left.
  
  PARAMETERS:
  uint8_t rowPattern - row pattern of the full character

  RETURN:	uint8_t - number of created custom characters
*/
  uint8_t graphHorizontalChars(uint8_t rowPattern);

/*
  Create custom characters for vertical graphs
  
  DESCRIPTION:
  Creates the set of custom characters for displaying vertical graphs.
  All 8 current custom characters will be overwritten.
  Particular custom characters are filled with rowPattern from the very
  bottom pixel line.
  
  PARAMETERS:
  uint8_t rowPattern - row pattern of the pixel line

  RETURN:	uint8_t - number of created custom characters
*/
  uint8_t graphVerticalChars(uint8_t rowPattern);

  // Private attributes
  uint8_t _Addr;
  uint8_t _displayfunction;
  uint8_t _displaycontrol;
  uint8_t _displaymode;
  uint8_t _numlines;
  uint8_t _cols;
  uint8_t _rows;
  uint8_t _backlightval;
  uint8_t _graphtype;   // Internal code for graph type
  uint8_t _graphstate[20];  // Internal last graph column/row state
};

#endif

LiquidCrystal_I2C.h

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

# Automatically added based on includes:
LiquidCrystal I2C
# ---
