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;
  }
}

[greenonline]

Whilst I understand that isn't the final code example, it would still be a good idea to correctly code-format, and indent, the code, just so it is easier to read.

[olikraus]

Done, I think the github md editor is little bit bad to use. It always requires some postprocessing.

[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 👍😀