Wgranie zmian do repozytorium

2026-05-10 16:46:04 +02:00
commit f171113450
1607 changed files with 254616 additions and 0 deletions
--- a/lib/LiquidCrystal_I2C/LICENSE
+++ b/lib/LiquidCrystal_I2C/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Libor Gabaj
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
--- a/lib/LiquidCrystal_I2C/README.md
+++ b/lib/LiquidCrystal_I2C/README.md
@@ -0,0 +1,858 @@
+<a id="library"></a>
+# LiquidCrystal_I2C
+It is the reimplementation of the standard Arduino LCD library, configured to work with parallel HD44780 compatible LCDs, and interfaced via a Chinese PCF8574 I2C serial extender.
+
+
+<a id="credit"></a>
+## Credit
+The reimplementation has been inspired by and credit goes to:
+
+- Mario H. atmega@xs4all.nl LiquidCrystal_I2C V2.0
+- Murray R. Van Luyn vanluynm@iinet.net.au Mods for Chinese I2C converter board
+
+
+<a id="dependency"></a>
+## Dependency
+The library class extends the system library *Print* and includes following sytem header files.
+
+- **inttypes.h**: Integer type conversions. This header file includes the exact-width integer definitions and extends them with additional facilities provided by the implementation.
+- **Print.h**: Base class that provides *print()* and *println()*.
+- **Wire.h**: TWI/I2C library for Arduino & Wiring.
+
+
+<a id="interface"></a>
+## Interface
+Some of listed functions come out of Arduino [LCD API 1.0](http://playground.arduino.cc/Code/LCDAPI), some of them are specific for this library. It is possible to use functions from the system library [Print](#dependency), which is extended by the *LiquidCrystal_I2C*.
+
+*) The function is an alias of another (usually previous) one.
+
+##### Initialization
+- [LiquidCrystal_I2C()](#LiquidCrystal_I2C)
+- [begin()](#begin)
+- [init()](#init)
+- [clear()](#clear)
+- [home()](#home)
+
+##### Printing
+- [print()](#print)
+- [write()](#write)
+
+##### Display control
+- [noDisplay()](#noDisplay)
+- *[off()](#noDisplay)
+- [display()](#display)
+- *[on()](#display)
+- [scrollDisplayLeft()](#scrollDisplayLeft)
+- [scrollDisplayRight()](#scrollDisplayRight)
+- [leftToRight()](#leftToRight)
+- [rightToLeft()](#rightToLeft)
+- [noAutoscroll()](#noAutoscroll)
+- [autoscroll()](#autoscroll)
+- [noBacklight()](#noBacklight)
+- [backlight()](#backlight)
+- *[setBacklight()](#backlight)
+
+##### Cursor manipulation
+- [noCursor()](#noCursor)
+- *[cursor_off()](#noCursor)
+- [cursor()](#cursor)
+- *[cursor_on()](#cursor)
+- [noBlink()](#noBlink)
+- *[blink_off()](#noBlink)
+- [blink()](#blink)
+- *[blink_on()](#blink)
+- [setCursor()](#setCursor)
+
+##### Graphs
+- [init_bargraph()](#init_bargraph)
+- [draw_horizontal_graph()](#draw_horizontal_graph)
+- [draw_vertical_graph()](#draw_vertical_graph)
+
+##### Utilities
+- [createChar()](#createChar)
+- *[load_custom_character()](#createChar)
+- [command()](#command)
+
+
+<a id="LiquidCrystal_I2C"></a>
+## LiquidCrystal_I2C()
+#### Description
+Constructor of the object controlling an LCD. It defines address of the LCD and its geometry.
+
+- More LCDs can be connected to the same I2C bus if they are hardware configured for different addresses.
+- For each of LCDs the separate object has to be created. 
+- When the display powers up, it is configured as follows:
+
+1. Display clear
+1. Function set: 
+	- DL = 1; 8-bit interface data 
+	- N = 0; 1-line display 
+	- F = 0; 5x8 dot character font 
+1. Display on/off control: 
+	- D = 0; Display off 
+	- C = 0; Cursor off 
+	- B = 0; Blinking off 
+1. Entry mode set: 
+	- I/D = 1; Increment by 1
+	- S = 0; No shift 
+
+- Note, however, that resetting the Arduino does not reset the LCD, so we cannot assume that it is in that state when a sketch starts (and the constructor is called).
+
+#### Syntax
+	LiquidCrystal_I2C(uint8_t addr, uint8_t cols, uint8_t rows);
+
+#### Parameters
+- **addr**: I2C addres of the LCD predefined by the serial extender.
+	- *Valid values*: unsigned byte
+	- *Default value*: none
+	- *Usual values*:
+		- **0x3F** for LCDs *2004* with 20 columns and 4 rows.
+		- **0x27** for LCDs *1602* with 16 columns and 2 rows.
+
+
+<a id="prm_cols"></a>
+- **cols**: Number of characters in a row defined by the hardware construction of the LCD screen.
+	- *Valid values*: unsigned byte
+	- *Default value*: none
+	- *Usual values*: 20, 16, 8
+
+
+<a id="prm_rows"></a>
+- **rows**: Number of rows in the LCD screen defined by the hardware construction of the LCD.
+	- *Valid values*: unsigned byte
+	- *Default value*: none
+	- *Usual values*: 4, 2, 1
+
+#### Returns
+- **LCD object**: Object controlling the LCD communicating at defined address.
+
+#### Example
+
+``` cpp
+lcd = LiquidCrystal_I2C(0x27, 16, 2);
+```
+
+[Back to interface](#interface)
+
+
+<a id="begin"></a>
+## begin()
+#### Description
+Initialize the LCD with its specific geometry parameters.
+
+#### Syntax
+	void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS);
+
+#### Parameters
+- **cols**: Number of characters in a row defined by the hardware construction of the LCD screen.
+	- *Valid values*: unsigned byte
+	- *Default value*: none
+	- *Usual values*: 20, 16, 8
+
+
+- **rows**: Number of rows in the LCD screen defined by the hardware construction of the LCD.
+	- *Valid values*: unsigned byte
+	- *Default value*: none
+	- *Usual values*: 4, 2, 1
+
+
+- **charsize**: Geometry of the LCD's character defined by a library constant. 
+	- *Valid values*: unsigned byte LCD_5x8DOTS, LCD_5x10DOT 
+	- *Default value*: LCD_5x8DOTS
+
+#### Returns
+None
+
+#### See also
+[LiquidCrystal_I2C()](#LiquidCrystal_I2C)
+
+[init()](#init)
+
+[Back to interface](#interface)
+
+
+<a id="init"></a>
+## init()
+#### Description
+Initializes the display with values put to the [constructor](LiquidCrystal_I2C), clears the screen, and puts cursor to the upper left corner of the screen, i.e., to the home position 0,0. It is a wrapper function for function [begin()](#begin) with forgoing initialization of [Wire](#dependecy) library.
+
+#### Syntax
+	void init();
+
+#### Parameters
+None
+
+#### Returns
+None
+
+#### See also
+[LiquidCrystal_I2C()](#LiquidCrystal_I2C)
+
+[begin()](#begin)
+
+[Back to interface](#interface)
+
+
+<a id="clear"></a>
+## clear()
+#### Description
+Overloaded function for clearing the entire LCD screen or just a part of a row.
+- Using the function without any parameters clears the entire srceen.
+- For clearing the entire row use the function just with the first parameter.
+- The functions sets the cursor to the start column and row after clearing, i.e., after calling without parameters to the home position (0, 0), or after calling with parameters to the starts of cleared row segment.
+
+#### Syntax
+	void clear();
+	void clear(uint8_t rowStart, uint8_t colStart = 0, uint8_t colCnt = 255);
+
+#### Parameters
+- **rowStart**: Number of a row to be cleared counting from 0.
+	- *Valid values*: unsigned byte 0 to [rows - 1](#prm_rows) of the [constructor](#LiquidCrystal_I2C)
+	- *Default value*: none
+
+
+- **colStart**: Order number of the first character in a cleared row counting from 0, which the cleared segment starts from.
+	- *Valid values*: unsigned byte 0 to [cols - 1](#prm_cols) of the [constructor](#LiquidCrystal_I2C)
+	- *Default value*: 0 (start of a row)
+
+
+- **colCnt**: Number of cleared characters in a cleard row. 
+	- *Valid values*: unsigned byte 0 to [cols](#prm_cols) of the [constructor](#LiquidCrystal_I2C) 
+	- *Default value*: 255, but internally limited to (*cols* - *colStart*)
+
+#### Returns
+None
+
+#### See also
+[LiquidCrystal_I2C()](#LiquidCrystal_I2C)
+
+[Back to interface](#interface)
+
+
+<a id="home"></a>
+## home()
+#### Description
+Places the cursor to the home position (0, 0) and leaves displayed characters.
+
+#### Syntax
+	void init();
+
+#### Parameters
+None
+
+#### Returns
+None
+
+#### See also
+[LiquidCrystal_I2C()](#LiquidCrystal_I2C)
+
+[clear()](#clear)
+
+[Back to interface](#interface)
+
+
+<a id="print"></a>
+## print()
+#### Description
+Prints text or number to the LCD. It is inhereted function from the parent system one. The function is overloaded and acts according the data type of the input data to be printed.
+
+#### Syntax
+	byte print(char|byte|int|long|string data, int base);
+
+#### Parameters
+- **data**: String or number that should be printed on the LCD from current cursor position.
+	- *Valid values*: arbitrary
+	- *Default value*: none
+
+
+- **base**: Optional base in which to print numbers.
+	- *Valid values*: integer in form of preprocesor constants
+	    - BIN: binary base 2
+	    - DEC: decimal base 10
+	    - OCT: octal base 8
+	    - HEX hexadecimal base 16
+	- *Default value*: string
+
+#### Returns
+- **ProcessBytes**: Number of successfully printed bytes.
+
+#### Example
+
+``` cpp
+lcd = LiquidCrystal_I2C(0x27, 16, 2);
+void setup()
+{
+  lcd.print("Hello, world!");
+  lcd.setCursor(0, 1);
+  lcd.print(128, HEX);
+}
+
+void loop() {}
+```
+	>Hello, world!
+	>80
+
+
+#### See also
+[write()](#write)
+
+[setCursor()](#setCursor)
+
+[LiquidCrystal_I2C()](#LiquidCrystal_I2C)
+
+[Back to interface](#interface)
+
+
+<a id="write"></a>
+## write()
+#### Description
+Writes a raw value to the display.
+
+#### Syntax
+	size_t write(uint8_t value);
+
+#### Parameters
+- **value**: Value that should be write to the LCD at address set before.
+	- *Valid values*: unsigned byte
+	- *Default value*: none
+
+#### Returns
+- **ProcessBytes**: Number of successfully processed bytes; always 1.
+
+#### See also
+[print()](#print)
+
+[command()](#command)
+
+[Back to interface](#interface)
+
+
+<a id="noDisplay"></a>
+## noDisplay()
+#### Description
+Turns the display off quickly. If the display does not have an option to turn on the display, the function just turns backlight on.
+
+#### Syntax
+	void noDisplay();
+
+#### Alias
+	void off();
+
+#### Parameters
+None
+
+#### Returns
+None
+
+#### See also
+[display()](#display)
+
+[Back to interface](#interface)
+
+
+<a id="display"></a>
+## display()
+#### Description
+Turns the display on quickly. If the display does not have an option to turn off the display, the function just turns backlight off.
+
+#### Syntax
+	void display();
+
+#### Alias
+	void on();
+
+#### Parameters
+None
+
+#### Returns
+None
+
+#### See also
+[noDisplay()](#noDisplay)
+
+[Back to interface](#interface)
+
+
+<a id="scrollDisplayLeft"></a>
+## scrollDisplayLeft()
+#### Description
+Scrolls the display text to the left without changing the RAM. The function scrolls entire 40 character buffer. If you print 40 characters to a row and start scrolling, you get continuous moving banner in a row especially on 1602 LCDs.
+
+#### Syntax
+	void scrollDisplayLeft();
+
+#### Parameters
+None
+
+#### Returns
+None
+
+#### See also
+[scrollDisplayRight()](#scrollDisplayRight)
+
+[Back to interface](#interface)
+
+
+<a id="scrollDisplayRight"></a>
+## scrollDisplayRight()
+#### Description
+Scrolls the display text to the right without changing the RAM. The function scrolls entire 40 character buffer. If you print 40 characters to a row and start scrolling, you get continuous moving banner in a row especially on 1602 LCDs.
+
+#### Syntax
+	void scrollDisplayRight();
+
+#### Parameters
+None
+
+#### Returns
+None
+
+#### See also
+[scrollDisplayLeft()](#scrollDisplayLeft)
+
+[Back to interface](#interface)
+
+
+<a id="leftToRight"></a>
+## leftToRight()
+#### Description
+Sets the flow of text from left to right as it is normal for Latin languages.
+
+#### Syntax
+	void leftToRight();
+
+#### Parameters
+None
+
+#### Returns
+None
+
+#### See also
+[rightToLeft()](#rightToLeft)
+
+[Back to interface](#interface)
+
+
+<a id="rightToLeft"></a>
+## rightToLeft()
+#### Description
+Sets the flow of text from right to left as it is normal for Arabic languages.
+
+#### Syntax
+	void rightToLeft();
+
+#### Parameters
+None
+
+#### Returns
+None
+
+#### See also
+[leftToRight()](#leftToRight)
+
+[Back to interface](#interface)
+
+
+<a id="noAutoscroll"></a>
+## noAutoscroll()
+#### Description
+Justifies the text from the cursor to the left.
+
+#### Syntax
+	void noAutoscroll();
+
+#### Parameters
+None
+
+#### Returns
+None
+
+#### See also
+[autoscroll()](#autoscroll)
+
+[Back to interface](#interface)
+
+
+<a id="autoscroll"></a>
+## autoscroll()
+#### Description
+Justifies the text from the cursor to the right.
+
+#### Syntax
+	void autoscroll();
+
+#### Parameters
+None
+
+#### Returns
+None
+
+#### See also
+[noAutoscroll()](#noAutoscroll)
+
+[Back to interface](#interface)
+
+
+<a id="noBacklight"></a>
+## noBacklight()
+#### Description
+Turns the backlight off.
+
+#### Syntax
+	void noBacklight();
+
+#### Alias
+  void setBacklight(0);
+
+#### Parameters
+None
+
+#### Returns
+None
+
+#### See also
+[backlight()](#backlight)
+
+[Back to interface](#interface)
+
+
+<a id="backlight"></a>
+## backlight()
+#### Description
+Turns the backlight on.
+
+#### Syntax
+	void backlight();
+
+#### Alias
+  void setBacklight(1);
+
+#### Parameters
+None
+
+#### Returns
+None
+
+#### See also
+[noBacklight()](#noBacklight)
+
+[Back to interface](#interface)
+
+
+<a id="noCursor"></a>
+## noCursor()
+#### Description
+Turns the block cursor off.
+
+#### Syntax
+	void noCursor();
+
+#### Alias
+	void cursor_off();
+
+#### Parameters
+None
+
+#### Returns
+None
+
+#### See also
+[cursor()](#cursor)
+
+[Back to interface](#interface)
+
+
+<a id="cursor"></a>
+## cursor()
+#### Description
+Turns the block cursor on.
+
+#### Syntax
+	void cursor();
+
+#### Alias
+	void cursor_on();
+
+#### Parameters
+None
+
+#### Returns
+None
+
+#### See also
+[noCursor()](#noCursor)
+
+[Back to interface](#interface)
+
+
+<a id="noBlink"></a>
+## noBlink()
+#### Description
+Turns on the blinking underline cursor.
+
+#### Syntax
+	void noBlink();
+
+#### Alias
+	void blink_off();
+
+#### Parameters
+None
+
+#### Returns
+None
+
+#### See also
+[blink()](#blink)
+
+[Back to interface](#interface)
+
+
+<a id="blink"></a>
+## blink()
+#### Description
+Turns off the blinking underline cursor.
+
+#### Syntax
+	void blink();
+
+#### Alias
+	void blink_on();
+
+#### Parameters
+None
+
+#### Returns
+None
+
+#### See also
+[noBlink()](#noBlink)
+
+[Back to interface](#interface)
+
+
+<a id="setCursor"></a>
+## setCursor()
+#### Description
+Fills the first 8 character generator RAM (CGRAM) locations with custom characters.
+
+#### Syntax
+	void setCursor(uint8_t col, uint8_t row);
+
+#### Parameters
+- **col**: Number of a column where the cursor will be located counting from 0.
+	- *Valid values*: unsigned byte 0 to [cols - 1](#prm_cols) of the [constructor](#LiquidCrystal_I2C)
+	- *Default value*: none
+
+	
+- **row**: Number of a row where the cursor will be located counting from 0.
+	- *Valid values*: unsigned byte 0 to [rows - 1](#prm_rows) of the [constructor](#LiquidCrystal_I2C) 
+	- *Default value*: none
+
+#### Returns
+None
+
+#### See also
+[home()](#home)
+
+[Back to interface](#interface)
+
+
+<a id="init_bargraph"></a>
+## init_bargraph()
+#### Description
+Initializes particular bar graph. The function creates a set of custom
+characters for displaying bar graphs. Some number of first current custom
+characters (5 or 8) will be overwritten according to the type of graph.
+
+#### Syntax
+	uint8_t init_bargraph(uint8_t graphtype);
+
+#### Parameters
+- **graphtype**: Type of a graph.
+	- *Valid values*: unsigned integer
+		- 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
+	- *Default value*: none
+
+#### Returns
+- **ResultCode**: Numeric code determining processing of the initialization.
+	- 0: success
+	- 1: failure, e.g., not recognized graph type
+
+#### See also
+[draw_horizontal_graph()](#draw_horizontal_graph)
+
+[draw_vertical_graph()](#draw_vertical_graph)
+
+[Back to interface](#interface)
+
+
+<a id="draw_horizontal_graph"></a>
+## draw_horizontal_graph()
+#### Description
+Displays horizontal graph from desired cursor position with input value.
+- The bar graph is composed of solid, full rectangle characters eventually except final character with reduced vertical pipes. Value of the bar graph is displayed as equivalent number of pipes in the graph segment.
+- The line graph is composed of one pipe running across a LCD row. Value
+  of the bar graph is displayed as a pipe at equivalent dot position in the graph segment.
+- The function is overloaded by data type of a displayed graph value, which
+  determines its form.
+- Zero value of the graph is displayed as the very left pipe in the	graph segment due to counting from 0, so that the graph always displays something.
+  
+#### Syntax
+	void draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len, uint8_t pixel_col_end);
+	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);
+
+#### Parameters
+- **row**: Row positon of graph segment counting from 0 to physical number of rows.
+	- *Valid values*: non-negative integer 0 to [rows - 1](#prm_rows) of the [constructor](#LiquidCrystal_I2C) 
+	- *Default value*: none
+
+	
+- **col**: Column position of graph segment counting from 0 physical number of columns on a row.
+	- *Valid values*: non-negative integer 0 to [cols - 1](#prm_cols) of the [constructor](#LiquidCrystal_I2C)
+	- *Default value*: none
+
+	
+- **len**: Length of a graph segment in characters limited to remaining	physical columns from starting *col* position.
+	- *Valid values*: non-negative integer 0 to [cols - col](#prm_cols) of the [constructor](#LiquidCrystal_I2C)
+	- *Default value*: none
+
+	
+- **pixel_col_end**: Displayed value in pipes (horizontal dots) counting from 0 to number of pipes of the graph segment. A sketch should calculate the number of segment pipes in order to map an application value to displayed value.
+	- *Valid values*: non-negative integer 0 to 5 * *len*
+	- *Default value*: none
+
+	
+- **percentage**: Displayed value in percentage of a graph segment length. Accepted value is rounded to integer per cents.
+	- *Valid values*: non-negative integer 0 to 100
+	- *Default value*: none
+
+	
+- **ratio**: Displayed value as a fragment of a graph segment length.
+	- *Valid values*: non-negative decimal 0. to 1.
+	- *Default value*: none
+	
+#### Returns
+None
+
+#### See also
+[init_bargraph()](#init_bargraph)
+
+[draw_vertical_graph()](#draw_vertical_graph)
+
+[Back to interface](#interface)
+
+
+<a id="draw_vertical_graph"></a>
+## draw_vertical_graph()
+#### Description
+Displays vertical bar from desired cursor position with input value.
+- The bar graph is composed of solid, full rectangle characters eventually except final character with reduced horizontal dashes. Value of the bar	graph is displayed as equivalent number of dashes in the graph segment.
+- The function is overloaded by data type of a displayed graph value, which
+  determines its form.
+  
+#### Syntax
+	void draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len,  uint8_t pixel_row_end);
+	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);
+
+#### Parameters
+- **row**: Row positon of graph segment counting from 0 to physical limit.
+	- *Valid values*: non-negative integer 0 to [rows - 1](#prm_rows) of the [constructor](#LiquidCrystal_I2C) 
+	- *Default value*: none
+
+	
+- **col**: Column position of graph segment counting from 0 physical limit.
+	- *Valid values*: non-negative integer 0 to [cols - 1](#prm_cols) of the [constructor](#LiquidCrystal_I2C)
+	- *Default value*: none
+
+	
+- **len**: Length of a graph segment in rows limited to remaining physical rows from starting *row* position.
+	- *Valid values*: non-negative integer 0 to [row + 1](#prm_rows) of the [constructor](#LiquidCrystal_I2C)
+	- *Default value*: none
+
+	
+- **pixel_col_end**: Displayed value in dashes (vertical dots) counting	from 0 to	number of dashes of the graph segment. A sketch should calculate the number of segment dashes in order to map an application value to displayed value.
+	- *Valid values*: non-negative integer 0 to 8 * *len* or 10 * *len*
+	- *Default value*: none
+
+	
+- **percentage**: Displayed value in percentage of a graph segment length. Accepted value is rounded to integer per cents.
+	- *Valid values*: non-negative integer 0 to 100
+	- *Default value*: none
+
+	
+- **ratio**: Displayed value as a fragment of a graph segment length.
+	- *Valid values*: non-negative decimal 0. to 1.
+	- *Default value*: none
+	
+#### Returns
+None
+
+#### See also
+[init_bargraph()](#init_bargraph)
+
+[draw_horizontal_graph()](#draw_horizontal_graph)
+
+[Back to interface](#interface)
+
+
+<a id="createChar"></a>
+## createChar()
+#### Description
+Fills the first 8 character generator RAM (CGRAM) locations with custom characters.
+
+#### Syntax
+	void createChar(uint8_t, uint8_t[]);
+
+#### Alias
+  void load_custom_character(uint8_t char_num, uint8_t *rows);
+
+#### Parameters
+- **char_num**: Position of a custom character in CGRAM for custom chars.
+	- *Valid values*: 0 - 7
+	- *Default value*: none
+
+	
+- **uint8_t[]**: Array of custom characters definitions.
+	- *Valid values*: Character row byte patterns from the top of the char.
+		- Array length 8 bytes for 5x8 characters.
+		- Array length 10 bytes for 5x10 characters.
+	- *Default value*: none
+
+	
+- **rows**: Pointer to the array of custom characters definitions.
+
+#### Returns
+None
+
+#### See also
+[init_bargraph()](#init_bargraph)
+
+[Back to interface](#interface)
+
+
+<a id="command"></a>
+## command()
+#### Description
+Sends a command to the display. It is useful for commands not supported
+by the library.
+
+#### Syntax
+	void command(uint8_t value);
+
+#### Parameters
+- **value**: Command code that should be send to the LCD.
+	- *Valid values*: unsigned byte
+	- *Default value*: none
+
+#### Returns
+None
+
+#### See also
+[write()](#write)
+
+[Back to interface](#interface)
--- a/lib/LiquidCrystal_I2C/examples/Autoscroll/Autoscroll.ino
+++ b/lib/LiquidCrystal_I2C/examples/Autoscroll/Autoscroll.ino
@@ -0,0 +1,67 @@
+/*
+  NAME:
+  Demonstration of Autoscroll function
+
+  DESCRIPTION:
+  This sketch demonstrates the use of the autoscroll() and noAutoscroll()
+  functions to make new text scroll or not.
+  * The sketch is intended preferrably for 16x2 LCD, but can be configured
+    for 20x4 LCDs just by uncommenting and commenting related sections.
+  * The sketch is just for demonstration purposes, so that it is not
+    optimized for memory usage.
+
+  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
+  Version: 1.0.0
+  Updated: 20.03.2016
+  
+  CREDIT:
+  The example taken and rewritten for I2C from official Arduino standard library
+  (https://github.com/arduino/Arduino/tree/master/libraries/LiquidCrystal)
+*/
+#include <Wire.h>
+#include <LiquidCrystal_I2C.h>
+
+// LCD address and geometry and library initialization
+const byte lcdAddr = 0x27;  // Address of I2C backpack
+const byte lcdCols = 16;    // Number of character in a row
+const byte lcdRows = 2;     // Number of lines
+//const byte lcdAddr = 0x3F;  // Address of I2C backpack
+//const byte lcdCols = 20;    // Number of character in a row
+//const byte lcdRows = 4;     // Number of lines
+
+LiquidCrystal_I2C lcd(lcdAddr, lcdCols, lcdRows);
+
+// Demo parameters
+const byte lcdScrollRow = 0;          // Number of a demo row counting from 0
+const unsigned int digitDelay = 500;  // Miliseconds before displaying next digit
+
+// Function for displaying demo digits
+void printDigits() {
+  for (byte thisChar = 0; thisChar < 10; thisChar++) {
+    lcd.print(thisChar);
+    delay(digitDelay);
+  }
+}
+
+void setup() {
+  lcd.init();
+  lcd.backlight();
+}
+
+void loop() {
+  lcd.setCursor(0, lcdScrollRow);
+  printDigits();
+
+  // Set the cursor to the last column of the demo row and turn on autoscroll
+  lcd.setCursor(lcdCols, lcdScrollRow);
+  lcd.autoscroll();
+  printDigits();
+  lcd.noAutoscroll();
+  lcd.clear();
+}
+
--- a/lib/LiquidCrystal_I2C/examples/CompleteTest/CompleteTest.ino
+++ b/lib/LiquidCrystal_I2C/examples/CompleteTest/CompleteTest.ino
@@ -0,0 +1,162 @@
+/*
+  NAME:
+  Demo sketch for complete printing test of LCD
+
+  DESCRIPTION:
+  The sketch demonstrates capabalities of the LCD by displaying several
+  test.
+  * The sketch is intended preferrably for 16x2 LCD, but can be configured
+    for 20x4 LCDs just by uncommenting and commenting related sections.
+  * The sketch is just for demonstration purposes, so that it is not
+    optimized for memory usage.
+
+  LICENSE:
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the MIT License (MIT).
+  
+  CREDITS:
+  Inspired by the example LCD_Test in the library LCDi2cW
+  from "4-2-2009 dale@wentztech.com".
+    
+  CREDENTIALS:
+  Author: Libor Gabaj
+  Version: 1.1.0
+  Updated: 04.03.2015
+*/
+#include <Wire.h>
+#include <LiquidCrystal_I2C.h>
+
+// LCD address and geometry for LCD 1602
+const byte lcdAddr = 0x27;  // Typical address of I2C backpack for 1602
+const byte lcdCols = 16;    // Number of characters in a row of display
+const byte lcdRows = 2;     // Number of lines of display
+
+// LCD address and geometry for LCD 2004
+//const byte lcdAddr = 0x3F;  // Typical address of I2C backpack for 2004
+//const byte lcdCols = 20;    // Number of characters in a row of display
+//const byte lcdRows = 4;     // Number of lines of display
+
+// Initialize library and setting LCD geometry
+LiquidCrystal_I2C lcd(lcdAddr, lcdCols, lcdRows);
+
+// Demo constants
+const int testDelay = 500;  // Delay between tests in ms
+const int demoDelay = 3000;  // Delay between demos in ms
+const byte demoNumMin = 1;    // Range of demo tests
+const byte demoNumMax = 255;
+const byte charNumMin = 0;    // Code of first displayed character
+const byte charNumMax = 255;  // Code of last displayed character
+
+// Demo variables
+byte col, row;
+unsigned int demoNum, charNum;
+char buffer[lcdCols + 1];
+
+void setup() { 
+  // Initialize LCD
+  lcd.init();
+  lcd.backlight();  // Switch on the backlight LED, if any or wired
+}
+
+void loop()
+{
+  demoNum = max(demoNumMin, 1);
+  while(demoNum >= demoNumMin && demoNum <= demoNumMax) {
+    lcd.clear();
+    lcd.cursor_off();
+    lcd.blink_off();
+    sprintf(buffer, "%u.", demoNum);
+    lcd.print(buffer);
+    
+    switch (demoNum) {
+      case 1:
+        lcd.print(F("Hello World!"));
+        break;
+      case 2:
+        lcd.print(F("Dash Cursor"));
+        lcd.setCursor(0, 1);
+        lcd.cursor_on();
+        break;
+      case 3:
+        lcd.print (F("Block Cursor"));
+        lcd.setCursor(0, 1);
+        lcd.blink_on();
+        break;
+      case 4:
+        lcd.print(F("No Cursor"));
+        lcd.setCursor(0, 1);
+        break;
+      case 5:
+        lcd.print(F("Characters"));
+        lcd.cursor_on();
+        charNum = charNumMin;
+        while(charNum <= charNumMax) {
+          row = 1;
+          do {
+            lcd.clear(row);
+            col = 0;
+            lcd.setCursor(col, row);
+            do {
+              lcd.write(char(charNum++));
+              delay(testDelay);
+            } while(++col < lcdCols && charNum <= charNumMax);
+          } while(++row < lcdRows && charNum <= charNumMax);
+        }        
+        lcd.cursor_off();
+        break;
+      case 6:
+        for (byte row=0; row < lcdRows; row++) {
+          lcd.print(F("Line "));
+          lcd.print(row);
+          delay(testDelay);
+          lcd.setCursor(0, row + 1);
+        }
+        break;
+      case 7:
+        lcd.print(F("Count to 255"));
+        for (unsigned int i = 0; i < 256; i++) {
+          lcd.clear(1);
+          sprintf(buffer, "%03u 0x%02X %c", i, i, i);
+          lcd.print(buffer);
+          if (lcdCols >= 20) {
+            lcd.print(" B");
+            lcd.print(i, BIN);
+          }
+          delay(testDelay);
+        }
+        break;
+      case 8:
+        lcd.print(F("Positions"));
+        lcd.setCursor(0, 1);
+        for (byte col = 0; col < lcdCols; col++) {
+          lcd.write(col%10 + char('0'));
+          delay(testDelay);
+        }
+        break;
+      case 9:
+        lcd.print(F("Clearing"));
+        for (byte row = 1; row < lcdRows; row++) {
+          // Fill row
+          lcd.setCursor(0, row);
+          for (byte col = 0; col < lcdCols; col++) {
+            lcd.write(col%10 + char('0'));
+          }
+          delay(testDelay);
+          // Clear row
+          for (byte i = 0; i < lcdCols / 2; i++) {
+            lcd.setCursor(lcdCols / 2 - i - 1, row);
+            lcd.write(' ');
+            lcd.setCursor(lcdCols / 2 + i, row);
+            lcd.write(' ');
+            delay(testDelay);
+          }
+        }
+        break;
+      default:
+        demoNum = 0;
+        continue;
+    }
+    delay(demoDelay);
+    demoNum++;
+  }
+}
--- a/lib/LiquidCrystal_I2C/examples/CustomChars/CustomChars.ino
+++ b/lib/LiquidCrystal_I2C/examples/CustomChars/CustomChars.ino
@@ -0,0 +1,60 @@
+#include <Wire.h>
+#include <LiquidCrystal_I2C.h>
+
+uint8_t bell[8]  = {0x4,0xe,0xe,0xe,0x1f,0x0,0x4};
+uint8_t note[8]  = {0x2,0x3,0x2,0xe,0x1e,0xc,0x0};
+uint8_t clock[8] = {0x0,0xe,0x15,0x17,0x11,0xe,0x0};
+uint8_t heart[8] = {0x0,0xa,0x1f,0x1f,0xe,0x4,0x0};
+uint8_t duck[8]  = {0x0,0xc,0x1d,0xf,0xf,0x6,0x0};
+uint8_t check[8] = {0x0,0x1,0x3,0x16,0x1c,0x8,0x0};
+uint8_t cross[8] = {0x0,0x1b,0xe,0x4,0xe,0x1b,0x0};
+uint8_t retarrow[8] = {	0x1,0x1,0x5,0x9,0x1f,0x8,0x4};
+  
+LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display
+
+void setup()
+{
+  lcd.init();                      // initialize the lcd 
+  lcd.backlight();
+  
+  lcd.createChar(0, bell);
+  lcd.createChar(1, note);
+  lcd.createChar(2, clock);
+  lcd.createChar(3, heart);
+  lcd.createChar(4, duck);
+  lcd.createChar(5, check);
+  lcd.createChar(6, cross);
+  lcd.createChar(7, retarrow);
+  lcd.home();
+  
+  lcd.print("Hello world...");
+  lcd.setCursor(0, 1);
+  lcd.print(" i ");
+  lcd.write(3);
+  lcd.print(" arduinos!");
+  delay(5000);
+  displayKeyCodes();
+  
+}
+
+// display all keycodes
+void displayKeyCodes(void) {
+  uint8_t i = 0;
+  while (1) {
+    lcd.clear();
+    lcd.print("Codes 0x"); lcd.print(i, HEX);
+    lcd.print("-0x"); lcd.print(i+16, HEX);
+    lcd.setCursor(0, 1);
+    for (int j=0; j<16; j++) {
+      lcd.write(i+j);
+    }
+    i+=16;
+    
+    delay(4000);
+  }
+}
+
+void loop()
+{
+
+}
--- a/lib/LiquidCrystal_I2C/examples/HelloWorld/HelloWorld.ino
+++ b/lib/LiquidCrystal_I2C/examples/HelloWorld/HelloWorld.ino
@@ -0,0 +1,17 @@
+#include <Wire.h> 
+#include <LiquidCrystal_I2C.h>
+
+LiquidCrystal_I2C lcd(0x27,20,4);  // set the LCD address to 0x27 for a 20 chars and 4 line display
+
+void setup()
+{
+  lcd.init();                      // initialize the lcd 
+ 
+  // Print a message to the LCD.
+  lcd.backlight();
+  lcd.print("Hello, world!");
+}
+
+void loop()
+{
+}
--- a/lib/LiquidCrystal_I2C/examples/Histogram/Histogram.ino
+++ b/lib/LiquidCrystal_I2C/examples/Histogram/Histogram.ino
@@ -0,0 +1,95 @@
+/*
+  NAME:
+  Demo sketch for Histogram composed of Vertical Bar Graphs
+
+  DESCRIPTION:
+  The sketch demonstrates usage of LiquidCrystal_I2C library version 2.x
+  for programing histograms with help of vertical graphs.
+  * The sketch is intended preferrably for 16x2 LCD, but can be configured
+    for 20x4 LCDs just by uncommenting and commenting related sections.
+  * All graph values are displayed in number of vertical pixels.
+  * The sketch demostrates a histogram
+    - in second row with one row height
+    - in full display are with
+    with values changed randomly.
+  * The sketch is just for demonstration purposes, so that it is not
+    optimized for memory usage.
+
+  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
+  Version: 1.0.0
+  Updated: 01.03.2015
+*/
+
+/*  Needed libraries
+    Dispite the LCD library includes Wire library, the ArduinoIDE does not
+    includes nested libraries, if they are not in the same folder.
+*/
+#include <Wire.h>
+#include <LiquidCrystal_I2C.h>
+
+// LCD address and geometry for LCD 1602
+const byte lcdAddr = 0x27;  // Typical address of I2C backpack for 1602
+const byte lcdCols = 16;    // Number of characters in a row of display
+const byte lcdRows = 2;     // Number of lines of display
+
+// LCD address and geometry for LCD 2004
+//const byte lcdAddr = 0x3F;  // Typical address of I2C backpack for 2004
+//const byte lcdCols = 20;    // Number of characters in a row of display
+//const byte lcdRows = 4;     // Number of lines of display
+
+// Initialize library and setting LCD geometry
+LiquidCrystal_I2C lcd(lcdAddr, lcdCols, lcdRows);
+
+// Demo constants
+const int graphDelay = 100;  // Delay between histograms
+const int demoTime   = 5000; // Showing time of a demo
+
+// Demo variables
+byte graphPixelsCur, graphPixelsMax;
+unsigned long demoStart;
+
+void setup()
+{
+  // Initialize LCD
+  lcd.init();
+  lcd.backlight();  // Switch on the backlight LED, if any or wired
+  
+  /*  Initialize graph
+      * Macro is defined in LiquidCrystal_I2C library.
+      * Function uses all 8 custom character positions (0-7)
+        and creates custom characters for displaying vertical bar.
+  */
+  lcd.init_bargraph(LCDI2C_VERTICAL_BAR_GRAPH);
+}
+
+void loop()
+{
+  // Demo 1: One row histogram
+  lcd.clear();
+  lcd.print("Histogram");
+  graphPixelsMax = LCD_CHARACTER_VERTICAL_DOTS;
+  demoStart = millis();
+  while(millis() - demoStart < demoTime) {
+    for(byte graphCol = 0; graphCol < lcdCols; graphCol++) {
+      graphPixelsCur = random(0, graphPixelsMax);
+      lcd.draw_vertical_graph(1, graphCol, 1, graphPixelsCur);
+    }
+    delay(graphDelay);
+  }
+  // Demo 2: Full display histogram
+  lcd.clear();
+  graphPixelsMax = lcdRows * LCD_CHARACTER_VERTICAL_DOTS;
+  demoStart = millis();
+  while(millis() - demoStart < demoTime) {
+    for(byte graphCol = 0; graphCol < lcdCols; graphCol++) {
+      graphPixelsCur = random(0, graphPixelsMax);
+      lcd.draw_vertical_graph(lcdRows - 1, graphCol, lcdRows, graphPixelsCur);
+    }
+    delay(graphDelay);
+  }
+}
--- a/lib/LiquidCrystal_I2C/examples/HorizontalBarGraph/HorizontalBarGraph.ino
+++ b/lib/LiquidCrystal_I2C/examples/HorizontalBarGraph/HorizontalBarGraph.ino
@@ -0,0 +1,135 @@
+/*
+  NAME:
+  Demo sketch for Horizontal Bar Graph
+
+  DESCRIPTION:
+  The sketch demonstrates usage of LiquidCrystal_I2C library version 2.x
+  for programing horizontal graphs, which mimics progress bar.
+  * The sketch is intended preferrably for 16x2 LCD, but can be configured
+    for 20x4 LCDs just by uncommenting and commenting related sections.
+  * All graph values are displayed in number of horizontal pixels.
+  * The sketch demostrates
+    - 1. Continues full row progress bar
+    - 2. Continues half row central progress bar
+    - 3. Random full row progress bar
+  * The sketch is just for demonstration purposes, so that it is not
+    optimized for memory usage.
+
+  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
+  Version: 1.0.0
+  Updated: 01.03.2015
+*/
+
+/*  Needed libraries
+    Dispite the LCD library includes Wire library, the ArduinoIDE does not
+    includes nested libraries, if they are not in the same folder.
+*/
+#include <Wire.h>
+#include <LiquidCrystal_I2C.h>
+
+// LCD address and geometry for LCD 1602
+const byte lcdAddr = 0x27;  // Typical address of I2C backpack for 1602
+const byte lcdCols = 16;    // Number of characters in a row of display
+const byte lcdRows = 2;     // Number of lines of display
+
+// LCD address and geometry for LCD 2004
+//const byte lcdAddr = 0x3F;  // Typical address of I2C backpack for 2004
+//const byte lcdCols = 20;    // Number of characters in a row of display
+//const byte lcdRows = 4;     // Number of lines of display
+
+// Initialize library and setting LCD geometry
+LiquidCrystal_I2C lcd(lcdAddr, lcdCols, lcdRows);
+
+// Cursor coordinates and character row pattern for progress bar
+const byte graphRow = 1;  // In this row the graph is displayed
+const byte labelRow = 0;  // In this row the label is displayed
+const byte valueCol = lcdCols - 2; // In this column starts graph value
+const int graphDelay = 100;  // Delay between graph values in ms
+const int demoDelay  = 3000; // Delay between demos in ms
+
+// Demo parameters
+const char  graphType[] = " Bar";
+const char* graphLbls[] = {"Full", "Half", "Random"};
+const byte  graphLens[] = {lcdCols, lcdCols / 2, lcdCols};
+const byte  graphCols[] = {0, lcdCols / 4, 0};
+
+// Demo variables
+byte graphPixelsCur, graphPixelsMax;
+
+// Function for displaying graph label
+void printLabel(byte demo) {
+  // Create label
+  char labelText[valueCol];
+  sprintf(labelText, "%1u.%s%s", demo + 1, graphLbls[demo], graphType);
+  // Display label on clear display
+  lcd.clear();
+  lcd.setCursor(0, labelRow);
+  lcd.print(labelText);
+  
+}
+
+// Function for displaying graph value
+void printValue(byte value) {
+  lcd.clear(labelRow, valueCol);      // Clear value space
+  lcd.setCursor(valueCol, labelRow);
+  lcd.print(value);
+}
+
+void setup()
+{
+  // Initialize LCD
+  lcd.init();
+  lcd.backlight();  // Switch on the backlight LED, if any or wired
+  
+  /*  Initialize graph
+      * Macro is defined in LiquidCrystal_I2C library.
+      * Function uses the first 5 custom character positions (0-4)
+        and creates custom characters for displaying progress bar.
+  */
+  lcd.init_bargraph(LCDI2C_HORIZONTAL_BAR_GRAPH);
+}
+
+void loop()
+{
+  for(byte demoNum = 0; demoNum < sizeof(graphLens)/sizeof(graphLens[0]); demoNum++) {
+    graphPixelsMax = graphLens[demoNum] * LCD_CHARACTER_HORIZONTAL_DOTS;
+    printLabel(demoNum);
+    switch (demoNum) {
+      case 0:
+      case 1:
+        // Demo 1: Graph in full row with sequence values
+        // Demo 2: Graph in half row with sequence values
+        // Descending graph values
+        for (byte i = graphPixelsMax; i > 0; i--) {
+          graphPixelsCur = i - 1;
+          printValue(graphPixelsCur);
+          lcd.draw_horizontal_graph(graphRow, graphCols[demoNum], graphLens[demoNum], graphPixelsCur);
+          delay(graphDelay);
+        }
+        // Ascending graph values
+        for (byte i = 0; i < graphPixelsMax; i++) {
+          graphPixelsCur = i;
+          printValue(graphPixelsCur);
+          lcd.draw_horizontal_graph(graphRow, graphCols[demoNum], graphLens[demoNum], graphPixelsCur);
+          delay(graphDelay);
+        }
+        break;
+      case 2:
+        // Demo 3: Graph in full row with random values
+        for (byte i = 0; i < graphPixelsMax; i++) {
+          graphPixelsCur = random(0, graphPixelsMax);
+          printValue(graphPixelsCur);
+          lcd.draw_horizontal_graph(graphRow, graphCols[demoNum], graphLens[demoNum], graphPixelsCur);
+          delay(graphDelay);
+        }
+        break;
+    }
+    delay(demoDelay);
+  }
+}
+
--- a/lib/LiquidCrystal_I2C/examples/HorizontalLineGraph/HorizontalLineGraph.ino
+++ b/lib/LiquidCrystal_I2C/examples/HorizontalLineGraph/HorizontalLineGraph.ino
@@ -0,0 +1,135 @@
+/*
+  NAME:
+  Demo sketch for Horizontal Line Graph
+
+  DESCRIPTION:
+  The sketch demonstrates usage of LiquidCrystal_I2C library version 2.x
+  for programing horizontal graphs, which mimics scale graphs.
+  * The sketch is intended preferrably for 16x2 LCD, but can be configured
+    for 20x4 LCDs just by uncommenting and commenting related sections.
+  * All graph values are displayed in number of horizontal pixels.
+  * The sketch demostrates
+    - 1. Continues full row scale graph
+    - 2. Continues half row central scale graph
+    - 3. Random full row scale graph
+  * The sketch is just for demonstration purposes, so that it is not
+    optimized for memory usage.
+
+  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
+  Version: 1.0.0
+  Updated: 01.03.2015
+*/
+
+/*  Needed libraries
+    Dispite the LCD library includes Wire library, the ArduinoIDE does not
+    includes nested libraries, if they are not in the same folder.
+*/
+#include <Wire.h>
+#include <LiquidCrystal_I2C.h>
+
+// LCD address and geometry for LCD 1602
+const byte lcdAddr = 0x27;  // Typical address of I2C backpack for 1602
+const byte lcdCols = 16;    // Number of characters in a row of display
+const byte lcdRows = 2;     // Number of lines of display
+
+// LCD address and geometry for LCD 2004
+//const byte lcdAddr = 0x3F;  // Typical address of I2C backpack for 2004
+//const byte lcdCols = 20;    // Number of characters in a row of display
+//const byte lcdRows = 4;     // Number of lines of display
+
+// Initialize library and setting LCD geometry
+LiquidCrystal_I2C lcd(lcdAddr, lcdCols, lcdRows);
+
+// Cursor coordinates and character row pattern for progress bar
+const byte graphRow = 1;  // In this row the graph is displayed
+const byte labelRow = 0;  // In this row the label is displayed
+const byte valueCol = lcdCols - 2; // In this column starts graph value
+const int graphDelay = 200;  // Delay between graph values in ms
+const int demoDelay  = 3000; // Delay between demos in ms
+
+// Demo parameters
+const char  graphType[] = "Scale";
+const char* graphLbls[] = {"Full ", "Half ", "Random"};
+const byte  graphLens[] = {lcdCols, lcdCols / 2, lcdCols};
+const byte  graphCols[] = {0, lcdCols / 4, 0};
+
+// Demo variables
+byte graphPixelsCur, graphPixelsMax;
+
+// Function for displaying graph label
+void printLabel(byte demo) {
+  // Create label
+  char labelText[valueCol];
+  sprintf(labelText, "%1u.%s%s", demo + 1, graphLbls[demo], graphType);
+  // Display label on clear display
+  lcd.clear();
+  lcd.setCursor(0, labelRow);
+  lcd.print(labelText);
+  
+}
+
+// Function for displaying graph value
+void printValue(byte value) {
+  lcd.clear(labelRow, valueCol);      // Clear value space
+  lcd.setCursor(valueCol, labelRow);
+  lcd.print(value);
+}
+
+void setup()
+{
+  // Initialize LCD
+  lcd.init();
+  lcd.backlight();  // Switch on the backlight LED, if any or wired
+  
+  /*  Initialize graph
+      * Macro is defined in LiquidCrystal_I2C library.
+      * Function uses the first 5 custom character positions (0-4)
+        and creates custom characters for displaying progress bar.
+  */
+  lcd.init_bargraph(LCDI2C_HORIZONTAL_LINE_GRAPH);
+}
+
+void loop()
+{
+  for(byte demoNum = 0; demoNum < sizeof(graphLens)/sizeof(graphLens[0]); demoNum++) {
+    graphPixelsMax = graphLens[demoNum] * LCD_CHARACTER_HORIZONTAL_DOTS;
+    printLabel(demoNum);
+    switch (demoNum) {
+      case 0:
+      case 1:
+        // Demo 1: Graph in full row with sequence values
+        // Demo 2: Graph in half row with sequence values
+        // Descending graph values
+        for (byte i = graphPixelsMax; i > 0; i--) {
+          graphPixelsCur = i - 1;
+          printValue(graphPixelsCur);
+          lcd.draw_horizontal_graph(graphRow, graphCols[demoNum], graphLens[demoNum], graphPixelsCur);
+          delay(graphDelay);
+        }
+        // Ascending graph values
+        for (byte i = 0; i < graphPixelsMax; i++) {
+          graphPixelsCur = i;
+          printValue(graphPixelsCur);
+          lcd.draw_horizontal_graph(graphRow, graphCols[demoNum], graphLens[demoNum], graphPixelsCur);
+          delay(graphDelay);
+        }
+        break;
+      case 2:
+        // Demo 3: Graph in full row with random values
+        for (byte i = 0; i < graphPixelsMax; i++) {
+          graphPixelsCur = random(0, graphPixelsMax);
+          printValue(graphPixelsCur);
+          lcd.draw_horizontal_graph(graphRow, graphCols[demoNum], graphLens[demoNum], graphPixelsCur);
+          delay(graphDelay);
+        }
+        break;
+    }
+    delay(demoDelay);
+  }
+}
+
--- a/lib/LiquidCrystal_I2C/examples/MultipleLcd/MultipleLcd.ino
+++ b/lib/LiquidCrystal_I2C/examples/MultipleLcd/MultipleLcd.ino
@@ -0,0 +1,24 @@
+#include <Wire.h> 
+#include <LiquidCrystal_I2C.h>
+ 
+LiquidCrystal_I2C lcd1(0x26,16,2);  // set the LCD address of the first lcd to 0x26 for a 16 chars and 2 line display
+LiquidCrystal_I2C lcd2(0x27,16,2);  // set the LCD address of the second lcd to 0x27 for a 16 chars and 2 line display
+ 
+void setup()
+{
+  lcd1.init();                      // initialize the first lcd 
+  lcd2.init();                      // initialize the second lcd 
+ 
+  // Print a message on the first LCD.
+  lcd1.backlight();
+  lcd1.print("Hello, #1 world!");
+ 
+  // Print a message on the second LCD.
+  lcd2.backlight();
+  lcd2.print("Hello, #2 world!");
+ 
+}
+ 
+void loop()
+{
+}
--- a/lib/LiquidCrystal_I2C/examples/README.md
+++ b/lib/LiquidCrystal_I2C/examples/README.md
@@ -0,0 +1,46 @@
+<a id="library"></a>
+# LiquidCrystal_I2C
+It is the reimplementation of the standard Arduino LCD library, configured to work with parallel HD44780 compatible LCDs, and interfaced via a Chinese PCF8574 I2C serial extender.
+
+<a id="examples"></a>
+## Examples
+##### Autoscroll
+Demonstrates autoscroll function.
+
+##### CompleteTest
+Demo sketch for complete printing test of the LCD. The test suit consist of 9 tests each labeled in the first row.
+
+##### CustomChars
+Creation of 8 custom characters in form of graphical symbols.
+
+##### HelloWorld
+Standard initial example. Use it for checking basic functionality and address of the LCD.
+
+##### Histogram
+Demo sketch for several histograms composed of vertical bar graphs. The values for graphs are generated randomly.
+1. The first demo histogram is displayed in one row only.
+1. The second demo histogram display across all rows of the LCD and uses its entire screen.
+
+##### HorizontalBarGraph
+Demo sketch for horizontal bar graphs.
+1. The first demo histogram uses full row for continues increasing and decreasing values (breathing graph).
+1. The second demo histogram is a breathing graph using just one half of a row.
+1. The third demo histogram displays values generated randomly.
+
+##### HorizontalLineGraph
+Demo sketch for horizontal line graphs. A value is represented just with a pipe on a row.
+1. The first demo histogram uses full row for continues increasing and decreasing values (running graph).
+1. The second demo histogram is a running graph using just one half of a row.
+1. The third demo histogram displays values generated randomly.
+
+##### MultipleLcd
+Using multiple LCD on the same I2C bus but communicating on different addresses.
+
+##### Scroll
+Demonstrates scrolling text to the left and right without changing text.
+
+##### SerialDisplay
+Sketch receives characters from the serial port and displays them on the LCD one by one.
+
+##### VerticalBarGraph
+Demo sketch for vertical bar graph. The graph uses all rows in the last column for continues increasing and decreasing values (breathing graph).
--- a/lib/LiquidCrystal_I2C/examples/Scroll/Scroll.ino
+++ b/lib/LiquidCrystal_I2C/examples/Scroll/Scroll.ino
@@ -0,0 +1,71 @@
+/*
+  NAME:
+  Demonstration scrolling text to the left and right without changing text.
+
+  DESCRIPTION:
+  This sketch demonstrates the use of the scrollDisplayLeft() and
+  scrollDisplayRight() functions to make new text scroll to the left and right.
+  * The sketch is intended preferrably for 16x2 LCD, but can be configured
+    for 20x4 LCDs just by uncommenting and commenting related sections.
+  * The sketch is just for demonstration purposes, so that it is not
+    optimized for memory usage.
+
+  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
+  Version: 1.0.0
+  Updated: 20.03.2016
+  
+  CREDIT:
+  The example taken and rewritten for I2C from official Arduino standard library
+  (https://github.com/arduino/Arduino/tree/master/libraries/LiquidCrystal)
+*/
+#include <Wire.h>
+#include <LiquidCrystal_I2C.h>
+
+// LCD address and geometry and library initialization
+const byte lcdAddr = 0x27;  // Address of I2C backpack
+const byte lcdCols = 16;    // Number of character in a row
+const byte lcdRows = 2;     // Number of lines
+//const byte lcdAddr = 0x3F;  // Address of I2C backpack
+//const byte lcdCols = 20;    // Number of character in a row
+//const byte lcdRows = 4;     // Number of lines
+
+LiquidCrystal_I2C lcd(lcdAddr, lcdCols, lcdRows);
+
+// Demo parameters
+const char demoText[]= "Hello World!";
+const unsigned int scrollDelay = 500;   // Miliseconds before scrolling next char
+const unsigned int demoDelay = 2000;    // Miliseconds between demo loops
+byte textLen;                           // Number of visible characters in the text
+
+void setup() {
+  textLen = sizeof(demoText) - 1;
+  lcd.init();
+  lcd.backlight();
+  lcd.print(demoText);
+  delay(demoDelay);
+}
+
+void loop() {
+  // Scroll entire text in a row to the left outside the screen
+  for (byte positionCounter = 0; positionCounter < textLen; positionCounter++) {
+    lcd.scrollDisplayLeft();
+    delay(scrollDelay);
+  }
+  // Scroll hidden text through entire row to the right outside the screen
+  for (byte positionCounter = 0; positionCounter < textLen + lcdCols; positionCounter++) {
+    lcd.scrollDisplayRight();
+    delay(scrollDelay);
+  }
+  // Scroll text to the right back to original position
+  for (byte positionCounter = 0; positionCounter < lcdCols; positionCounter++) {
+    lcd.scrollDisplayLeft();
+    delay(scrollDelay);
+  }
+  delay(demoDelay);
+}
+
--- a/lib/LiquidCrystal_I2C/examples/SerialDisplay/SerialDisplay.ino
+++ b/lib/LiquidCrystal_I2C/examples/SerialDisplay/SerialDisplay.ino
@@ -0,0 +1,31 @@
+/*
+ * Displays text sent over the serial port (e.g. from the Serial Monitor) on
+ * an attached LCD.
+ */
+#include <Wire.h> 
+#include <LiquidCrystal_I2C.h>
+
+LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display
+
+void setup()
+{
+  lcd.init();                      // initialize the lcd 
+  lcd.backlight();
+  Serial.begin(9600);
+}
+
+void loop()
+{
+  // when characters arrive over the serial port...
+  if (Serial.available()) {
+    // wait a bit for the entire message to arrive
+    delay(100);
+    // clear the screen
+    lcd.clear();
+    // read all the available characters
+    while (Serial.available() > 0) {
+      // display each character to the LCD
+      lcd.write(Serial.read());
+    }
+  }
+}
--- a/lib/LiquidCrystal_I2C/examples/VerticalBarGraph/VerticalBarGraph.ino
+++ b/lib/LiquidCrystal_I2C/examples/VerticalBarGraph/VerticalBarGraph.ino
@@ -0,0 +1,120 @@
+/*
+  NAME:
+  Demo sketch for Vertical Bar Graph
+
+  DESCRIPTION:
+  The sketch demonstrates usage of LiquidCrystal_I2C library version 2.x
+  for programing vertical graphs, which mimics histogram.
+  * The sketch is intended preferrably for 16x2 LCD, but can be configured
+    for 20x4 LCDs just by uncommenting and commenting related sections.
+  * All graph values are displayed in number of vertical pixels.
+  * The sketch demostrates vertical graphs from one row graph to full rows
+    graph of the display.
+  * The sketch is just for demonstration purposes, so that it is not
+    optimized for memory usage.
+
+  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
+  Version: 1.0.0
+  Updated: 01.03.2015
+*/
+
+/*  Needed libraries
+    Dispite the LCD library includes Wire library, the ArduinoIDE does not
+    includes nested libraries, if they are not in the same folder.
+*/
+#include <Wire.h>
+#include <LiquidCrystal_I2C.h>
+
+// LCD address and geometry for LCD 1602
+const byte lcdAddr = 0x27;  // Typical address of I2C backpack for 1602
+const byte lcdCols = 16;    // Number of characters in a row of display
+const byte lcdRows = 2;     // Number of lines of display
+
+// LCD address and geometry for LCD 2004
+//const byte lcdAddr = 0x3F;  // Typical address of I2C backpack for 2004
+//const byte lcdCols = 20;    // Number of characters in a row of display
+//const byte lcdRows = 4;     // Number of lines of display
+
+// Initialize library and setting LCD geometry
+LiquidCrystal_I2C lcd(lcdAddr, lcdCols, lcdRows);
+
+// Cursor coordinates and character row pattern for progress bar
+const byte graphCol = lcdCols - 1;  // In this column the graph is displayed
+const int graphDelay = 200;  // Delay between graph values in ms
+const int demoDelay  = 3000; // Delay between demos in ms
+
+// Demo parameters
+const char  graphType[] = " Col(s) Graph";
+
+// Demo variables
+byte graphPixelsCur, graphPixelsMax;
+
+// Function for displaying graph label
+void printLabel(byte rows) {
+  const byte labelCol = 0;
+  const byte labelRow = 0;
+  // Create label
+  char labelText[graphCol];
+  sprintf(labelText, "%1u%s", rows, graphType);
+  // Display label on clear display
+  lcd.clear();
+  lcd.setCursor(labelCol, labelRow);
+  lcd.print(labelText);
+  
+}
+
+// Function for displaying graph value
+void printValue(byte value) {
+  const byte valueWidth = 2; // Max. digits in value
+  const byte valueCol = graphCol - valueWidth - 1;
+  const byte valueRow = 1;
+  // Create value
+  char valueFormat[4], valueText[valueWidth + 1];
+  sprintf(valueFormat, "%%%1uu", valueWidth);
+  sprintf(valueText, valueFormat, value);
+  // Display label on clear display
+  lcd.clear(valueRow, valueCol, valueWidth);
+  lcd.setCursor(valueCol, valueRow);
+  lcd.print(valueText);
+}
+
+void setup()
+{
+  // Initialize LCD
+  lcd.init();
+  lcd.backlight();  // Switch on the backlight LED, if any or wired
+  
+  /*  Initialize graph
+      * Macro is defined in LiquidCrystal_I2C library.
+      * Function uses all 8 custom character positions (0-7)
+        and creates custom characters for displaying vertical bar.
+  */
+  lcd.init_bargraph(LCDI2C_VERTICAL_BAR_GRAPH);
+}
+
+void loop()
+{
+  for(byte graphHight = 1; graphHight <= lcdRows; graphHight++) {
+    graphPixelsMax = graphHight * LCD_CHARACTER_VERTICAL_DOTS;
+    printLabel(graphHight);
+    for (byte i = graphPixelsMax; i > 0; i--) {
+      graphPixelsCur = i - 1;
+      printValue(graphPixelsCur);
+      lcd.draw_vertical_graph(graphHight - 1, graphCol, graphHight, graphPixelsCur);
+      delay(graphDelay);
+    }
+    // Ascending graph values
+    for (byte i = 0; i < graphPixelsMax; i++) {
+      graphPixelsCur = i;
+      printValue(graphPixelsCur);
+      lcd.draw_vertical_graph(graphHight - 1, graphCol, graphHight, graphPixelsCur);
+      delay(graphDelay);
+    }
+    delay(demoDelay);
+  }
+}
--- a/lib/LiquidCrystal_I2C/extras/hardware/1602_I2C_LCD_Display.url
+++ b/lib/LiquidCrystal_I2C/extras/hardware/1602_I2C_LCD_Display.url
@@ -0,0 +1,5 @@
+[{000214A0-0000-0000-C000-000000000046}]
+Prop3=19,2
+[InternetShortcut]
+URL=http://www.banggood.com/IIC-Or-I2C-Or-TWI-SPI-LCD1602-Character-LCD-Module-For-Arduino-p-88316.html?p=5G0704100426201212C9
+IDList=
--- a/lib/LiquidCrystal_I2C/extras/hardware/Blue_2004_I2C_LCD_Display.url
+++ b/lib/LiquidCrystal_I2C/extras/hardware/Blue_2004_I2C_LCD_Display.url
@@ -0,0 +1,5 @@
+[{000214A0-0000-0000-C000-000000000046}]
+Prop3=19,2
+[InternetShortcut]
+URL=http://www.banggood.com/IIC-Or-I2C-2004-204-20-X-4-Character-LCD-Display-Module-Blue-p-908616.html?p=5G0704100426201212C9
+IDList=
--- a/lib/LiquidCrystal_I2C/extras/hardware/I2C_Serial_LCD_Converter_Board_1602_2004.url
+++ b/lib/LiquidCrystal_I2C/extras/hardware/I2C_Serial_LCD_Converter_Board_1602_2004.url
@@ -0,0 +1,5 @@
+[{000214A0-0000-0000-C000-000000000046}]
+Prop3=19,2
+[InternetShortcut]
+URL=http://www.banggood.com/IIC-Or-I2C-Or-TWI-Or-SP-Serial-Interface-Module-Port-For-5V-Arduino-1602LCD-p-80365.html?p=5G0704100426201212C9
+IDList=
--- a/lib/LiquidCrystal_I2C/extras/hardware/Yellow_Green_2004_I2C_LCD_Display.url
+++ b/lib/LiquidCrystal_I2C/extras/hardware/Yellow_Green_2004_I2C_LCD_Display.url
@@ -0,0 +1,5 @@
+[{000214A0-0000-0000-C000-000000000046}]
+Prop3=19,2
+[InternetShortcut]
+URL=http://www.banggood.com/IIC-Or-I2C-2004-204-20-X-4-Character-LCD-Display-Module-Yellow-Green-p-908821.html?p=5G0704100426201212C9
+IDList=
--- a/lib/LiquidCrystal_I2C/extras/info/2004_I2C_Serial_LCD_Display.jpg
+++ b/lib/LiquidCrystal_I2C/extras/info/2004_I2C_Serial_LCD_Display.jpg
--- a/lib/LiquidCrystal_I2C/extras/info/2004_Pinout.jpg
+++ b/lib/LiquidCrystal_I2C/extras/info/2004_Pinout.jpg
--- a/lib/LiquidCrystal_I2C/extras/info/Arduino
+++ b/lib/LiquidCrystal_I2C/extras/info/Arduino
@@ -0,0 +1,7 @@
+[{000214A0-0000-0000-C000-000000000046}]
+Prop3=19,2
+[InternetShortcut]
+URL=http://playground.arduino.cc/Code/LCDi2c
+IDList=
+IconFile=http://playground.arduino.cc/favicon.png
+IconIndex=1
--- a/lib/LiquidCrystal_I2C/extras/info/Arduino
+++ b/lib/LiquidCrystal_I2C/extras/info/Arduino
@@ -0,0 +1,5 @@
+[{000214A0-0000-0000-C000-000000000046}]
+Prop3=19,2
+[InternetShortcut]
+URL=http://playground.arduino.cc/Code/LCDAPI
+IDList=
--- a/lib/LiquidCrystal_I2C/extras/info/Character_Set.jpg
+++ b/lib/LiquidCrystal_I2C/extras/info/Character_Set.jpg
--- a/lib/LiquidCrystal_I2C/extras/info/Chinese_I2C_Serial_LCD_Converter_Board_1602_2004.jpg
+++ b/lib/LiquidCrystal_I2C/extras/info/Chinese_I2C_Serial_LCD_Converter_Board_1602_2004.jpg
--- a/lib/LiquidCrystal_I2C/extras/info/readme.txt
+++ b/lib/LiquidCrystal_I2C/extras/info/readme.txt
@@ -0,0 +1,47 @@
+// LiquidCrystal_I2C V2.0 - Mario H. atmega@xs4all.nl
+// Mods for Chinese I2C converter board - Murray R. Van Luyn. vanluynm@iinet.net.au
+
+The LiquidCrystal_I2C library is a modified version of the standard LiquidCrystal library as found on 
+the Arduino website.
+This library is intended to be used when a parallel HD44780 compatible LCD is controlled over I2C using 
+a Chinese PCF8574 extender.
+4 of the 8 outputs are used for LCD data lines 4 to 7.
+4 outputs are used for the Enable, register-select, Read/Write and backlight control lines.
+
+The Chinese PCF8574 extender is available in two versions, the PCF8574 and the PCF8574A.
+The only difference between the two is the I2C base address.
+The base address for the PCF8574 is 0x27 and the base address for the PCF8574A is 0x4E.
+The examples included in this zip file assume the use of an PCF8574 set for address 0x27 
+(A0, A1 and A3 un-linked, so pulled high).
+
+For PCF8574 the addressing is:
+
+Jp3	Jp2	Jp1		
+A2	A1	A0	Dec	Hex	
+L	L	L	32	0x20
+L	L	H	33	0x21
+L	H	L	34	0x22
+L	H	H	35	0x23
+H	L	L	36	0x24
+H	L	H	37	0x25
+H	H	L	38	0x26
+H	H	H	39	0x27
+
+For PCF8574A the addressing is:
+				
+Jp3	Jp2	Jp1		
+A2	A1	A0	Dec	Hex	
+L	L	L	56	0x38
+L	L	H	57	0x39
+L	H	L	64	0x40
+L	H	H	74	0x4A
+H	L	L	75	0x4B
+H	L	H	76	0x4C
+H	H	L	77	0x4D
+H	H	H	78	0x4E
+
+For compatibility reasons this library contains some aliases for functions that are known under different 
+names in other libraries. This should make it fairly easy to implement the library in existing sketches 
+without changing to much code.
+Functions not supported by this library will return nothing at all and in case a return value is expected 
+the function will return 0.
--- a/lib/LiquidCrystal_I2C/keywords.txt
+++ b/lib/LiquidCrystal_I2C/keywords.txt
@@ -0,0 +1,50 @@
+###########################################
+# Syntax Coloring Map For LiquidCrystal_I2C
+###########################################
+
+###########################################
+# Datatypes (KEYWORD1)
+###########################################
+LiquidCrystal_I2C	KEYWORD1
+
+###########################################
+# Methods and Functions (KEYWORD2)
+###########################################
+init					KEYWORD2
+begin					KEYWORD2
+clear					KEYWORD2
+home					KEYWORD2
+noDisplay				KEYWORD2
+display					KEYWORD2
+noBlink					KEYWORD2
+blink					KEYWORD2
+noCursor				KEYWORD2
+cursor					KEYWORD2
+scrollDisplayLeft		KEYWORD2
+scrollDisplayRight		KEYWORD2
+leftToRight				KEYWORD2
+rightToLeft				KEYWORD2
+shiftIncrement			KEYWORD2
+shiftDecrement			KEYWORD2
+noBacklight				KEYWORD2
+backlight				KEYWORD2
+autoscroll				KEYWORD2
+noAutoscroll			KEYWORD2
+createChar				KEYWORD2
+setCursor				KEYWORD2
+print					KEYWORD2
+blink_on				KEYWORD2
+blink_off				KEYWORD2
+cursor_on				KEYWORD2
+cursor_off				KEYWORD2
+setBacklight			KEYWORD2
+load_custom_character	KEYWORD2
+printstr				KEYWORD2
+init_bargraph			KEYWORD2
+draw_horizontal_graph	KEYWORD2
+graphHorizontalChars	KEYWORD2
+graphVerticalChars		KEYWORD2
+###########################################
+# Constants (LITERAL1)
+###########################################
+LIQUIDCRYSTAL_I2C_VERSION	LITERAL1
--- a/lib/LiquidCrystal_I2C/library.properties
+++ b/lib/LiquidCrystal_I2C/library.properties
@@ -0,0 +1,9 @@
+name=LiquidCrystal_I2C
+version=2.6.1
+author=Libor Gabaj <libor.gabaj@gmail.com>
+maintainer=Libor Gabaj <libor.gabaj@gmail.com>
+sentence=Library for parallel HD44780 compatible LCDs interfaced via a Chinese PCF8574 I2C serial extender.
+paragraph=Library for parallel HD44780 compatible LCDs interfaced via a Chinese PCF8574 I2C serial extender. It adds overloaded clear() function for clearing particular segment of an input row. Library also implements extended graph functions with help of custom characters and adds overloaded graph functions for expressing graph value in percentage or ration instead of pixels.
+category=Display
+url=https://github.com/mrkaleArduinoLib/LiquidCrystal_I2C.git
+architectures=avr
--- a/lib/LiquidCrystal_I2C/src/LiquidCrystal_I2C.cpp
+++ b/lib/LiquidCrystal_I2C/src/LiquidCrystal_I2C.cpp
@@ -0,0 +1,444 @@
+#include "LiquidCrystal_I2C.h"
+
+// 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()
+{
+	Wire.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(1000);
+
+  // 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){                                        
+	Wire.beginTransmission(_Addr);
+	Wire.write((int)(_data) | _backlightval);
+	Wire.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);
+}
--- a/lib/LiquidCrystal_I2C/src/LiquidCrystal_I2C.h
+++ b/lib/LiquidCrystal_I2C/src/LiquidCrystal_I2C.h
@@ -0,0 +1,303 @@
+/*
+  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>
+#include <inttypes.h>
+#include <Wire.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
+// LK ESP32
+#define LCD_BACKLIGHT   0x08
+#define LCD_NOBACKLIGHT 0x00
+
+// 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