0x6d61726b
fixed compiler warnings
Fork of
TextLCD
by 
Wim Huiskamp
Embed:
(wiki syntax)
Show/hide line numbers
TextLCD.cpp
00001 /* mbed TextLCD Library, for LCDs based on HD44780 controllers 00002 * Copyright (c) 2007-2010, sford, http://mbed.org 00003 * 2013, v01: WH, Added LCD types, fixed LCD address issues, added Cursor and UDCs 00004 * 2013, v02: WH, Added I2C and SPI bus interfaces 00005 * 2013, v03: WH, Added support for LCD40x4 which uses 2 controllers 00006 * 2013, v04: WH, Added support for Display On/Off, improved 4bit bootprocess 00007 * 2013, v05: WH, Added support for 8x2B, added some UDCs 00008 * 2013, v06: WH, Added support for devices that use internal DC/DC converters 00009 * 2013, v07: WH, Added support for backlight and include portdefinitions for LCD2004 Module from DFROBOT 00010 * 2014, v08: WH, Refactored in Base and Derived Classes to deal with mbed lib change regarding 'NC' defined pins 00011 * 2014, v09: WH/EO, Added Class for Native SPI controllers such as ST7032 00012 * 2014, v10: WH, Added Class for Native I2C controllers such as ST7032i, Added support for MCP23008 I2C portexpander, Added support for Adafruit module 00013 * 2014, v11: WH, Added support for native I2C controllers such as PCF21XX, Improved the _initCtrl() method to deal with differences between all supported controllers 00014 * 2014, v12: WH, Added support for native I2C controller PCF2119 and native I2C/SPI controllers SSD1803, ST7036, added setContrast method (by JH1PJL) for supported devices (eg ST7032i) 00015 * 2014, v13: WH, Added support for controllers US2066/SSD1311 (OLED), added setUDCBlink() method for supported devices (eg SSD1803), fixed issue in setPower() 00016 * 2014, v14: WH, Added support for PT6314 (VFD), added setOrient() method for supported devices (eg SSD1803, US2066), added Double Height lines for supported devices, 00017 * added 16 UDCs for supported devices (eg PCF2103), moved UDC defines to TextLCD_UDC file, added TextLCD_Config.h for feature and footprint settings. 00018 * 2014, v15: WH, Added AC780 support, added I2C expander modules, fixed setBacklight() for inverted logic modules. Fixed bug in LCD_SPI_N define 00019 * 2014, v16: WH, Added ST7070 and KS0073 support, added setIcon(), clrIcon() and setInvert() method for supported devices 00020 * 2015, v17: WH, Clean up low-level _writeCommand() and _writeData(), Added support for alternative fonttables (eg PCF21XX), Added ST7066_ACM controller for ACM1602 module 00021 * 2015, v18: WH, Performance improvement I2C portexpander 00022 * 2015, v19: WH, Fixed Adafruit I2C/SPI portexpander pinmappings, fixed SYDZ Backlight 00023 * 2015, v20: WH, Fixed occasional Init fail caused by insufficient wait time after ReturnHome command (0x02), Added defines to reduce memory footprint (eg LCD_ICON), 00024 * Fixed and Added more fonttable support for PCF2119R_3V3, Added HD66712 controller. 00025 * 2015, v21: WH, Added LCD32x2 defines and code, Fixed KS0073 DL=1 init for SPI, Added defines to reduce memory footprint (LCD_TWO_CTRL, LCD_CONTRAST, LCD_UTF8_FONT) 00026 * Added SPLC792A controller, Added UTF8_2_LCD decode for Cyrilic font (By Andriy Ribalko). Added setFont() 00027 * 00028 * Permission is hereby granted, free of charge, to any person obtaining a copy 00029 * of this software and associated documentation files (the "Software"), to deal 00030 * in the Software without restriction, including without limitation the rights 00031 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 00032 * copies of the Software, and to permit persons to whom the Software is 00033 * furnished to do so, subject to the following conditions: 00034 * 00035 * The above copyright notice and this permission notice shall be included in 00036 * all copies or substantial portions of the Software. 00037 * 00038 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00039 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00040 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 00041 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00042 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 00043 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 00044 * THE SOFTWARE. 00045 */ 00046 #include "mbed.h" 00047 #include "TextLCD.h" 00048 #include "TextLCD_UDC.inc" 00049 #include "TextLCD_UTF8.inc" 00050 00051 /** Create a TextLCD_Base interface 00052 * 00053 * @param type Sets the panel size/addressing mode (default = LCD16x2) 00054 * @param ctrl LCD controller (default = HD44780) 00055 */ 00056 TextLCD_Base::TextLCD_Base(LCDType type, LCDCtrl ctrl) : _type(type), _ctrl(ctrl) { 00057 00058 // Extract LCDType data 00059 00060 // Columns encoded in b15..b8 00061 _nr_cols = (_type & LCD_T_COL_MSK) >> LCD_T_COL_SHFT; 00062 00063 // Rows encoded in b23..b16 00064 _nr_rows = (_type & LCD_T_ROW_MSK) >> LCD_T_ROW_SHFT; 00065 00066 // Addressing mode encoded in b27..b24 00067 _addr_mode = _type & LCD_T_ADR_MSK; 00068 00069 // Font table, encoded in LCDCtrl 00070 _font = _ctrl & LCD_C_FNT_MSK; 00071 } 00072 00073 /** Init the LCD Controller(s) 00074 * Clear display 00075 * @param _LCDDatalength dl sets the datalength of data/commands 00076 * @return none 00077 */ 00078 void TextLCD_Base::_init(_LCDDatalength dl) { 00079 00080 wait_ms(100); // Wait 100ms to ensure powered up 00081 00082 #if (LCD_TWO_CTRL == 1) 00083 // Select and configure second LCD controller when needed 00084 if(_type==LCD40x4) { 00085 _ctrl_idx=_LCDCtrl_1; // Select 2nd controller 00086 _initCtrl(dl); // Init 2nd controller 00087 } 00088 #endif 00089 00090 // Select and configure primary LCD controller 00091 _ctrl_idx=_LCDCtrl_0; // Select primary controller 00092 _initCtrl(dl); // Init primary controller 00093 00094 // Clear whole display and Reset Cursor location 00095 // Note: This will make sure that some 3-line displays that skip topline of a 4-line configuration 00096 // are cleared and init cursor correctly. 00097 cls(); 00098 } 00099 00100 /** Init the LCD controller 00101 * Set number of lines, fonttype, no cursor etc 00102 * The controller is accessed in 4-bit parallel mode either directly via mbed pins or through I2C or SPI expander. 00103 * Some controllers also support native I2C or SPI interfaces. 00104 * 00105 * @param _LCDDatalength dl sets the 4 or 8 bit datalength of data/commands. Required for some native serial modes that dont work when DL=0. 00106 * @return none 00107 * 00108 * Note: some configurations are commented out because they have not yet been tested due to lack of hardware 00109 */ 00110 void TextLCD_Base::_initCtrl(_LCDDatalength dl) { 00111 int _bias_lines=0; // Set Bias and lines (Instr Set 1), temporary variable. 00112 int _lines=0; // Set lines (Ext Instr Set), temporary variable. 00113 00114 this->_setRS(false); // command mode 00115 00116 if (dl == _LCD_DL_4) { 00117 // The Controller could be in 8 bit mode (power-on reset) or in 4 bit mode (warm reboot) at this point. 00118 // Follow this procedure to make sure the Controller enters the correct state. The hardware interface 00119 // between the uP and the LCD can only write the 4 most significant bits (Most Significant Nibble, MSN). 00120 // In 4 bit mode the LCD expects the MSN first, followed by the LSN. 00121 // 00122 // Current state: 8 bit mode | 4 bit mode, MSN is next | 4 bit mode, LSN is next 00123 //------------------------------------------------------------------------------------------------- 00124 _writeNibble(0x3); // set 8 bit mode (MSN) and dummy LSN, | set 8 bit mode (MSN), | set dummy LSN, 00125 // remains in 8 bit mode | remains in 4 bit mode | remains in 4 bit mode 00126 wait_ms(15); // 00127 00128 _writeNibble(0x3); // set 8 bit mode (MSN) and dummy LSN, | set dummy LSN, | set 8bit mode (MSN), 00129 // remains in 8 bit mode | change to 8 bit mode | remains in 4 bit mode 00130 wait_ms(15); // 00131 00132 _writeNibble(0x3); // set 8 bit mode (MSN) and dummy LSN, | set 8 bit mode (MSN) and dummy LSN, | set dummy LSN, 00133 // remains in 8 bit mode | remains in 8 bit mode | change to 8 bit mode 00134 wait_ms(15); // 00135 00136 // Controller is now in 8 bit mode 00137 00138 _writeNibble(0x2); // Change to 4-bit mode (MSN), the LSN is undefined dummy 00139 wait_us(40); // most instructions take 40us 00140 00141 // Controller is now in 4-bit mode 00142 // Note: 4/8 bit mode is ignored for most native SPI and I2C devices. They dont use the parallel bus. 00143 // However, _writeNibble() method is void anyway for native SPI and I2C devices. 00144 } 00145 else { 00146 // Reset in 8 bit mode, final Function set will follow 00147 _writeCommand(0x30); // Function set 0 0 1 DL=1 N F x x 00148 wait_ms(1); // most instructions take 40us 00149 } 00150 00151 // Device specific initialisations: DC/DC converter to generate VLCD or VLED, number of lines etc 00152 switch (_ctrl) { 00153 00154 case KS0073: 00155 // Initialise Display configuration 00156 switch (_type) { 00157 // case LCD6x1: 00158 case LCD8x1: //8x1 is a regular 1 line display 00159 // case LCD8x2B: //8x1 is a 16x1 line display 00160 case LCD12x1: 00161 case LCD16x1: 00162 case LCD20x1: 00163 case LCD24x1: 00164 // case LCD32x1: // EXT pin is High, extension driver needed 00165 // case LCD40x1: // EXT pin is High, extension driver needed 00166 // case LCD52x1: // EXT pin is High, extension driver needed 00167 _function = dl | 0x02; // Set function, 0 0 1 DL, N, RE(0), DH, REV 00168 // Note: 4 bit mode is NOT ignored for native SPI ! 00169 // DL=1 (8 bits bus), DL=0 (4 bits bus) 00170 // N=0 (1-line mode), N=1 (2-line mode), dont care for 4 line mode 00171 // RE=0 (Dis. Extended Regs, special mode for KS0073) 00172 // DH=1 (Disp shift enable, special mode for KS0073) 00173 // REV=0 (Reverse normal, special mode for KS0073) 00174 00175 _function_1 = dl | 0x04; // Set function, 0 0 1 DL, N, RE(1), BE, LP (Ext Regs) 00176 // Note: 4 bit mode is NOT ignored for native SPI ! 00177 // DL=1 (8 bits bus), DL=0 (4 bits bus) 00178 // N=0 (1-line mode), N=1 (2-line mode), dont care for 4 line mode 00179 // RE=1 (Ena Extended Regs, special mode for KS0073) 00180 // BE=0 (Blink Enable, CG/SEG RAM, special mode for KS0073) 00181 // LP=0 (LP=1 Low power mode, LP=0 Normal) 00182 00183 _function_x = 0x00; // Ext Function set 0000 1 FW BW NW (Ext Regs) 00184 // NW=0 (1,2 line), NW=1 (4 Line, special mode for KS0073) 00185 break; 00186 00187 // case LCD12x3D: // Special mode for KS0073, KS0078 and PCF21XX 00188 // case LCD12x3D1: // Special mode for KS0073, KS0078 and PCF21XX 00189 case LCD12x4D: // Special mode for KS0073, KS0078 and PCF21XX 00190 // case LCD16x3D: // Special mode for KS0073, KS0078 00191 // case LCD16x3D1: // Special mode for KS0073, KS0078 00192 // case LCD16x4D: // Special mode for KS0073, KS0078 00193 case LCD20x4D: // Special mode for KS0073, KS0078 00194 _function = dl | 0x02; // Set function, 0 0 1 DL, N, RE(0), DH, REV 00195 // Note: 4 bit mode is NOT ignored for native SPI ! 00196 // DL=1 (8 bits bus), DL=0 (4 bits bus) 00197 // N=0 (1-line mode), N=1 (2-line mode), dont care for 4 line mode 00198 // RE=0 (Dis. Extended Regs, special mode for KS0073) 00199 // DH=1 (Disp shift enable, special mode for KS0073) 00200 // REV=0 (Reverse normal, special mode for KS0073) 00201 00202 _function_1 = dl | 0x04; // Set function, 0 0 1 DL, N, RE(1), BE, LP (Ext Regs) 00203 // Note: 4 bit mode is NOT ignored for native SPI ! 00204 // DL=1 (8 bits bus), DL=0 (4 bits bus) 00205 // N=0 (1-line mode), N=1 (2-line mode), dont care for 4 line mode 00206 // RE=1 (Ena Extended Regs, special mode for KS0073) 00207 // BE=0 (Blink Enable, CG/SEG RAM, special mode for KS0073) 00208 // LP=0 (LP=1 Low power mode, LP=0 Normal) 00209 00210 _function_x = 0x01; // Ext Function set 0000 1 FW BW NW (Ext Regs) 00211 // NW=0 (1,2 line), NW=1 (4 Line, special mode for KS0073) 00212 break; 00213 00214 // case LCD6x2: 00215 case LCD8x2: 00216 case LCD16x2: 00217 // case LCD16x1C: 00218 case LCD20x2: 00219 case LCD24x2: 00220 case LCD32x2: 00221 // All other LCD types are initialised as 2 Line displays 00222 _function = dl | 0x0A; // Set function, 0 0 1 DL, N, RE(0), DH, REV 00223 // Note: 4 bit mode is NOT ignored for native SPI ! 00224 // DL=1 (8 bits bus), DL=0 (4 bits bus) 00225 // N=1 (2-line mode), N=0 (1-line mode) 00226 // RE=0 (Dis. Extended Regs, special mode for KS0073) 00227 // DH=1 (Disp shift enable, special mode for KS0073) 00228 // REV=0 (Reverse normal, special mode for KS0073) 00229 00230 _function_1 = dl | 0x0C; // Set function, 0 0 1 DL, N, RE(1), BE, LP (Ext Regs) 00231 // Note: 4 bit mode is NOT ignored for native SPI ! 00232 // DL=1 (8 bits bus), DL=0 (4 bits bus) 00233 // N=1 (2 line mode), N=0 (1-line mode) 00234 // RE=1 (Ena Extended Regs, special mode for KS0073) 00235 // BE=0 (Blink Enable, CG/SEG RAM, special mode for KS0073) 00236 // LP=0 (LP=1 Low power mode, LP=0 Normal) 00237 00238 _function_x = 0x00; // Ext Function set 0000 1 FW BW NW (Ext Regs) 00239 // NW=0 (1,2 line), NW=1 (4 Line, special mode for KS0073) 00240 break; 00241 00242 default: 00243 error("Error: LCD Controller type does not support this Display type\n\r"); 00244 break; 00245 } // switch type 00246 00247 // init special features 00248 _writeCommand(0x20 | _function_1);// Function set 001 DL N RE(1) BE LP (Ext Regs) 00249 // DL=0 (4 bits bus), DL=1 (8 bits mode) 00250 // N=0 (1 line mode), N=1 (2 line mode) 00251 // RE=1 (Ena Extended Regs, special mode for KS0073) 00252 // BE=0 (Blink Enable/Disable, CG/SEG RAM, special mode for KS0073) 00253 // LP=0 (LP=1 Low power mode, LP=0 Normal) 00254 00255 _writeCommand(0x08 | _function_x); // Ext Function set 0000 1 FW BW NW (Ext Regs) 00256 // FW=0 (5-dot font, special mode for KS0073) 00257 // BW=0 (Cur BW invert disable, special mode for KS0073) 00258 // NW=0 (1,2 Line), NW=1 (4 line, special mode for KS0073) 00259 00260 _writeCommand(0x10); // Scroll/Shift set 0001 DS/HS4 DS/HS3 DS/HS2 DS/HS1 (Ext Regs) 00261 // Dotscroll/Display shift enable (Special mode for KS0073) 00262 00263 _writeCommand(0x80); // Scroll Quantity set 1 0 SQ5 SQ4 SQ3 SQ2 SQ1 SQ0 (Ext Regs) 00264 // Scroll quantity (Special mode for KS0073) 00265 00266 _writeCommand(0x20 | _function); // Function set 001 DL N RE(0) DH REV (Std Regs) 00267 // DL=0 (4 bits bus), DL=1 (8 bits mode) 00268 // N=0 (1 line mode), N=1 (2 line mode) 00269 // RE=0 (Dis. Extended Regs, special mode for KS0073) 00270 // DH=1 (Disp shift enable/disable, special mode for KS0073) 00271 // REV=0 (Reverse/Normal, special mode for KS0073) 00272 break; // case KS0073 Controller 00273 00274 00275 case KS0078: 00276 // Initialise Display configuration 00277 switch (_type) { 00278 case LCD8x1: //8x1 is a regular 1 line display 00279 case LCD8x2B: //8x2B is a special case of 16x1 00280 // case LCD12x1: 00281 case LCD16x1: 00282 // case LCD20x1: 00283 case LCD24x1: 00284 _function = dl | 0x02; // Function set 001 DL N RE(0) DH REV (Std Regs) 00285 // DL=0 (4 bits bus) 00286 // N=0 (1 line mode), N=1 (2 line mode) 00287 // RE=0 (Dis. Extended Regs, special mode for KS0078) 00288 // DH=1 (Disp shift enable, special mode for KS0078) 00289 // REV=0 (Reverse normal, special mode for KS0078) 00290 00291 _function_1 = dl | 0x04; // Function set 001 DL N RE(1) BE 0 (Ext Regs) 00292 // DL=0 (4 bits bus) 00293 // N=0 (1 line mode), N=1 (2 line mode) 00294 // RE=1 (Ena Extended Regs, special mode for KS0078) 00295 // BE=0 (Blink Enable, CG/SEG RAM, special mode for KS0078) 00296 // 0 00297 00298 _function_x = 0x00; // Ext Function set 0000 1 FW BW NW (Ext Regs) 00299 // NW=0 (1,2 line), NW=1 (4 Line, special mode for KS0078) 00300 break; 00301 00302 // case LCD12x3D: // Special mode for KS0073, KS0078 and PCF21XX 00303 // case LCD12x3D1: // Special mode for KS0073, KS0078 and PCF21XX 00304 // case LCD12x4D: // Special mode for KS0073, KS0078 and PCF21XX 00305 // case LCD16x3D: // Special mode for KS0073, KS0078 00306 // case LCD16x4D: // Special mode for KS0073, KS0078 00307 // case LCD20x4D: // Special mode for KS0073, KS0078 00308 // case LCD24x3D: // Special mode for KS0078 00309 // case LCD24x3D1: // Special mode for KS0078 00310 case LCD24x4D: // Special mode for KS0078 00311 _function = dl | 0x02; // Function set 001 DL N RE(0) DH REV (Std Regs) 00312 // DL=0 (4 bits bus) 00313 // N=0 (dont care for 4 line mode) 00314 // RE=0 (Dis. Extended Regs, special mode for KS0078) 00315 // DH=1 (Disp shift enable, special mode for KS0078) 00316 // REV=0 (Reverse normal, special mode for KS0078) 00317 00318 _function_1 = dl | 0x04; // Function set 001 DL N RE(1) BE 0 (Ext Regs) 00319 // DL=0 (4 bits bus) 00320 // N=0 (1 line mode), N=1 (2 line mode) 00321 // RE=1 (Ena Extended Regs, special mode for KS0078) 00322 // BE=0 (Blink Enable, CG/SEG RAM, special mode for KS0078) 00323 // 0 00324 00325 _function_x = 0x01; // Ext Function set 0000 1 FW BW NW (Ext Regs) 00326 // NW=0 (1,2 line), NW=1 (4 Line, special mode for KS0078) 00327 break; 00328 00329 // case LCD6x2: 00330 case LCD8x2: 00331 case LCD16x2: 00332 // case LCD16x1C: 00333 case LCD20x2: 00334 case LCD24x2: 00335 case LCD32x2: 00336 case LCD40x2: 00337 // All other LCD types are initialised as 2 Line displays (including LCD16x1C and LCD40x4) 00338 _function = dl | 0x0A; // Function set 001 DL N RE(0) DH REV (Std Regs) 00339 // DL=0 (4 bits bus) 00340 // N=1 (1 line mode), N=1 (2 line mode) 00341 // RE=0 (Dis. Extended Regs, special mode for KS0078) 00342 // DH=1 (Disp shift enable, special mode for KS0078) 00343 // REV=0 (Reverse normal, special mode for KS0078) 00344 00345 _function_1 = dl | 0x0C; // Function set 001 DL N RE(1) BE 0 (Ext Regs) 00346 // DL=0 (4 bits bus) 00347 // N=1 (1 line mode), N=1 (2 line mode) 00348 // RE=1 (Ena Extended Regs, special mode for KS0078) 00349 // BE=0 (Blink Enable, CG/SEG RAM, special mode for KS0078) 00350 // 0 00351 00352 _function_x = 0x00; // Ext Function set 0000 1 FW BW NW (Ext Regs) 00353 // NW=0 (1,2 line), NW=1 (4 Line, special mode for KS0078) 00354 break; 00355 00356 default: 00357 error("Error: LCD Controller type does not support this Display type\n\r"); 00358 break; 00359 } // switch type 00360 00361 // init special features 00362 _writeCommand(0x20 | _function_1);// Function set 001 DL N RE(1) BE 0 (Ext Regs) 00363 // DL=0 (4 bits bus), DL=1 (8 bits mode) 00364 // N=0 (1 line mode), N=1 (2 line mode) 00365 // RE=1 (Ena Extended Regs, special mode for KS0078) 00366 // BE=0 (Blink Enable/Disable, CG/SEG RAM, special mode for KS0078) 00367 // 0 00368 00369 _writeCommand(0x08 | _function_x); // Ext Function set 0000 1 FW BW NW (Ext Regs) 00370 // FW=0 (5-dot font, special mode for KS0078) 00371 // BW=0 (Cur BW invert disable, special mode for KS0078) 00372 // NW=0 (1,2 Line), NW=1 (4 line, special mode for KS0078) 00373 00374 _writeCommand(0x10); // Scroll/Shift set 0001 DS/HS4 DS/HS3 DS/HS2 DS/HS1 (Ext Regs) 00375 // Dotscroll/Display shift enable (Special mode for KS0078) 00376 00377 _writeCommand(0x80); // Scroll Quantity set 1 0 SQ5 SQ4 SQ3 SQ2 SQ1 SQ0 (Ext Regs) 00378 // Scroll quantity (Special mode for KS0078) 00379 00380 _writeCommand(0x20 | _function); // Function set 001 DL N RE(0) DH REV (Std Regs) 00381 // DL=0 (4 bits bus), DL=1 (8 bits mode) 00382 // N=0 (1 line mode), N=1 (2 line mode) 00383 // RE=0 (Dis. Extended Regs, special mode for KS0078) 00384 // DH=1 (Disp shift enable/disable, special mode for KS0078) 00385 // REV=0 (Reverse/Normal, special mode for KS0078) 00386 break; // case KS0078 Controller 00387 00388 case ST7032_3V3: 00389 // ST7032 controller: Initialise Voltage booster for VLCD. VDD=3V3 00390 // Note: very similar to SPLC792A 00391 case ST7032_5V: 00392 // ST7032 controller: Disable Voltage booster for VLCD. VDD=5V 00393 00394 // Initialise Display configuration 00395 switch (_type) { 00396 case LCD8x1: //8x1 is a regular 1 line display 00397 case LCD8x2B: //8x2B is a special case of 16x1 00398 // case LCD12x1: 00399 case LCD16x1: 00400 // case LCD20x1: 00401 case LCD24x1: 00402 _function = 0x00; // FUNCTION SET 0 0 1 DL=0 (4 bit), N=0 (1-line display mode), F=0 (5*7dot), 0, IS 00403 // Note: 4 bit mode is ignored for native SPI and I2C devices 00404 // Saved to allow switch between Instruction sets at later time 00405 break; 00406 00407 case LCD12x3D: // Special mode for KS0078 and PCF21XX 00408 case LCD12x3D1: // Special mode for KS0078 and PCF21XX 00409 case LCD12x4D: // Special mode for KS0078 and PCF21XX 00410 case LCD16x3G: // Special mode for ST7036 00411 case LCD24x4D: // Special mode for KS0078 00412 error("Error: LCD Controller type does not support this Display type\n\r"); 00413 break; 00414 00415 default: 00416 // All other LCD types are initialised as 2 Line displays 00417 _function = 0x08; // FUNCTION SET 0 0 1 DL=0 (4 bit), N=1 (2-line display mode), F=0 (5*7dot), 0, IS 00418 // Note: 4 bit mode is ignored for native SPI and I2C devices 00419 // Saved to allow switch between Instruction sets at later time 00420 break; 00421 } // switch type 00422 00423 // init special features 00424 _writeCommand(0x20 | _function | 0x01); // Set function, 0 0 1 DL N F 0 IS=1 Select Instr Set = 1 00425 00426 _writeCommand(0x1C); // Internal OSC frequency adjustment Framefreq=183HZ, Bias will be 1/4 (Instr Set=1) 00427 // Note: Bias and Osc register not available on SPLC792A 00428 00429 _contrast = LCD_ST7032_CONTRAST; 00430 _writeCommand(0x70 | (_contrast & 0x0F)); // Set Contrast Low bits, 0 1 1 1 C3 C2 C1 C0 (IS=1) 00431 00432 00433 if (_ctrl == ST7032_3V3) { 00434 // _icon_power = 0x04; // Icon display off (Bit3=0), Booster circuit is turned on (Bit2=1) (IS=1) 00435 _icon_power = 0x0C; // Icon display on (Bit3=1), Booster circuit is turned on (Bit2=1) (IS=1) 00436 // Note: Booster circuit always on for SPLC792A, Bit2 is dont care 00437 // Saved to allow contrast change at later time 00438 } 00439 else { 00440 // _icon_power = 0x00; // Icon display off, Booster circuit is turned off (IS=1) 00441 _icon_power = 0x08; // Icon display on, Booster circuit is turned off (IS=1) 00442 // Saved to allow contrast change at later time 00443 } 00444 _writeCommand(0x50 | _icon_power | ((_contrast >> 4) & 0x03)); // Set Icon, Booster and Contrast High bits, 0 1 0 1 Ion Bon C5 C4 (IS=1) 00445 wait_ms(10); // Wait 10ms to ensure powered up 00446 00447 _writeCommand(0x68 | (LCD_ST7032_RAB & 0x07)); // Voltage follower, 0 1 1 0 FOn=1, Ampl ratio Rab2=1, Rab1=0, Rab0=0 (IS=1) 00448 wait_ms(10); // Wait 10ms to ensure powered up 00449 00450 _writeCommand(0x20 | _function); // Select Instruction Set = 0 00451 00452 break; // case ST7032_3V3 Controller 00453 // case ST7032_5V Controller 00454 00455 case ST7036_3V3: 00456 // ST7036 controller: Initialise Voltage booster for VLCD. VDD=3V3 00457 // Note: supports 1,2 (LCD_T_A) or 3 lines (LCD_T_G) 00458 case ST7036_5V: 00459 // ST7036 controller: Disable Voltage booster for VLCD. VDD=5V 00460 // Note: supports 1,2 (LCD_T_A) or 3 lines (LCD_T_G) 00461 00462 // Initialise Display configuration 00463 switch (_type) { 00464 case LCD8x1: //8x1 is a regular 1 line display 00465 case LCD8x2B: //8x2D is a special case of 16x1 00466 // case LCD12x1: 00467 case LCD16x1: 00468 case LCD24x1: 00469 _function = 0x00; // Set function, 0 0 1 DL=0 (4-bit Databus), N=0 (1 Line), DH=0 (5x7font), IS2, IS1 (Select Instruction Set) 00470 // Note: 4 bit mode is ignored for native SPI and I2C devices 00471 // Saved to allow switch between Instruction sets at later time 00472 00473 _bias_lines = 0x04; // Bias: 1/5, 1 or 2-Lines LCD 00474 break; 00475 00476 // case LCD12x3G: // Special mode for ST7036 00477 case LCD16x3G: // Special mode for ST7036 00478 _function = 0x08; // Set function, 0 0 1 DL=0 (4-bit Databus), N=1 (2 Line), DH=0 (5x7font), IS2,IS1 (Select Instruction Set) 00479 // Note: 4 bit mode is ignored for native SPI and I2C devices 00480 // Saved to allow switch between Instruction sets at later time 00481 00482 _bias_lines = 0x05; // Bias: 1/5, 3-Lines LCD 00483 break; 00484 00485 // case LCD12x3D1: // Special mode for KS0078 and PCF21XX 00486 // case LCD16x3D1: // Special mode for SSD1803 00487 case LCD12x4D: // Special mode for PCF2116 00488 case LCD24x4D: // Special mode for KS0078 00489 error("Error: LCD Controller type does not support this Display type\n\r"); 00490 break; 00491 00492 default: 00493 // All other LCD types are initialised as 2 Line displays (including LCD16x1C and LCD40x4) 00494 _function = 0x08; // Set function, 0 0 1 DL=0 (4-bit Databus), N=1 (2 Line), DH=0 (5x7font), IS2,IS1 (Select Instruction Set) 00495 // Note: 4 bit mode is ignored for native SPI and I2C devices 00496 // Saved to allow switch between Instruction sets at later time 00497 00498 _bias_lines = 0x04; // Bias: 1/5, 1 or 2-Lines LCD 00499 break; 00500 } // switch type 00501 00502 00503 // init special features 00504 _writeCommand(0x20 | _function | 0x01); // Set function, IS2,IS1 = 01 (Select Instr Set = 1) 00505 _writeCommand(0x10 | _bias_lines); // Set Bias and 1,2 or 3 lines (Instr Set 1) 00506 00507 _contrast = LCD_ST7036_CONTRAST; 00508 _writeCommand(0x70 | (_contrast & 0x0F)); // Set Contrast, 0 1 1 1 C3 C2 C1 C0 (Instr Set 1) 00509 00510 if (_ctrl == ST7036_3V3) { 00511 _icon_power = 0x0C; // Set Icon, Booster, Contrast High bits, 0 1 0 1 Ion=1 Bon=1 C5 C4 (Instr Set 1) 00512 // _icon_power = 0x04; // Set Icon, Booster, Contrast High bits, 0 1 0 1 Ion=0 Bon=1 C5 C4 (Instr Set 1) 00513 // Saved to allow contrast change at later time 00514 } 00515 else { 00516 _icon_power = 0x08; // Set Icon, Booster, Contrast High bits, 0 1 0 1 Ion=1 Bon=0 C5 C4 (Instr Set 1) 00517 // _icon_power = 0x00; // Set Icon, Booster, Contrast High bits, 0 1 0 1 Ion=0 Bon=0 C5 C4 (Instr Set 1) 00518 } 00519 00520 _writeCommand(0x50 | _icon_power | ((_contrast >> 4) & 0x03)); // Set Contrast C5, C4 (Instr Set 1) 00521 wait_ms(10); // Wait 10ms to ensure powered up 00522 00523 _writeCommand(0x68 | (LCD_ST7036_RAB & 0x07)); // Voltagefollower On = 1, Ampl ratio Rab2, Rab1, Rab0 = 1 0 1 (Instr Set 1) 00524 wait_ms(10); // Wait 10ms to ensure powered up 00525 00526 _writeCommand(0x20 | _function); // Set function, IS2,IS1 = 00 (Select Instruction Set = 0) 00527 00528 break; // case ST7036_3V3 Controller 00529 // case ST7036_5V Controller 00530 00531 case ST7070: 00532 // Initialise Display configuration 00533 switch (_type) { 00534 case LCD8x1: //8x1 is a regular 1 line display 00535 case LCD8x2B: //8x2D is a special case of 16x1 00536 // case LCD12x1: 00537 case LCD16x1: 00538 case LCD24x1: 00539 _function = dl | 0x00; // Set function, 0 0 1 DL=0 (4-bit Databus), N=0 (1 Line), EXT=0, x, x 00540 // Note: 4 bit mode is NOT ignored for native SPI ! 00541 // Saved to allow switch between Instruction sets at later time 00542 break; 00543 00544 // case LCD12x3D1: // Special mode for KS0078 and PCF21XX 00545 // case LCD16x3D1: // Special mode for SSD1803 00546 case LCD12x4D: // Special mode for PCF2116 00547 case LCD24x4D: // Special mode for KS0078 00548 // case LCD12x3G: // Special mode for ST7036 00549 case LCD16x3G: // Special mode for ST7036 00550 error("Error: LCD Controller type does not support this Display type\n\r"); 00551 break; 00552 00553 default: 00554 // All other LCD types are initialised as 2 Line displays (including LCD16x1C and LCD40x4) 00555 _function = dl | 0x08; // Set function, 0 0 1 DL, N=1 (2 Line), EXT=0, x, x 00556 // Note: 4 bit mode is NOT ignored for native SPI ! 00557 // Saved to allow switch between Instruction sets at later time 00558 break; 00559 } // switch type 00560 00561 // _writeCommand(0x00); // NOP, make sure to sync SPI 00562 00563 // init special features 00564 _writeCommand(0x20 | _function | 0x04); // Set function, 0 0 1 DL N EXT=1 x x (Select Instr Set = 1) 00565 00566 _writeCommand(0x04 | 0x00); // Set Bias resistors 0 0 0 0 0 1 Rb1,Rb0= 0 0 (Extern Res) (Instr Set 1) 00567 00568 _writeCommand(0x40 | 0x00); // COM/SEG directions 0 1 0 0 C1, C2, S1, S2 (Instr Set 1) 00569 // C1=1: Com1-8 -> Com8-1; C2=1: Com9-16 -> Com16-9 00570 // S1=1: Seg1-40 -> Seg40-1; S2=1: Seg41-80 -> Seg80-41 00571 00572 _writeCommand(0x20 | _function); // Set function, EXT=0 (Select Instr Set = 0) 00573 00574 break; // case ST7070 Controller 00575 00576 case SSD1803_3V3: 00577 // changes have been made according to the register description of SSD1803 Rev 2.0 00578 // http://www.lcd-module.de/fileadmin/eng/pdf/zubehoer/ssd1803_2_0.pdf 00579 // SSD1803 controller: Initialize Voltage booster for VLCD. VDD=3V3 00580 // Note: supports 1,2, 3 or 4 lines 00581 // case SSD1803_5V: 00582 // SSD1803 controller: No Voltage booster for VLCD. VDD=5V 00583 00584 // Initialize Display configuration 00585 switch (_type) { 00586 case LCD8x1: //8x1 is a regular 1 line display 00587 case LCD8x2B: //8x2D is a special case of 16x1 00588 // case LCD12x1: 00589 case LCD16x1: 00590 case LCD24x1: 00591 _function = 0x20; // Set function 0 0 1 DL N RE(0) DH REV 00592 // Saved to allow switch between Instruction sets at later time 00593 // DL=0 4-bit data bus, 00594 // Note: 4 bit mode is ignored for native SPI and I2C devices 00595 // N=0 1 Line / 3 Line 00596 // DH=0 Double Height disable 00597 // REV=0 Reverse off, special feature of SSD1803 00598 00599 _function_1 = 0x24; // Set function, 0 0 1 DL N RE(1) BE 0 00600 // Saved to allow switch between Instruction sets at later time 00601 // DL=0 4-bit data bus, 00602 // Note: 4 bit mode is ignored for native SPI and I2C devices 00603 // N=0 1 Line / 3 Line 00604 // BE=0 Blink Enable off, special feature of SSD1803 00605 00606 _lines = 0x08; // Ext function set 0 0 0 0 1 FW BW NW 00607 // FW=0 6-dot font width off 00608 // BW=0 Black/White inversion at cursor position off 00609 // NW=0 1-Line LCD (N=0) 00610 break; 00611 00612 case LCD12x3D: // Special mode for KS0078 and PCF21XX 00613 // case LCD12x3D1: // Special mode for KS0078 and PCF21XX 00614 case LCD16x3D: // Special mode for KS0078 00615 // case LCD16x3D1: // Special mode for SSD1803 00616 // case LCD20x3D: // Special mode for SSD1803 00617 _function = 0x20; // Set function 0 0 1 DL N RE(0) DH REV 00618 // Saved to allow switch between Instruction sets at later time 00619 // DL=0 4-bit data bus, 00620 // Note: 4 bit mode is ignored for native SPI and I2C devices 00621 // N=0 1 Line / 3 Line 00622 // DH=0 Double Height disable 00623 // REV=0 Reverse off, special feature of SSD1803 00624 00625 _function_1 = 0x24; // Set function, 0 0 1 DL N RE(1) BE 0 00626 // Saved to allow switch between Instruction sets at later time 00627 // DL=0 4-bit data bus, 00628 // Note: 4 bit mode is ignored for native SPI and I2C devices 00629 // N=0 1 Line / 3 Line 00630 // BE=0 Blink Enable off, special feature of SSD1803 00631 00632 _lines = 0x08; // Ext function set 0 0 0 0 1 FW BW NW 00633 // FW=0 6-dot font width off 00634 // BW=0 Black/White inversion at cursor position off 00635 // NW=0 1-Line LCD (N=0) 00636 break; 00637 00638 // case LCD10x2D: // Special mode for SSD1803, 4-line mode but switch to double height font 00639 case LCD10x4D: // Special mode for SSD1803 00640 case LCD20x4D: // Special mode for SSD1803 (register description according to SSD1803 Rev 2.0) 00641 _function = 0x28; // Set function 0 0 1 DL N RE(0) DH REV 00642 // Saved to allow switch between Instruction sets at later time 00643 // DL=0 4-bit data bus, 00644 // Note: 4 bit mode is ignored for native SPI and I2C devices 00645 // N=1 4 Line mode when NW=1 00646 // DH=0 Double Height disable 00647 // REV=0 Reverse off, special feature of SSD1803 00648 00649 _function_1 = 0x2C; // Set function, 0 0 1 DL N RE(1) BE 0 00650 // Saved to allow switch between Instruction sets at later time 00651 // DL=0 4-bit data bus, 00652 // Note: 4 bit mode is ignored for native SPI and I2C devices 00653 // N=1 4 Line 00654 // BE=0 Blink Enable off, special feature of SSD1803 00655 00656 _lines = 0x09; // Ext function set 0 0 0 0 1 FW BW NW 00657 // FW=0 6-dot font width off 00658 // BW=0 Black/White inversion at cursor position off 00659 // NW=1 4-Line LCD (N=1) 00660 break; 00661 00662 case LCD16x3G: // Special mode for ST7036 00663 case LCD24x4D: // Special mode for KS0078 00664 error("Error: LCD Controller type does not support this Display type\n\r"); 00665 break; 00666 00667 default: 00668 // All other LCD types are Initialized as 2 Line displays (including LCD16x1C and LCD40x4) 00669 _function = 0x28; // Set function 0 0 1 DL N RE(0) DH REV 00670 // Saved to allow switch between Instruction sets at later time 00671 // DL=0 4-bit data bus, 00672 // Note: 4 bit mode is ignored for native SPI and I2C devices 00673 // N=1 4 Line mode when NW=1 00674 // DH=0 Double Height disable 00675 // REV=0 Reverse off, special feature of SSD1803 00676 00677 _function_1 = 0x2C; // Set function, 0 0 1 DL N RE(1) BE 0 00678 // Saved to allow switch between Instruction sets at later time 00679 // DL=0 4-bit data bus, 00680 // Note: 4 bit mode is ignored for native SPI and I2C devices 00681 // N=1 2 line / 4 Line 00682 // BE=0 Blink Enable off, special feature of SSD1803 00683 00684 _lines = 0x08; // Ext function set 0 0 0 0 1 FW BW NW 00685 // FW=0 6-dot font width off 00686 // BW=0 Black/White inversion at cursor position off 00687 // NW=0 2-Line LCD (N=1) 00688 00689 break; 00690 } // switch type 00691 00692 00693 // init special features 00694 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 DL N BE RE(1) REV 00695 // Select Extended Instruction Set 00696 00697 _writeCommand(0x06); // Set ext entry mode, 0 0 0 0 0 1 BDC=1 COM1-32, BDS=0 SEG100-1 "Bottom View" (Ext Instr Set) 00698 // _writeCommand(0x05); // Set ext entry mode, 0 0 0 0 0 1 BDC=0 COM32-1, BDS=1 SEG1-100 "Top View" (Ext Instr Set) 00699 wait_ms(5); // Wait to ensure completion or SSD1803 fails to set Top/Bottom after reset.. 00700 00701 _writeCommand(0x08 | _lines); // Set ext function 0 0 0 0 1 FW BW NW 1,2,3 or 4 lines (Ext Instr Set) 00702 00703 _writeCommand(0x10); // Double Height and Bias, 0 0 0 1 UD2=0, UD1=0, BS1=0 Bias 1/5, DH=0 (Ext Instr Set) 00704 00705 // _writeCommand(0x76); // Set TC Control, 0 1 1 1 0 1 1 0 (Ext Instr Set) 00706 // _writeData(0x02); // Set TC data, 0 0 0 0 0 TC2,TC1,TC0 = 0 1 0 (Ext Instr Set) 00707 00708 _writeCommand(0x20 | _function | 0x01); // Set function, 0 0 1 DL N DH RE(0) IS=1 Select Instruction Set 1 00709 // Select Std Instr set, Select IS=1 00710 00711 _contrast = LCD_SSD1_CONTRAST; 00712 _writeCommand(0x70 | (_contrast & 0x0F)); // Set Contrast 0 1 1 1 C3, C2, C1, C0 (Instr Set 1) 00713 00714 // _icon_power = 0x04; // Icon off, Booster on (Instr Set 1) 00715 _icon_power = 0x0C; // Icon on, Booster on (Instr Set 1) 00716 // Saved to allow contrast change at later time 00717 _writeCommand(0x50 | _icon_power | ((_contrast >> 4) & 0x03)); // Set Power, Icon and Contrast, 0 1 0 1 Ion Bon C5 C4 (Instr Set 1) 00718 wait_ms(10); // Wait 10ms to ensure powered up 00719 00720 _writeCommand(0x68 | (LCD_SSD1_RAB & 0x07)); // Set Voltagefollower 0 1 1 0 Don = 1, Ampl ratio Rab2, Rab1, Rab0 = 1 1 0 (Instr Set 1) 00721 wait_ms(10); // Wait 10ms to ensure powered up 00722 00723 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 DL N BE RE(1) REV 00724 // Select Extended Instruction Set 1 00725 _writeCommand(0x10); // Shift/Scroll enable, 0 0 0 1 DS4/HS4 DS3/HS3 DS2/HS2 DS1/HS1 (Ext Instr Set 1) 00726 00727 00728 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS=0 Select Instruction Set 0 00729 // Select Std Instr set, Select IS=0 00730 00731 break; // case SSD1803 Controller 00732 00733 00734 // Note1: The PCF21XX family of controllers has several types that dont have an onboard voltage generator for V-LCD. 00735 // You must supply this LCD voltage externally and not try to enable VGen. 00736 // Note2: The early versions of PCF2116 controllers (eg PCF2116C) can not generate sufficiently negative voltage for the LCD at a VDD of 3V3. 00737 // You must supply this voltage externally and not enable VGen or you must use a higher VDD (e.g. 5V) and enable VGen. 00738 // More recent versions of the controller (eg PCF2116K) have an improved VGen that will work with 3V3. 00739 // Note3: See datasheet, PCF2116 and other types provide a V0 pin to control the LCD contrast voltage that is provided by VGen. This pins allows 00740 // contrast control similar to that of pin 3 on the standard 14pin LCD module connector. 00741 // You can disable VGen by connecting Vo to VDD. VLCD will then be used directly as LCD voltage. 00742 // Note4: PCF2113 and PCF2119 are different wrt to VLCD generator! There is no V0 pin. The contrast voltage is software controlled by setting the VA and VB registers. 00743 // Vgen is automatically switched off when the contrast voltage VA or VB is set to 0x00. Note that certain limits apply to allowed values for VA and VB. 00744 // Note5: See datasheet, members of the PCF21XX family support different numbers of rows/columns. Not all can support 3 or 4 rows. 00745 // Note6: See datasheet, the PCF21XX-C and PCF21XX-K use a non-standard character set. This may result is strange looking text when not corrected.. 00746 00747 case PCF2103_3V3: 00748 // PCF2103 controller: No Voltage generator for VLCD, VDD=3V3..5V, VLCD input controls contrast voltage. 00749 // Initialise Display configuration 00750 switch (_type) { 00751 case LCD24x1: 00752 _function = 0x00; //FUNCTION SET 0 0 1 DL=0 4-bit, 0, M=0 1-line/24 chars display mode, 0, H=0 00753 //Note: 4 bit mode is ignored for I2C mode 00754 break; 00755 00756 // case LCD12x1D: //Special mode for PCF21XX, Only top line used 00757 case LCD12x2: 00758 _function = 0x04; //FUNCTION SET 0 0 1 DL=0 4-bit, 0, M=1 2-line/12 chars display mode, 0, H=0 00759 //Note: 4 bit mode is ignored for I2C mode 00760 break; 00761 00762 default: 00763 error("Error: LCD Controller type does not support this Display type\n\r"); 00764 break; 00765 00766 } // switch type 00767 00768 _writeCommand(0x20 | _function | 0x01); // Set function, Select Instr Set = 1 00769 wait_ms(10); // Wait 10ms to ensure powered up 00770 00771 // Note: Display from GA628 shows 12 chars. This is actually the right half of a 24x1 display. The commons have been connected in reverse order. 00772 _writeCommand(0x05); // Display Conf Set 0000 0, 1, P=0, Q=1 (Instr. Set 1) 00773 00774 _writeCommand(0x02); // Screen Config 0000 001, L=0 (Instr. Set 1) 00775 _writeCommand(0x08); // ICON Conf 0000 1, IM=0 (Char mode), IB=0 (no Icon blink), 0 (Instr. Set 1) 00776 00777 _writeCommand(0x20 | _function); // Set function, Select Instr Set = 0 00778 00779 #if(0) 00780 // Select CG RAM 00781 _writeCommand(0x40); //Set CG-RAM address, 8 sequential locations needed per UDC 00782 // Store UDC/Icon pattern: 00783 // 3 x 8 rows x 5 bits = 120 bits for Normal pattern (UDC 0..2) and 00784 // 3 x 8 rows x 5 bits = 120 bits for Blink pattern (UDC 4..6) 00785 for (int i=0; i<(8 * 8); i++) { 00786 // _writeData(0x1F); // All On 00787 _writeData(0x00); // All Off 00788 } 00789 #endif 00790 break; // case PCF2103_3V3 Controller 00791 00792 case PCF2113_3V3: 00793 // PCF2113 controller: Initialise Voltage booster for VLCD. VDD=3V3. VA and VB control contrast. 00794 // Initialise Display configuration 00795 switch (_type) { 00796 // case LCD12x1: 00797 // _function = 0x02; // FUNCTION SET 0 0 1 DL=0 4 bit, 0, M=0 1-line/12 chars display mode, SL=1, IS=0 00798 // Note: 4 bit mode is ignored for I2C mode 00799 case LCD24x1: 00800 _function = 0x00; // FUNCTION SET 0 0 1 DL=0 4 bit, 0, M=0 1-line/24 chars display mode, SL=0, IS=0 00801 // Note: 4 bit mode is ignored for I2C mode 00802 break; 00803 00804 case LCD12x2: 00805 _function = 0x04; // FUNCTION SET 0 0 1 DL=0 4 bit, 0, M=1 2-line/12 chars display mode, SL=0, IS=0 00806 break; 00807 00808 default: 00809 error("Error: LCD Controller type does not support this Display type\n\r"); 00810 break; 00811 00812 } // switch type 00813 00814 // Init special features 00815 _writeCommand(0x20 | _function | 0x01); // Set function, Select Instr Set = 1 00816 00817 _writeCommand(0x04); // Display Conf Set 0000 0, 1, P=0, Q=0 (Instr. Set 1) 00818 _writeCommand(0x10); // Temp Compensation Set 0001 0, 0, TC1=0, TC2=0 (Instr. Set 1) 00819 // _writeCommand(0x42); // HV GEN 0100 S1=1, S2=0 (2x multiplier) (Instr. Set 1) 00820 _writeCommand(0x40 | (LCD_PCF2_S12 & 0x03)); // HV Gen 0100 S1=1, S2=0 (2x multiplier) (Instr. Set 1) 00821 00822 _contrast = LCD_PCF2_CONTRAST; 00823 _writeCommand(0x80 | 0x00 | (_contrast & 0x3F)); // VLCD_set (Instr. Set 1) 1, V=0, VA=contrast 00824 _writeCommand(0x80 | 0x40 | (_contrast & 0x3F)); // VLCD_set (Instr. Set 1) 1, V=1, VB=contrast 00825 wait_ms(10); // Wait 10ms to ensure powered up 00826 00827 _writeCommand(0x02); // Screen Config 0000 001, L=0 (Instr. Set 1) 00828 _writeCommand(0x08); // ICON Conf 0000 1, IM=0 (Char mode), IB=0 (no icon blink) DM=0 (no direct mode) (Instr. Set 1) 00829 00830 _writeCommand(0x20 | _function); // Set function, Select Instr Set = 0 00831 00832 break; // case PCF2113_3V3 Controller 00833 00834 00835 // case PCF2113_5V: 00836 // PCF2113 controller: No Voltage generator for VLCD. VDD=5V. Contrast voltage controlled by VA or VB. 00837 //@TODO 00838 00839 00840 case PCF2116_3V3: 00841 // PCF2116 controller: Voltage generator for VLCD. VDD=5V. V0 controls contrast voltage. 00842 // Initialise Display configuration 00843 switch (_type) { 00844 // case LCD12x1: 00845 // case LCD12x2: 00846 case LCD24x1: 00847 _writeCommand(0x22); //FUNCTION SET 0 0 1 DL=0 4-bit, N=0/M=0 1-line/24 chars display mode, G=1 Vgen on, 0 00848 //Note: 4 bit mode is ignored for I2C mode 00849 wait_ms(10); // Wait 10ms to ensure powered up 00850 break; 00851 00852 case LCD12x3D: // Special mode for KS0078 and PCF21XX 00853 case LCD12x3D1: // Special mode for PCF21XX 00854 case LCD12x4D: // Special mode for PCF21XX: 00855 _writeCommand(0x2E); //FUNCTION SET 0 0 1 DL=0 4-bit, N=1/M=1 4-line/12 chars display mode, G=1 VGen on, 0 00856 //Note: 4 bit mode is ignored for I2C mode 00857 wait_ms(10); // Wait 10ms to ensure powered up 00858 break; 00859 00860 case LCD24x2: 00861 _writeCommand(0x2A); //FUNCTION SET 0 0 1 DL=0 4-bit, N=1/M=0 2-line/24 chars display mode, G=1 VGen on, 0 00862 //Note: 4 bit mode is ignored for I2C mode 00863 wait_ms(10); // Wait 10ms to ensure powered up 00864 break; 00865 00866 default: 00867 error("Error: LCD Controller type does not support this Display type\n\r"); 00868 break; 00869 00870 } // switch type 00871 00872 break; // case PCF2116_3V3 Controller 00873 00874 00875 //Experimental for cellphone 3-line display, SA=0x74, No Ack supported, Character set C or K, DL = 8 bit, N=0,M=1 (reserved mode !!), external VLCD -2V5 00876 //@TODO 00877 case PCF2116_5V: 00878 // PCF2116 controller: No Voltage generator for VLCD. VDD=5V. V0 controls contrast voltage. 00879 // Initialise Display configuration 00880 switch (_type) { 00881 // case LCD12x1: 00882 // case LCD12x2: 00883 // case LCD24x1: 00884 // _writeCommand(0x20); //FUNCTION SET 0 0 1 DL=0 4-bit, N=0/M=0 1-line/24 chars display mode, G=0 no Vgen, 0 00885 //Note: 4 bit mode is ignored for I2C mode 00886 // wait_ms(10); // Wait 10ms to ensure powered up 00887 // break; 00888 00889 case LCD12x3D: // Special mode for KS0078 and PCF21XX 00890 case LCD12x3D1: // Special mode for PCF21XX 00891 case LCD12x4D: // Special mode for PCF21XX: 00892 // _writeCommand(0x34); //FUNCTION SET 8 bit, N=0/M=1 4-line/12 chars display mode OK 00893 // _writeCommand(0x24); //FUNCTION SET 4 bit, N=0/M=1 4-line/12 chars display mode OK 00894 _writeCommand(0x2C); //FUNCTION SET 0 0 1 DL=0 4-bit, N=1/M=1 4-line/12 chars display mode, G=0 no Vgen, 0 OK 00895 //Note: 4 bit mode is ignored for I2C mode 00896 wait_ms(10); // Wait 10ms to ensure powered up 00897 break; 00898 00899 // case LCD24x2: 00900 // _writeCommand(0x28); //FUNCTION SET 4 bit, N=1/M=0 2-line/24 chars display mode 00901 //Note: 4 bit mode is ignored for I2C mode 00902 // wait_ms(10); // Wait 10ms to ensure powered up 00903 // break; 00904 00905 default: 00906 error("Error: LCD Controller type does not support this Display type\n\r"); 00907 break; 00908 00909 } // switch type 00910 00911 break; // case PCF2116_5V Controller 00912 00913 case PCF2119_3V3: 00914 case PCF2119R_3V3: 00915 // PCF2119 controller: Initialise Voltage booster for VLCD. VDD=3V3. VA and VB control contrast. 00916 // Note1: See datasheet, the PCF2119 supports icons and provides separate constrast control for Icons and characters. 00917 // Note2: Vgen is switched off when the contrast voltage VA or VB is set to 0x00. 00918 00919 //POR or Hardware Reset should be applied 00920 wait_ms(10); // Wait 10ms to ensure powered up 00921 00922 // Initialise Display configuration 00923 switch (_type) { 00924 case LCD8x1: 00925 // case LCD12x1: 00926 case LCD16x1: 00927 _function = 0x02; // FUNCTION SET 0 0 1 DL=0 4-bit, 0 , M=0 1-line/16 chars display mode, SL=1 00928 // Note: 4 bit mode is ignored for I2C mode 00929 break; 00930 00931 case LCD24x1: 00932 // case LCD32x1: 00933 _function = 0x00; // FUNCTION SET 0 0 1 DL=0 4-bit, 0 , M=0 1-line/32 chars display mode, SL=0 00934 // Note: 4 bit mode is ignored for I2C mode 00935 break; 00936 00937 case LCD8x2: 00938 // case LCD12x2: 00939 case LCD16x2: 00940 _function = 0x04; // FUNCTION SET 0 0 1 DL=0 4-bit, 0, M=1 2-line/16 chars display mode, SL=0 00941 // Note: 4 bit mode is ignored for I2C mode 00942 break; 00943 00944 default: 00945 error("Error: LCD Controller type does not support this Display type\n\r"); 00946 break; 00947 00948 } // switch type 00949 00950 // Init special features 00951 _writeCommand(0x20 | _function | 0x01); // Set function, Select Instruction Set = 1 00952 00953 // _writeCommand(0x04); // DISP CONF SET (Instr. Set 1) 0000, 0, 1, P=0, Q=0 (IC at Bottom) 00954 // _writeCommand(0x05); // Display Conf Set 0000, 0, 1, P=0, Q=1 00955 // _writeCommand(0x06); // Display Conf Set 0000, 0, 1, P=1, Q=0 00956 _writeCommand(0x07); // Display Conf Set 0000, 0, 1, P=1, Q=1 (IC at Top) 00957 00958 _writeCommand(0x10); // TEMP CTRL SET (Instr. Set 1) 0001, 0, 0, TC1=0, TC2=0 00959 // _writeCommand(0x42); // HV GEN (Instr. Set 1) 0100, 0, 0, S1=1, S2=0 (2x multiplier) 00960 _writeCommand(0x40 | (LCD_PCF2_S12 & 0x03)); // HV GEN (Instr. Set 1) 0100, 0, 0, S1=1, S2=0 (2x multiplier) 00961 00962 _contrast = LCD_PCF2_CONTRAST; 00963 _writeCommand(0x80 | 0x00 | (_contrast & 0x3F)); // VLCD_set (Instr. Set 1) V=0, VA=contrast 00964 _writeCommand(0x80 | 0x40 | (_contrast & 0x3F)); // VLCD_set (Instr. Set 1) V=1, VB=contrast 00965 wait_ms(10); // Wait 10ms to ensure powered up 00966 00967 _writeCommand(0x02); // SCRN CONF (Instr. Set 1) L=0 00968 _writeCommand(0x08); // ICON CONF (Instr. Set 1) IM=0 (Char mode) IB=0 (no icon blink) DM=0 (no direct mode) 00969 00970 _writeCommand(0x20 | _function); // Select Instruction Set = 0 00971 00972 break; // case PCF2119_3V3 Controller 00973 00974 // case PCF2119_5V: 00975 // PCF2119 controller: No Voltage booster for VLCD. VDD=3V3. VA and VB control contrast. 00976 // Note1: See datasheet, the PCF2119 supports icons and provides separate constrast control for Icons and characters. 00977 // Note2: Vgen is switched off when the contrast voltage VA or VB is set to 0x00. 00978 //@TODO 00979 00980 case WS0010: 00981 // WS0010 OLED controller: Initialise DC/DC Voltage converter for LEDs 00982 // Note1: Identical to RS0010 00983 // Note2: supports 1 or 2 lines (and 16x100 graphics) 00984 // supports 4 fonts (English/Japanese (default), Western European-I, English/Russian, Western European-II) 00985 // Cursor/Disp shift set 0001 SC RL 0 0 00986 // 00987 // Mode and Power set 0001 GC PWR 1 1 00988 // GC = 0 (Graph Mode=1, Char Mode=0) 00989 // PWR = 1 (DC/DC On/Off) 00990 00991 //@Todo: This may be needed to enable a warm reboot 00992 //_writeCommand(0x13); // Char mode, DC/DC off 00993 //wait_ms(10); // Wait 10ms to ensure powered down 00994 _writeCommand(0x17); // Char mode, DC/DC on 00995 wait_ms(10); // Wait 10ms to ensure powered up 00996 00997 // Initialise Display configuration 00998 switch (_type) { 00999 case LCD8x1: //8x1 is a regular 1 line display 01000 case LCD8x2B: //8x2B is a special case of 16x1 01001 // case LCD12x1: 01002 case LCD16x1: 01003 case LCD24x1: 01004 _writeCommand(0x20); // Function set 001 DL N F FT1 FT0 01005 // DL=0 (4 bits bus) 01006 // N=0 (1 line) 01007 // F=0 (5x7 dots font) 01008 // FT=00 (00 = Engl/Jap, 01 = WestEur1, 10 = Engl/Russian, 11 = WestEur2 01009 break; 01010 01011 case LCD12x3D: // Special mode for KS0078 and PCF21XX 01012 case LCD12x3D1: // Special mode for PCF21XX 01013 case LCD12x4D: // Special mode for PCF21XX: 01014 case LCD16x3G: // Special mode for ST7036 01015 case LCD24x4D: // Special mode for KS0078 01016 error("Error: LCD Controller type does not support this Display type\n\r"); 01017 break; 01018 01019 default: 01020 // All other LCD types are initialised as 2 Line displays (including LCD16x1C and LCD40x4) 01021 _writeCommand(0x28); // Function set 001 DL N F FT1 FT0 01022 // DL=0 (4 bits bus) 01023 // N=1 (2 lines) 01024 // F=0 (5x7 dots font) 01025 // FT=00 (00 = Engl/Jap, 01 = WestEur1, 10 = Engl/Russian, 11 = WestEur2 01026 01027 break; 01028 } // switch type 01029 01030 break; // case WS0010 Controller 01031 01032 01033 case US2066_3V3: 01034 // US2066/SSD1311 OLED controller, Initialise for VDD=3V3 01035 // Note: supports 1,2, 3 or 4 lines 01036 // case USS2066_5V: 01037 // US2066 controller, VDD=5V 01038 01039 // Initialise Display configuration 01040 switch (_type) { 01041 case LCD8x1: //8x1 is a regular 1 line display 01042 case LCD8x2B: //8x2D is a special case of 16x1 01043 // case LCD12x1: 01044 case LCD16x1: 01045 // case LCD20x1: 01046 _function = 0x00; // Set function 0 0 1 X N DH RE(0) IS 01047 // Saved to allow switch between Instruction sets at later time 01048 // DL=X bit is ignored for US2066. Uses hardwired pins instead 01049 // N=0 1 Line / 3 Line 01050 // DH=0 Double Height disable 01051 // IS=0 01052 01053 _function_1 = 0x02; // Set function, 0 0 1 X N BE RE(1) REV 01054 // Saved to allow switch between Instruction sets at later time 01055 // DL=X bit is ignored for US2066. Uses hardwired pins instead 01056 // N=0 1 Line / 3 Line 01057 // BE=0 Blink Enable off, special feature of SSD1803, US2066 01058 // REV=0 Reverse off, special feature of SSD1803, US2066 01059 01060 _lines = 0x00; // Ext function set 0 0 0 0 1 FW BW NW 01061 // NW=0 1-Line LCD (N=0) 01062 break; 01063 01064 case LCD16x1C: 01065 case LCD8x2: 01066 case LCD16x2: 01067 case LCD20x2: 01068 _function = 0x08; // Set function 0 0 1 X N DH RE(0) IS 01069 // Saved to allow switch between Instruction sets at later time 01070 // DL=X bit is ignored for US2066. Uses hardwired pins instead 01071 // N=1 2 line / 4 Line 01072 // DH=0 Double Height disable 01073 // IS=0 01074 01075 _function_1 = 0x0A; // Set function, 0 0 1 X N BE RE(1) REV 01076 // Saved to allow switch between Instruction sets at later time 01077 // DL=X bit is ignored for US2066. Uses hardwired pins instead 01078 // N=1 2 line / 4 Line 01079 // BE=0 Blink Enable off, special feature of SSD1803, US2066 01080 // REV=0 Reverse off, special feature of SSD1803, US2066 01081 01082 _lines = 0x00; // Ext function set 0 0 0 0 1 FW BW NW 01083 // NW=0 2-Line LCD (N=1) 01084 break; 01085 01086 case LCD12x3D: // Special mode for KS0078 and PCF21XX 01087 // case LCD12x3D1: // Special mode for KS0078 and PCF21XX 01088 case LCD16x3D: // Special mode for KS0078, SSD1803 and US2066 01089 // case LCD16x3D1: // Special mode for SSD1803, US2066 01090 // case LCD20x3D: // Special mode for SSD1803, US2066 01091 _function = 0x00; // Set function 0 0 1 X N DH RE(0) IS 01092 // Saved to allow switch between Instruction sets at later time 01093 // DL=X bit is ignored for US2066. Uses hardwired pins instead 01094 // N=0 1 Line / 3 Line 01095 // DH=0 Double Height disable 01096 // IS=0 01097 01098 _function_1 = 0x02; // Set function, 0 0 1 X N BE RE(1) REV 01099 // Saved to allow switch between Instruction sets at later time 01100 // DL=X bit is ignored for US2066. Uses hardwired pins instead 01101 // N=0 1 Line / 3 Line 01102 // BE=0 Blink Enable off, special feature of SSD1803, US2066 01103 // REV=0 Reverse off, special feature of SSD1803, US2066 01104 01105 _lines = 0x00; // Ext function set 0 0 0 0 1 FW BW NW 01106 // NW=1 3-Line LCD (N=0) 01107 break; 01108 01109 case LCD20x4D: // Special mode for SSD1803, US2066 01110 _function = 0x08; // Set function 0 0 1 X N DH RE(0) IS 01111 // Saved to allow switch between Instruction sets at later time 01112 // DL=X bit is ignored for US2066. Uses hardwired pins instead 01113 // N=1 2 line / 4 Line 01114 // DH=0 Double Height disable 01115 // IS=0 01116 01117 _function_1 = 0x0A; // Set function, 0 0 1 DL N BE RE(1) REV 01118 // Saved to allow switch between Instruction sets at later time 01119 // DL=0 bit is ignored for US2066. Uses hardwired pins instead 01120 // N=1 2 line / 4 Line 01121 // BE=0 Blink Enable off, special feature of SSD1803, US2066 01122 // REV=0 Reverse off, special feature of SSD1803, US2066 01123 01124 _lines = 0x01; // Ext function set 0 0 0 0 1 FW BW NW 01125 // NW=1 4-Line LCD (N=1) 01126 break; 01127 01128 // case LCD24x1: 01129 // case LCD16x3G: // Special mode for ST7036 01130 // case LCD24x4D: // Special mode for KS0078 01131 default: 01132 error("Error: LCD Controller type does not support this Display type\n\r"); 01133 break; 01134 01135 } // switch type 01136 01137 _writeCommand(0x00); // NOP, make sure to sync SPI 01138 01139 // init special features 01140 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 X N BE RE(1) REV 01141 // Select Extended Instruction Set 01142 01143 _writeCommand(0x71); // Function Select A: 0 1 1 1 0 0 0 1 (Ext Instr Set) 01144 _writeData(0x00); // Disable Internal VDD 01145 01146 _writeCommand(0x79); // Function Select OLED: 0 1 1 1 1 0 0 1 (Ext Instr Set) 01147 01148 _writeCommand(0xD5); // Display Clock Divide Ratio: 1 1 0 1 0 1 0 1 (Ext Instr Set, OLED Instr Set) 01149 _writeCommand(0x70); // Display Clock Divide Ratio value: 0 1 1 1 0 0 0 0 (Ext Instr Set, OLED Instr Set) 01150 01151 _writeCommand(0x78); // Function Disable OLED: 0 1 1 1 1 0 0 0 (Ext Instr Set) 01152 01153 // _writeCommand(0x06); // Set ext entry mode, 0 0 0 0 0 1 BDC=1 COM1-32, BDS=0 SEG100-1 "Bottom View" (Ext Instr Set) 01154 _writeCommand(0x05); // Set ext entry mode, 0 0 0 0 0 1 BDC=0 COM32-1, BDS=1 SEG1-100 "Top View" (Ext Instr Set) 01155 01156 _writeCommand(0x08 | _lines); // Set ext function 0 0 0 0 1 FW BW NW 1,2,3 or 4 lines (Ext Instr Set) 01157 01158 // _writeCommand(0x1C); // Double Height, 0 0 0 1 UD2=1, UD1=1, X, DH'=0 (Ext Instr Set) 01159 // // Default 01160 01161 _writeCommand(0x72); // Function Select B: 0 1 1 1 0 0 1 0 (Ext Instr Set) 01162 _writeData(0x01); // Select ROM A (CGRAM 8, CGROM 248) 01163 01164 _writeCommand(0x79); // Function Select OLED: 0 1 1 1 1 0 0 1 (Ext Instr Set) 01165 01166 _writeCommand(0xDA); // Set Segm Pins Config: 1 1 0 1 1 0 1 0 (Ext Instr Set, OLED) 01167 _writeCommand(0x10); // Set Segm Pins Config value: Altern Odd/Even, Disable Remap (Ext Instr Set, OLED) 01168 01169 _writeCommand(0xDC); // Function Select C: 1 1 0 1 1 1 0 0 (Ext Instr Set, OLED) 01170 // _writeCommand(0x00); // Set internal VSL, GPIO pin HiZ (always read low) 01171 _writeCommand(0x80); // Set external VSL, GPIO pin HiZ (always read low) 01172 01173 _contrast = LCD_US20_CONTRAST; 01174 _writeCommand(0x81); // Set Contrast Control: 1 0 0 0 0 0 0 1 (Ext Instr Set, OLED) 01175 _writeCommand((_contrast << 2) | 0x03); // Set Contrast Value: 8 bits, use 6 bits for compatibility 01176 01177 _writeCommand(0xD9); // Set Phase Length: 1 1 0 1 1 0 0 1 (Ext Instr Set, OLED) 01178 _writeCommand(0xF1); // Set Phase Length Value: 01179 01180 _writeCommand(0xDB); // Set VCOMH Deselect Lvl: 1 1 0 1 1 0 1 1 (Ext Instr Set, OLED) 01181 _writeCommand(0x30); // Set VCOMH Deselect Value: 0.83 x VCC 01182 01183 wait_ms(10); // Wait 10ms to ensure powered up 01184 01185 //Test Fade/Blinking. Hard Blink on/off, No fade in/out ?? 01186 // _writeCommand(0x23); // Set (Ext Instr Set, OLED) 01187 // _writeCommand(0x3F); // Set interval 128 frames 01188 //End Test Blinking 01189 01190 _writeCommand(0x78); // Function Disable OLED: 0 1 1 1 1 0 0 0 (Ext Instr Set) 01191 01192 _writeCommand(0x20 | _function | 0x01); // Set function, 0 0 1 X N DH RE(0) IS=1 Select Instruction Set 1 01193 // Select Std Instr set, Select IS=1 01194 01195 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 X N BE RE(1) REV 01196 // Select Ext Instr Set, IS=1 01197 _writeCommand(0x10); // Shift/Scroll enable, 0 0 0 1 DS4/HS4 DS3/HS3 DS2/HS2 DS1/HS1 (Ext Instr Set, IS=1) 01198 01199 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS=0 Select Instruction Set 0 01200 // Select Std Instr set, Select IS=0 01201 break; // case US2066/SSD1311 Controller 01202 01203 //not yet tested on hardware 01204 case PT6314 : 01205 // Initialise Display configuration 01206 switch (_type) { 01207 case LCD8x1: //8x1 is a regular 1 line display 01208 case LCD8x2B: //8x2B is a special case of 16x1 01209 // case LCD12x1: 01210 case LCD16x1: 01211 case LCD20x1: 01212 case LCD24x1: 01213 _function = 0x00; // Function set 001 DL N X BR1 BR0 01214 // DL=0 (4 bits bus) 01215 // Note: 4 bit mode is ignored for native SPI and I2C devices 01216 // N=0 (1 line) 01217 // X 01218 // BR1=0 (2 significant bits for brightness 01219 // BR0=0 01220 // 0x0 = 100% 01221 // 0x1 = 75% 01222 // 0x2 = 50% 01223 // 0x3 = 25% 01224 01225 break; 01226 01227 // All other valid LCD types are initialised as 2 Line displays 01228 case LCD8x2: 01229 case LCD16x2: 01230 case LCD20x2: 01231 case LCD24x2: 01232 _function = 0x08; // Function set 001 DL N X BR1 BR2 01233 // DL=0 (4 bits bus) 01234 // Note: 4 bit mode is ignored for native SPI and I2C devices 01235 // N=1 (2 lines) 01236 // X 01237 // BR1=0 (2 significant bits for brightness 01238 // BR0=0 01239 break; 01240 01241 default: 01242 error("Error: LCD Controller type does not support this Display type\n\r"); 01243 break; 01244 } // switch type 01245 01246 _contrast = LCD_PT63_CONTRAST; 01247 _writeCommand(0x20 | _function | ((~_contrast) >> 4)); // Invert and shift to use 2 MSBs 01248 break; // case PT6314 Controller (VFD) 01249 01250 01251 case HD66712: 01252 // Initialise Display configuration 01253 switch (_type) { 01254 case LCD8x1: //8x1 is a regular 1 line display 01255 case LCD12x1: 01256 case LCD16x1: 01257 case LCD20x1: 01258 case LCD24x1: 01259 // case LCD32x1: // EXT pin is High, extension driver needed 01260 _function = 0x02; // Function set 001 DL N RE(0) - - (Std Regs) 01261 // DL=0 (4 bits bus) 01262 // N=0 (1-line mode, N=1 2-line mode) 01263 // RE=0 (Dis. Extended Regs, special mode for HD66712) 01264 // 01265 01266 _function_1 = 0x04; // Function set 001 DL N RE(1) BE LP (Ext Regs) 01267 // DL=0 (4 bits bus) 01268 // N=0 (1-line mode, N=1 2-line mode) 01269 // RE=1 (Ena Extended Regs; special mode for HD66712) 01270 // BE=0 (Blink Enable, CG/SEG RAM; special mode for HD66712) 01271 // LP=0 (LP=1 Low power mode, LP=0 Normal; special mode for HD66712) 01272 01273 _function_x = 0x00; // Ext Function set 0000 1 FW BW NW (Ext Regs) 01274 // NW=0 (1,2 line), NW=1 (4 Line, special mode for HD66712) 01275 break; 01276 01277 // case LCD12x3D: // Special mode for KS0073, KS0078, PCF21XX and HD66712 01278 // case LCD12x3D1: // Special mode for KS0073, KS0078, PCF21XX and HD66712 01279 case LCD12x4D: // Special mode for KS0073, KS0078, PCF21XX and HD66712 01280 // case LCD16x3D: // Special mode for KS0073, KS0078 and HD66712 01281 // case LCD16x4D: // Special mode for KS0073, KS0078 and HD66712 01282 case LCD20x4D: // Special mode for KS0073, KS0078 and HD66712 01283 _function = 0x02; // Function set 001 DL N RE(0) - - (Std Regs) 01284 // DL=0 (4 bits bus) 01285 // N=0 (1-line mode, N=1 2-line mode) 01286 // RE=0 (Dis. Extended Regs, special mode for HD66712) 01287 // 01288 01289 _function_1 = 0x04; // Function set 001 DL N RE(1) BE LP (Ext Regs) 01290 // DL=0 (4 bits bus) 01291 // N=0 (1-line mode, N=1 2-line mode) 01292 // RE=1 (Ena Extended Regs; special mode for HD66712) 01293 // BE=0 (Blink Enable, CG/SEG RAM; special mode for HD66712) 01294 // LP=0 (LP=1 Low power mode, LP=0 Normal; special mode for HD66712) 01295 01296 _function_x = 0x01; // Ext Function set 0000 1 FW BW NW (Ext Regs) 01297 // NW=0 (1,2 line), NW=1 (4 Line, special mode for HD66712) 01298 break; 01299 01300 case LCD16x3G: // Special mode for ST7036 01301 // case LCD24x3D: // Special mode for KS0078 01302 // case LCD24x3D1: // Special mode for KS0078 01303 case LCD24x4D: // Special mode for KS0078 01304 error("Error: LCD Controller type does not support this Display type\n\r"); 01305 break; 01306 01307 default: 01308 // All other LCD types are initialised as 2 Line displays (including LCD16x1C and LCD40x4) 01309 _function = 0x0A; // Function set 001 DL N RE(0) - - (Std Regs) 01310 // DL=0 (4 bits bus) 01311 // N=1 (2-line mode), N=0 (1-line mode) 01312 // RE=0 (Dis. Extended Regs, special mode for HD66712) 01313 01314 _function_1 = 0x0C; // Function set 001 DL N RE(1) BE LP (Ext Regs) 01315 // DL=0 (4 bits bus) 01316 // N=1 (2 line mode), N=0 (1-line mode) 01317 // RE=1 (Ena Extended Regs, special mode for HD66712) 01318 // BE=0 (Blink Enable, CG/SEG RAM, special mode for HD66712) 01319 // LP=0 (LP=1 Low power mode, LP=0 Normal) 01320 01321 _function_x = 0x00; // Ext Function set 0000 1 FW BW NW (Ext Regs) 01322 // NW=0 (1,2 line), NW=1 (4 Line, special mode for HD66712) 01323 break; 01324 } // switch type 01325 01326 // init special features 01327 _writeCommand(0x20 | _function_1);// Function set 001 DL N RE(1) BE LP (Ext Regs) 01328 // DL=0 (4 bits bus), DL=1 (8 bits mode) 01329 // N=0 (1 line mode), N=1 (2 line mode) 01330 // RE=1 (Ena Extended Regs, special mode for HD66712) 01331 // BE=0 (Blink Enable/Disable, CG/SEG RAM, special mode for HD66712) 01332 // LP=0 (LP=1 Low power mode, LP=0 Normal) 01333 01334 _writeCommand(0x08 | _function_x); // Ext Function set 0000 1 FW BW NW (Ext Regs) 01335 // FW=0 (5-dot font, special mode for HD66712) 01336 // BW=0 (Cur BW invert disable, special mode for HD66712) 01337 // NW=0 (1,2 Line), NW=1 (4 line, special mode for HD66712) 01338 01339 _writeCommand(0x10); // Scroll/Shift set 0001 HS4 HS3 HS2 HS1 (Ext Regs) 01340 // Dotscroll/Display shift enable (Special mode for HD66712) 01341 01342 _writeCommand(0x80); // Scroll Quantity set 1 0 HDS5 HDS4 HDS3 HDS2 HDS1 HDS0 (Ext Regs) 01343 // Scroll quantity (Special mode for HD66712) 01344 01345 _writeCommand(0x20 | _function); // Function set 001 DL N RE(0) DH REV (Std Regs) 01346 // DL=0 (4 bits bus), DL=1 (8 bits mode) 01347 // N=0 (1 line mode), N=1 (2 line mode) 01348 // RE=0 (Dis. Extended Regs, special mode for HD66712) 01349 // DH=1 (Disp shift enable/disable, special mode for HD66712) 01350 // REV=0 (Reverse/Normal, special mode for HD66712) 01351 break; // case HD66712 Controller 01352 01353 case SPLC792A_3V3: 01354 // SPLC792A controller: Initialise Voltage booster for VLCD. VDD=3V3 01355 // Note very similar to ST7032 01356 01357 // Initialise Display configuration 01358 switch (_type) { 01359 case LCD8x1: //8x1 is a regular 1 line display 01360 case LCD8x2B: //8x2B is a special case of 16x1 01361 // case LCD12x1: 01362 case LCD16x1: 01363 // case LCD20x1: 01364 case LCD24x1: 01365 _function = 0x00; // FUNCTION SET 0 0 1 DL=0 (4 bit), N=0 (1-line display mode), F=0 (5*7dot), 0, IS 01366 // Note: 4 bit mode is ignored for native SPI and I2C devices 01367 // Saved to allow switch between Instruction sets at later time 01368 break; 01369 01370 case LCD12x3D: // Special mode for KS0078 and PCF21XX 01371 case LCD12x3D1: // Special mode for KS0078 and PCF21XX 01372 case LCD12x4D: // Special mode for KS0078 and PCF21XX 01373 case LCD16x3G: // Special mode for ST7036 01374 case LCD24x4D: // Special mode for KS0078 01375 error("Error: LCD Controller type does not support this Display type\n\r"); 01376 break; 01377 01378 default: 01379 // All other LCD types are initialised as 2 Line displays 01380 _function = 0x08; // FUNCTION SET 0 0 1 DL=0 (4 bit), N=1 (2-line display mode), F=0 (5*7dot), 0, IS 01381 // Note: 4 bit mode is ignored for native SPI and I2C devices 01382 // Saved to allow switch between Instruction sets at later time 01383 break; 01384 } // switch type 01385 01386 // init special features 01387 _writeCommand(0x20 | _function | 0x01); // Set function, 0 0 1 DL N F 0 IS=1 Select Instr Set = 1 01388 01389 //SPLC792A Does not support Bias and Internal Osc register 01390 // _writeCommand(0x1C); // Internal OSC frequency adjustment Framefreq=183HZ, Bias will be 1/4 (Instr Set=1) 01391 01392 _contrast = LCD_SPLC792A_CONTRAST; 01393 _writeCommand(0x70 | (_contrast & 0x0F)); // Set Contrast Low bits, 0 1 1 1 C3 C2 C1 C0 (IS=1) 01394 01395 01396 // _icon_power = 0x04; // Icon display off (Bit3=0), Booster circuit is turned on (Bit2=1) (IS=1) 01397 _icon_power = 0x0C; // Icon display on (Bit3=1), Booster circuit is turned on (Bit2=1) (IS=1) 01398 // Note: Booster circuit always on for SPLC792A, Bit2 is dont care 01399 // Saved to allow contrast change at later time 01400 01401 _writeCommand(0x50 | _icon_power | ((_contrast >> 4) & 0x03)); // Set Icon, Booster and Contrast High bits, 0 1 0 1 Ion Bon C5 C4 (IS=1) 01402 wait_ms(10); // Wait 10ms to ensure powered up 01403 01404 _writeCommand(0x68 | (LCD_SPLC792A_RAB & 0x07)); // Voltage follower, 0 1 1 0 FOn=1, Ampl ratio Rab2=1, Rab1=0, Rab0=0 (IS=1) 01405 // Note: Follower circuit always on for SPLC792A, Bit3 is dont care 01406 wait_ms(10); // Wait 10ms to ensure powered up 01407 01408 _writeCommand(0x20 | _function); // Select Instruction Set = 0 01409 01410 break; // case SPLC792A_3V3 Controller 01411 01412 case ST7066_ACM: // ST7066 4/8 bit, I2C on ACM1602 using a PIC 01413 default: 01414 // Devices fully compatible to HD44780 that do not use any DC/DC Voltage converters but external VLCD, no icons etc 01415 01416 // Initialise Display configuration 01417 switch (_type) { 01418 case LCD8x1: //8x1 is a regular 1 line display 01419 case LCD8x2B: //8x2B is a special case of 16x1 01420 // case LCD12x1: 01421 case LCD16x1: 01422 // case LCD20x1: 01423 case LCD24x1: 01424 // case LCD40x1: 01425 _function = 0x00; // Function set 001 DL N F - - 01426 // DL=0 (4 bits bus) 01427 // N=0 (1 line) 01428 // F=0 (5x7 dots font) 01429 break; 01430 01431 case LCD12x3D: // Special mode for KS0078 and PCF21XX 01432 case LCD12x3D1: // Special mode for KS0078 and PCF21XX 01433 case LCD12x4D: // Special mode for KS0078 and PCF21XX: 01434 case LCD16x3D: // Special mode for KS0078 01435 // case LCD16x3D1: // Special mode for KS0078 01436 // case LCD24x3D: // Special mode for KS0078 01437 // case LCD24x3D1: // Special mode for KS0078 01438 case LCD24x4D: // Special mode for KS0078 01439 error("Error: LCD Controller type does not support this Display type\n\r"); 01440 break; 01441 01442 // All other LCD types are initialised as 2 Line displays (including LCD16x1C and LCD40x4) 01443 default: 01444 _function = 0x08; // Function set 001 DL N F - - 01445 // DL=0 (4 bits bus) 01446 // Note: 4 bit mode is ignored for native SPI and I2C devices 01447 // N=1 (2 lines) 01448 // F=0 (5x7 dots font, only option for 2 line display) 01449 // - (Don't care) 01450 break; 01451 } // switch type 01452 01453 _writeCommand(0x20 | _function); 01454 break; // case default Controller 01455 01456 } // switch Controller specific initialisations 01457 01458 // Controller general initialisations 01459 // _writeCommand(0x01); // Clear Display and set cursor to 0 01460 // wait_ms(10); // The CLS command takes 1.64 ms. 01461 // // Since we are not using the Busy flag, Lets be safe and take 10 ms 01462 01463 _writeCommand(0x02); // Cursor Home, DDRAM Address to Origin 01464 wait_ms(10); // The Return Home command takes 1.64 ms. 01465 // Since we are not using the Busy flag, Lets be safe and take 10 ms 01466 01467 _writeCommand(0x06); // Entry Mode 0000 0 1 I/D S 01468 // Cursor Direction and Display Shift 01469 // I/D=1 (Cur incr) 01470 // S=0 (No display shift) 01471 01472 _writeCommand(0x14); // Cursor or Display shift 0001 S/C R/L x x 01473 // S/C=0 Cursor moves 01474 // R/L=1 Right 01475 // 01476 01477 // _writeCommand(0x0C); // Display Ctrl 0000 1 D C B 01478 // // Display On, Cursor Off, Blink Off 01479 01480 // setCursor(CurOff_BlkOff); 01481 setCursor(CurOn_BlkOff); 01482 setMode(DispOn); 01483 } 01484 01485 01486 /** Clear the screen, Cursor home. 01487 * Note: The whole display is initialised to charcode 0x20, which may not be a 'space' on some controllers with a 01488 * different fontset such as the PCF2116C or PCF2119R. In this case you should fill the display with 'spaces'. 01489 */ 01490 void TextLCD_Base::cls() { 01491 01492 #if (LCD_TWO_CTRL == 1) 01493 // Select and configure second LCD controller when needed 01494 if(_type==LCD40x4) { 01495 _ctrl_idx=_LCDCtrl_1; // Select 2nd controller 01496 01497 // Second LCD controller Cursor always Off 01498 _setCursorAndDisplayMode(_currentMode, CurOff_BlkOff); 01499 01500 // Second LCD controller Clearscreen 01501 _writeCommand(0x01); // cls, and set cursor to 0 01502 wait_ms(20); // The CLS command takes 1.64 ms. 01503 // Since we are not using the Busy flag, Lets be safe and take 10 ms 01504 01505 _ctrl_idx=_LCDCtrl_0; // Select primary controller 01506 } 01507 01508 01509 // Primary LCD controller Clearscreen 01510 _writeCommand(0x01); // cls, and set cursor to 0 01511 wait_ms(20); // The CLS command takes 1.64 ms. 01512 // Since we are not using the Busy flag, Lets be safe and take 10 ms 01513 01514 // Restore cursormode on primary LCD controller when needed 01515 if(_type==LCD40x4) { 01516 _setCursorAndDisplayMode(_currentMode,_currentCursor); 01517 } 01518 01519 #else 01520 // Support only one LCD controller 01521 _writeCommand(0x01); // cls, and set cursor to 0 01522 wait_ms(20); // The CLS command takes 1.64 ms. 01523 // Since we are not using the Busy flag, Lets be safe and take 10 ms 01524 #endif 01525 01526 setAddress(0, 0); // Reset Cursor location 01527 // Note: This is needed because some displays (eg PCF21XX) don't use line 0 in the '3 Line' mode. 01528 } 01529 01530 /** Locate cursor to a screen column and row 01531 * 01532 * @param column The horizontal position from the left, indexed from 0 01533 * @param row The vertical position from the top, indexed from 0 01534 */ 01535 void TextLCD_Base::locate(int column, int row) { 01536 01537 // setAddress() does all the heavy lifting: 01538 // check column and row sanity, 01539 // switch controllers for LCD40x4 if needed 01540 // switch cursor for LCD40x4 if needed 01541 // set the new memory address to show cursor at correct location 01542 setAddress(column, row); 01543 } 01544 01545 01546 /** Write a single character (Stream implementation) 01547 */ 01548 int TextLCD_Base::_putc(int value) { 01549 int addr; 01550 01551 if (value == '\n') { 01552 //No character to write 01553 01554 //Update Cursor 01555 _column = 0; 01556 _row++; 01557 if (_row >= rows()) { 01558 _row = 0; 01559 } 01560 } 01561 else { 01562 //Character to write 01563 01564 #if (LCD_DEF_FONT == 1) //Default HD44780 font 01565 _writeData(value); 01566 #elif (LCD_C_FONT == 1) || (LCD_R_FONT == 1) //PCF21xxC or PCF21xxR font 01567 _writeData(ASCII_2_LCD(value)); 01568 #elif (LCD_UTF8_FONT == 1) // UTF8 2 byte font (eg Cyrillic) 01569 // value = UTF_2_LCD(value, utf_seq_rec_first_cyr, utf_seq_recode_cyr, &utf_rnd_recode_cyr[0][0]); 01570 value = UTF_2_LCD(value); 01571 if (value >= 0) { 01572 _writeData(value); 01573 01574 // Only increment cursor when there is something to write 01575 // Continue below to closing bracket... 01576 #else 01577 _writeData('?'); //Oops, no font defined 01578 #endif 01579 01580 //Update Cursor 01581 _column++; 01582 if (_column >= columns()) { 01583 _column = 0; 01584 _row++; 01585 if (_row >= rows()) { 01586 _row = 0; 01587 } 01588 } 01589 01590 #if (LCD_DEF_FONT == 1) //Default HD44780 font 01591 01592 #elif (LCD_C_FONT == 1) || (LCD_R_FONT == 1) //PCF21xxC or PCF21xxR font 01593 01594 #elif (LCD_UTF8_FONT == 1) //UTF8 2 byte font (eg Cyrillic) 01595 // Continue code above to close bracket... 01596 } // if (value >= 0) {.. 01597 #else 01598 01599 #endif 01600 01601 } //else 01602 01603 //Set next memoryaddress, make sure cursor blinks at next location 01604 addr = getAddress(_column, _row); 01605 _writeCommand(0x80 | addr); 01606 01607 return value; 01608 } 01609 01610 01611 // get a single character (Stream implementation) 01612 int TextLCD_Base::_getc() { 01613 return -1; 01614 } 01615 01616 01617 #if ((LCD_C_FONT == 1) || (LCD_R_FONT == 1)) //PCF21xxC or PCF21xxR font 01618 /** Convert ASCII character code to the LCD fonttable code 01619 * 01620 * @param c The character to write to the display 01621 * @return The character code for the specific fonttable of the controller 01622 */ 01623 int TextLCD_Base::ASCII_2_LCD (int c) { 01624 01625 //LCD_C_F0 is default for HD44780 and compatible series 01626 // if (_font == LCD_C_F0) return c; 01627 01628 //LCD_C_FC for PCF21XXC series 01629 //LCD_C_FR for PCF21XXR series 01630 //Used code from Suga koubou library for PCF2119K and PCF2119R 01631 if (((c >= ' ') && (c <= '?')) || ((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z'))) { 01632 c |= 0x80; 01633 } else if (c >= 0xF0 && c <= 0xFF) { 01634 c &= 0x0F; 01635 } 01636 return c; 01637 } 01638 #endif 01639 01640 #if(LCD_UTF8_FONT == 1) 01641 01642 /** Convert UTF8 2-byte character code to the LCD fonttable code 01643 * @param c The character to write to the display 01644 * @return character code for the specific fonttable of the controller or -1 if UTF8 code is not yet complete or incorrect 01645 * 01646 * Orig by Andriy, Modified by WH 01647 * 01648 * Note: The UTF8 decoding table for a specific controller is defined and selected in file TextLCD_UTF8.inc 01649 * The table is accessed in this UTF_2_LCD() method through 01650 * #define UTF_FIRST, UTF_LAST, UTF_SEQ_REC_FIRST, UTF_SEQ_REC_LAST and 01651 * #define UTF_SEQ_RECODE and UTF_RND_RECODE 01652 */ 01653 int TextLCD_Base::UTF_2_LCD (int c) { 01654 int utf_code; 01655 int utf_low_byte; // Low byte UTF8 01656 static int utf_hi_byte = 0; // High byte UTF8 01657 01658 if (c < 0x80) { // Regular ASCII code, no need to convert 01659 return c; 01660 } 01661 else { // UTF8 handling, See wikipedia.org/wiki/UTF-8 and www.utf8-chartable.de 01662 // printf("0x%X ", c); 01663 01664 if (c >= 0xC0) { // First UTF8 byte should be formatted as 110b bbaa, Do sanity check 01665 utf_hi_byte = c & 0x1F; // Mask out significant bits (0x1F) and save high byte 01666 return -1; // Nothing to display as yet, wait for second UTF8 byte 01667 } 01668 01669 if (c <= 0xBF) { // Second UTF8 byte should be formatted as 10aa aaaa, Do sanity check 01670 utf_low_byte = c & 0x3F; // Mask out significant bits (0x3F) 01671 01672 // Compose UTF character code from UTF8 bytes. The UTF codes will be between U+0080 and U+07FF 01673 utf_code = (utf_hi_byte << 6) | utf_low_byte; // 00000bbb aaaaaaaa 01674 // printf("0x%4X ", utf_code); 01675 01676 // Sanity check on UTF codes 01677 // For example Cyrillic characters are UTF encoded between 0x0400 and 0x04FF 01678 if ((utf_code < UTF_FIRST) || (utf_code > UTF_LAST)) { 01679 return -1; // Invalid UTF8 code 01680 }; 01681 01682 //Map some specific UTF codes on a character in LCD fonttable using a special correcting lookup table 01683 for (char i=0; UTF_RND_RECODE[i][0]; i++) { // Step through table until endvalue 0 is found or until a match is found 01684 if (utf_code == UTF_RND_RECODE[i][0]) { // UTF8 code match is found 01685 c = UTF_RND_RECODE[1][1]; 01686 return c; // found match in correcting random table 01687 } 01688 } 01689 01690 //Sanity check on table idx range 01691 if ((utf_code < UTF_SEQ_REC_FIRST) || (utf_code > UTF_SEQ_REC_LAST)) { 01692 return -1; // Invalid UTF8 code 01693 }; 01694 01695 //Map all other UTF codes on a character in LCD fonttable using a sequential lookup table 01696 c = UTF_SEQ_RECODE[utf_code - UTF_SEQ_REC_FIRST]; 01697 return c; // entry in sequential table 01698 } 01699 else { 01700 return -1; // Invalid UTF8 code for second byte 01701 } 01702 } // End UTF8 handling 01703 } 01704 01705 #endif 01706 01707 01708 #if(LCD_PRINTF != 1) 01709 /** Write a character to the LCD 01710 * 01711 * @param c The character to write to the display 01712 */ 01713 int TextLCD_Base::putc(int c){ 01714 return _putc(c); 01715 } 01716 01717 01718 /** Write a raw string to the LCD 01719 * 01720 * @param string text, may be followed by variables to emulate formatting the string. 01721 * However, printf formatting is NOT supported and variables will be ignored! 01722 */ 01723 int TextLCD_Base::printf(const char* text, ...) { 01724 01725 while (*text !=0) { 01726 _putc(*text); 01727 text++; 01728 } 01729 return 0; 01730 } 01731 #endif 01732 01733 01734 // Write a nibble using the 4-bit interface 01735 void TextLCD_Base::_writeNibble(int value) { 01736 01737 // Enable is Low 01738 this->_setEnable(true); 01739 this->_setData(value); // Low nibble of value on D4..D7 01740 wait_us(1); // Data setup time 01741 this->_setEnable(false); 01742 wait_us(1); // Datahold time 01743 // Enable is Low 01744 } 01745 01746 // Write a byte using the 4-bit interface 01747 void TextLCD_Base::_writeByte(int value) { 01748 01749 // Enable is Low 01750 this->_setEnable(true); 01751 this->_setData(value >> 4); // High nibble 01752 wait_us(1); // Data setup time 01753 this->_setEnable(false); 01754 wait_us(1); // Data hold time 01755 01756 this->_setEnable(true); 01757 this->_setData(value); // Low nibble 01758 wait_us(1); // Data setup time 01759 this->_setEnable(false); 01760 wait_us(1); // Datahold time 01761 01762 // Enable is Low 01763 } 01764 01765 // Write a command byte to the LCD controller 01766 void TextLCD_Base::_writeCommand(int command) { 01767 01768 this->_setRS(false); 01769 wait_us(1); // Data setup time for RS 01770 01771 this->_writeByte(command); 01772 wait_us(40); // most instructions take 40us 01773 } 01774 01775 // Write a data byte to the LCD controller 01776 void TextLCD_Base::_writeData(int data) { 01777 01778 this->_setRS(true); 01779 wait_us(1); // Data setup time for RS 01780 01781 this->_writeByte(data); 01782 wait_us(40); // data writes take 40us 01783 } 01784 01785 01786 // This replaces the original _address() method. 01787 // It is confusing since it returns the memoryaddress or-ed with the set memorycommand 0x80. 01788 // Left it in here for compatibility with older code. New applications should use getAddress() instead. 01789 int TextLCD_Base::_address(int column, int row) { 01790 return 0x80 | getAddress(column, row); 01791 } 01792 01793 01794 // This is new method to return the memory address based on row, column and displaytype. 01795 // 01796 /** Return the memoryaddress of screen column and row location 01797 * 01798 * @param column The horizontal position from the left, indexed from 0 01799 * @param row The vertical position from the top, indexed from 0 01800 * @return The memoryaddress of screen column and row location 01801 * 01802 */ 01803 int TextLCD_Base::getAddress(int column, int row) { 01804 01805 switch (_addr_mode) { 01806 01807 case LCD_T_A: 01808 //Default addressing mode for 1, 2 and 4 rows (except 40x4) 01809 //The two available rows are split and stacked on top of eachother. Addressing for 3rd and 4th line continues where lines 1 and 2 were split. 01810 //Displays top rows when less than four are used. 01811 switch (row) { 01812 case 0: 01813 return 0x00 + column; 01814 case 1: 01815 return 0x40 + column; 01816 case 2: 01817 return 0x00 + _nr_cols + column; 01818 case 3: 01819 return 0x40 + _nr_cols + column; 01820 // Should never get here. 01821 // default: 01822 // return 0x00; 01823 } 01824 01825 case LCD_T_B: 01826 // LCD8x2B is a special layout of LCD16x1 01827 if (row==0) 01828 return 0x00 + column; 01829 else 01830 // return _nr_cols + column; 01831 return 0x08 + column; 01832 01833 case LCD_T_C: 01834 // LCD16x1C is a special layout of LCD8x2 01835 // LCD32x1C is a special layout of LCD16x2 01836 // LCD40x1C is a special layout of LCD20x2 01837 #if(0) 01838 if (column < 8) 01839 return 0x00 + column; 01840 else 01841 return 0x40 + (column - 8); 01842 #else 01843 if (column < (_nr_cols >> 1)) 01844 return 0x00 + column; 01845 else 01846 return 0x40 + (column - (_nr_cols >> 1)); 01847 #endif 01848 01849 case LCD_T_D: 01850 //Alternate addressing mode for 3 and 4 row displays (except 40x4). Used by PCF21XX, KS0073, KS0078, SSD1803 01851 //The 4 available rows start at a hardcoded address. 01852 //Displays top rows when less than four are used. 01853 switch (row) { 01854 case 0: 01855 return 0x00 + column; 01856 case 1: 01857 return 0x20 + column; 01858 case 2: 01859 return 0x40 + column; 01860 case 3: 01861 return 0x60 + column; 01862 // Should never get here. 01863 // default: 01864 // return 0x00; 01865 } 01866 01867 case LCD_T_D1: 01868 //Alternate addressing mode for 3 row displays. Used by PCF21XX, KS0073, KS0078, SSD1803 01869 //The 4 available rows start at a hardcoded address. 01870 //Skips top row of 4 row display and starts display at row 1 01871 switch (row) { 01872 case 0: 01873 return 0x20 + column; 01874 case 1: 01875 return 0x40 + column; 01876 case 2: 01877 return 0x60 + column; 01878 // Should never get here. 01879 // default: 01880 // return 0x00; 01881 } 01882 01883 case LCD_T_E: 01884 // LCD40x4 is a special case since it has 2 controllers. 01885 // Each controller is configured as 40x2 (Type A) 01886 if (row<2) { 01887 // Test to see if we need to switch between controllers 01888 if (_ctrl_idx != _LCDCtrl_0) { 01889 01890 // Second LCD controller Cursor Off 01891 _setCursorAndDisplayMode(_currentMode, CurOff_BlkOff); 01892 01893 // Select primary controller 01894 _ctrl_idx = _LCDCtrl_0; 01895 01896 // Restore cursormode on primary LCD controller 01897 _setCursorAndDisplayMode(_currentMode, _currentCursor); 01898 } 01899 01900 return 0x00 + (row * 0x40) + column; 01901 } 01902 else { 01903 01904 // Test to see if we need to switch between controllers 01905 if (_ctrl_idx != _LCDCtrl_1) { 01906 // Primary LCD controller Cursor Off 01907 _setCursorAndDisplayMode(_currentMode, CurOff_BlkOff); 01908 01909 // Select secondary controller 01910 _ctrl_idx = _LCDCtrl_1; 01911 01912 // Restore cursormode on secondary LCD controller 01913 _setCursorAndDisplayMode(_currentMode, _currentCursor); 01914 } 01915 01916 return 0x00 + ((row-2) * 0x40) + column; 01917 } 01918 01919 case LCD_T_F: 01920 //Alternate addressing mode for 3 row displays. 01921 //The first half of 3rd row continues from 1st row, the second half continues from 2nd row. 01922 switch (row) { 01923 case 0: 01924 return 0x00 + column; 01925 case 1: 01926 return 0x40 + column; 01927 case 2: 01928 if (column < (_nr_cols >> 1)) // check first or second half of line 01929 return (0x00 + _nr_cols + column); 01930 else 01931 return (0x40 + _nr_cols + (column - (_nr_cols >> 1))); 01932 // Should never get here. 01933 // default: 01934 // return 0x00; 01935 } 01936 01937 case LCD_T_G: 01938 //Alternate addressing mode for 3 row displays. Used by ST7036 01939 switch (row) { 01940 case 0: 01941 return 0x00 + column; 01942 case 1: 01943 return 0x10 + column; 01944 case 2: 01945 return 0x20 + column; 01946 // Should never get here. 01947 // default: 01948 // return 0x00; 01949 } 01950 01951 // Should never get here. 01952 default: 01953 return 0x00; 01954 01955 } // switch _addr_mode 01956 } 01957 01958 01959 /** Set the memoryaddress of screen column and row location 01960 * 01961 * @param column The horizontal position from the left, indexed from 0 01962 * @param row The vertical position from the top, indexed from 0 01963 */ 01964 void TextLCD_Base::setAddress(int column, int row) { 01965 01966 // Sanity Check column 01967 if (column < 0) { 01968 _column = 0; 01969 } 01970 else if (column >= _nr_cols) { 01971 _column = _nr_cols - 1; 01972 } else _column = column; 01973 01974 // Sanity Check row 01975 if (row < 0) { 01976 _row = 0; 01977 } 01978 else if (row >= _nr_rows) { 01979 _row = _nr_rows - 1; 01980 } else _row = row; 01981 01982 01983 // Compute the memory address 01984 // For LCD40x4: switch controllers if needed 01985 // switch cursor if needed 01986 int addr = getAddress(_column, _row); 01987 01988 _writeCommand(0x80 | addr); 01989 } 01990 01991 01992 /** Return the number of columns 01993 * 01994 * @return The number of columns 01995 * 01996 * Note: some configurations are commented out because they have not yet been tested due to lack of hardware 01997 */ 01998 int TextLCD_Base::columns() { 01999 02000 // Columns encoded in b7..b0 02001 //return (_type & 0xFF); 02002 return _nr_cols; 02003 } 02004 02005 /** Return the number of rows 02006 * 02007 * @return The number of rows 02008 * 02009 * Note: some configurations are commented out because they have not yet been tested due to lack of hardware 02010 */ 02011 int TextLCD_Base::rows() { 02012 02013 // Rows encoded in b15..b8 02014 //return ((_type >> 8) & 0xFF); 02015 return _nr_rows; 02016 } 02017 02018 /** Set the Cursormode 02019 * 02020 * @param cursorMode The Cursor mode (CurOff_BlkOff, CurOn_BlkOff, CurOff_BlkOn, CurOn_BlkOn) 02021 */ 02022 void TextLCD_Base::setCursor(LCDCursor cursorMode) { 02023 02024 // Save new cursor mode, needed when 2 controllers are in use or when display is switched off/on 02025 _currentCursor = cursorMode; 02026 02027 // Configure only current LCD controller 02028 _setCursorAndDisplayMode(_currentMode, _currentCursor); 02029 } 02030 02031 /** Set the Displaymode 02032 * 02033 * @param displayMode The Display mode (DispOff, DispOn) 02034 */ 02035 void TextLCD_Base::setMode(LCDMode displayMode) { 02036 02037 // Save new displayMode, needed when 2 controllers are in use or when cursor is changed 02038 _currentMode = displayMode; 02039 02040 #if (LCD_TWO_CTRL == 1) 02041 // Select and configure second LCD controller when needed 02042 if(_type==LCD40x4) { 02043 if (_ctrl_idx==_LCDCtrl_0) { 02044 // Configure primary LCD controller 02045 _setCursorAndDisplayMode(_currentMode, _currentCursor); 02046 02047 // Select 2nd controller 02048 _ctrl_idx=_LCDCtrl_1; 02049 02050 // Configure secondary LCD controller 02051 _setCursorAndDisplayMode(_currentMode, CurOff_BlkOff); 02052 02053 // Restore current controller 02054 _ctrl_idx=_LCDCtrl_0; 02055 } 02056 else { 02057 // Select primary controller 02058 _ctrl_idx=_LCDCtrl_0; 02059 02060 // Configure primary LCD controller 02061 _setCursorAndDisplayMode(_currentMode, CurOff_BlkOff); 02062 02063 // Restore current controller 02064 _ctrl_idx=_LCDCtrl_1; 02065 02066 // Configure secondary LCD controller 02067 _setCursorAndDisplayMode(_currentMode, _currentCursor); 02068 } 02069 } 02070 else { 02071 // Configure primary LCD controller 02072 _setCursorAndDisplayMode(_currentMode, _currentCursor); 02073 } 02074 #else 02075 // Support only one LCD controller 02076 _setCursorAndDisplayMode(_currentMode, _currentCursor); 02077 02078 #endif 02079 } 02080 02081 /** Low level method to restore the cursortype and display mode for current controller 02082 */ 02083 void TextLCD_Base::_setCursorAndDisplayMode(LCDMode displayMode, LCDCursor cursorType) { 02084 02085 // Configure current LCD controller 02086 switch (_ctrl) { 02087 case ST7070: 02088 //ST7070 does not support Cursorblink. The P bit selects the font instead ! 02089 _writeCommand(0x08 | displayMode | (cursorType & 0x02)); 02090 break; 02091 default: 02092 _writeCommand(0x08 | displayMode | cursorType); 02093 break; 02094 } //switch 02095 } 02096 02097 /** Set the Backlight mode 02098 * 02099 * @param backlightMode The Backlight mode (LightOff, LightOn) 02100 */ 02101 void TextLCD_Base::setBacklight(LCDBacklight backlightMode) { 02102 02103 #if (BACKLIGHT_INV==0) 02104 // Positive Backlight control pin logic 02105 if (backlightMode == LightOn) { 02106 this->_setBL(true); 02107 } 02108 else { 02109 this->_setBL(false); 02110 } 02111 #else 02112 // Inverted Backlight control pin logic 02113 if (backlightMode == LightOn) { 02114 this->_setBL(false); 02115 } 02116 else { 02117 this->_setBL(true); 02118 } 02119 #endif 02120 } 02121 02122 /** Set User Defined Characters 02123 * 02124 * @param unsigned char c The Index of the UDC (0..7) for HD44780 or clones and (0..15) for some more advanced controllers 02125 * @param char *udc_data The bitpatterns for the UDC (8 bytes of 5 significant bits for bitpattern and 3 bits for blinkmode (advanced types)) 02126 */ 02127 void TextLCD_Base::setUDC(unsigned char c, char *udc_data) { 02128 02129 #if (LCD_TWO_CTRL == 1) 02130 // Select and configure second LCD controller when needed 02131 if(_type==LCD40x4) { 02132 _LCDCtrl_Idx current_ctrl_idx = _ctrl_idx; // Temp save current controller 02133 02134 // Select primary controller 02135 _ctrl_idx=_LCDCtrl_0; 02136 02137 // Configure primary LCD controller 02138 _setUDC(c, udc_data); 02139 02140 // Select 2nd controller 02141 _ctrl_idx=_LCDCtrl_1; 02142 02143 // Configure secondary LCD controller 02144 _setUDC(c, udc_data); 02145 02146 // Restore current controller 02147 _ctrl_idx=current_ctrl_idx; 02148 } 02149 else { 02150 // Configure primary LCD controller 02151 _setUDC(c, udc_data); 02152 } 02153 #else 02154 // Support only one LCD controller 02155 _setUDC(c, udc_data); 02156 #endif 02157 } 02158 02159 /** Low level method to store user defined characters for current controller 02160 * 02161 * @param unsigned char c The Index of the UDC (0..7) for HD44780 clones and (0..15) for some more advanced controllers 02162 * @param char *udc_data The bitpatterns for the UDC (8 bytes of 5 significant bits for bitpattern and 3 bits for blinkmode (advanced types)) 02163 */ 02164 void TextLCD_Base::_setUDC(unsigned char c, char *udc_data) { 02165 02166 switch (_ctrl) { 02167 case PCF2103_3V3 : // Some UDCs may be used for Icons 02168 case PCF2113_3V3 : // Some UDCs may be used for Icons 02169 case PCF2116_3V3 : 02170 case PCF2116_5V : 02171 case PCF2119_3V3 : // Some UDCs may be used for Icons 02172 case PCF2119R_3V3: // Some UDCs may be used for Icons 02173 c = c & 0x0F; // mask down to valid range 02174 break; 02175 02176 default: 02177 c = c & 0x07; // mask down to valid range 02178 break; 02179 } //switch _ctrl 02180 02181 // Select DD RAM for current LCD controller 02182 // This is needed to correctly set Bit 6 of the addresspointer for controllers that support 16 UDCs 02183 _writeCommand(0x80 | ((c << 3) & 0x40)) ; 02184 02185 // Select CG RAM for current LCD controller 02186 _writeCommand(0x40 | ((c << 3) & 0x3F)); //Set CG-RAM address, (note that Bit 6 is retained and can not be set by this command !) 02187 //8 sequential locations needed per UDC 02188 // Store UDC pattern 02189 for (int i=0; i<8; i++) { 02190 _writeData(*udc_data++); 02191 } 02192 02193 //Select DD RAM again for current LCD controller and restore the addresspointer 02194 int addr = getAddress(_column, _row); 02195 _writeCommand(0x80 | addr); 02196 } 02197 02198 #if(LCD_BLINK == 1) 02199 /** Set UDC Blink and Icon blink 02200 * setUDCBlink method is supported by some compatible devices (eg SSD1803) 02201 * 02202 * @param blinkMode The Blink mode (BlinkOff, BlinkOn) 02203 */ 02204 void TextLCD_Base::setUDCBlink(LCDBlink blinkMode){ 02205 // Blinking UDCs (and icons) are enabled when a specific controlbit (BE) is set. 02206 // The blinking pixels in the UDC and icons can be controlled by setting additional bits in the UDC or icon bitpattern. 02207 // UDCs are defined by an 8 byte bitpattern. The P0..P4 form the character pattern. 02208 // P7 P6 P5 P4 P3 P2 P1 P0 02209 // 0 B1 B0 x 0 1 1 1 0 02210 // 1 B1 B0 x 1 0 0 0 1 02211 // ............. 02212 // 7 B1 B0 x 1 0 0 0 1 02213 // 02214 // Bit 6 and Bit 7 in the pattern will control the blinking mode when Blink is enabled through BE. 02215 // B1 B0 Mode 02216 // 0 0 No Blinking in this row of the UDC 02217 // 0 1 Enabled pixels in P4 will blink 02218 // 1 x Enabled pixels in P0..P4 will blink 02219 // 02220 // Note: the PCF2103 and PCF2113 use UDCs to set Icons 02221 // 3 x 8 rows x 5 bits = 120 bits Icons for Normal pattern (UDC 0..2) and 02222 // 3 x 8 rows x 5 bits = 120 bits Icons for Blink pattern (UDC 4..6) 02223 // Note: the PCF2119 uses UDCs to set Icons 02224 // 4 x 8 rows x 5 bits = 160 bits Icons for Normal pattern (UDC 0..3) and 02225 // 4 x 8 rows x 5 bits = 160 bits Icons for Blink pattern (UDC 4..7) 02226 switch (blinkMode) { 02227 case BlinkOn: 02228 // Controllers that support UDC/Icon Blink 02229 switch (_ctrl) { 02230 case KS0073 : 02231 case KS0078 : 02232 case HD66712 : 02233 _function_1 |= 0x02; // Enable UDC/Icon Blink 02234 _writeCommand(0x20 | _function_1); // Function set 0 0 1 DL N RE(1) BE 0/LP (Ext Regs) 02235 02236 _writeCommand(0x20 | _function); // Function set 0 0 1 DL N RE(0) DH REV (Std Regs) 02237 break; // case KS0073, KS0078, HD66712 Controller 02238 02239 case US2066_3V3 : 02240 case SSD1803_3V3 : 02241 _function_1 |= 0x04; // Enable UDC/Icon Blink 02242 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 DL N BE RE(1) REV 02243 // Select Ext Instr Set 02244 02245 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS=0 Select Instruction Set 0 02246 // Select Std Instr set, Select IS=0 02247 break; // case SSD1803, US2066 02248 02249 case PCF2103_3V3 : 02250 case PCF2113_3V3 : 02251 case PCF2119_3V3 : 02252 case PCF2119R_3V3 : 02253 // Enable Icon Blink 02254 _writeCommand(0x20 | _function | 0x01); // Set function, Select Instr Set = 1 02255 _writeCommand(0x08 | 0x02); // ICON Conf 0000 1, IM=0 (Char mode), IB=1 (Icon blink), 0 (Instr. Set 1) 02256 _writeCommand(0x20 | _function); // Set function, Select Instr Set = 0 02257 02258 break; 02259 02260 default: 02261 //Unsupported feature for other controllers 02262 break; 02263 } //switch _ctrl 02264 02265 break; // BlinkOn 02266 02267 case BlinkOff: 02268 // Controllers that support UDC Blink 02269 switch (_ctrl) { 02270 case KS0073 : 02271 case KS0078 : 02272 case HD66712: 02273 _function_1 &= ~0x02; // Disable UDC/Icon Blink 02274 _writeCommand(0x20 | _function_1); // Function set 0 0 1 DL N RE(1) BE 0/LP (Ext Regs) 02275 02276 _writeCommand(0x20 | _function); // Function set 0 0 1 DL N RE(0) DH REV (Std Regs) 02277 break; // case KS0073, KS0078, HD66712 Controller 02278 02279 case US2066_3V3 : 02280 case SSD1803_3V3 : 02281 _function_1 &= ~0x04; // Disable UDC/Icon Blink 02282 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 DL N BE RE(1) REV 02283 // Select Ext Instr Set 02284 02285 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS=0 Select Instruction Set 0 02286 // Select Std Instr set, Select IS=0 02287 break; // case SSD1803, US2066 02288 02289 case PCF2103_3V3 : 02290 case PCF2113_3V3 : 02291 case PCF2119_3V3 : 02292 case PCF2119R_3V3 : 02293 // Disable Icon Blink 02294 _writeCommand(0x20 | _function | 0x01); // Set function, Select Instr Set = 1 02295 _writeCommand(0x08); // ICON Conf 0000 1, IM=0 (Char mode), IB=1 (Icon blink), 0 (Instr. Set 1) 02296 _writeCommand(0x20 | _function); // Set function, Select Instr Set = 0 02297 02298 break; 02299 02300 default: 02301 //Unsupported feature for other controllers 02302 break; 02303 } //switch _ctrl 02304 02305 break; //BlinkOff 02306 02307 default: 02308 break; 02309 } // blinkMode 02310 02311 } // setUDCBlink() 02312 #endif 02313 02314 #if(LCD_CONTRAST == 1) 02315 /** Set Contrast 02316 * setContrast method is supported by some compatible devices (eg ST7032i) that have onboard LCD voltage generation 02317 * Initial code for ST70XX imported from fork by JH1PJL 02318 * 02319 * @param unsigned char c contrast data (6 significant bits, valid range 0..63, Value 0 will disable the Vgen) 02320 * @return none 02321 */ 02322 //@TODO Add support for 40x4 dual controller 02323 void TextLCD_Base::setContrast(unsigned char c) { 02324 02325 // Function set mode stored during Init. Make sure we dont accidentally switch between 1-line and 2-line mode! 02326 // Icon/Booster mode stored during Init. Make sure we dont accidentally change this! 02327 02328 _contrast = c & 0x3F; // Sanity check 02329 02330 switch (_ctrl) { 02331 case PCF2113_3V3 : 02332 case PCF2119_3V3 : 02333 case PCF2119R_3V3 : 02334 if (_contrast < 5) _contrast = 0; // See datasheet. Sanity check for PCF2113/PCF2119 02335 if (_contrast > 55) _contrast = 55; 02336 02337 _writeCommand(0x20 | _function | 0x01); // Set function, Select Instruction Set = 1 02338 _writeCommand(0x80 | 0x00 | (_contrast & 0x3F)); // VLCD_set (Instr. Set 1) V=0, VA=contrast 02339 _writeCommand(0x80 | 0x40 | (_contrast & 0x3F)); // VLCD_set (Instr. Set 1) V=1, VB=contrast 02340 _writeCommand(0x20 | _function); // Select Instruction Set = 0 02341 break; 02342 02343 case ST7032_3V3 : 02344 case ST7032_5V : 02345 case ST7036_3V3 : 02346 // case ST7036_5V : 02347 case SSD1803_3V3 : 02348 case SPLC792A_3V3 : 02349 _writeCommand(0x20 | _function | 0x01); // Select Instruction Set = 1 02350 _writeCommand(0x70 | (_contrast & 0x0F)); // Contrast Low bits 02351 _writeCommand(0x50 | _icon_power | ((_contrast >> 4) & 0x03)); // Contrast High bits 02352 _writeCommand(0x20 | _function); // Select Instruction Set = 0 02353 break; 02354 02355 case US2066_3V3 : 02356 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 DL N BE RE(1) REV 02357 // Select Extended Instruction Set 02358 02359 _writeCommand(0x79); // Function Select OLED: 0 1 1 1 1 0 0 1 (Ext Instr Set) 02360 02361 _writeCommand(0x81); // Set Contrast Control: 1 0 0 0 0 0 0 1 (Ext Instr Set, OLED) 02362 _writeCommand((_contrast << 2) | 0x03); // Set Contrast Value: 8 bits. Use 6 bits for compatibility 02363 02364 _writeCommand(0x78); // Function Disable OLED: 0 1 1 1 1 0 0 0 (Ext Instr Set) 02365 02366 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS=0 Select Instruction Set 0 02367 // Select Std Instr set, Select IS=0 02368 break; 02369 02370 //not yet tested on hardware 02371 case PT6314 : 02372 // Only 2 significant bits 02373 // 0x00 = 100% 02374 // 0x01 = 75% 02375 // 0x02 = 50% 02376 // 0x03 = 25% 02377 _writeCommand(0x20 | _function | ((~_contrast) >> 4)); // Invert and shift to use 2 MSBs 02378 break; 02379 02380 default: 02381 //Unsupported feature for other controllers 02382 break; 02383 } // end switch 02384 } // end setContrast() 02385 #endif 02386 02387 #if(LCD_POWER == 1) 02388 /** Set Power 02389 * setPower method is supported by some compatible devices (eg SSD1803) that have power down modes 02390 * 02391 * @param bool powerOn Power on/off 02392 * @return none 02393 */ 02394 //@TODO Add support for 40x4 dual controller 02395 void TextLCD_Base::setPower(bool powerOn) { 02396 02397 if (powerOn) { 02398 // Switch on 02399 setMode(DispOn); 02400 02401 // Controllers that supports specific Power Down mode 02402 switch (_ctrl) { 02403 02404 // case PCF2113_3V3 : 02405 // case PCF2119_3V3 : 02406 // case PCF2119R_3V3 : 02407 // case ST7032_3V3 : 02408 //@todo 02409 // enable Booster Bon 02410 02411 case WS0010: 02412 _writeCommand(0x17); // Char mode, DC/DC on 02413 wait_ms(10); // Wait 10ms to ensure powered up 02414 break; 02415 02416 case KS0073: 02417 case KS0078: 02418 case SSD1803_3V3 : 02419 // case SSD1803_5V : 02420 _writeCommand(0x20 | _function_1); // Select Ext Instr Set 02421 _writeCommand(0x02); // Power On 02422 _writeCommand(0x20 | _function); // Select Std Instr Set 02423 break; 02424 02425 default: 02426 //Unsupported feature for other controllers 02427 break; 02428 } // end switch 02429 } 02430 else { 02431 // Switch off 02432 setMode(DispOff); 02433 02434 // Controllers that support specific Power Down mode 02435 switch (_ctrl) { 02436 02437 // case PCF2113_3V3 : 02438 // case PCF2119_3V3 : 02439 // case PCF2119R_3V3 : 02440 // case ST7032_3V3 : 02441 //@todo 02442 // disable Booster Bon 02443 02444 case WS0010: 02445 _writeCommand(0x13); // Char mode, DC/DC off 02446 break; 02447 02448 case KS0073: 02449 case KS0078: 02450 case SSD1803_3V3 : 02451 // case SSD1803_5V : 02452 _writeCommand(0x20 | _function_1); // Select Ext Instr Set 02453 _writeCommand(0x03); // Power Down 02454 _writeCommand(0x20 | _function); // Select Std Instr Set 02455 break; 02456 02457 default: 02458 //Unsupported feature for other controllers 02459 break; 02460 } // end switch 02461 } 02462 } // end setPower() 02463 #endif 02464 02465 #if(LCD_ORIENT == 1) 02466 /** Set Orient 02467 * setOrient method is supported by some compatible devices (eg SSD1803, US2066) that have top/bottom view modes 02468 * 02469 * @param LCDOrient orient Orientation 02470 * @return none 02471 */ 02472 void TextLCD_Base::setOrient(LCDOrient orient){ 02473 02474 switch (orient) { 02475 02476 case Top: 02477 switch (_ctrl) { 02478 case PCF2103_3V3: 02479 case PCF2116_3V3: 02480 case PCF2116_5V: 02481 _writeCommand(0x20 | _function | 0x01); // Set function, Select Instr Set = 1 02482 _writeCommand(0x05); // Display Conf Set 0000 0, 1, P=0, Q=1 (Instr. Set 1) 02483 _writeCommand(0x20 | _function); // Set function, Select Instr Set = 0 02484 break; 02485 02486 case PCF2119_3V3: 02487 case PCF2119R_3V3: 02488 _writeCommand(0x20 | _function | 0x01); // Set function, Select Instr Set = 1 02489 _writeCommand(0x07); // Display Conf Set 0000 0, 1, P=1, Q=1 (Instr. Set 1) 02490 _writeCommand(0x20 | _function); // Set function, Select Instr Set = 0 02491 break; 02492 02493 case SSD1803_3V3 : 02494 // case SSD1803_5V : 02495 case US2066_3V3 : 02496 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 X N BE RE(1) REV 02497 // Select Extended Instruction Set 02498 // _writeCommand(0x06); // Set ext entry mode, 0 0 0 0 0 1 BDC=1 COM1-32, BDS=0 SEG100-1 "Bottom View" (Ext Instr Set) 02499 _writeCommand(0x05); // Set ext entry mode, 0 0 0 0 0 1 BDC=0 COM32-1, BDS=1 SEG1-100 "Top View" (Ext Instr Set) 02500 02501 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS=0 Select Instruction Set 0 02502 // Select Std Instr set, Select IS=0 02503 break; 02504 02505 case ST7070: 02506 _writeCommand(0x20 | _function | 0x04); // Set function, 0 0 1 DL, N, EXT=1, x, x (Select Instr Set = 1) 02507 02508 _writeCommand(0x40 | 0x00); // COM/SEG directions 0 1 0 0 C1, C2, S1, S2 (Instr Set 1) 02509 // C1=1: Com1-8 -> Com8-1; C2=1: Com9-16 -> Com16-9 02510 // S1=1: Seg1-40 -> Seg40-1; S2=1: Seg41-80 -> Seg80-41 02511 wait_ms(5); // Wait to ensure completion or ST7070 fails to set Top/Bottom after reset.. 02512 02513 _writeCommand(0x20 | _function); // Set function, EXT=0 (Select Instr Set = 0) 02514 02515 break; // case ST7070 Controller 02516 02517 default: 02518 //Unsupported feature for other controllers 02519 break; 02520 02521 } // end switch _ctrl 02522 break; // end Top 02523 02524 case Bottom: 02525 switch (_ctrl) { 02526 case PCF2103_3V3: 02527 case PCF2116_3V3: 02528 case PCF2116_5V: 02529 _writeCommand(0x20 | _function | 0x01); // Set function, Select Instr Set = 1 02530 _writeCommand(0x06); // Display Conf Set 0000 0, 1, P=1, Q=0 (Instr. Set 1) 02531 _writeCommand(0x20 | _function); // Set function, Select Instr Set = 0 02532 break; 02533 02534 case PCF2119_3V3: 02535 case PCF2119R_3V3 : 02536 _writeCommand(0x20 | _function | 0x01); // Set function, Select Instr Set = 1 02537 _writeCommand(0x04); // Display Conf Set 0000 0, 1, P=0, Q=0 (Instr. Set 1) 02538 _writeCommand(0x20 | _function); // Set function, Select Instr Set = 0 02539 break; 02540 02541 case SSD1803_3V3 : 02542 // case SSD1803_5V : 02543 case US2066_3V3 : 02544 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 X N BE RE(1) REV 02545 // Select Extended Instruction Set 02546 _writeCommand(0x06); // Set ext entry mode, 0 0 0 0 0 1 BDC=1 COM1-32, BDS=0 SEG100-1 "Bottom View" (Ext Instr Set) 02547 // _writeCommand(0x05); // Set ext entry mode, 0 0 0 0 0 1 BDC=0 COM32-1, BDS=1 SEG1-100 "Top View" (Ext Instr Set) 02548 02549 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS=0 Select Instruction Set 0 02550 // Select Std Instr set, Select IS=0 02551 break; 02552 02553 case ST7070: 02554 //Note: this does not result in correct top/bottom view. 02555 //The left and right half of each row are reversed and the addressing of both rows is also incorrect: 02556 //Top/bottomline when orientation is flipped: 02557 // 0x48...0x4F 0x40...0x47 02558 // 0x08...0x0F 0x00...0x07 02559 _writeCommand(0x20 | _function | 0x04); // Set function, 0 0 1 DL N EXT=1 x x (Select Instr Set = 1) 02560 02561 _writeCommand(0x40 | 0x0F); // COM/SEG directions 0 1 0 0 C1, C2, S1, S2 (Instr Set 1) 02562 // C1=1: Com1-8 -> Com8-1; C2=1: Com9-16 -> Com16-9 02563 // S1=1: Seg1-40 -> Seg40-1; S2=1: Seg41-80 -> Seg80-41 02564 wait_ms(5); // Wait to ensure completion or ST7070 fails to set Top/Bottom after reset.. 02565 02566 _writeCommand(0x20 | _function); // Set function, EXT=0 (Select Instr Set = 0) 02567 02568 break; // case ST7070 Controller 02569 02570 default: 02571 //Unsupported feature for other controllers 02572 break; 02573 02574 } // end switch _ctrl 02575 02576 break; // end Bottom 02577 } // end switch orient 02578 } // end setOrient() 02579 #endif 02580 02581 #if(LCD_BIGFONT == 1) 02582 /** Set Big Font 02583 * setBigFont method is supported by some compatible devices (eg SSD1803, US2066) 02584 * 02585 * @param lines The selected Big Font lines (None, TopLine, CenterLine, BottomLine, TopBottomLine) 02586 * Double height characters can be shown on lines 1+2, 2+3, 3+4 or 1+2 and 3+4 02587 * Valid double height lines depend on the LCDs number of rows. 02588 */ 02589 void TextLCD_Base::setBigFont(LCDBigFont lines) { 02590 02591 switch (lines) { 02592 case None: 02593 switch (_ctrl) { 02594 case SSD1803_3V3 : 02595 case US2066_3V3 : 02596 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 X N BE RE(1) REV 02597 // Select Extended Instruction Set 02598 _writeCommand(0x1C); // Double Height, 0 0 0 1 UD2=1, UD1=1, X, DH'=0 (Ext Instr Set) 02599 // Default 02600 _function = _function & ~0x04; // Set function, 0 0 1 DL N DH=0 RE(0) IS=0 Select Instruction Set 0 02601 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS=0 Select Instruction Set 0 02602 // Select Std Instr set, Select IS=0 02603 break; // end US2066 02604 02605 default: 02606 break; // end default 02607 } // end switch _ctrl 02608 break; // end None 02609 02610 case TopLine: 02611 if (_nr_rows < 2) return; //Sanity check 02612 02613 switch (_ctrl) { 02614 case SSD1803_3V3 : 02615 case US2066_3V3 : 02616 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 X N BE RE(1) REV 02617 // Select Extended Instruction Set 02618 _writeCommand(0x1C); // Double Height, 0 0 0 1 UD2=1, UD1=1, X, DH'=0 (Ext Instr Set) 02619 // Default 02620 _function = _function | 0x04; // Set function, 0 0 1 DL N DH=1 RE(0) IS=0 Select Instruction Set 0 02621 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS=0 Select Instruction Set 0 02622 // Select Std Instr set, Select IS=0 02623 break; // end US2066, SSD1803 02624 02625 default: 02626 break; // end default 02627 } // end switch _ctrl 02628 break; // end TopLine 02629 02630 case CenterLine: 02631 if (_nr_rows != 4) return; //Sanity check 02632 02633 switch (_ctrl) { 02634 case SSD1803_3V3 : 02635 case US2066_3V3 : 02636 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 X N BE RE(1) REV 02637 // Select Extended Instruction Set 02638 _writeCommand(0x14); // Double Height, 0 0 0 1 UD2=0, UD1=1, X, DH'=0 (Ext Instr Set) 02639 // Default 02640 _function = _function | 0x04; // Set function, 0 0 1 DL N DH=1 RE(0) IS=0 Select Instruction Set 0 02641 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS=0 Select Instruction Set 0 02642 // Select Std Instr set, Select IS=0 02643 break; // end US2066, SSD1803 02644 02645 default: 02646 break; // end default 02647 } // end switch _ctrl 02648 break; // end CenterLine 02649 02650 case BottomLine: 02651 if (_nr_rows < 3) return; //Sanity check 02652 02653 switch (_ctrl) { 02654 case SSD1803_3V3 : 02655 case US2066_3V3 : 02656 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 X N BE RE(1) REV 02657 // Select Extended Instruction Set 02658 if (_nr_rows == 3) { 02659 _writeCommand(0x14); // Double Height, 0 0 0 1 UD2=0, UD1=1, X, DH'=0 (Ext Instr Set) 02660 } 02661 else { 02662 _writeCommand(0x10); // Double Height, 0 0 0 1 UD2=0, UD1=0, X, DH'=0 (Ext Instr Set) 02663 } 02664 _function = _function | 0x04; // Set function, 0 0 1 DL N DH=1 RE(0) IS=0 Select Instruction Set 0 02665 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS=0 Select Instruction Set 0 02666 // Select Std Instr set, Select IS=0 02667 break; // end US2066, SSD1803 02668 02669 default: 02670 break; // end default 02671 } // end switch _ctrl 02672 break; // end BottomLine 02673 02674 case TopBottomLine: 02675 if (_nr_rows != 4) return; //Sanity check 02676 02677 switch (_ctrl) { 02678 case SSD1803_3V3 : 02679 case US2066_3V3 : 02680 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 X N BE RE(1) REV 02681 // Select Extended Instruction Set 02682 _writeCommand(0x18); // Double Height, 0 0 0 1 UD2=1, UD1=0, X, DH'=0 (Ext Instr Set) 02683 // Default 02684 _function = _function | 0x04; // Set function, 0 0 1 DL N DH=1 RE(0) IS=0 Select Instruction Set 0 02685 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS=0 Select Instruction Set 0 02686 // Select Std Instr set, Select IS=0 02687 break; // end US2066, SSD1803 02688 02689 default: 02690 break; // end default 02691 } // end switch _ctrl 02692 break; // end TopBottomLine 02693 02694 } // end switch lines 02695 02696 } // end setBigFont() 02697 #endif 02698 02699 02700 #if (LCD_FONTSEL == 1) 02701 /** Set Font 02702 * setFont method is supported by some compatible devices (eg SSD1803, US2066, ST7070) 02703 * 02704 * @param LCDFont font The selected Font 02705 * @return none 02706 * 02707 * Note: most controllers support only one font and the hardware specific 02708 * fonttable is encoded as part of the controller type number (eg PCF21XXC or PCF21XXR). 02709 * Some controllers support multiple tables that can only be selected by logic levels on a few pins. 02710 * Some controllers also support runtime fontable switching through a specific instruction 02711 */ 02712 void TextLCD_Base::setFont(LCDFont font) { 02713 02714 switch (font) { 02715 case Font_RA: // UK/EU 02716 switch (_ctrl) { 02717 case SSD1803_3V3 : 02718 case US2066_3V3 : 02719 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 X N BE RE(1) REV 02720 // Select Extended Instruction Set 02721 _writeCommand(0x72); // ROM Select command, 0 1 1 1 0 0 1 0 (Ext Instr Set) 02722 _writeData(0x00); // ROM_0 Select data, 0 0 0 0 ROM2 ROM1 0 0 (Ext Instr Set) 02723 02724 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS (Std Instr Set) 02725 02726 _font = font; // Save active font 02727 break; // end SSD1803, US2066 02728 02729 case ST7070: 02730 //ST7070 does not support Cursorblink. The P bit selects the font instead ! 02731 _writeCommand(0x08 | _currentMode | (_currentCursor & 0x02)); 02732 02733 _font = font; // Save active font 02734 break; // end ST7070 02735 02736 default: 02737 break; // end default 02738 } // end switch _ctrl 02739 break; // end Font_RA 02740 02741 case Font_RB: // UK/CYR 02742 switch (_ctrl) { 02743 case SSD1803_3V3 : 02744 case US2066_3V3 : 02745 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 X N BE RE(1) REV 02746 // Select Extended Instruction Set 02747 _writeCommand(0x72); // ROM Select command, 0 1 1 1 0 0 1 0 (Ext Instr Set) 02748 _writeData(0x04); // ROM_0 Select data, 0 0 0 0 ROM2 ROM1 0 0 (Ext Instr Set) 02749 02750 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS (Std Instr Set) 02751 02752 _font = font; // Save active font 02753 break; // end SSD1803, US2066 02754 02755 case ST7070: 02756 //ST7070 does not support Cursorblink. The P bit selects the font instead ! 02757 _writeCommand(0x08 | _currentMode | (_currentCursor & 0x02) | 0x01); 02758 02759 _font = font; // Save active font 02760 break; // end ST7070 02761 02762 default: 02763 break; // end default 02764 } // end switch _ctrl 02765 break; // end Font_RB 02766 02767 case Font_0: //Font_O is pretty similar to ROM_C 02768 case Font_RC: // UK/JAP 02769 switch (_ctrl) { 02770 case SSD1803_3V3 : 02771 case US2066_3V3 : 02772 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 X N BE RE(1) REV 02773 // Select Extended Instruction Set 02774 _writeCommand(0x72); // ROM Select command, 0 1 1 1 0 0 1 0 (Ext Instr Set) 02775 _writeData(0x08); // ROM_0 Select data, 0 0 0 0 ROM2 ROM1 0 0 (Ext Instr Set) 02776 02777 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS (Std Instr Set) 02778 02779 _font = font; // Save active font 02780 break; // end SSD1803, US2066 02781 02782 default: 02783 break; // end default 02784 } // end switch _ctrl 02785 break; // end Font_RC 02786 } // end switch font 02787 02788 //SSD1803 seems to screw up cursor position after selecting new font. Restore to make sure... 02789 //Set next memoryaddress, make sure cursor blinks at next location 02790 int addr = getAddress(_column, _row); 02791 _writeCommand(0x80 | addr); 02792 02793 } 02794 #endif 02795 02796 02797 #if(LCD_ICON==1) 02798 /** Set Icons 02799 * 02800 * @param unsigned char idx The Index of the icon pattern (0..15) for KS0073 and similar controllers 02801 * and Index (0..31) for PCF2103 and similar controllers 02802 * @param unsigned char data The bitpattern for the icons (6 lsb for KS0073 bitpattern (5 lsb for KS0078) and 2 msb for blinkmode) 02803 * The bitpattern for the PCF2103 icons is 5 lsb (UDC 0..2) and 5 lsb for blinkmode (UDC 4..6) 02804 */ 02805 void TextLCD_Base::setIcon(unsigned char idx, unsigned char data) { 02806 // Blinking icons are enabled when a specific controlbit (BE) is set. 02807 // The blinking pixels in the icons can be controlled by setting additional bits in the icon bitpattern. 02808 // Icons are defined by a byte bitpattern. The P0..P5 form the Icon pattern for KS0073, and P0..P4 for KS0078 02809 // P7 P6 P5 P4 P3 P2 P1 P0 02810 // 0 B1 B0 0 0 1 1 1 0 02811 // 1 B1 B0 1 1 0 0 0 1 02812 // ............. 02813 // 15 B1 B0 1 1 0 0 0 1 02814 // 02815 // Bit 6 and Bit 7 in the pattern will control the blinking mode when Blink is enabled through BE. 02816 // B1 B0 Mode 02817 // 0 0 No Blinking for this icon row 02818 // 0 1 Enabled pixels in P5 will blink 02819 // 1 x Enabled pixels in P0..P5 will blink 02820 // 02821 // Note: the PCF2103 and PCF2113 use UDCs to set Icons 02822 // 3 x 8 rows x 5 bits = 120 bits Icons for Normal pattern (UDC 0..2) and 02823 // 3 x 8 rows x 5 bits = 120 bits Icons for Blink pattern (UDC 4..6) 02824 // Note: the PCF2119 uses UDCs to set Icons 02825 // 4 x 8 rows x 5 bits = 160 bits Icons for Normal pattern (UDC 0..3) and 02826 // 4 x 8 rows x 5 bits = 160 bits Icons for Blink pattern (UDC 4..7) 02827 02828 switch (_ctrl) { 02829 case KS0073: 02830 case KS0078: 02831 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 DL N RE(1) BE LP 02832 // Select Extended Instruction Set 02833 _writeCommand(0x40 | (idx & 0x0F)); // Set Icon Address, mask Address to valid range (Ext Instr Set) 02834 02835 _writeData(data); // Set Icon pattern (Ext Instr Set) 02836 02837 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N RE(0) DH REV Select Instruction Set 0 02838 // Select Std Instr set, Select IS=0 02839 break; // end KS0073, KS0078 02840 02841 case ST7032_3V3: 02842 case ST7032_5V: 02843 case SPLC792A_3V3: 02844 _writeCommand(0x20 | _function | 0x01); // Set function, 0 0 1 DL N F 0 IS=1 Select Instr Set = 1 02845 _writeCommand(0x40 | (idx & 0x0F)); // Set Icon Address, mask Address to valid range (Instr Set 1) 02846 02847 _writeData(data & 0x1F); // Set Icon pattern, no blink support (Instr Set 1) 02848 02849 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N RE(0) DH REV Select Instruction Set 0 02850 // Select Std Instr set, Select IS=0 02851 break; // end ST7032 02852 02853 case ST7036_3V3: 02854 case ST7036_5V: 02855 _writeCommand(0x20 | _function | 0x01); // Set function, 0 0 1 DL N DH IS2,IS1 = 01 (Select Instr Set = 1) 02856 _writeCommand(0x40 | (idx & 0x0F)); // Set Icon Address, mask Address to valid range (Instr Set 1) 02857 02858 _writeData(data & 0x1F); // Set Icon pattern, no blink support (Instr Set 1) 02859 02860 _writeCommand(0x20 | _function); // Set function, IS2,IS1 = 00 (Select Instr Set = 0) 02861 // Select Std Instr set, Select IS=0 02862 break; // end ST7036 02863 02864 case SSD1803_3V3: 02865 // case SSD1803_5V: 02866 _writeCommand(0x20 | _function | 0x01); // Set function, 0 0 1 DL N DH RE(0) IS 02867 // Select Instruction Set 1 02868 _writeCommand(0x40 | (idx & 0x0F)); // Set Icon Address, mask Address to valid range (Instr Set = 1) 02869 _writeData(data); // Set Icon pattern (Instr Set = 1) 02870 02871 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS 02872 // Select IS=0 02873 break; // end SSD1803 02874 02875 case PCF2103_3V3: 02876 case PCF2113_3V3: 02877 case PCF2119_3V3: 02878 case PCF2119R_3V3: 02879 // Store UDC/Icon pattern for PCF2103 and PCF2113: 02880 // 3 x 8 rows x 5 bits = 120 bits for Normal pattern (UDC 0..2) and 02881 // 3 x 8 rows x 5 bits = 120 bits for Blink pattern (UDC 4..6) 02882 // Store UDC/Icon pattern for PCF2119: 02883 // 4 x 8 rows x 5 bits = 160 bits for Normal pattern (UDC 0..3) and 02884 // 4 x 8 rows x 5 bits = 160 bits for Blink pattern (UDC 4..7) 02885 _writeCommand(0x40 | (idx & 0x3F)); //Set CG-RAM address, 8 sequential locations needed per UDC 02886 _writeData(data); // Set Icon pattern (Instr Set = 1) 02887 break; // case PCF2103_3V3 Controller 02888 02889 default: 02890 break; // end default 02891 } // end switch _ctrl 02892 02893 //Select DD RAM again for current LCD controller and restore the addresspointer 02894 int addr = getAddress(_column, _row); 02895 _writeCommand(0x80 | addr); 02896 02897 } // end setIcon() 02898 02899 /** Clear Icons 02900 * 02901 * @param none 02902 * @return none 02903 */ 02904 //@TODO Add support for 40x4 dual controller 02905 void TextLCD_Base::clrIcon() { 02906 // Icons are defined by a byte bitpattern. The P0..P5 form the Icon pattern for KS0073, and P0..P4 for KS0078 02907 // P7 P6 P5 P4 P3 P2 P1 P0 02908 // 0 B1 B0 0 0 0 0 0 0 02909 // 1 B1 B0 0 0 0 0 0 0 02910 // ............. 02911 // 15 B1 B0 0 0 0 0 0 0 02912 // 02913 // Bit 6 and Bit 7 in the pattern will control the blinking mode when Blink is enabled through BE. 02914 // B1 B0 Mode 02915 // 0 0 No Blinking for this icon row 02916 // 0 1 Enabled pixels in P5 will blink 02917 // 1 x Enabled pixels in P0..P5 will blink 02918 // 02919 // Note: the PCF2103 and PCF2113 use UDCs to set Icons 02920 // 3 x 8 rows x 5 bits = 120 bits Icons for Normal pattern (UDC 0..2) and 02921 // 3 x 8 rows x 5 bits = 120 bits Icons for Blink pattern (UDC 4..6) 02922 // Note: the PCF2119 uses UDCs to set Icons 02923 // 4 x 8 rows x 5 bits = 160 bits Icons for Normal pattern (UDC 0..3) and 02924 // 4 x 8 rows x 5 bits = 160 bits Icons for Blink pattern (UDC 4..7) 02925 int idx; 02926 02927 switch (_ctrl) { 02928 case KS0073: 02929 case KS0078: 02930 _writeCommand(0x20 | _function_1); // Set function, 0 0 1 DL N RE(1) BE LP 02931 // Select Extended Instruction Set 02932 for (idx=0; idx<16; idx++) { 02933 _writeCommand(0x40 | idx); // Set Icon Address, mask Address to valid range (Ext Instr Set) 02934 _writeData(0x00); // Clear Icon pattern (Ext Instr Set) 02935 } 02936 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N RE(0) DH REV Select Std Instruction Set 02937 // Select Std Instr set 02938 break; // end KS0073, KS0078 02939 02940 case ST7032_3V3: 02941 case ST7032_5V: 02942 case SPLC792A_3V3: 02943 _writeCommand(0x20 | _function | 0x01); // Set function, 0 0 1 DL N F 0 IS=1 Select Instr Set = 1 02944 02945 for (idx=0; idx<16; idx++) { 02946 _writeCommand(0x40 | idx); // Set Icon Address, mask Address to valid range (Instr Set 1) 02947 _writeData(0x00); // Clear Icon pattern (Instr Set 1) 02948 } 02949 02950 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N RE(0) DH REV Select Instruction Set 0 02951 // Select Std Instr set, Select IS=0 02952 break; // end ST7032 02953 02954 case ST7036_3V3: 02955 case ST7036_5V: 02956 _writeCommand(0x20 | _function | 0x01); // Set function, 0 0 1 DL N DH IS2,IS1 = 01 (Select Instr Set = 1) 02957 02958 for (idx=0; idx<16; idx++) { 02959 _writeCommand(0x40 | idx); // Set Icon Address, mask Address to valid range (Instr Set 1) 02960 _writeData(0x00); // Clear Icon pattern (Instr Set 1) 02961 } 02962 02963 _writeCommand(0x20 | _function); // Set function, IS2,IS1 = 00 (Select Instr Set = 0) 02964 // Select Std Instr set, Select IS=0 02965 break; // end ST7036 02966 02967 case SSD1803_3V3: 02968 // case SSD1803_5V: 02969 _writeCommand(0x20 | _function | 0x01); // Set function, 0 0 1 DL N DH RE(0) IS 02970 // Select Instruction Set 1 02971 for (idx=0; idx<16; idx++) { 02972 _writeCommand(0x40 | idx); // Set Icon Address, mask Address to valid range (Ext Instr Set) 02973 _writeData(0x00); // Clear Icon pattern (Ext Instr Set) 02974 } 02975 _writeCommand(0x20 | _function); // Set function, 0 0 1 DL N DH RE(0) IS 02976 // Select IS=0 02977 break; // end SSD1803 02978 02979 case PCF2103_3V3: 02980 case PCF2113_3V3: 02981 // PCF2103 and PCF2113 use part of the UDC RAM to control Icons 02982 // Select CG RAM 02983 02984 _writeCommand(0x40 | (0 * 8)); //Set CG-RAM address, 8 sequential locations needed per UDC 02985 // Store UDC/Icon pattern: 02986 // 3 x 8 rows x 5 bits = 120 bits for Normal pattern (UDC 0..2) and 02987 for (int i=0; i<(3 * 8); i++) { 02988 // _writeData(0x1F); // All On 02989 _writeData(0x00); // All Off 02990 } 02991 02992 _writeCommand(0x40 | (4 * 8)); //Set CG-RAM address, 8 sequential locations needed per UDC 02993 // 3 x 8 rows x 5 bits = 120 bits for Blink pattern (UDC 4..6) 02994 for (int i=0; i<(3 * 8); i++) { 02995 // _writeData(0x1F); // All On 02996 _writeData(0x00); // All Off 02997 } 02998 break; // case PCF2103_3V3 Controller 02999 03000 case PCF2119_3V3: 03001 case PCF2119R_3V3: 03002 // PCF2119 uses part of the UDC RAM to control Icons 03003 // Select CG RAM 03004 03005 _writeCommand(0x40 | (0 * 8)); //Set CG-RAM address, 8 sequential locations needed per UDC 03006 // Store UDC/Icon pattern: 03007 // 4 x 8 rows x 5 bits = 160 bits for Normal pattern (UDC 0..3) and 03008 for (int i=0; i<(4 * 8); i++) { 03009 // _writeData(0x1F); // All On 03010 _writeData(0x00); // All Off 03011 } 03012 03013 _writeCommand(0x40 | (4 * 8)); //Set CG-RAM address, 8 sequential locations needed per UDC 03014 // 4 x 8 rows x 5 bits = 160 bits for Blink pattern (UDC 4..7) 03015 for (int i=0; i<(4 * 8); i++) { 03016 // _writeData(0x1F); // All On 03017 _writeData(0x00); // All Off 03018 } 03019 break; // case PCF2119_3V3 Controller 03020 03021 default: 03022 break; // end default 03023 } // end switch _ctrl 03024 03025 //Select DD RAM again for current LCD controller and restore the addresspointer 03026 int addr = getAddress(_column, _row); 03027 _writeCommand(0x80 | addr); 03028 } //end clrIcon() 03029 #endif 03030 03031 #if(LCD_INVERT == 1) 03032 /** Set Invert 03033 * setInvert method is supported by some compatible devices (eg KS0073) to swap between black and white 03034 * 03035 * @param bool invertOn Invert on/off 03036 * @return none 03037 */ 03038 //@TODO Add support for 40x4 dual controller 03039 void TextLCD_Base::setInvert(bool invertOn) { 03040 03041 if (invertOn) { 03042 // Controllers that support Invert 03043 switch (_ctrl) { 03044 case KS0073: 03045 case KS0078: 03046 _function = _function | 0x01; // Enable Invert 03047 _writeCommand(0x20 | _function); // Activate Invert (Std Instr Set) 03048 break; 03049 case SSD1803_3V3 : 03050 // case SSD1803_5V : 03051 case US2066_3V3: 03052 // case USS2066_5V: 03053 _function_1 = _function_1 | 0x01; // Enable Invert 03054 // Set function, 0 0 1 DL N BE RE(1) REV (SSD1803) 03055 // Set function, 0 0 1 X N BE RE(1) REV (US2066) 03056 _writeCommand(0x20 | _function_1); // Activate Invert (Ext Instr Set) 03057 _writeCommand(0x20 | _function); // Return to Std Instr Set 03058 break; 03059 default: 03060 //Unsupported feature for other controllers 03061 break; 03062 } // end switch 03063 } 03064 else { 03065 // Controllers that support Invert 03066 switch (_ctrl) { 03067 case KS0073: 03068 case KS0078: 03069 _function = _function & ~0x01; // Disable Invert 03070 _writeCommand(0x20 | _function); // Disable Invert (Std Instr Set) 03071 break; 03072 case SSD1803_3V3 : 03073 // case SSD1803_5V : 03074 case US2066_3V3: 03075 // case USS2066_5V: 03076 _function_1 = _function_1 & ~0x01; // Disable Invert 03077 // Set function, 0 0 1 DL N BE RE(1) REV (SSD1803) 03078 // Set function, 0 0 1 X N BE RE(1) REV (US2066) 03079 _writeCommand(0x20 | _function_1); // Activate Invert (Ext Instr Set) 03080 _writeCommand(0x20 | _function); // Return to Std Instr Set 03081 break; 03082 03083 default: 03084 //Unsupported feature for other controllers 03085 break; 03086 } // end switch 03087 } 03088 } // end setInvert() 03089 #endif 03090 03091 //--------- End TextLCD_Base ----------- 03092 03093 03094 //--------- Start TextLCD Bus ----------- 03095 03096 /* Create a TextLCD interface for using regular mbed pins 03097 * 03098 * @param rs Instruction/data control line 03099 * @param e Enable line (clock) 03100 * @param d4-d7 Data lines for using as a 4-bit interface 03101 * @param type Sets the panel size/addressing mode (default = LCD16x2) 03102 * @param bl Backlight control line (optional, default = NC) 03103 * @param e2 Enable2 line (clock for second controller, LCD40x4 only) 03104 * @param ctrl LCD controller (default = HD44780) 03105 */ 03106 TextLCD::TextLCD(PinName rs, PinName e, 03107 PinName d4, PinName d5, PinName d6, PinName d7, 03108 LCDType type, PinName bl, PinName e2, LCDCtrl ctrl) : 03109 TextLCD_Base(type, ctrl), 03110 _rs(rs), _e(e), _d(d4, d5, d6, d7) { 03111 03112 // The hardware Backlight pin is optional. Test and make sure whether it exists or not to prevent illegal access. 03113 if (bl != NC) { 03114 _bl = new DigitalOut(bl); //Construct new pin 03115 _bl->write(0); //Deactivate 03116 } 03117 else { 03118 // No Hardware Backlight pin 03119 _bl = NULL; //Construct dummy pin 03120 } 03121 03122 // The hardware Enable2 pin is only needed for LCD40x4. Test and make sure whether it exists or not to prevent illegal access. 03123 if (e2 != NC) { 03124 _e2 = new DigitalOut(e2); //Construct new pin 03125 _e2->write(0); //Deactivate 03126 } 03127 else { 03128 // No Hardware Enable pin 03129 _e2 = NULL; //Construct dummy pin 03130 } 03131 03132 _init(_LCD_DL_4); // Set Datalength to 4 bit for mbed bus interfaces 03133 } 03134 03135 /** Destruct a TextLCD interface for using regular mbed pins 03136 * 03137 * @param none 03138 * @return none 03139 */ 03140 TextLCD::~TextLCD() { 03141 if (_bl != NULL) {delete _bl;} // BL pin 03142 if (_e2 != NULL) {delete _e2;} // E2 pin 03143 } 03144 03145 /** Set E pin (or E2 pin) 03146 * Used for mbed pins, I2C bus expander or SPI shiftregister 03147 * Default PinName value for E2 is NC, must be used as pointer to avoid issues with mbed lib and DigitalOut pins 03148 * @param value true or false 03149 * @return none 03150 */ 03151 void TextLCD::_setEnable(bool value) { 03152 03153 if(_ctrl_idx==_LCDCtrl_0) { 03154 if (value) { 03155 _e = 1; // Set E bit 03156 } 03157 else { 03158 _e = 0; // Reset E bit 03159 } 03160 } 03161 else { 03162 if (value) { 03163 if (_e2 != NULL) {_e2->write(1);} //Set E2 bit 03164 } 03165 else { 03166 if (_e2 != NULL) {_e2->write(0);} //Reset E2 bit 03167 } 03168 } 03169 } 03170 03171 // Set RS pin 03172 // Used for mbed pins, I2C bus expander or SPI shiftregister 03173 void TextLCD::_setRS(bool value) { 03174 03175 if (value) { 03176 _rs = 1; // Set RS bit 03177 } 03178 else { 03179 _rs = 0; // Reset RS bit 03180 } 03181 } 03182 03183 /** Set BL pin 03184 * Used for mbed pins, I2C bus expander or SPI shiftregister 03185 * Default PinName value is NC, must be used as pointer to avoid issues with mbed lib and DigitalOut pins 03186 * @param value true or false 03187 * @return none 03188 */ 03189 void TextLCD::_setBL(bool value) { 03190 03191 if (value) { 03192 if (_bl != NULL) {_bl->write(1);} //Set BL bit 03193 } 03194 else { 03195 if (_bl != NULL) {_bl->write(0);} //Reset BL bit 03196 } 03197 } 03198 03199 // Place the 4bit data on the databus 03200 // Used for mbed pins, I2C bus expander or SPI shifregister 03201 void TextLCD::_setData(int value) { 03202 _d = value & 0x0F; // Write Databits 03203 } 03204 03205 //----------- End TextLCD --------------- 03206 03207 03208 //--------- Start TextLCD_I2C ----------- 03209 #if(LCD_I2C == 1) /* I2C Expander PCF8574/MCP23008 */ 03210 /** Create a TextLCD interface using an I2C PC8574 (or PCF8574A) or MCP23008 portexpander 03211 * 03212 * @param i2c I2C Bus 03213 * @param deviceAddress I2C slave address (PCF8574, PCF8574A or MCP23008, default = 0x40) 03214 * @param type Sets the panel size/addressing mode (default = LCD16x2) 03215 * @param ctrl LCD controller (default = HD44780) 03216 */ 03217 TextLCD_I2C::TextLCD_I2C(I2C *i2c, char deviceAddress, LCDType type, LCDCtrl ctrl) : 03218 TextLCD_Base(type, ctrl), 03219 _i2c(i2c){ 03220 03221 _slaveAddress = deviceAddress & 0xFE; 03222 03223 // Setup the I2C bus 03224 // The max bitrate for PCF8574 is 100kbit, the max bitrate for MCP23008 is 400kbit, 03225 _i2c->frequency(100000); 03226 03227 #if (MCP23008==1) 03228 // MCP23008 portexpander Init 03229 _writeRegister(IODIR, 0x00); // All pins are outputs 03230 _writeRegister(IPOL, 0x00); // No reverse polarity on inputs 03231 _writeRegister(GPINTEN, 0x00); // No interrupt on change of input pins 03232 _writeRegister(DEFVAL, 0x00); // Default value to compare against for interrupts 03233 _writeRegister(INTCON, 0x00); // No interrupt on changes, compare against previous pin value 03234 _writeRegister(IOCON, 0x20); // b1=0 - Interrupt polarity active low 03235 // b2=0 - Interrupt pin active driver output 03236 // b4=0 - Slew rate enable on SDA 03237 // b5=0 - Auto-increment on registeraddress 03238 // b5=1 - No auto-increment on registeraddress => needed for performance improved I2C expander mode 03239 _writeRegister(GPPU, 0x00); // No Pullup 03240 // INTF // Interrupt flags read (Read-Only) 03241 // INTCAP // Captured inputpins at time of interrupt (Read-Only) 03242 // _writeRegister(GPIO, 0x00); // Output/Input pins 03243 // _writeRegister(OLAT, 0x00); // Output Latch 03244 03245 // Init the portexpander bus 03246 _lcd_bus = LCD_BUS_I2C_DEF; 03247 03248 // write the new data to the portexpander 03249 _writeRegister(GPIO, _lcd_bus); 03250 #else 03251 // PCF8574 of PCF8574A portexpander 03252 03253 // Init the portexpander bus 03254 _lcd_bus = LCD_BUS_I2C_DEF; 03255 03256 // write the new data to the portexpander 03257 _i2c->write(_slaveAddress, &_lcd_bus, 1); 03258 #endif 03259 03260 _init(_LCD_DL_4); // Set Datalength to 4 bit for all serial expander interfaces 03261 } 03262 03263 // Set E bit (or E2 bit) in the databus shadowvalue 03264 // Used for mbed I2C bus expander 03265 void TextLCD_I2C::_setEnableBit(bool value) { 03266 03267 #if (LCD_TWO_CTRL == 1) 03268 if(_ctrl_idx==_LCDCtrl_0) { 03269 if (value) { 03270 _lcd_bus |= LCD_BUS_I2C_E; // Set E bit 03271 } 03272 else { 03273 _lcd_bus &= ~LCD_BUS_I2C_E; // Reset E bit 03274 } 03275 } 03276 else { 03277 if (value) { 03278 _lcd_bus |= LCD_BUS_I2C_E2; // Set E2 bit 03279 } 03280 else { 03281 _lcd_bus &= ~LCD_BUS_I2C_E2; // Reset E2bit 03282 } 03283 } 03284 #else 03285 // Support only one controller 03286 if (value) { 03287 _lcd_bus |= LCD_BUS_I2C_E; // Set E bit 03288 } 03289 else { 03290 _lcd_bus &= ~LCD_BUS_I2C_E; // Reset E bit 03291 } 03292 03293 #endif 03294 } 03295 03296 // Set E pin (or E2 pin) 03297 // Used for mbed pins, I2C bus expander or SPI shiftregister 03298 void TextLCD_I2C::_setEnable(bool value) { 03299 03300 // Place the E or E2 bit data on the databus shadowvalue 03301 _setEnableBit(value); 03302 03303 #if (MCP23008==1) 03304 // MCP23008 portexpander 03305 03306 // write the new data to the portexpander 03307 _writeRegister(GPIO, _lcd_bus); 03308 #else 03309 // PCF8574 of PCF8574A portexpander 03310 03311 // write the new data to the I2C portexpander 03312 _i2c->write(_slaveAddress, &_lcd_bus, 1); 03313 #endif 03314 } 03315 03316 03317 // Set RS pin 03318 // Used for mbed pins, I2C bus expander or SPI shiftregister 03319 void TextLCD_I2C::_setRS(bool value) { 03320 03321 if (value) { 03322 _lcd_bus |= LCD_BUS_I2C_RS; // Set RS bit 03323 } 03324 else { 03325 _lcd_bus &= ~LCD_BUS_I2C_RS; // Reset RS bit 03326 } 03327 03328 #if (MCP23008==1) 03329 // MCP23008 portexpander 03330 03331 // write the new data to the portexpander 03332 _writeRegister(GPIO, _lcd_bus); 03333 #else 03334 // PCF8574 of PCF8574A portexpander 03335 03336 // write the new data to the I2C portexpander 03337 _i2c->write(_slaveAddress, &_lcd_bus, 1); 03338 #endif 03339 } 03340 03341 // Set BL pin 03342 // Used for mbed pins, I2C bus expander or SPI shiftregister 03343 void TextLCD_I2C::_setBL(bool value) { 03344 03345 if (value) { 03346 _lcd_bus |= LCD_BUS_I2C_BL; // Set BL bit 03347 } 03348 else { 03349 _lcd_bus &= ~LCD_BUS_I2C_BL; // Reset BL bit 03350 } 03351 03352 #if (MCP23008==1) 03353 // MCP23008 portexpander 03354 03355 // write the new data to the portexpander 03356 _writeRegister(GPIO, _lcd_bus); 03357 #else 03358 // PCF8574 of PCF8574A portexpander 03359 03360 // write the new data to the I2C portexpander 03361 _i2c->write(_slaveAddress, &_lcd_bus, 1); 03362 #endif 03363 } 03364 03365 #if(0) 03366 // New optimized v018 03367 // Test faster _writeByte 0.11s vs 0.27s for a 20x4 fillscreen (PCF8574), same as v018 03368 // Place the 4bit data in the databus shadowvalue 03369 // Used for mbed I2C bus expander 03370 const char _LCD_DATA_BITS[16] = { 03371 0x00, 03372 ( LCD_BUS_I2C_D4), 03373 ( LCD_BUS_I2C_D5 ), 03374 ( LCD_BUS_I2C_D5 | LCD_BUS_I2C_D4), 03375 ( LCD_BUS_I2C_D6 ), 03376 ( LCD_BUS_I2C_D6 | LCD_BUS_I2C_D4), 03377 ( LCD_BUS_I2C_D6 | LCD_BUS_I2C_D5 ), 03378 ( LCD_BUS_I2C_D6 | LCD_BUS_I2C_D5 | LCD_BUS_I2C_D4), 03379 (LCD_BUS_I2C_D7 ), 03380 (LCD_BUS_I2C_D7 | LCD_BUS_I2C_D4), 03381 (LCD_BUS_I2C_D7 | LCD_BUS_I2C_D5 ), 03382 (LCD_BUS_I2C_D7 | LCD_BUS_I2C_D5 | LCD_BUS_I2C_D4), 03383 (LCD_BUS_I2C_D7 | LCD_BUS_I2C_D6 ), 03384 (LCD_BUS_I2C_D7 | LCD_BUS_I2C_D6 | LCD_BUS_I2C_D4), 03385 (LCD_BUS_I2C_D7 | LCD_BUS_I2C_D6 | LCD_BUS_I2C_D5 ), 03386 (LCD_BUS_I2C_D7 | LCD_BUS_I2C_D6 | LCD_BUS_I2C_D5 | LCD_BUS_I2C_D4) 03387 }; 03388 void TextLCD_I2C::_setDataBits(int value) { 03389 03390 //Clear all databits 03391 _lcd_bus &= ~LCD_BUS_I2C_MSK; 03392 03393 // Set bit by bit to support any mapping of expander portpins to LCD pins 03394 _lcd_bus |= _LCD_DATA_BITS[value & 0x0F]; 03395 } 03396 #endif 03397 03398 // Test faster _writeByte 0.11s vs 0.27s for a 20x4 fillscreen (PCF8574) 03399 // Place the 4bit data in the databus shadowvalue 03400 // Used for mbed I2C bus expander 03401 void TextLCD_I2C::_setDataBits(int value) { 03402 03403 //Clear all databits 03404 _lcd_bus &= ~LCD_BUS_I2C_MSK; 03405 03406 // Set bit by bit to support any mapping of expander portpins to LCD pins 03407 if (value & 0x01){ 03408 _lcd_bus |= LCD_BUS_I2C_D4; // Set Databit 03409 } 03410 03411 if (value & 0x02){ 03412 _lcd_bus |= LCD_BUS_I2C_D5; // Set Databit 03413 } 03414 03415 if (value & 0x04) { 03416 _lcd_bus |= LCD_BUS_I2C_D6; // Set Databit 03417 } 03418 03419 if (value & 0x08) { 03420 _lcd_bus |= LCD_BUS_I2C_D7; // Set Databit 03421 } 03422 } 03423 03424 03425 // Place the 4bit data on the databus 03426 // Used for mbed pins, I2C bus expander or SPI shifregister 03427 void TextLCD_I2C::_setData(int value) { 03428 03429 // Place the 4bit data on the databus shadowvalue 03430 _setDataBits(value); 03431 03432 // Place the 4bit data on the databus 03433 #if (MCP23008==1) 03434 // MCP23008 portexpander 03435 03436 // write the new data to the portexpander 03437 _writeRegister(GPIO, _lcd_bus); 03438 #else 03439 // PCF8574 of PCF8574A portexpander 03440 03441 // write the new data to the I2C portexpander 03442 _i2c->write(_slaveAddress, &_lcd_bus, 1); 03443 #endif 03444 } 03445 03446 // Write data to MCP23008 I2C portexpander 03447 // Used for mbed I2C bus expander 03448 void TextLCD_I2C::_writeRegister (int reg, int value) { 03449 char data[] = {(char)reg, (char)value}; 03450 03451 _i2c->write(_slaveAddress, data, 2); 03452 } 03453 03454 //New optimized 03455 //Test faster _writeByte 0.11s vs 0.27s for a 20x4 fillscreen (PCF8574) 03456 //Test faster _writeByte 0.14s vs 0.34s for a 20x4 fillscreen (MCP23008) 03457 03458 // Write a byte using I2C 03459 void TextLCD_I2C::_writeByte(int value) { 03460 char data[6]; 03461 03462 #if (MCP23008==1) 03463 // MCP23008 portexpander 03464 03465 data[0] = GPIO; // set registeraddres 03466 // Note: auto-increment is disabled so all data will go to GPIO register 03467 03468 _setEnableBit(true); // set E 03469 _setDataBits(value >> 4); // set data high 03470 data[1] = _lcd_bus; 03471 03472 _setEnableBit(false); // clear E 03473 data[2] = _lcd_bus; 03474 03475 _setEnableBit(true); // set E 03476 _setDataBits(value); // set data low 03477 data[3] = _lcd_bus; 03478 03479 _setEnableBit(false); // clear E 03480 data[4] = _lcd_bus; 03481 03482 // write the packed data to the I2C portexpander 03483 _i2c->write(_slaveAddress, data, 5); 03484 #else 03485 // PCF8574 of PCF8574A portexpander 03486 03487 _setEnableBit(true); // set E 03488 _setDataBits(value >> 4); // set data high 03489 data[0] = _lcd_bus; 03490 03491 _setEnableBit(false); // clear E 03492 data[1] = _lcd_bus; 03493 03494 _setEnableBit(true); // set E 03495 _setDataBits(value); // set data low 03496 data[2] = _lcd_bus; 03497 03498 _setEnableBit(false); // clear E 03499 data[3] = _lcd_bus; 03500 03501 // write the packed data to the I2C portexpander 03502 _i2c->write(_slaveAddress, data, 4); 03503 #endif 03504 } 03505 03506 #endif /* I2C Expander PCF8574/MCP23008 */ 03507 //---------- End TextLCD_I2C ------------ 03508 03509 03510 //--------- Start TextLCD_SPI ----------- 03511 #if(LCD_SPI == 1) /* SPI Expander SN74595 */ 03512 03513 /** Create a TextLCD interface using an SPI 74595 portexpander 03514 * 03515 * @param spi SPI Bus 03516 * @param cs chip select pin (active low) 03517 * @param type Sets the panel size/addressing mode (default = LCD16x2) 03518 * @param ctrl LCD controller (default = HD44780) 03519 */ 03520 TextLCD_SPI::TextLCD_SPI(SPI *spi, PinName cs, LCDType type, LCDCtrl ctrl) : 03521 TextLCD_Base(type, ctrl), 03522 _spi(spi), 03523 _cs(cs) { 03524 // Init cs 03525 _cs = 1; 03526 03527 // Setup the spi for 8 bit data, low steady state clock, 03528 // rising edge capture, with a 500KHz or 1MHz clock rate 03529 _spi->format(8,0); 03530 _spi->frequency(500000); 03531 //_spi.frequency(1000000); 03532 03533 wait_ms(100); // Wait 100ms to ensure LCD powered up 03534 03535 // Init the portexpander bus 03536 _lcd_bus = LCD_BUS_SPI_DEF; 03537 03538 // write the new data to the portexpander 03539 _cs = 0; 03540 _spi->write(_lcd_bus); 03541 _cs = 1; 03542 03543 _init(_LCD_DL_4); // Set Datalength to 4 bit for all serial expander interfaces 03544 } 03545 03546 // Set E pin (or E2 pin) 03547 // Used for mbed pins, I2C bus expander or SPI shiftregister 03548 void TextLCD_SPI::_setEnable(bool value) { 03549 03550 if(_ctrl_idx==_LCDCtrl_0) { 03551 if (value) { 03552 _lcd_bus |= LCD_BUS_SPI_E; // Set E bit 03553 } 03554 else { 03555 _lcd_bus &= ~LCD_BUS_SPI_E; // Reset E bit 03556 } 03557 } 03558 else { 03559 if (value) { 03560 _lcd_bus |= LCD_BUS_SPI_E2; // Set E2 bit 03561 } 03562 else { 03563 _lcd_bus &= ~LCD_BUS_SPI_E2; // Reset E2 bit 03564 } 03565 } 03566 03567 // write the new data to the SPI portexpander 03568 _cs = 0; 03569 _spi->write(_lcd_bus); 03570 _cs = 1; 03571 } 03572 03573 // Set RS pin 03574 // Used for mbed pins, I2C bus expander or SPI shiftregister and SPI_N 03575 void TextLCD_SPI::_setRS(bool value) { 03576 03577 if (value) { 03578 _lcd_bus |= LCD_BUS_SPI_RS; // Set RS bit 03579 } 03580 else { 03581 _lcd_bus &= ~LCD_BUS_SPI_RS; // Reset RS bit 03582 } 03583 03584 // write the new data to the SPI portexpander 03585 _cs = 0; 03586 _spi->write(_lcd_bus); 03587 _cs = 1; 03588 } 03589 03590 // Set BL pin 03591 // Used for mbed pins, I2C bus expander or SPI shiftregister 03592 void TextLCD_SPI::_setBL(bool value) { 03593 03594 if (value) { 03595 _lcd_bus |= LCD_BUS_SPI_BL; // Set BL bit 03596 } 03597 else { 03598 _lcd_bus &= ~LCD_BUS_SPI_BL; // Reset BL bit 03599 } 03600 03601 // write the new data to the SPI portexpander 03602 _cs = 0; 03603 _spi->write(_lcd_bus); 03604 _cs = 1; 03605 } 03606 03607 // Place the 4bit data on the databus 03608 // Used for mbed pins, I2C bus expander or SPI shiftregister 03609 void TextLCD_SPI::_setData(int value) { 03610 03611 // Set bit by bit to support any mapping of expander portpins to LCD pins 03612 if (value & 0x01) { 03613 _lcd_bus |= LCD_BUS_SPI_D4; // Set Databit 03614 } 03615 else { 03616 _lcd_bus &= ~LCD_BUS_SPI_D4; // Reset Databit 03617 } 03618 03619 if (value & 0x02) { 03620 _lcd_bus |= LCD_BUS_SPI_D5; // Set Databit 03621 } 03622 else { 03623 _lcd_bus &= ~LCD_BUS_SPI_D5; // Reset Databit 03624 } 03625 03626 if (value & 0x04) { 03627 _lcd_bus |= LCD_BUS_SPI_D6; // Set Databit 03628 } 03629 else { 03630 _lcd_bus &= ~LCD_BUS_SPI_D6; // Reset Databit 03631 } 03632 03633 if (value & 0x08) { 03634 _lcd_bus |= LCD_BUS_SPI_D7; // Set Databit 03635 } 03636 else { 03637 _lcd_bus &= ~LCD_BUS_SPI_D7; // Reset Databit 03638 } 03639 03640 // write the new data to the SPI portexpander 03641 _cs = 0; 03642 _spi->write(_lcd_bus); 03643 _cs = 1; 03644 } 03645 03646 #endif /* SPI Expander SN74595 */ 03647 //---------- End TextLCD_SPI ------------ 03648 03649 03650 //--------- Start TextLCD_I2C_N --------- 03651 #if(LCD_I2C_N == 1) /* Native I2C */ 03652 03653 /** Create a TextLCD interface using a controller with native I2C interface 03654 * 03655 * @param i2c I2C Bus 03656 * @param deviceAddress I2C slave address (default = 0x7C) 03657 * @param type Sets the panel size/addressing mode (default = LCD16x2) 03658 * @param bl Backlight control line (optional, default = NC) 03659 * @param ctrl LCD controller (default = ST7032_3V3) 03660 */ 03661 TextLCD_I2C_N::TextLCD_I2C_N(I2C *i2c, char deviceAddress, LCDType type, PinName bl, LCDCtrl ctrl) : 03662 TextLCD_Base(type, ctrl), 03663 03664 _i2c(i2c){ 03665 03666 _slaveAddress = deviceAddress & 0xFE; 03667 03668 // Setup the I2C bus 03669 // The max bitrate for ST7032i is 400kbit, lets stick to default here 03670 _i2c->frequency(100000); 03671 03672 03673 // The hardware Backlight pin is optional. Test and make sure whether it exists or not to prevent illegal access. 03674 if (bl != NC) { 03675 _bl = new DigitalOut(bl); //Construct new pin 03676 _bl->write(0); //Deactivate 03677 } 03678 else { 03679 // No Hardware Backlight pin 03680 _bl = NULL; //Construct dummy pin 03681 } 03682 03683 //Sanity check 03684 if (_ctrl & LCD_C_I2C) { 03685 _init(_LCD_DL_8); // Set Datalength to 8 bit for all native serial interfaces 03686 } 03687 else { 03688 error("Error: LCD Controller type does not support native I2C interface\n\r"); 03689 } 03690 } 03691 03692 TextLCD_I2C_N::~TextLCD_I2C_N() { 03693 if (_bl != NULL) {delete _bl;} // BL pin 03694 } 03695 03696 // Not used in this mode 03697 void TextLCD_I2C_N::_setEnable(bool value) { 03698 } 03699 03700 // Set RS pin 03701 // Used for mbed pins, I2C bus expander or SPI shiftregister and native I2C or SPI 03702 void TextLCD_I2C_N::_setRS(bool value) { 03703 // The controlbyte defines the meaning of the next byte. This next byte can either be data or command. 03704 // Start Slaveaddress+RW b7 b6 b5 b4 b3 b2 b1 b0 b7...........b0 Stop 03705 // Co RS RW 0 0 0 0 0 command or data 03706 // 03707 // C0=1 indicates that another controlbyte will follow after the next data or command byte 03708 // RS=1 means that next byte is data, RS=0 means that next byte is command 03709 // RW=0 means write to controller. RW=1 means that controller will be read from after the next command. 03710 // Many native I2C controllers dont support this option and it is not used by this lib. 03711 // 03712 03713 if (value) { 03714 _controlbyte = 0x40; // Next byte is data, No more control bytes will follow 03715 } 03716 else { 03717 _controlbyte = 0x00; // Next byte is command, No more control bytes will follow 03718 } 03719 } 03720 03721 // Set BL pin 03722 void TextLCD_I2C_N::_setBL(bool value) { 03723 if (_bl) { 03724 _bl->write(value); 03725 } 03726 } 03727 03728 // Not used in this mode 03729 void TextLCD_I2C_N::_setData(int value) { 03730 } 03731 03732 // Write a byte using I2C 03733 void TextLCD_I2C_N::_writeByte(int value) { 03734 // The controlbyte defines the meaning of the next byte. This next byte can either be data or command. 03735 // Start Slaveaddress+RW b7 b6 b5 b4 b3 b2 b1 b0 b7...........b0 Stop 03736 // Co RS RW 0 0 0 0 0 command or data 03737 // 03738 // C0=1 indicates that another controlbyte will follow after the next data or command byte 03739 // RS=1 means that next byte is data, RS=0 means that next byte is command 03740 // RW=0 means write to controller. RW=1 means that controller will be read from after the next command. 03741 // Many native I2C controllers dont support this option and it is not used by this lib. 03742 // 03743 char data[] = {(char)_controlbyte, (char)value}; 03744 03745 #if(LCD_I2C_ACK==1) 03746 //Controllers that support ACK 03747 _i2c->write(_slaveAddress, data, 2); 03748 #else 03749 //Controllers that dont support ACK 03750 //Note: This may be issue with some mbed platforms that dont fully/correctly support I2C byte operations. 03751 _i2c->start(); 03752 _i2c->write(_slaveAddress); 03753 _i2c->write(data[0]); 03754 _i2c->write(data[1]); 03755 _i2c->stop(); 03756 #endif 03757 } 03758 #endif /* Native I2C */ 03759 //-------- End TextLCD_I2C_N ------------ 03760 03761 03762 //--------- Start TextLCD_SPI_N --------- 03763 #if(LCD_SPI_N == 1) /* Native SPI bus */ 03764 /** Create a TextLCD interface using a controller with a native SPI4 interface 03765 * 03766 * @param spi SPI Bus 03767 * @param cs chip select pin (active low) 03768 * @param rs Instruction/data control line 03769 * @param type Sets the panel size/addressing mode (default = LCD16x2) 03770 * @param bl Backlight control line (optional, default = NC) 03771 * @param ctrl LCD controller (default = ST7032_3V3) 03772 */ 03773 TextLCD_SPI_N::TextLCD_SPI_N(SPI *spi, PinName cs, PinName rs, LCDType type, PinName bl, LCDCtrl ctrl) : 03774 TextLCD_Base(type, ctrl), 03775 _spi(spi), 03776 _cs(cs), 03777 _rs(rs) { 03778 03779 // Init CS 03780 _cs = 1; 03781 03782 // Setup the spi for 8 bit data, high steady state clock, 03783 // rising edge capture, with a 500KHz or 1MHz clock rate 03784 // _spi->format(8,3); 03785 // _spi->frequency(500000); 03786 // _spi->frequency(1000000); 03787 03788 // Setup the spi for 8 bit data, low steady state clock, 03789 // rising edge capture, with a 500KHz or 1MHz clock rate 03790 _spi->format(8,0); 03791 // _spi->frequency(500000); 03792 _spi->frequency(1000000); 03793 03794 // The hardware Backlight pin is optional. Test and make sure whether it exists or not to prevent illegal access. 03795 if (bl != NC) { 03796 _bl = new DigitalOut(bl); //Construct new pin 03797 _bl->write(0); //Deactivate 03798 } 03799 else { 03800 // No Hardware Backlight pin 03801 _bl = NULL; //Construct dummy pin 03802 } 03803 03804 //Sanity check 03805 if (_ctrl & LCD_C_SPI4) { 03806 _init(_LCD_DL_8); // Set Datalength to 8 bit for all native serial interfaces 03807 // ST7070 must set datalength to 8 bits! 03808 } 03809 else { 03810 error("Error: LCD Controller type does not support native SPI4 interface\n\r"); 03811 } 03812 } 03813 03814 TextLCD_SPI_N::~TextLCD_SPI_N() { 03815 if (_bl != NULL) {delete _bl;} // BL pin 03816 } 03817 03818 // Not used in this mode 03819 void TextLCD_SPI_N::_setEnable(bool value) { 03820 } 03821 03822 // Set RS pin 03823 // Used for mbed pins, I2C bus expander or SPI shiftregister, SPI_N 03824 void TextLCD_SPI_N::_setRS(bool value) { 03825 _rs = value; 03826 } 03827 03828 // Set BL pin 03829 void TextLCD_SPI_N::_setBL(bool value) { 03830 if (_bl) { 03831 _bl->write(value); 03832 } 03833 } 03834 03835 // Not used in this mode 03836 void TextLCD_SPI_N::_setData(int value) { 03837 } 03838 03839 // Write a byte using SPI 03840 void TextLCD_SPI_N::_writeByte(int value) { 03841 _cs = 0; 03842 wait_us(1); 03843 _spi->write(value); 03844 wait_us(1); 03845 _cs = 1; 03846 } 03847 #endif /* Native SPI bus */ 03848 //-------- End TextLCD_SPI_N ------------ 03849 03850 03851 //-------- Start TextLCD_SPI_N_3_8 -------- 03852 #if(LCD_SPI_N_3_8 == 1) /* Native SPI bus */ 03853 03854 /** Create a TextLCD interface using a controller with a native SPI3 8 bits interface 03855 * This mode is supported by ST7070. Note that implementation in TexTLCD is not very efficient due to 03856 * structure of the TextLCD library: each databyte is written separately and requires a separate 'count command' set to 1 byte. 03857 * 03858 * @param spi SPI Bus 03859 * @param cs chip select pin (active low) 03860 * @param type Sets the panel size/addressing mode (default = LCD16x2) 03861 * @param bl Backlight control line (optional, default = NC) 03862 * @param ctrl LCD controller (default = ST7070) 03863 */ 03864 TextLCD_SPI_N_3_8::TextLCD_SPI_N_3_8(SPI *spi, PinName cs, LCDType type, PinName bl, LCDCtrl ctrl) : 03865 TextLCD_Base(type, ctrl), 03866 _spi(spi), 03867 _cs(cs) { 03868 03869 // Init CS 03870 _cs = 1; 03871 03872 // Setup the spi for 8 bit data, high steady state clock, 03873 // rising edge capture, with a 500KHz or 1MHz clock rate 03874 // _spi->format(8,3); 03875 // _spi->frequency(500000); 03876 // _spi->frequency(1000000); 03877 03878 // Setup the spi for 8 bit data, low steady state clock, 03879 // rising edge capture, with a 500KHz or 1MHz clock rate 03880 _spi->format(8,0); 03881 // _spi->frequency(500000); 03882 _spi->frequency(1000000); 03883 03884 03885 // The hardware Backlight pin is optional. Test and make sure whether it exists or not to prevent illegal access. 03886 if (bl != NC) { 03887 _bl = new DigitalOut(bl); //Construct new pin 03888 _bl->write(0); //Deactivate 03889 } 03890 else { 03891 // No Hardware Backlight pin 03892 _bl = NULL; //Construct dummy pin 03893 } 03894 03895 //Sanity check 03896 if (_ctrl & LCD_C_SPI3_8) { 03897 _init(_LCD_DL_8); // Set Datalength to 8 bit for all native serial interfaces 03898 } 03899 else { 03900 error("Error: LCD Controller type does not support native SPI3 8 bits interface\n\r"); 03901 } 03902 } 03903 03904 TextLCD_SPI_N_3_8::~TextLCD_SPI_N_3_8() { 03905 if (_bl != NULL) {delete _bl;} // BL pin 03906 } 03907 03908 // Not used in this mode 03909 void TextLCD_SPI_N_3_8::_setEnable(bool value) { 03910 } 03911 03912 // Used for mbed pins, I2C bus expander or SPI shiftregister, SPI_N 03913 // RS=1 means that next byte is data, RS=0 means that next byte is command 03914 void TextLCD_SPI_N_3_8::_setRS(bool value) { 03915 03916 if (value) { 03917 _controlbyte = 0x01; // Next byte is data, No more control bytes will follow 03918 } 03919 else { 03920 _controlbyte = 0x00; // Next byte is command, No more control bytes will follow 03921 } 03922 } 03923 03924 // Set BL pin 03925 void TextLCD_SPI_N_3_8::_setBL(bool value) { 03926 if (_bl) { 03927 _bl->write(value); 03928 } 03929 } 03930 03931 // Not used in this mode 03932 void TextLCD_SPI_N_3_8::_setData(int value) { 03933 } 03934 03935 // Write a byte using SPI3 8 bits mode (ST7070) 03936 void TextLCD_SPI_N_3_8::_writeByte(int value) { 03937 03938 if (_controlbyte == 0x00) { // Byte is command 03939 _cs = 0; 03940 wait_us(1); 03941 _spi->write(value); 03942 wait_us(1); 03943 _cs = 1; 03944 } 03945 else { // Byte is data 03946 // Select Extended Instr Set 03947 _cs = 0; 03948 wait_us(1); 03949 _spi->write(0x20 | _function | 0x04); // Set function, 0 0 1 DL N EXT=1 x x (Select Instr Set = 1)); 03950 wait_us(1); 03951 _cs = 1; 03952 03953 wait_us(40); // Wait until command has finished... 03954 03955 // Set Count to 1 databyte 03956 _cs = 0; 03957 wait_us(1); 03958 _spi->write(0x80); // Set display data length, 1 L6 L5 L4 L3 L2 L1 L0 (Instr Set = 1) 03959 wait_us(1); 03960 _cs = 1; 03961 03962 wait_us(40); 03963 03964 // Write 1 databyte 03965 _cs = 0; 03966 wait_us(1); 03967 _spi->write(value); // Write data (Instr Set = 1) 03968 wait_us(1); 03969 _cs = 1; 03970 03971 wait_us(40); 03972 03973 // Select Standard Instr Set 03974 _cs = 0; 03975 wait_us(1); 03976 _spi->write(0x20 | _function); // Set function, 0 0 1 DL N EXT=0 x x (Select Instr Set = 0)); 03977 wait_us(1); 03978 _cs = 1; 03979 } 03980 } 03981 #endif /* Native SPI bus */ 03982 //------- End TextLCD_SPI_N_3_8 ----------- 03983 03984 03985 //-------- Start TextLCD_SPI_N_3_9 -------- 03986 #if(LCD_SPI_N_3_9 == 1) /* Native SPI bus */ 03987 //Code checked out on logic analyser. Not yet tested on hardware.. 03988 03989 /** Create a TextLCD interface using a controller with a native SPI3 9 bits interface 03990 * 03991 * @param spi SPI Bus 03992 * @param cs chip select pin (active low) 03993 * @param type Sets the panel size/addressing mode (default = LCD16x2) 03994 * @param bl Backlight control line (optional, default = NC) 03995 * @param ctrl LCD controller (default = AIP31068) 03996 */ 03997 TextLCD_SPI_N_3_9::TextLCD_SPI_N_3_9(SPI *spi, PinName cs, LCDType type, PinName bl, LCDCtrl ctrl) : 03998 TextLCD_Base(type, ctrl), 03999 _spi(spi), 04000 _cs(cs) { 04001 04002 // Init CS 04003 _cs = 1; 04004 04005 // Setup the spi for 9 bit data, high steady state clock, 04006 // rising edge capture, with a 500KHz or 1MHz clock rate 04007 _spi->format(9,3); 04008 _spi->frequency(1000000); 04009 04010 // The hardware Backlight pin is optional. Test and make sure whether it exists or not to prevent illegal access. 04011 if (bl != NC) { 04012 _bl = new DigitalOut(bl); //Construct new pin 04013 _bl->write(0); //Deactivate 04014 } 04015 else { 04016 // No Hardware Backlight pin 04017 _bl = NULL; //Construct dummy pin 04018 } 04019 04020 //Sanity check 04021 if (_ctrl & LCD_C_SPI3_9) { 04022 _init(_LCD_DL_8); // Set Datalength to 8 bit for all native serial interfaces 04023 } 04024 else { 04025 error("Error: LCD Controller type does not support native SPI3 9 bits interface\n\r"); 04026 } 04027 } 04028 04029 TextLCD_SPI_N_3_9::~TextLCD_SPI_N_3_9() { 04030 if (_bl != NULL) {delete _bl;} // BL pin 04031 } 04032 04033 // Not used in this mode 04034 void TextLCD_SPI_N_3_9::_setEnable(bool value) { 04035 } 04036 04037 // Set RS pin 04038 // Used for mbed pins, I2C bus expander or SPI shiftregister 04039 void TextLCD_SPI_N_3_9::_setRS(bool value) { 04040 // The controlbits define the meaning of the next byte. This next byte can either be data or command. 04041 // b8 b7...........b0 04042 // RS command or data 04043 // 04044 // RS=1 means that next byte is data, RS=0 means that next byte is command 04045 // 04046 04047 if (value) { 04048 _controlbyte = 0x01; // Next byte is data 04049 } 04050 else { 04051 _controlbyte = 0x00; // Next byte is command 04052 } 04053 } 04054 04055 // Set BL pin 04056 void TextLCD_SPI_N_3_9::_setBL(bool value) { 04057 if (_bl) { 04058 _bl->write(value); 04059 } 04060 } 04061 04062 // Not used in this mode 04063 void TextLCD_SPI_N_3_9::_setData(int value) { 04064 } 04065 04066 // Write a byte using SPI3 9 bits mode 04067 void TextLCD_SPI_N_3_9::_writeByte(int value) { 04068 _cs = 0; 04069 wait_us(1); 04070 _spi->write( (_controlbyte << 8) | (value & 0xFF)); 04071 wait_us(1); 04072 _cs = 1; 04073 } 04074 #endif /* Native SPI bus */ 04075 //------- End TextLCD_SPI_N_3_9 ----------- 04076 04077 04078 //------- Start TextLCD_SPI_N_3_10 -------- 04079 #if(LCD_SPI_N_3_10 == 1) /* Native SPI bus */ 04080 04081 /** Create a TextLCD interface using a controller with a native SPI3 10 bits interface 04082 * 04083 * @param spi SPI Bus 04084 * @param cs chip select pin (active low) 04085 * @param type Sets the panel size/addressing mode (default = LCD16x2) 04086 * @param bl Backlight control line (optional, default = NC) 04087 * @param ctrl LCD controller (default = AIP31068) 04088 */ 04089 TextLCD_SPI_N_3_10::TextLCD_SPI_N_3_10(SPI *spi, PinName cs, LCDType type, PinName bl, LCDCtrl ctrl) : 04090 TextLCD_Base(type, ctrl), 04091 _spi(spi), 04092 _cs(cs) { 04093 04094 // Init CS 04095 _cs = 1; 04096 04097 // Setup the spi for 10 bit data, low steady state clock, 04098 // rising edge capture, with a 500KHz or 1MHz clock rate 04099 _spi->format(10,0); 04100 _spi->frequency(1000000); 04101 04102 // The hardware Backlight pin is optional. Test and make sure whether it exists or not to prevent illegal access. 04103 if (bl != NC) { 04104 _bl = new DigitalOut(bl); //Construct new pin 04105 _bl->write(0); //Deactivate 04106 } 04107 else { 04108 // No Hardware Backlight pin 04109 _bl = NULL; //Construct dummy pin 04110 } 04111 04112 //Sanity check 04113 if (_ctrl & LCD_C_SPI3_10) { 04114 _init(_LCD_DL_8); // Set Datalength to 8 bit for all native serial interfaces 04115 } 04116 else { 04117 error("Error: LCD Controller type does not support native SPI3 10 bits interface\n\r"); 04118 } 04119 } 04120 04121 TextLCD_SPI_N_3_10::~TextLCD_SPI_N_3_10() { 04122 if (_bl != NULL) {delete _bl;} // BL pin 04123 } 04124 04125 // Not used in this mode 04126 void TextLCD_SPI_N_3_10::_setEnable(bool value) { 04127 } 04128 04129 // Set RS pin 04130 // Used for mbed pins, I2C bus expander or SPI shiftregister 04131 void TextLCD_SPI_N_3_10::_setRS(bool value) { 04132 // The controlbits define the meaning of the next byte. This next byte can either be data or command. 04133 // b9 b8 b7...........b0 04134 // RS RW command or data 04135 // 04136 // RS=1 means that next byte is data, RS=0 means that next byte is command 04137 // RW=0 means that next byte is writen, RW=1 means that next byte is read (not used in this lib) 04138 // 04139 04140 if (value) { 04141 _controlbyte = 0x02; // Next byte is data 04142 } 04143 else { 04144 _controlbyte = 0x00; // Next byte is command 04145 } 04146 } 04147 04148 // Set BL pin 04149 void TextLCD_SPI_N_3_10::_setBL(bool value) { 04150 if (_bl) { 04151 _bl->write(value); 04152 } 04153 } 04154 04155 // Not used in this mode 04156 void TextLCD_SPI_N_3_10::_setData(int value) { 04157 } 04158 04159 // Write a byte using SPI3 10 bits mode 04160 void TextLCD_SPI_N_3_10::_writeByte(int value) { 04161 _cs = 0; 04162 wait_us(1); 04163 _spi->write( (_controlbyte << 8) | (value & 0xFF)); 04164 wait_us(1); 04165 _cs = 1; 04166 } 04167 #endif /* Native SPI bus */ 04168 //------- End TextLCD_SPI_N_3_10 ---------- 04169 04170 04171 //------- Start TextLCD_SPI_N_3_16 -------- 04172 #if(LCD_SPI_N_3_16 == 1) /* Native SPI bus */ 04173 04174 /** Create a TextLCD interface using a controller with a native SPI3 16 bits interface 04175 * 04176 * @param spi SPI Bus 04177 * @param cs chip select pin (active low) 04178 * @param type Sets the panel size/addressing mode (default = LCD16x2) 04179 * @param bl Backlight control line (optional, default = NC) 04180 * @param ctrl LCD controller (default = PT6314) 04181 */ 04182 TextLCD_SPI_N_3_16::TextLCD_SPI_N_3_16(SPI *spi, PinName cs, LCDType type, PinName bl, LCDCtrl ctrl) : 04183 TextLCD_Base(type, ctrl), 04184 _spi(spi), 04185 _cs(cs) { 04186 04187 // Init CS 04188 _cs = 1; 04189 04190 // Setup the spi for 8 bit data, low steady state clock, 04191 // rising edge capture, with a 500KHz or 1MHz clock rate 04192 _spi->format(8,0); 04193 _spi->frequency(1000000); 04194 04195 // The hardware Backlight pin is optional. Test and make sure whether it exists or not to prevent illegal access. 04196 if (bl != NC) { 04197 _bl = new DigitalOut(bl); //Construct new pin 04198 _bl->write(0); //Deactivate 04199 } 04200 else { 04201 // No Hardware Backlight pin 04202 _bl = NULL; //Construct dummy pin 04203 } 04204 04205 //Sanity check 04206 if (_ctrl & LCD_C_SPI3_16) { 04207 _init(_LCD_DL_8); // Set Datalength to 8 bit for all native serial interfaces 04208 } 04209 else { 04210 error("Error: LCD Controller type does not support native SPI3 16 bits interface\n\r"); 04211 } 04212 } 04213 04214 TextLCD_SPI_N_3_16::~TextLCD_SPI_N_3_16() { 04215 if (_bl != NULL) {delete _bl;} // BL pin 04216 } 04217 04218 // Not used in this mode 04219 void TextLCD_SPI_N_3_16::_setEnable(bool value) { 04220 } 04221 04222 // Set RS pin 04223 // Used for mbed pins, I2C bus expander or SPI shiftregister 04224 void TextLCD_SPI_N_3_16::_setRS(bool value) { 04225 // The 16bit mode is split in 2 bytes. The first byte is for synchronisation and controlbits. The controlbits define the meaning of the next byte. 04226 // The 8 actual bits represent either a data or a command byte. 04227 // b15 b14 b13 b12 b11 b10 b9 b8 - b7 b6 b5 b4 b3 b2 b1 b0 04228 // 1 1 1 1 1 RW RS 0 d7 d6 d5 d4 d3 d2 d1 d0 04229 // 04230 // RS=1 means that next byte is data, RS=0 means that next byte is command 04231 // RW=0 means that next byte is writen, RW=1 means that next byte is read (not used in this lib) 04232 // 04233 04234 if (value) { 04235 _controlbyte = 0xFA; // Next byte is data 04236 } 04237 else { 04238 _controlbyte = 0xF8; // Next byte is command 04239 } 04240 } 04241 04242 // Set BL pin 04243 void TextLCD_SPI_N_3_16::_setBL(bool value) { 04244 if (_bl) { 04245 _bl->write(value); 04246 } 04247 } 04248 04249 // Not used in this mode 04250 void TextLCD_SPI_N_3_16::_setData(int value) { 04251 } 04252 04253 // Write a byte using SPI3 16 bits mode 04254 void TextLCD_SPI_N_3_16::_writeByte(int value) { 04255 _cs = 0; 04256 wait_us(1); 04257 04258 _spi->write(_controlbyte); 04259 04260 _spi->write(value); 04261 04262 wait_us(1); 04263 _cs = 1; 04264 } 04265 #endif /* Native SPI bus */ 04266 //------- End TextLCD_SPI_N_3_16 ---------- 04267 04268 04269 //------- Start TextLCD_SPI_N_3_24 -------- 04270 #if(LCD_SPI_N_3_24 == 1) /* Native SPI bus */ 04271 04272 /** Create a TextLCD interface using a controller with a native SPI3 24 bits interface 04273 * 04274 * @param spi SPI Bus 04275 * @param cs chip select pin (active low) 04276 * @param type Sets the panel size/addressing mode (default = LCD16x2) 04277 * @param bl Backlight control line (optional, default = NC) 04278 * @param ctrl LCD controller (default = SSD1803) 04279 */ 04280 TextLCD_SPI_N_3_24::TextLCD_SPI_N_3_24(SPI *spi, PinName cs, LCDType type, PinName bl, LCDCtrl ctrl) : 04281 TextLCD_Base(type, ctrl), 04282 _spi(spi), 04283 _cs(cs) { 04284 04285 // Init CS 04286 _cs = 1; 04287 04288 // Setup the spi for 8 bit data, high steady state clock, 04289 // rising edge capture, with a 500KHz or 1MHz clock rate 04290 _spi->format(8,3); 04291 _spi->frequency(1000000); 04292 04293 // The hardware Backlight pin is optional. Test and make sure whether it exists or not to prevent illegal access. 04294 if (bl != NC) { 04295 _bl = new DigitalOut(bl); //Construct new pin 04296 _bl->write(0); //Deactivate 04297 } 04298 else { 04299 // No Hardware Backlight pin 04300 _bl = NULL; //Construct dummy pin 04301 } 04302 04303 //Sanity check 04304 if (_ctrl & LCD_C_SPI3_24) { 04305 _init(_LCD_DL_8); // Set Datalength to 8 bit for all native serial interfaces 04306 } 04307 else { 04308 error("Error: LCD Controller type does not support native SPI3 24 bits interface\n\r"); 04309 } 04310 } 04311 04312 TextLCD_SPI_N_3_24::~TextLCD_SPI_N_3_24() { 04313 if (_bl != NULL) {delete _bl;} // BL pin 04314 } 04315 04316 // Not used in this mode 04317 void TextLCD_SPI_N_3_24::_setEnable(bool value) { 04318 } 04319 04320 // Set RS pin 04321 // Used for mbed pins, I2C bus expander or SPI shiftregister 04322 void TextLCD_SPI_N_3_24::_setRS(bool value) { 04323 // The 24bit mode is split in 3 bytes. The first byte is for synchronisation and controlbits. The controlbits define the meaning of the next two bytes. 04324 // Each byte encodes 4 actual bits. The 8 actual bits represent either a data or a command byte. 04325 // b23 b22 b21 b20 b19 b18 b17 b16 - b15 b14 b13 b12 b11 b10 b9 b8 - b7 b6 b5 b4 b3 b2 b1 b0 04326 // 1 1 1 1 1 RW RS 0 d0 d1 d2 d3 0 0 0 0 d4 d5 d6 d7 0 0 0 0 04327 // 04328 // RS=1 means that next byte is data, RS=0 means that next byte is command 04329 // RW=0 means that next byte is writen, RW=1 means that next byte is read (not used in this lib) 04330 // 04331 // Note: SPI3_24 expects LSB first. This is inconsistent with regular SPI convention (and hardware) that sends MSB first. 04332 04333 if (value) { 04334 _controlbyte = 0xFA; // Next byte is data 04335 } 04336 else { 04337 _controlbyte = 0xF8; // Next byte is command 04338 } 04339 } 04340 04341 // Set BL pin 04342 void TextLCD_SPI_N_3_24::_setBL(bool value) { 04343 if (_bl) { 04344 _bl->write(value); 04345 } 04346 } 04347 04348 // Not used in this mode 04349 void TextLCD_SPI_N_3_24::_setData(int value) { 04350 } 04351 04352 //Mapping table to flip the bits around cause SPI3_24 expects LSB first. 04353 const uint8_t map3_24[16] = {0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0}; 04354 04355 // Write a byte using SPI3 24 bits mode 04356 void TextLCD_SPI_N_3_24::_writeByte(int value) { 04357 _cs = 0; 04358 wait_us(1); 04359 _spi->write(_controlbyte); 04360 04361 //Map and send the LSB nibble 04362 _spi->write( map3_24[value & 0x0F]); 04363 04364 //Map and send the MSB nibble 04365 _spi->write( map3_24[(value >> 4) & 0x0F]); 04366 04367 wait_us(1); 04368 _cs = 1; 04369 } 04370 #endif /* Native SPI bus */ 04371 //------- End TextLCD_SPI_N_3_24 ----------
Generated on Fri Jul 15 2022 00:00:56 by
1.7.2