Arduino UNOとOLED、OLED096UNO-Aで12345678を表示(16x24)



x 新規タブを作ってファイルを入れてください
x 長いです。

目的
OLEDのテスト


![o_con613.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/840352/9244b592-4ae1-562e-0cc4-5530e691c4ab.jpeg)


![o_con614.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/840352/3d9679c6-ca0e-3f22-7ff1-59be2fe509fa.jpeg)


改造元


https://os.mbed.com/users/wim/code/SSD1308_128x64_I2C/



oled_16x24_UNO_1


```c++


#include <Arduino.h>
//#include <Wire.h>

#include "SSD1308.h"



void setup() {

   //シリアルの初期化
  Serial.begin(9600);

  Serial.println("\r\n<START>\r\n");

SSD1308 oled = SSD1308(  SSD1308_SA0);


    //char n1_8[] = "12345678";
    char n1_8[] = "87654321";
    //char n1_8[] =   "88888888";

    int ii=0;
    for(int nn=0; nn<8; nn++) {
        //                y   x
        oled.writeBigChar(0, ii*16,n1_8[nn]);
        ii = ii + 1;
    } //for

  Serial.println("\r\n<END>\r\n");


}

void loop() {


}




```


font_16x24.h


```c++


#ifndef _FONT_16x24_H_
#define _FONT_16x24_H_

//----- DEFINES -----
#define FONT16x24_START                   0x20
#define FONT16x24_END                     0x44
#define FONT16x24_WIDTH                   11
#define FONT16x24_HEIGHT                  24
#define FONT16x24_BYTES                   3

//Used for displaying numbers 0 - 9 and '+', '-', '.'

const uint8_t font_16x24[36][3][11]  = 
{

  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x20
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x21
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x22
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x23
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x24
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x25
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x26
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x27
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x28
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x29
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x2A

  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,64,64,64,254,254,64,64 , 0,0,0,0,0,0,0,15,15,0,0  ,// '+'// 0x2B
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0          , 0,0,0,0,0,0,0,0,0,0,0    ,//    // 0x2C
 
  0,0,0,0,0,0,0,0,0,0,0  ,  0,64,64,64,64,64,64,0,0,0,0    , 0,0,0,0,0,0,0,0,0,0,0    ,// '-'// 0x2D
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,         0,0,0,60,60,60,0,0,0,0,0 ,// '.'// 0x2E
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,         0,0,0,0,0,0,0,0,0,0,0    ,//       0x2F
  
  0,128,192,224,224,96,224,224,192,128,0     ,  112,255,255,1,0,0,0,0,255,255,254  ,  0,15,31,60,56,48,56,56,31,15,3           , //'0' 0x30
  0,0,0,0,128,224,224,0,0,0,0                ,  0,0,3,3,3,255,255,0,0,0,0          ,  0,0,56,56,56,63,63,56,56,56,0            , //'1' 0x31
  0,192,192,224,96,96,224,224,192,128,0      ,  0,1,0,0,128,192,224,249,63,31,0    ,  0,60,62,63,63,59,57,56,56,56,56          , //'2' 0x32
  0,192,224,224,96,96,224,224,192,192,0      ,  0,1,0,0,48,48,56,125,239,207,0     ,  0,28,56,56,48,48,56,60,31,15,1           , //'3' 0x33
  0,0,0,0,0,128,192,224,224,0,0              ,  224,240,248,222,207,199,193,255,255,192,192 ,  0,0,0,0,0,0,0,63,63,0,0         , //'4' 0x34
  0,224,224,224,224,224,224,224,224,224,224  ,  0,63,63,63,56,56,48,112,240,224,0           ,  0,28,56,56,48,48,56,60,31,15,1  , //'5' 0x35
  0,0,128,192,192,224,96,96,224,224,0        ,  224,254,255,55,57,24,24,56,240,240,192      ,  0,15,31,28,56,48,48,56,31,15,7  , //'6' 0x36
  0,224,224,224,224,224,224,224,224,224,224  ,  0,0,0,0,128,224,248,126,31,7,1              ,  0,0,56,62,31,7,1,0,0,0,0        , //'7' 0x37
  0,128,192,224,224,96,96,224,192,192,0      ,  0,207,255,127,56,48,112,112,255,239,199     ,  3,15,31,60,56,48,48,56,31,31,15 , //'8' 0x38
  0,128,192,224,224,96,224,224,192,128,0     ,  12,63,127,241,224,192,192,225,255,255,254   ,  0,0,56,48,48,56,56,30,15,7,0    , //'9' 0x39
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x3A
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x3B
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x3C
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x3D
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x3E
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x3F
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x40
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x41
  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,  0,0,0,0,0,0,0,0,0,0,0  ,// 0x42
  0,128,192,224,224,96,224,224,192,128,0    ,  112,112,112,1,0,0,0,0,112,112,112            ,  0,0,0,0,0,0,0,0,0,0,0    //'C' 0x43
};

#endif



```

SSD1308


```c++


#include <Arduino.h>
#include <Wire.h>

//#include "mbed.h"
#include "SSD1308.h"

//#include "font_8x8.h"
#include "font_16x24.h"

//最初に呼び出される
SSD1308::SSD1308( uint8_t deviceAddress)
{
    _writeOpcode = deviceAddress & 0xFE; // low order bit = 0 for write
    _readOpcode  = deviceAddress | 0x01; // low order bit = 1 for read

    initialize();
}//SSD1308



void write_s(uint8_t *str1, uint8_t len1) {

  Wire.beginTransmission(   0x3c  );

  for (int ii = 0; ii < len1; ii++) {

    //一文字出力
    //eeprom_write(*str1 ++);
    Wire.write(*str1 ++);
    
  }//for

  Wire.endTransmission();
  //delay(5);

}//eeprom_write_s


//イニシャライズ
void SSD1308::initialize()
{
    //I2Cの初期化
    Wire.begin();

    //リセット対策
    delay(100);
    //_i2c->write(_writeOpcode, "\200\215\200\024\200\257", 6);
    write_s("\200\215\200\024\200\257", 6);
    delay(100);
    //_i2c->write(_writeOpcode, "\200\215\200\024\200\257", 6);
    write_s("\200\215\200\024\200\257", 6);
    delay(100);
    //_i2c->write(_writeOpcode, "\200\215\200\024\200\257", 6);
    write_s("\200\215\200\024\200\257", 6);
    delay(100);

    setHorizontalAddressingMode(); //メモリーアクセスモード

    clearDisplay();

    setDisplayOn();

    //charge pump  add=>ca45040
    //_i2c->write(_writeOpcode, "\200\215\200\024", 4); //0x80,0x8d,0x80,0x14
    write_s("\200\215\200\024", 4);
    //set access
    //setDisplayFlip(false, false);

}//initialize

//クリアディスプレー
void SSD1308::clearDisplay()
{
    setPageAddress(0, MAX_PAGE);  // all pages
    setColumnAddress(0, MAX_COL); // all columns

    //128*64/8=1024
    char databytes[2] = {DATA_MODE,0x00};
    for (int icount = 0; icount < 1024; icount++) {
        //_i2c->write(_writeOpcode, databytes, 2);
        write_s(databytes, 2);
    }//for
}//clearDisplay

//ライトビットマップ
void SSD1308::writeBitmap(uint8_t* data,
                          uint8_t start_page, uint8_t end_page,
                          uint8_t start_col, uint8_t end_col)
{
    int count = (end_page - start_page + 1) * (end_col - start_col + 1);

    setPageAddress(start_page, end_page);  // set page window
    setColumnAddress(start_col, end_col);  // set column window

    char databytes[2] = {DATA_MODE,0x00};
    for (int i=0; i<count; i++) {
        databytes[1] = data[i];
        //_i2c->write(_writeOpcode, databytes, 2);
        write_s(databytes, 2);
    }//for
}//writeBitmap

//ライトビッグキャラ
void SSD1308::writeBigChar(uint8_t row, uint8_t col, char chr)
{
    writeBitmap((uint8_t*) font_16x24[int(chr) - FONT16x24_START],
                row, (row + FONT16x24_BYTES - 1),
                col, (col + FONT16x24_WIDTH - 1));
}//writeBigChar

//セットホリゾンタルアドレシングモード(水平)
void SSD1308::setHorizontalAddressingMode()
{
    setMemoryAddressingMode(HORIZONTAL_ADDRESSING_MODE);
}//setHorizontalAddressingMode

//セットメモリーアドレシングモード
void SSD1308::setMemoryAddressingMode(uint8_t mode)
{
    char databytes[4] = {COMMAND_MODE,SET_MEMORY_ADDRESSING_MODE,COMMAND_MODE,mode};
    //_i2c->write(_writeOpcode, databytes, 4);
    write_s(databytes, 4);
}//setMemoryAddressingMode

//セットページアドレス
void SSD1308::setPageAddress(uint8_t start, uint8_t end)
{
    char databytes[6] = {COMMAND_MODE,SET_PAGE_ADDRESS,COMMAND_MODE,start,COMMAND_MODE,end};
    //_i2c->write(_writeOpcode, databytes, 6);
    write_s(databytes, 6);
}//setPageAddress

//セットカラムアクセス
void SSD1308::setColumnAddress(uint8_t start, uint8_t end)
{
    char databytes[6] = {COMMAND_MODE,SET_COLUMN_ADDRESS,COMMAND_MODE,start,COMMAND_MODE,end};
    //_i2c->write(_writeOpcode, databytes, 6);
    write_s(databytes, 6);
}//setColumnAddress

//セットディスプレーオン
void SSD1308::setDisplayOn()
{
    char databytes[2] = {COMMAND_MODE,SET_DISPLAY_POWER_ON};
    //_i2c->write(_writeOpcode,databytes, 2);
    write_s(databytes, 2);
}//setDisplayOn

/*
//セットディスプレーオフ
void SSD1308::setDisplayOff()
{
    _sendCommand(SET_DISPLAY_POWER_OFF);
}//setDisplayOff
*/

/*
//セットディスプレー Flip
void SSD1308::setDisplayFlip(bool left, bool down)
{
    if (left) {
        // column address   0 is mapped to SEG0 (Reset)
        _sendCommand(SET_SEGMENT_REMAP_0);
    } else {
        // column address 127 is mapped to SEG0
        _sendCommand(SET_SEGMENT_REMAP_127);
    }

    if (down) {
        // Reset mode
        _sendCommand(SET_COMMON_REMAP_0);
    } else {
        // Flip Up/Down (Need to rewrite display before H effect shows)
        _sendCommand(SET_COMMON_REMAP_63);
    }

}//setDisplayFlip
*/



```

SSD1308.h


```c++

/** @file SSD1308 I2C device class header file
 *   Based on Solomon Systech SSD1308 datasheet, rev. 1, 10/2008
 *   The SSD1308 is used for example in the Seeed 128x64 OLED Display
 *   http://www.seeedstudio.com/depot/grove-oled-display-12864-p-781.html?cPath=163_167
 */
// The original code by Andrew Schamp is using (and has been submitted as a part of) Jeff Rowberg's I2Cdevlib library,
// which should (hopefully) always be available at https://github.com/jrowberg/i2cdevlib
// Some parts also mashed up from Graphic Library for driving monochrome displays based on the PCD8544,
// Copyright (c) 2011, Wim De Roeve, who in turn did partial port of code found on
// http://serdisplib.sourceforge.net/ser/pcd8544.html#links and by Petras Saduikis <petras@petras.co.uk>
//
// Changelog:
//   2011-08-25 - Initial release by Andrew Schamp <schamp@gmail.com>
//   2012-06-19 - Ported to mbed and optimised (WH)
//   2013-07-12 - Minor comment fix and placeholder for SSD1306 (WH)
//   2015-01-01 - Switch for optimised I2C calls to test on F401 (WH)
//   2017-12-18 - Fixed non-copyable issue (Thx kenjiArai)
//             
/* 
================================================================================
I2Cdev device library code is placed under the MIT license
Copyright (c) 2011 Andrew Schamp
Copyright (c) 2012,2013,2017 WH (mbed port)

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
================================================================================
*/

#ifndef SSD1308_H
#define SSD1308_H

// This is the I2C address (8 bit)
//  There are two possible addresses: with D/C# (pin 13) grounded, the address is 0x78,
//  with D/C# tied high it is 0x7A. Assume grounded by default.
#define SSD1308_SA0                0x78
#define SSD1308_SA1                0x7A
#define SSD1308_DEF_SA             SSD1308_SA0

// Display dimensions
#define ROWS                       64
#define COLUMNS                    128
#define PAGES                      (ROWS / 8)
#define MAX_PAGE                   (PAGES - 1)
#define MAX_ROW                    (ROWS - 1)
#define MAX_COL                    (COLUMNS - 1)

// Character dimensions 8x8 font
#define CHARS                      (COLUMNS / FONT8x8_WIDTH)

// Command and Datamode 
#define COMMAND_MODE               0x80 // continuation bit is set!
#define DATA_MODE                  0x40

// Commands and Parameter defines
#define SET_LOWER_COLUMN           0x00 // | with lower nibble  (Page mode only)
#define SET_HIGHER_COLUMN          0x10 // | with higher nibble (Page mode only)

#define HORIZONTAL_ADDRESSING_MODE 0x00
#define VERTICAL_ADDRESSING_MODE   0x01
#define PAGE_ADDRESSING_MODE       0x02
#define SET_MEMORY_ADDRESSING_MODE 0x20 // takes one byte as given above

#define SET_COLUMN_ADDRESS         0x21 // takes two bytes, start address and end address of display data RAM
#define SET_PAGE_ADDRESS           0x22 // takes two bytes, start address and end address of display data RAM

// Command maybe unsupported by SSD1308
#define FADE_INTERVAL_8_FRAMES     0x00
#define FADE_INTERVAL_16_FRAMES    0x01
#define FADE_INTERVAL_24_FRAMES    0x02
#define FADE_INTERVAL_32_FRAMES    0x03
#define FADE_INTERVAL_64_FRAMES    0x07
#define FADE_INTERVAL_128_FRAMES   0x0F
#define FADE_BLINK_DISABLE         0x00
#define FADE_OUT_ENABLE            0x20
#define BLINK_ENABLE               0x30
#define SET_FADE_BLINK             0x23 // takes one byte
                                        //  bit5-4 = 0, fade/blink mode
                                        //  bit3-0 = Time interval in frames 

#define SET_DISPLAY_START_LINE     0x40 // | with a row number 0-63 to set start row. (Reset = 0)

#define SET_CONTRAST               0x81 // takes one byte, 0x00 - 0xFF

#define SET_SEGMENT_REMAP_0        0xA0 // column address 0 is mapped to SEG0 (Reset)
#define SET_SEGMENT_REMAP_127      0xA1 // column address 127 is mapped to SEG0

#define SET_DISPLAY_GDDRAM         0xA4 // restores display to contents of RAM
#define SET_ENTIRE_DISPLAY_ON      0xA5 // turns all pixels on, does not affect RAM

#define SET_NORMAL_DISPLAY         0xA6 // a databit of 1 indicates pixel 'ON'
#define SET_INVERSE_DISPLAY        0xA7 // a databit of 1 indicates pixel 'OFF'

#define SET_MULTIPLEX_RATIO        0xA8 // takes one byte, from 16xMUX to 64xMUX (MUX Ratio = byte+1; Default 64)

#define EXTERNAL_IREF              0x10
#define INTERNAL_IREF              0x00
#define SET_IREF_SELECTION         0xAD // sets internal or external Iref

#define SET_DISPLAY_POWER_OFF      0xAE
#define SET_DISPLAY_POWER_ON       0xAF

#define PAGE0                      0x00
#define PAGE1                      0x01
#define PAGE2                      0x02
#define PAGE3                      0x03
#define PAGE4                      0x04
#define PAGE5                      0x05
#define PAGE6                      0x06
#define PAGE7                      0x07
#define SET_PAGE_START_ADDRESS     0xB0 // | with a page number to get start address (Page mode only)

#define SET_COMMON_REMAP_0         0xC0 // row address  0 is mapped to COM0 (Reset)
#define SET_COMMON_REMAP_63        0xC8 // row address 63 is mapped to COM0

#define SET_DISPLAY_OFFSET         0xD3 // takes one byte from 0-63 for vertical shift, Reset = 0

#define SET_DISPLAY_CLOCK          0xD5 // takes one byte
                                        //  bit7-4 = Osc Freq DCLK (Reset = 1000b) 
                                        //  bit3-0 = Divide ration (Reset = oooob, Ratio = 1)   

#define SET_PRECHARGE_TIME         0xD9 // takes one byte
                                        //  bit7-4 = Phase2, upto 15 DCLKs (Reset = 0010b) 
                                        //  bit3-0 = Phase1, upto 15 DCLKs (Reset = 0010b)   

                                       
#define COMMON_BASE                0x02 // 
#define COMMON_SEQUENTIAL          0x00 // Sequential common pins config
#define COMMON_ALTERNATIVE         0x10 // Odd/Even common pins config (Reset)
#define COMMON_LEFTRIGHT_NORMAL    0x00 // LeftRight Normal (Reset)
#define COMMON_LEFTRIGHT_FLIP      0x20 // LeftRight Flip 
#define SET_COMMON_CONF            0xDA // takes one byte as given above


#define VCOMH_DESELECT_0_65_CODE   0x00
#define VCOMH_DESELECT_0_77_CODE   0x20
#define VCOMH_DESELECT_0_83_CODE   0x30
#define SET_VCOMH_DESELECT_LEVEL   0xDB // takes one byte as given above

#define NOP                        0xE3

#define SCROLL_INTERVAL_5_FRAMES   0x00
#define SCROLL_INTERVAL_64_FRAMES  0x01
#define SCROLL_INTERVAL_128_FRAMES 0x02
#define SCROLL_INTERVAL_256_FRAMES 0x03
#define SCROLL_INTERVAL_3_FRAMES   0x04
#define SCROLL_INTERVAL_4_FRAMES   0x05
#define SCROLL_INTERVAL_25_FRAMES  0x06
#define SCROLL_INTERVAL_2_FRAMES   0x07

#define SET_RIGHT_HOR_SCROLL       0x26 // takes 6 bytes: 0x00, PageStart, Scroll_Interval, PageEnd, 0x00, 0xFF
#define SET_LEFT_HOR_SCROLL        0x27 // takes 6 bytes: 0x00, PageStart, Scroll_Interval, PageEnd, 0x00, 0xFF

#define SET_VERT_RIGHT_HOR_SCROLL  0x29 // takes 5 bytes: 0x00, PageStart, Scroll_Interval, PageEnd, VertOffset
#define SET_VERT_LEFT_HOR_SCROLL   0x2A // takes 5 bytes: 0x00, PageStart, Scroll_Interval, PageEnd, VertOffset

#define SET_DEACTIVATE_SCROLL      0x2E
#define SET_ACTIVATE_SCROLL        0x2F

#define SET_VERTICAL_SCROLL_AREA   0xA3 // takes 2 bytes: Rows in Top Area (Reset=0), Rows in Scroll Area (Reset=64)



/** Class to control an SSD1308 based oled Display
 *
 * Example:
 * @code
 * #include "mbed.h"
 * #include "mbed_logo.h"
 * #include "SSD1308.h"
 
 * //Pin Defines for I2C Bus
 * #define D_SDA                  p28
 * #define D_SCL                  p27
 * I2C i2c(D_SDA, D_SCL);
 *
 * // Host PC Communication channels
 * Serial pc(USBTX, USBRX); // tx, rx
 *
 * // Instantiate OLED
 * SSD1308 oled = SSD1308(&i2c, SSD1308_SA0);
 * 
 * int main() {
 *   pc.printf("OLED test start\r");  
 *   oled.writeString(0, 0, "Hello World !");
 *   //  oled.printf("Hello World !");
 * 
 *   oled.fillDisplay(0xAA);
 *   oled.setDisplayOff();
 *   wait(1);   
 *   oled.setDisplayOn();
 * 
 *   oled.clearDisplay();
 *   oled.setDisplayInverse();
 *   wait(0.5);
 *   oled.setDisplayNormal();                                         
 *
 *   oled.writeBitmap((uint8_t*) mbed_logo);
 *
 *   pc.printf("OLED test done\r\n");  
 * }
 *
 * @endcode
 */
//class SSD1308 : public Stream {
struct SSD1308 {
 
 
//  public:
    
/**
  *@brief Constructor
  *@param I2C &i2c reference to i2c,
  *@param uint8_t deviceAddress slaveaddress (8bit to use for the controller (0x78 by default, assumes D/C# (pin 13) grounded)
 */    
    SSD1308( uint8_t address = SSD1308_DEF_SA);

// High Level methods

/** @brief High level Init, most settings remain at Power-On reset value
 */
    void initialize();

/** @brief clear the display
*/
    void clearDisplay();


/** @brief fill the display
 *  @param uint8_t pattern fillpattern vertical patch or 8 bits 
 *  @param uint8_t start_page begin page   (0..MAX_PAGE)
 *  @param uint8_t end_page   end page     (start_page..MAX_PAGE)                     
 *  @param uint8_t start_col  begin column (0..MAX_COL)
 *  @param uint8_t end_col    end column   (start_col..MAX_COL)
*/ 
    void fillDisplay(uint8_t pattern = 0x00,
                     uint8_t start_page=0, uint8_t end_page=MAX_PAGE,
                     uint8_t start_col=0, uint8_t end_col=MAX_COL);


/** @brief write a bitmap to the display
 *  @param uint8_t* data pointer to bitmap
 *  @param uint8_t start_page begin page   (0..MAX_PAGE)
 *  @param uint8_t end_page   end page     (start_page..MAX_PAGE)                     
 *  @param uint8_t start_col  begin column (0..MAX_COL)
 *  @param uint8_t end_col    end column   (start_col..MAX_COL)
*/  
    void writeBitmap(uint8_t* data,
                     uint8_t start_page=0, uint8_t end_page=MAX_PAGE,
                     uint8_t start_col=0, uint8_t end_col=MAX_COL);
    
    // Select inverted or normal text    
    //void setInverted(bool inverted) { _inverted = inverted; };    

 
/** @brief Write large character (16x24 font)
 *  @param uint8_t row  row number    (0...MAX_ROW)
 *  @param uint8_t col  column number (0...MAX_COL)
 *  @param char chr     Used for displaying numbers 0 - 9 and '+', '-', '.'
 */   
    void writeBigChar(uint8_t row, uint8_t col, char chr);      
  

  
    
    
// Medium Level methods

/** @brief Set Horizontal Addressing Mode (cursor incr left-to-right, top-to-bottom)
 * 
 */
    void setHorizontalAddressingMode();
 
/** @brief Set Page Addressing Mode  (cursor incr left-to-right)
 * 
 */
    void setPageAddressingMode();
        
/** @brief Set Addressing Mode
 *  @param uint8_t mode 
 */
    void setMemoryAddressingMode(uint8_t mode);


/** @param uint8_t start startcolumn (valid range 0..MAX_COL)
 *  @param uint8_t end   endcolumn   (valid range start..MAX_COL)
 */   
    void setColumnAddress(uint8_t start, uint8_t end);
    
/** @param uint8_t start startpage (valid range 0..MAX_PAGE)
 *  @param uint8_t end   endpage   (valid range start..MAX_PAGE)
 */  
    void setPageAddress(uint8_t start, uint8_t end);
    

/** @brief Enable Display
*/    
    void setDisplayOn();

/** @brief Disable Display
*/     
    void setDisplayOff();
    
/** @brief Display Flip (Left/Right, Up/Down)
 *  @param bool left flip Left/Right
 *  @param bool down flip Up/Down
 */  
    void setDisplayFlip(bool left, bool down);

 
 
 
//  private:


// Low Level methods

/** @brief Write command that has no parameters
*/    
    void _sendCommand(uint8_t command); 

/** @brief Write command that has one parameter
*/    
    void _sendCommand(uint8_t command, uint8_t param1);

/** @brief Write command that has two parameters
*/ 
    void _sendCommand(uint8_t command, uint8_t param1, uint8_t param2);              
//    void sendCommands(uint8_t len, uint8_t* buf);

/** @brief Write command that has five parameters
*/ 
    void _sendCommand(uint8_t command, uint8_t param1, uint8_t param2,
                                       uint8_t param3, uint8_t param4,
                                       uint8_t param5);

/** @brief Write command that has six parameters
*/ 
    void _sendCommand(uint8_t command, uint8_t param1, uint8_t param2,
                                       uint8_t param3, uint8_t param4,
                                       uint8_t param5, uint8_t param6);
    
/** @brief Write databyte to display
 *  @brief Start at current cursor location
 *  @param uint8_t data databyte to write
*/  
    void _sendData(uint8_t data);

/** @brief Write len bytes from buffer data to display, 
 *  @brief Start at current cursor location
 *  @param uint8_t len number of bytes to write 
 *  @param uint8_t* data pointer to data
*/   
    void _sendData(uint8_t len, uint8_t* data);


    //I2C *_i2c;             // I2C bus reference
    uint8_t _readOpcode;   // contains the I2C address of the device
    uint8_t _writeOpcode;  // contains the I2C address of the device
    
    //bool _inverted;        // inverted or normal text   
};

#endif



```