20:I[70597,["866","static/chunks/6468630d-22307b9b819d1ded.js","8888","static/chunks/2e5b0c64-7cbf44ca347d2d5d.js","633","static/chunks/74efd9f1-833e51e84fea5d40.js","5779","static/chunks/2a223334-0d3ae1764fe2e3c6.js","4229","static/chunks/4229-41f4706592bf466a.js","4924","static/chunks/4924-36441c47c9b0a188.js","5688","static/chunks/5688-ed04d0b25a253e36.js","9852","static/chunks/9852-37309ff0626aec67.js","347","static/chunks/347-7d940c9f2911a7e6.js","6217","static/chunks/6217-0bff6acfd692b9d4.js","8885","static/chunks/8885-d692d13679bc698a.js","9304","static/chunks/9304-0caae1685ba31302.js","4765","static/chunks/4765-fde2550ad52b08ad.js","8398","static/chunks/8398-d2159dfa9fa13b99.js","2046","static/chunks/2046-246e71b9b7745283.js","8500","static/chunks/8500-e4dd1cb1bb626827.js","9562","static/chunks/9562-b7af60810e69228a.js","5620","static/chunks/5620-915ca76664e92a3d.js","2734","static/chunks/2734-3297a9d5f7b63215.js","2919","static/chunks/2919-ad5c1b0887b56700.js","5473","static/chunks/5473-0f2759abf6b4b402.js","323","static/chunks/323-43a28b8c938eaa26.js","2045","static/chunks/2045-8bc379237be974a5.js","7025","static/chunks/7025-faed5b4ca9dd3ebb.js","8091","static/chunks/8091-fb1fc96f03806f24.js","257","static/chunks/257-279b506c25d197d8.js","6107","static/chunks/6107-7ad811632ee61907.js","5138","static/chunks/5138-1b2909f998b223a3.js","4689","static/chunks/4689-78fbca4c1735e10f.js","2513","static/chunks/2513-4ce943a31c2f594b.js","306","static/chunks/306-fc3d7c1dbf7d3934.js","5744","static/chunks/5744-50b0c6a000d87525.js","626","static/chunks/626-27b34a76cb44f257.js","8619","static/chunks/8619-7a3de8f920a1306f.js","6383","static/chunks/6383-ad80e382512286a6.js","1332","static/chunks/app/projects/%5BprojectId%5D/page-5e054ad1e5498c09.js"],"ProjectPageClient"] 24:I[86869,[],"IconMark"] 21:T95f,{ "version": 1, "author": "Uri Shaked", "editor": "wokwi", "parts": [ { "type": "board-st-nucleo-c031c6", "id": "nucleo", "top": -37.71, "left": -264.45, "attrs": {} }, { "type": "wokwi-potentiometer", "id": "pot1", "top": 65.9, "left": -384.2, "rotate": 270, "attrs": {} }, { "type": "wokwi-led", "id": "led1", "top": -70.8, "left": 80.6, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led2", "top": 111.6, "left": 80.6, "attrs": { "color": "red" } }, { "type": "wokwi-led", "id": "led3", "top": 6, "left": 80.6, "attrs": { "color": "green" } }, { "type": "wokwi-led", "id": "led4", "top": 150, "left": 80.6, "attrs": { "color": "green" } }, { "type": "wokwi-led", "id": "led5", "top": -32.4, "left": 80.6, "attrs": { "color": "yellow" } }, { "type": "wokwi-pushbutton", "id": "btn1", "top": 227, "left": 76.8, "attrs": { "color": "green", "xray": "1" } } ], "connections": [ [ "$serialMonitor:TX", "nucleo:PA3", "", [] ], [ "$serialMonitor:RX", "nucleo:PA2", "", [] ], [ "pot1:GND", "nucleo:GND.6", "black", [ "h18.1", "v69.5", "h72.08" ] ], [ "pot1:VCC", "nucleo:5V.2", "red", [ "v-6.5", "h37.3", "v76.66" ] ], [ "nucleo:A2", "pot1:SIG", "green", [ "h-62.48", "v-127.36" ] ], [ "nucleo:GND.9", "led3:C", "black", [ "h107.52", "v-67.06" ] ], [ "nucleo:GND.9", "led5:C", "black", [ "h97.92", "v-105.46" ] ], [ "nucleo:GND.9", "led1:C", "black", [ "h88.32", "v-143.86" ] ], [ "nucleo:GND.9", "led2:C", "black", [ "h107.52", "v38.54" ] ], [ "nucleo:GND.9", "led4:C", "black", [ "h97.92", "v76.94" ] ], [ "nucleo:GND.9", "btn1:1.l", "black", [ "h88.32", "v124.94" ] ], [ "led3:A", "nucleo:D13", "green", [ "v9.6", "h28.8", "v-144", "h-124.8", "v211.06" ] ], [ "led5:A", "nucleo:D12", "gold", [ "v9.6", "h19.2", "v-96", "h-105.6", "v211.06" ] ], [ "nucleo:D11", "led1:A", "red", [ "h69.12", "v-191.86", "h0", "v-19.2", "h86.4", "v48", "h0", "v0", "h-9.6" ] ], [ "nucleo:D9", "led2:A", "red", [ "h117.12", "v-47.86", "h38.4", "v38.4" ] ], [ "nucleo:D8", "led4:A", "green", [ "h117.12", "v28.94", "h38.4", "v-9.6" ] ], [ "btn1:2.l", "nucleo:D4", "green", [ "h-38.4", "v-38.34" ] ] ], "dependencies": {} }22:T35ca,#include #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); }23:T2862,/* 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 }; #endif6:["$","$L20",null,{"project":{"name":"Practice 1","id":"474584253695022081","files":[{"name":"sketch.ino","content":"#define LED_R 13\n#define LED_Y 12\n#define LED_G 11\n"},{"name":"diagram.json","content":"$21"},{"name":"LiquidCrystal_I2C.cpp","content":"$22"},{"name":"LiquidCrystal_I2C.h","content":"$23"},{"name":"libraries.txt","content":"# Wokwi Library List\n# See https://docs.wokwi.com/guides/libraries\n\n# Automatically added based on includes:\nLiquidCrystal I2C\n# ---\n"}],"serverFiles":[],"owner":"474583937859624961","locked":false,"unlisted":false,"updated":1788857663702,"hearts":0,"userLiked":false}}] 9:null e:[["$","title","0",{"children":"Practice 1 - Wokwi ESP32, STM32, Arduino Simulator"}],["$","meta","1",{"name":"description","content":"Run IoT and embedded projects in your browser: ESP32, STM32, Arduino, Pi Pico, and more. No installation required!"}],["$","meta","2",{"property":"og:title","content":"Practice 1 - Wokwi ESP32, STM32, Arduino Simulator"}],["$","meta","3",{"property":"og:description","content":"Run IoT and embedded projects in your browser: ESP32, STM32, Arduino, Pi Pico, and more. No installation required!"}],["$","meta","4",{"property":"og:image","content":"https://thumbs.wokwi.com/projects/474584253695022081/social/1788857663702.png"}],["$","meta","5",{"property":"og:image:type","content":"image/png"}],["$","meta","6",{"property":"og:image:width","content":"1200"}],["$","meta","7",{"property":"og:image:height","content":"630"}],["$","meta","8",{"name":"twitter:card","content":"summary_large_image"}],["$","meta","9",{"name":"twitter:site","content":"@WokwiMakes"}],["$","meta","10",{"name":"twitter:title","content":"Practice 1 - Wokwi ESP32, STM32, Arduino Simulator"}],["$","meta","11",{"name":"twitter:description","content":"Run IoT and embedded projects in your browser: ESP32, STM32, Arduino, Pi Pico, and more. No installation required!"}],["$","meta","12",{"name":"twitter:image","content":"https://thumbs.wokwi.com/projects/474584253695022081/social/1788857663702.png"}],["$","meta","13",{"name":"twitter:image:type","content":"image/png"}],["$","meta","14",{"name":"twitter:image:width","content":"1200"}],["$","meta","15",{"name":"twitter:image:height","content":"630"}],["$","link","16",{"rel":"icon","href":"/favicon-white.png","media":"(prefers-color-scheme: dark)"}],["$","link","17",{"rel":"icon","href":"/favicon.png","media":"(prefers-color-scheme: light)"}],["$","$L24","18",{}]]