SSD1308.h

00001 /** @file SSD1308 I2C device class header file
00002  *   Based on Solomon Systech SSD1308 datasheet, rev. 1, 10/2008
00003  *   The SSD1308 is used for example in the Seeed 128x64 OLED Display
00004  *   http://www.seeedstudio.com/depot/grove-oled-display-12864-p-781.html?cPath=163_167
00005  */
00006 // The original code by Andrew Schamp is using (and has been submitted as a part of) Jeff Rowberg's I2Cdevlib library,
00007 // which should (hopefully) always be available at https://github.com/jrowberg/i2cdevlib
00008 // Some parts also mashed up from Graphic Library for driving monochrome displays based on the PCD8544,
00009 // Copyright (c) 2011, Wim De Roeve, who in turn did partial port of code found on
00010 // http://serdisplib.sourceforge.net/ser/pcd8544.html#links and by Petras Saduikis <petras@petras.co.uk>
00011 //
00012 // Changelog:
00013 //   2011-08-25 - Initial release by Andrew Schamp <schamp@gmail.com>
00014 //   2012-06-19 - Ported to mbed and optimised (WH)
00015 //   2013-07-12 - Minor comment fix and placeholder for SSD1306 (WH)
00016 //   2015-01-01 - Switch for optimised I2C calls to test on F401 (WH)
00017 //   2017-12-18 - Fixed non-copyable issue (Thx kenjiArai)
00018 //             
00019 /* 
00020 ================================================================================
00021 I2Cdev device library code is placed under the MIT license
00022 Copyright (c) 2011 Andrew Schamp
00023 Copyright (c) 2012,2013,2017 WH (mbed port)
00024 
00025 Permission is hereby granted, free of charge, to any person obtaining a copy
00026 of this software and associated documentation files (the "Software"), to deal
00027 in the Software without restriction, including without limitation the rights
00028 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
00029 copies of the Software, and to permit persons to whom the Software is
00030 furnished to do so, subject to the following conditions:
00031 
00032 The above copyright notice and this permission notice shall be included in
00033 all copies or substantial portions of the Software.
00034 
00035 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00036 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00037 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
00038 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00039 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00040 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
00041 THE SOFTWARE.
00042 ================================================================================
00043 */
00044 
00045 #ifndef SSD1308_H
00046 #define SSD1308_H
00047 
00048 // This is the I2C address (8 bit)
00049 //  There are two possible addresses: with D/C# (pin 13) grounded, the address is 0x78,
00050 //  with D/C# tied high it is 0x7A. Assume grounded by default.
00051 #define SSD1308_SA0                0x78
00052 #define SSD1308_SA1                0x7A
00053 #define SSD1308_DEF_SA             SSD1308_SA0
00054 
00055 // Display dimensions
00056 #define ROWS                       64
00057 #define COLUMNS                    128
00058 #define PAGES                      (ROWS / 8)
00059 #define MAX_PAGE                   (PAGES - 1)
00060 #define MAX_ROW                    (ROWS - 1)
00061 #define MAX_COL                    (COLUMNS - 1)
00062 
00063 // Character dimensions 8x8 font
00064 #define CHARS                      (COLUMNS / FONT8x8_WIDTH)
00065 
00066 // Command and Datamode 
00067 #define COMMAND_MODE               0x80 // continuation bit is set!
00068 #define DATA_MODE                  0x40
00069 
00070 // Commands and Parameter defines
00071 #define SET_LOWER_COLUMN           0x00 // | with lower nibble  (Page mode only)
00072 #define SET_HIGHER_COLUMN          0x10 // | with higher nibble (Page mode only)
00073 
00074 #define HORIZONTAL_ADDRESSING_MODE 0x00
00075 #define VERTICAL_ADDRESSING_MODE   0x01
00076 #define PAGE_ADDRESSING_MODE       0x02
00077 #define SET_MEMORY_ADDRESSING_MODE 0x20 // takes one byte as given above
00078 
00079 #define SET_COLUMN_ADDRESS         0x21 // takes two bytes, start address and end address of display data RAM
00080 #define SET_PAGE_ADDRESS           0x22 // takes two bytes, start address and end address of display data RAM
00081 
00082 // Command maybe unsupported by SSD1308
00083 #define FADE_INTERVAL_8_FRAMES     0x00
00084 #define FADE_INTERVAL_16_FRAMES    0x01
00085 #define FADE_INTERVAL_24_FRAMES    0x02
00086 #define FADE_INTERVAL_32_FRAMES    0x03
00087 #define FADE_INTERVAL_64_FRAMES    0x07
00088 #define FADE_INTERVAL_128_FRAMES   0x0F
00089 #define FADE_BLINK_DISABLE         0x00
00090 #define FADE_OUT_ENABLE            0x20
00091 #define BLINK_ENABLE               0x30
00092 #define SET_FADE_BLINK             0x23 // takes one byte
00093                                         //  bit5-4 = 0, fade/blink mode
00094                                         //  bit3-0 = Time interval in frames 
00095 
00096 #define SET_DISPLAY_START_LINE     0x40 // | with a row number 0-63 to set start row. (Reset = 0)
00097 
00098 #define SET_CONTRAST               0x81 // takes one byte, 0x00 - 0xFF
00099 
00100 #define SET_SEGMENT_REMAP_0        0xA0 // column address 0 is mapped to SEG0 (Reset)
00101 #define SET_SEGMENT_REMAP_127      0xA1 // column address 127 is mapped to SEG0
00102 
00103 #define SET_DISPLAY_GDDRAM         0xA4 // restores display to contents of RAM
00104 #define SET_ENTIRE_DISPLAY_ON      0xA5 // turns all pixels on, does not affect RAM
00105 
00106 #define SET_NORMAL_DISPLAY         0xA6 // a databit of 1 indicates pixel 'ON'
00107 #define SET_INVERSE_DISPLAY        0xA7 // a databit of 1 indicates pixel 'OFF'
00108 
00109 #define SET_MULTIPLEX_RATIO        0xA8 // takes one byte, from 16xMUX to 64xMUX (MUX Ratio = byte+1; Default 64)
00110 
00111 #define EXTERNAL_IREF              0x10
00112 #define INTERNAL_IREF              0x00
00113 #define SET_IREF_SELECTION         0xAD // sets internal or external Iref
00114 
00115 #define SET_DISPLAY_POWER_OFF      0xAE
00116 #define SET_DISPLAY_POWER_ON       0xAF
00117 
00118 #define PAGE0                      0x00
00119 #define PAGE1                      0x01
00120 #define PAGE2                      0x02
00121 #define PAGE3                      0x03
00122 #define PAGE4                      0x04
00123 #define PAGE5                      0x05
00124 #define PAGE6                      0x06
00125 #define PAGE7                      0x07
00126 #define SET_PAGE_START_ADDRESS     0xB0 // | with a page number to get start address (Page mode only)
00127 
00128 #define SET_COMMON_REMAP_0         0xC0 // row address  0 is mapped to COM0 (Reset)
00129 #define SET_COMMON_REMAP_63        0xC8 // row address 63 is mapped to COM0
00130 
00131 #define SET_DISPLAY_OFFSET         0xD3 // takes one byte from 0-63 for vertical shift, Reset = 0
00132 
00133 #define SET_DISPLAY_CLOCK          0xD5 // takes one byte
00134                                         //  bit7-4 = Osc Freq DCLK (Reset = 1000b) 
00135                                         //  bit3-0 = Divide ration (Reset = oooob, Ratio = 1)   
00136 
00137 #define SET_PRECHARGE_TIME         0xD9 // takes one byte
00138                                         //  bit7-4 = Phase2, upto 15 DCLKs (Reset = 0010b) 
00139                                         //  bit3-0 = Phase1, upto 15 DCLKs (Reset = 0010b)   
00140 
00141                                        
00142 #define COMMON_BASE                0x02 // 
00143 #define COMMON_SEQUENTIAL          0x00 // Sequential common pins config
00144 #define COMMON_ALTERNATIVE         0x10 // Odd/Even common pins config (Reset)
00145 #define COMMON_LEFTRIGHT_NORMAL    0x00 // LeftRight Normal (Reset)
00146 #define COMMON_LEFTRIGHT_FLIP      0x20 // LeftRight Flip 
00147 #define SET_COMMON_CONF            0xDA // takes one byte as given above
00148 
00149 
00150 #define VCOMH_DESELECT_0_65_CODE   0x00
00151 #define VCOMH_DESELECT_0_77_CODE   0x20
00152 #define VCOMH_DESELECT_0_83_CODE   0x30
00153 #define SET_VCOMH_DESELECT_LEVEL   0xDB // takes one byte as given above
00154 
00155 #define NOP                        0xE3
00156 
00157 #define SCROLL_INTERVAL_5_FRAMES   0x00
00158 #define SCROLL_INTERVAL_64_FRAMES  0x01
00159 #define SCROLL_INTERVAL_128_FRAMES 0x02
00160 #define SCROLL_INTERVAL_256_FRAMES 0x03
00161 #define SCROLL_INTERVAL_3_FRAMES   0x04
00162 #define SCROLL_INTERVAL_4_FRAMES   0x05
00163 #define SCROLL_INTERVAL_25_FRAMES  0x06
00164 #define SCROLL_INTERVAL_2_FRAMES   0x07
00165 
00166 #define SET_RIGHT_HOR_SCROLL       0x26 // takes 6 bytes: 0x00, PageStart, Scroll_Interval, PageEnd, 0x00, 0xFF
00167 #define SET_LEFT_HOR_SCROLL        0x27 // takes 6 bytes: 0x00, PageStart, Scroll_Interval, PageEnd, 0x00, 0xFF
00168 
00169 #define SET_VERT_RIGHT_HOR_SCROLL  0x29 // takes 5 bytes: 0x00, PageStart, Scroll_Interval, PageEnd, VertOffset
00170 #define SET_VERT_LEFT_HOR_SCROLL   0x2A // takes 5 bytes: 0x00, PageStart, Scroll_Interval, PageEnd, VertOffset
00171 
00172 #define SET_DEACTIVATE_SCROLL      0x2E
00173 #define SET_ACTIVATE_SCROLL        0x2F
00174 
00175 #define SET_VERTICAL_SCROLL_AREA   0xA3 // takes 2 bytes: Rows in Top Area (Reset=0), Rows in Scroll Area (Reset=64)
00176 
00177 
00178 
00179 /** Class to control an SSD1308 based oled Display
00180  *
00181  * Example:
00182  * @code
00183  * #include "mbed.h"
00184  * #include "mbed_logo.h"
00185  * #include "SSD1308.h"
00186  
00187  * //Pin Defines for I2C Bus
00188  * #define D_SDA                  p28
00189  * #define D_SCL                  p27
00190  * I2C i2c(D_SDA, D_SCL);
00191  *
00192  * // Host PC Communication channels
00193  * Serial pc(USBTX, USBRX); // tx, rx
00194  *
00195  * // Instantiate OLED
00196  * SSD1308 oled = SSD1308(&i2c, SSD1308_SA0);
00197  * 
00198  * int main() {
00199  *   pc.printf("OLED test start\r");  
00200  *   oled.writeString(0, 0, "Hello World !");
00201  *   //  oled.printf("Hello World !");
00202  * 
00203  *   oled.fillDisplay(0xAA);
00204  *   oled.setDisplayOff();
00205  *   wait(1);   
00206  *   oled.setDisplayOn();
00207  * 
00208  *   oled.clearDisplay();
00209  *   oled.setDisplayInverse();
00210  *   wait(0.5);
00211  *   oled.setDisplayNormal();                                         
00212  *
00213  *   oled.writeBitmap((uint8_t*) mbed_logo);
00214  *
00215  *   pc.printf("OLED test done\r\n");  
00216  * }
00217  *
00218  * @endcode
00219  */
00220 class SSD1308 : public Stream {
00221   public:
00222     
00223 /**
00224   *@brief Constructor
00225   *@param I2C &i2c reference to i2c,
00226   *@param uint8_t deviceAddress slaveaddress (8bit to use for the controller (0x78 by default, assumes D/C# (pin 13) grounded)
00227  */    
00228     SSD1308(I2C *i2c, uint8_t address = SSD1308_DEF_SA);
00229 
00230 // High Level methods
00231 
00232 /** @brief High level Init, most settings remain at Power-On reset value
00233  */
00234     void initialize();
00235 
00236 /** @brief clear the display
00237 */
00238     void clearDisplay();
00239 
00240 
00241 /** @brief fill the display
00242  *  @param uint8_t pattern fillpattern vertical patch or 8 bits 
00243  *  @param uint8_t start_page begin page   (0..MAX_PAGE)
00244  *  @param uint8_t end_page   end page     (start_page..MAX_PAGE)                     
00245  *  @param uint8_t start_col  begin column (0..MAX_COL)
00246  *  @param uint8_t end_col    end column   (start_col..MAX_COL)
00247 */ 
00248     void fillDisplay(uint8_t pattern = 0x00,
00249                      uint8_t start_page=0, uint8_t end_page=MAX_PAGE,
00250                      uint8_t start_col=0, uint8_t end_col=MAX_COL);
00251 
00252 
00253 /** @brief write a bitmap to the display
00254  *  @param uint8_t* data pointer to bitmap
00255  *  @param uint8_t start_page begin page   (0..MAX_PAGE)
00256  *  @param uint8_t end_page   end page     (start_page..MAX_PAGE)                     
00257  *  @param uint8_t start_col  begin column (0..MAX_COL)
00258  *  @param uint8_t end_col    end column   (start_col..MAX_COL)
00259 */  
00260     void writeBitmap(uint8_t* data,
00261                      uint8_t start_page=0, uint8_t end_page=MAX_PAGE,
00262                      uint8_t start_col=0, uint8_t end_col=MAX_COL);
00263     
00264 /** @brief write a level meter to the display, Width is (PRG_MAX_SCALE + 2) pixels
00265  *  @param uint8_t page begin page   (0..MAX_PAGE)
00266  *  @param uint8_t col  begin column (0..MAX_COL)
00267  *  @param int percentage value      (0..100)
00268 */
00269     void writeProgressBar(uint8_t page, uint8_t col, int percentage);
00270 
00271 
00272 /** @brief write a level meter to the display, Width is (PRG_MAX_SCALE + 2) pixels
00273  *  @param uint8_t page begin page   (0..MAX_PAGE)
00274  *  @param uint8_t col  begin column (0..MAX_COL)
00275  *  @param int percentage value      (0..100)
00276 */
00277     void writeLevelBar(uint8_t page, uint8_t col, int percentage);
00278 
00279     //void setXY(uint8_t, uint8_t y);
00280     
00281     // Select inverted or normal text    
00282     void setInverted(bool inverted) { _inverted = inverted; };    
00283         
00284 /** @brief Write single character to the display using the 8x8 fontable
00285  *  @brief Start at current cursor location
00286  *  @param char chr character to write
00287 */ 
00288     void writeChar(char chr);  
00289     
00290 /** @brief Write large character (16x24 font)
00291  *  @param uint8_t row  row number    (0...MAX_ROW)
00292  *  @param uint8_t col  column number (0...MAX_COL)
00293  *  @param char chr     Used for displaying numbers 0 - 9 and '+', '-', '.'
00294  */   
00295     void writeBigChar(uint8_t row, uint8_t col, char chr);      
00296     
00297 /** @brief Write a string to the display using the 8x8 font
00298  *  @brief Start at selected cursor location, text will wrap around until it is done
00299  *  @param uint8_t row  row number    (0...ROWS/FONT_HEIGHT)
00300  *  @param uint8_t col  column number (0...COLUMNS/FONT_WIDTH)
00301  *  @param const char * text pointer to text
00302  */   
00303     void writeString(uint8_t row, uint8_t col, const char* txt);
00304     
00305     // Stream implementation - provides printf() interface
00306     // You would otherwise be forced to use writeChar() or writeString()
00307     virtual int _putc(int value) { writeChar(value); return 1; };
00308     virtual int _getc() { return -1; };
00309    
00310 // Future extension with graphics features
00311     // this must be defined by the subclass
00312 //    virtual void drawPixel(int16_t x, int16_t y, uint16_t color) = 0;
00313     
00314 // Medium Level methods
00315 
00316 /** @brief Set Horizontal Addressing Mode (cursor incr left-to-right, top-to-bottom)
00317  * 
00318  */
00319     void setHorizontalAddressingMode();
00320     
00321 /** @brief Set Vertical Addressing Mode  (cursor incr top-to-bottom, left-to-right)
00322  * 
00323  */
00324     void setVerticalAddressingMode();
00325     
00326 /** @brief Set Page Addressing Mode  (cursor incr left-to-right)
00327  * 
00328  */
00329     void setPageAddressingMode();
00330         
00331 /** @brief Set Addressing Mode
00332  *  @param uint8_t mode 
00333  */
00334     void setMemoryAddressingMode(uint8_t mode);
00335 
00336 
00337 /** 
00338  *  @brief Set Column Start (for Page Addressing Mode only)
00339  *  @param uint8_t column column start (valid range 0..MAX_COLS)
00340  */    
00341     void setColumnStartForPageAddressingMode(uint8_t column);
00342     
00343 /** 
00344  *  @brief Set Page Start (for Page Addressing Mode only)
00345  *  @param uint8_t page page start (valid range PAGE0 - PAGE7)
00346  */    
00347     void setPageStartForPageAddressingMode(uint8_t page);
00348    
00349 
00350 
00351 /** @param uint8_t start startcolumn (valid range 0..MAX_COL)
00352  *  @param uint8_t end   endcolumn   (valid range start..MAX_COL)
00353  */   
00354     void setColumnAddress (uint8_t start, uint8_t end);
00355     
00356 /** @param uint8_t start startpage (valid range 0..MAX_PAGE)
00357  *  @param uint8_t end   endpage   (valid range start..MAX_PAGE)
00358  */  
00359     void setPageAddress (uint8_t start, uint8_t end);
00360     
00361 
00362 /** 
00363  *  @brief Set Display StartLine, takes one byte, 0x00-0x3F
00364  *  @param uint8_t line startline (valid range 0..MAX_ROWS)
00365  */  
00366     void setDisplayStartLine(uint8_t line);
00367     
00368 /** @brief Set Contrast
00369  *  @param uint8_t contrast (valid range 0x00 (lowest) - 0xFF (highest))
00370 */    
00371     void setContrastControl(uint8_t contrast);
00372 
00373 
00374 /** @brief Shows All Pixels On
00375  */
00376     void setEntireDisplayOn();
00377     
00378 /** @brief Shows Pixels as RAM content
00379  */
00380     void setEntireDisplayRAM();
00381     
00382 /** @brief Shows Pixels On or as RAM content
00383  *  @param bool on (true is All on, false is RAM content)
00384  */
00385     void setEntireDisplay(bool on);
00386     
00387  
00388     // @brief Set Display line MPX Ratio, takes one byte, 0x00-0x3F
00389     // @param uint8_t lines (valid range 0..MAX_ROWS)
00390     void setMultiplexRatio(uint8_t lines);
00391 
00392 
00393 /** @brief Sets Internal Iref
00394  */
00395     void setInternalIref();
00396 
00397 /** @brief Sets External Iref (default)
00398  */   
00399     void setExternalIref();
00400 
00401 
00402 /** @brief Enable Display
00403 */    
00404     void setDisplayOn();
00405 
00406 /** @brief Disable Display
00407 */     
00408     void setDisplayOff();
00409 
00410 /** @brief Enable or Disable Display
00411  *  @param bool on
00412  */    
00413     void setDisplayPower(bool on);
00414 
00415 /** @brief Show White pixels on Black background
00416  */ 
00417     void setDisplayNormal();
00418 
00419 /** @brief Show Black pixels on White background
00420  */   
00421     void setDisplayInverse();
00422 
00423 /** @brief Blink display by fading in and out over a set number of frames
00424  *  @param bool on
00425  */
00426     void setDisplayBlink(bool on);  
00427     
00428 /** @brief Fade out display in set number of frames
00429  *  @param bool on
00430  */        
00431     void setDisplayFade(bool on);    
00432     
00433 /** @brief Display Flip (Left/Right, Up/Down)
00434  *  @param bool left flip Left/Right
00435  *  @param bool down flip Up/Down
00436  */  
00437     void setDisplayFlip(bool left, bool down);
00438 
00439     // Set vertical shift by COM from 0 - 63 (0x00 - 0x3F) (Reset = 0x00)
00440     void setDisplayOffset(uint8_t offset);
00441     
00442     // Oscillator freq 0x00-0x0F (reset 0x08)
00443     // Divide ratio 0x00-0x0F, value +1 (reset 0x00)
00444     void setDisplayClock(uint8_t divideRatio, uint8_t oscFreq);
00445     
00446     // Phase1 0x01-0x0F period of up to 15 DCLK clocks (reset 0x02, 0 is invalid)
00447     // Phase2 0x01-0x0F period of up to 15 DCLK clocks (reset 0x02, 0 is invalid)
00448     void setPrechargePeriod(uint8_t phase1, uint8_t phase2);
00449     
00450     // See defines above for levels
00451     void setVcomhDeselectLevel(uint8_t level);
00452 
00453 
00454     // Command for no-operation
00455     void nop();
00456     
00457 
00458 /** @brief Horizontal scroll by one column per interval
00459  *  @param bool left select Left/Right scroll
00460  *  @param uint8_t start_page begin page   (0..MAX_PAGE)
00461  *  @param uint8_t end_page   end page     (start_page..MAX_PAGE)                     
00462  *  @param uint8_t interval   scroll interval in frames (see codes above)                      
00463  */  
00464     void setContinuousHorizontalScroll(bool left, uint8_t start_page, uint8_t end_page, uint8_t interval);
00465 
00466 
00467 /** @brief Horizontal and Vertical scroll by one column per interval
00468  *  @param bool left select Left/Right scroll
00469  *  @param uint8_t start_page begin page   (0..MAX_PAGE)
00470  *  @param uint8_t end_page   end page     (start_page..MAX_PAGE)                     
00471  *  @param uint8_t offset     vert offset  (0x01..0x63)                       
00472  *  @param uint8_t interval   scroll interval in frames (see codes above)                       
00473  */  
00474     void setContinuousVerticalAndHorizontalScroll(bool left, uint8_t start_page, uint8_t end_page, 
00475                                                   uint8_t offset, uint8_t interval);
00476     
00477 /** @brief Activate or Deactivate Horizontal and Vertical scroll
00478  *  @brief Note: after deactivating scrolling, the RAM data needs to be rewritten
00479  *  @param bool on activate scroll 
00480  */  
00481     void setDisplayScroll(bool on);
00482     
00483 
00484 /** @brief Set Vertical scroll area
00485  *  @param uint8_t topRowsFixed      fixed rows   (0..MAX_ROW)                     
00486  *  @param uint8_t scrollRowsoffset  scroll rows  (topRowsFixed..MAX_ROW)                       
00487  */  
00488     void setVerticalScrollArea(uint8_t topRowsFixed, uint8_t scrollRows); 
00489   
00490   private:
00491 
00492 // Low Level methods
00493 
00494 /** @brief Write command that has no parameters
00495 */    
00496     void _sendCommand(uint8_t command); 
00497 
00498 /** @brief Write command that has one parameter
00499 */    
00500     void _sendCommand(uint8_t command, uint8_t param1);
00501 
00502 /** @brief Write command that has two parameters
00503 */ 
00504     void _sendCommand(uint8_t command, uint8_t param1, uint8_t param2);              
00505 //    void sendCommands(uint8_t len, uint8_t* buf);
00506 
00507 /** @brief Write command that has five parameters
00508 */ 
00509     void _sendCommand(uint8_t command, uint8_t param1, uint8_t param2,
00510                                        uint8_t param3, uint8_t param4,
00511                                        uint8_t param5);
00512 
00513 /** @brief Write command that has six parameters
00514 */ 
00515     void _sendCommand(uint8_t command, uint8_t param1, uint8_t param2,
00516                                        uint8_t param3, uint8_t param4,
00517                                        uint8_t param5, uint8_t param6);
00518     
00519 /** @brief Write databyte to display
00520  *  @brief Start at current cursor location
00521  *  @param uint8_t data databyte to write
00522 */  
00523     void _sendData(uint8_t data);
00524 
00525 /** @brief Write len bytes from buffer data to display, 
00526  *  @brief Start at current cursor location
00527  *  @param uint8_t len number of bytes to write 
00528  *  @param uint8_t* data pointer to data
00529 */   
00530     void _sendData(uint8_t len, uint8_t* data);
00531 
00532 /** @brief Low level Init
00533  *  @brief Init the configuration registers in accordance with the datasheet
00534  */   
00535     void _init();
00536 
00537     I2C *_i2c;             // I2C bus reference
00538     uint8_t _readOpcode;   // contains the I2C address of the device
00539     uint8_t _writeOpcode;  // contains the I2C address of the device
00540     
00541     bool _inverted;        // inverted or normal text   
00542 };
00543 
00544 #endif