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