Auto detect SSD1306,SH1106 and SH1107 display type

[alextrical]

I know a similar question has been asked before, but I'm hoping for some help and advise on how to try and implement this.

Using a I2C display, It is possible to read the registers of an SSD1306,SH1106 and SH1107 to be able to detect presence, driver type, and address. See https://github.com/bitbank2/ss_oled

Is there any way that it could be possible to setup, or create a new display type that follows this kind of functionality with U8G2?

I believe this feature would be of great use to the community, as a group I'm collaborating is having issues with sellers mixing SSD1306 and SH1107 drivers within listings.

Further information:
The 3 displays in question can be set to either 0x3C or 0x3D

  // find the device address if requested
  if (iAddr == -1 || iAddr == 0 || iAddr == 0xff) // find it
  {
    I2CTest(&pOLED->bbi2c, 0x3c);
    if (I2CTest(&pOLED->bbi2c, 0x3c))
       pOLED->oled_addr = 0x3c;
    else if (I2CTest(&pOLED->bbi2c, 0x3d))
       pOLED->oled_addr = 0x3d;
    else
       return rc; // no display found!
  }
  else
  {
    pOLED->oled_addr = iAddr;
    I2CTest(&pOLED->bbi2c, iAddr);
    if (!I2CTest(&pOLED->bbi2c, iAddr))
       return rc; // no display found
  }

and the registers can be read to identify the display in question

  // Detect the display controller (SSD1306, SH1107 or SH1106)
  uint8_t u = 0;
  I2CReadRegister(&pOLED->bbi2c, pOLED->oled_addr, 0x00, &u, 1); // read the status register
  u &= 0x0f; // mask off power on/off bit
  if (u == 0x7 || u == 0xf) // SH1107
  {
    pOLED->oled_type = OLED_128x128;
    rc = OLED_SH1107_3C;
    bFlip = !bFlip; // SH1107 seems to have this reversed from the usual direction
  }
  else if (u == 0x8) // SH1106
  {
    rc = OLED_SH1106_3C;
    pOLED->oled_type = OLED_132x64; // needs to be treated a little differently
  }
  else if (u == 3 || u == 6) // 6=128x64 display, 3=smaller
  {
    rc = OLED_SSD1306_3C;
  }
  if (pOLED->oled_addr == 0x3d)
     rc++; // return the '3D' version of the type

https://github.com/bitbank2/ss_oled/blob/01fb9a53388002bbb653c7c05d8e80ca413aa306/src/ss_oled.cpp#L792-L830

[olikraus]

U8g2 had been designed as a write-only library. This is a design decision to have a common code base with SPI based displays (SPI based displays usually do not allow read operation).

[alextrical]

I have managed to get an example of what I'm looking for, allowing one sketch to work for both a SSD1306 and a SH1106, after detecting the presence.

I'm wondering if you could advise if there was a cleaner way to redirect the class name at run time, to remove the duplicated up user code. I.e. can i call one class in the user code (i.e. 'u8g2'), but redirect that to 'u8g2_1' or 'u8g2_2' programmatically at run time?

`#include <U8g2lib.h>
#include <Wire.h>
byte buffer[0];

int Type3C;
int Type3D;
bool flip = false;

U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2_1(U8G2_R0, /* reset=/U8X8_PIN_NONE); //Type1
U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2_2(U8G2_R0, / reset=*/U8X8_PIN_NONE); //Type2

void setup() {
Wire.begin();
Serial.begin(9600);
// while (!Serial); // Leonardo: wait for Serial Monitor

delay(20);

for (byte address = 1; address < 127; ++address) {
Wire.beginTransmission(address);
byte error = Wire.endTransmission();

if (error == 0) {
  if (address == 0x3C) {
    Serial.print("OLED Display 0x3C, Type: ");
    Type3C = DisplayType(address);
  }
  if (address == 0x3D) {
    Serial.print("OLED Display 0x3D, Type: ");
    Type3D = DisplayType(address);
  }
}

}

switch (Type3C) {
case 1:
u8g2_1.begin();
u8g2_1.setFlipMode(flip);
break;
case 2:
u8g2_2.begin();
u8g2_2.setFlipMode(flip);
break;
default:
// statements
break;
}
}

void loop() {
switch (Type3C) {
case 1:
u8g2_1.firstPage();
do {
u8g2_1.setFont(u8g2_font_ncenB10_tr);
u8g2_1.drawStr(35, 24, "SH1106!");
u8g2_1.drawStr(15, 48, "Hello World!");
} while (u8g2_1.nextPage());
break;
case 2:
u8g2_2.firstPage();
do {
u8g2_2.setFont(u8g2_font_ncenB10_tr);
u8g2_2.drawStr(35, 24, "SSD1306!");
u8g2_2.drawStr(15, 48, "Hello World!");
} while (u8g2_2.nextPage());
break;
default:
// statements
break;
}

delay(1000);
}

int DisplayType(int address) {
Wire.beginTransmission(address); //Can't reliably read register on first try
Wire.write(0x00); //Can't reliably read register on first try
Wire.endTransmission(); //Can't reliably read register on first try

Wire.beginTransmission(address);
Wire.write(0x00);
Wire.requestFrom(address, 1); // This register is 8 bits = 1 byte long
if (Wire.available() > 0) {
Wire.readBytes(buffer, 1);
}
Wire.endTransmission();

buffer[0] &= 0x0f; // mask off power on/off bit
switch (buffer[0]) {
case 0x7 || 0xf: // SH1107
Serial.println("SH1107");
return 0;
// break;
case 0x8: // SH1106
Serial.println("SH1106");
return 1;
// break;
case 0x6: // SSD1306 6=128x64 display
Serial.println("SSD1306");
return 2;
// break;
case 0x3: // SSD1306 3=128x32 display
Serial.println("SSD1306");
return 3;
// break;
default:
Serial.print("UNKNOWN: 0x0");
Serial.println(buffer[0], HEX);
return -1; //Unknown
// break;
}
}
`

[olikraus]

Arduino is C++, so you can create a base U8g2 base object and assign the desired constructor.

U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2_1(U8G2_R0, /* reset=*/U8X8_PIN_NONE); //Type1
U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2_2(U8G2_R0, /* reset=*/U8X8_PIN_NONE); //Type2
U8G2 *u8g2;
...
if ( isSSD1306 )
  u8g2 = &u8g2_2;
else 
  u8g2 = &u8g2_1;
...

u8g2->begin();

Now you can write your code with the u8g2 object insted. But: Instead of the "." syntax you need to use the "->" syntax.

[alextrical]

Thank you, its working nicely now, and is a lot cleaner on the code base. The resulting sketch can now switch between the SSD1306 and SH1106 at runtime. Attaching the example here for anyone who needs such a feature in the future.

#include <Wire.h>

U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2_1(U8G2_R0, /* reset=*/U8X8_PIN_NONE);  //SSD1306 Type1
U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2_2(U8G2_R0, /* reset=*/U8X8_PIN_NONE);   //SH1106 Type2
U8G2 *u8g2;

void setup() {
  Wire.begin();

  if (isSSD1306(0x3C)) { //Address of the display to be checked
    u8g2 = &u8g2_1;
  } else {
    u8g2 = &u8g2_2;
  }
  
  u8g2->begin();
}

void loop() {
  u8g2->firstPage();
  do {
    u8g2->setFont(u8g2_font_ncenB10_tr);
    u8g2->drawStr(15, 24, "Hello World!");

    //Show the display type
    if (isSSD1306(0x3C)) { //Address of the display to be checked
      u8g2->drawStr(32, 48, "SSD1306!");
    } else {
      u8g2->drawStr(35, 48, "SH1106!");
    }

  } while (u8g2->nextPage());

  delay(1000);
}

bool isSSD1306(int address) {
  byte buffer[0];

  Wire.beginTransmission(address);
  Wire.write(0x00);
  Wire.requestFrom(address, 1);  // This register is 8 bits = 1 byte long
  if (Wire.available() > 0) {
    Wire.readBytes(buffer, 1);
  }
  Wire.endTransmission();

  buffer[0] &= 0x0f;        // mask off power on/off bit
  return buffer[0] == 0x6;  //0x3 = SSD1306 128x32, 0x6 = SSD1306 128x64, 0x7 || 0xf = SH1107, 0x8 = SH1106
}

[olikraus]

Looks good 👍😀