OLED SH1107 driver errors

[Johnl52]

I'm using a Pico with Thonny version 4.0.1 with Python 3.8.10. I have a BME280 sensor and a Adafruit Featherwing OLED display. Before using this display, I had another OLED that uses the ssd1306 driver and it all worked fine, was able to display the BME values.
I'm now trying to get the Adafruit display working as well, it's a bit bigger and I like that it has some buttons on it I can use, I had read that the sh1107 driver was similar and could be configured the same as the ssd1306, evidently not as it's not working for me. I don't understand what the error message is pointing out. Here's the error:

Traceback (most recent call last):
File "", line 9, in
File "/lib/sh1107.py", line 137, in init
File "/lib/sh1107.py", line 34, in init
ValueError:

Here is my code

from machine import Pin, I2C
from ssd1306 import SSD1306_I2C
from sh1107 import SH1107_I2C
from time import sleep
import bme280

i2c=I2C(0,sda=Pin(0), scl=Pin(1), freq=400000)
#oled = SSD1306_I2C(128, 32, i2c)
oled = SH1107_I2C(128, 32, i2c)
bme = (bme280.BME280(i2c=i2c))


while True:
    bme = (bme280.BME280(i2c=i2c))
    temp, pressure, humidity = bme.read_compensated_data()
    temp_f = ((temp * 1.8) / 100) + 32
    press_Hg = (pressure/256) / 3386.39
    humd = humidity/1024
    reading = 'Temperature: ' + f'{(temp_f): .2f}' + '   Humidity: ' + f'{(humd): .2f}' + '   Pressure: ' + f'{(press_Hg): .2f}'
    print(reading)
    oled.fill(0)
    # Show values (data, x, y)
    oled.text("T = ", 0, 2 )
    oled.text(f'{(temp_f): .2f}', 25, 2)
    oled.text("P =: ", 0, 15 )
    oled.text(f'{(press_Hg): .2f}', 25, 15)
    oled.text("H = ", 0, 25 )
    oled.text(f'{(humd): .2f}', 28, 28)
    oled.show()
    sleep(10)

and the sh1107 driver

from micropython import const
from framebuf import FrameBuffer, MONO_VLSB, MONO_HMSB

SET_CONTRAST = const(0x81)
SET_ENTIRE_ON = const(0xA4)
SET_NORM_INV = const(0xA6)
SET_DISP = const(0xAE)
SET_DCDC_MODE = const(0xAD)
SET_MEM_MODE = const(0x20)
SET_PAGE_ADDR = const(0xB0)
SET_COL_LO_ADDR = const(0x00)
SET_COL_HI_ADDR = const(0x10)
SET_DISP_START_LINE = const(0xDC)
SET_SEG_REMAP = const(0xA0)
SET_MUX_RATIO = const(0xA8)
SET_COM_OUT_DIR = const(0xC0)
SET_DISP_OFFSET = const(0xD3)
SET_DISP_CLK_DIV = const(0xD5)
SET_PRECHARGE = const(0xD9)
SET_VCOM_DESEL = const(0xDB)

TEST_CHUNK = const(8)

class SH1107(FrameBuffer):
    def __init__(self, width, height, external_vcc):
        self.external_vcc = external_vcc
        if width == 128 and height == 64:
            self.page_mode = False
        elif (width == 64 and height == 128) or (width == 128 and height == 128):
            self.page_mode = True
        else:
            raise ValueError
        self.width = width
        self.height = height
        self.pages = self.height // 8
        self.line_bytes = self.width // 8
        size = self.width * self.height // 8
        self.curr_buffer = bytearray(b'\x00' * size) # self.fill(0)
        self.prev_buffer = bytearray(b'\xff' * size) # force full refresh
        super().__init__(self.curr_buffer, self.width, self.height, MONO_VLSB if self.page_mode else MONO_HMSB)
        self.init_display()

    def init_display(self):
        for cmd in (
            SET_DISP |           0x00, # off
            # address setting
            SET_MEM_MODE |       (0x00 if self.page_mode else 0x01), # 0x00 = page, 0x01 = vertical
            # resolution and layout
            SET_DISP_START_LINE, 0x00,
            SET_SEG_REMAP |      0x00, # 0x01 rotate 180 deg
            SET_COM_OUT_DIR |    (0x00 if self.page_mode else 0x08), # 0x08 rotate 180 deg
            SET_MUX_RATIO,       0x7f, # always this?
            SET_DISP_OFFSET,     0x60 if self.width != self.height else 0x00, # offseted for 64 x 128 (Aliexpress 0.96")
            # timing and driving scheme
            SET_DISP_CLK_DIV,    0x50,
            SET_PRECHARGE,       0x22 if self.external_vcc else 0xf1,
            SET_VCOM_DESEL,      0x35, # 0.77 * Vcc
            SET_DCDC_MODE,       0x81, # on, 0.6 * switch freq
            # display
            SET_CONTRAST,        0x10, # very low to avoid uneven background
            SET_ENTIRE_ON |      0x00, # output follows RAM contents, not entire on
            SET_NORM_INV |       0x00  # 0x00 = not inverted, 0x01 = inverted
        ):
            self.write_cmd(cmd)
        # buffers are initialized as if self.fill(0) was called
        self.show()
        self.poweron()

    def poweroff(self):
        self.write_cmd(SET_DISP | 0x00)

    def poweron(self):
        self.write_cmd(SET_DISP | 0x01)

    def contrast(self, contrast):
        self.write_cmd(SET_CONTRAST)
        self.write_cmd(contrast)

    def invert(self, invert):
        self.write_cmd(SET_NORM_INV | (invert & 1))

    def show(self):
        if self.page_mode:
            self.show_page_mode()
        else:
            self.show_vert_mode()
        self.prev_buffer[:] = self.curr_buffer

    def show_page_mode(self):
        for page in range(self.pages):
            noffs = page * self.width
            for col1, col2 in self.test_modified(noffs, self.width):
                c = col1 - noffs
                self.write_cmd(SET_PAGE_ADDR | page)
                self.write_cmd(SET_COL_LO_ADDR | (c & 0x0f))
                self.write_cmd(SET_COL_HI_ADDR | ((c & 0x70) >> 4))
                self.write_data(self.curr_buffer[col1 : col2])
                # print('Write offsets {} : {}, col: {}'.format(col1, col2, c))

    def show_vert_mode(self):
        for col in range(self.height):
            noffs = col * self.line_bytes
            for page1, page2 in self.test_modified(noffs, self.line_bytes):
                self.write_cmd(SET_PAGE_ADDR | (page1 - noffs))
                self.write_cmd(SET_COL_LO_ADDR | (col & 0x0f))
                self.write_cmd(SET_COL_HI_ADDR | ((col & 0x70) >> 4))
                self.write_data(self.curr_buffer[page1 : page2])
                # print('Write offsets {} : {}, page: {}'.format(page1, page2, page1 - noffs))

    def test_modified(self, offs, width):
        ptr = offs
        width += offs
        while ptr < width:
            # skip unmodified chunks
            while ptr < width and self.curr_buffer[ptr : ptr + TEST_CHUNK] == self.prev_buffer[ptr : ptr + TEST_CHUNK]:
                ptr += TEST_CHUNK

            if ptr < width:
                first = ptr
                ptr += TEST_CHUNK
                # find modified chunks
                while ptr < width and self.curr_buffer[ptr : ptr + TEST_CHUNK] != self.prev_buffer[ptr : ptr + TEST_CHUNK]:
                    ptr += TEST_CHUNK

                yield first, ptr
                ptr += TEST_CHUNK


class SH1107_I2C(SH1107):
    def __init__(self, width, height, i2c, addr = 0x3C, external_vcc = False):
        self.i2c = i2c
        self.addr = addr
        self.temp = bytearray(2)
        self.write_list = [b'\x40', None]  # Co=0, D/C#=1
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.temp[0] = 0x80  # Co=1, D/C#=0
        self.temp[1] = cmd
        self.i2c.writeto(self.addr, self.temp)

    def write_data(self, buf):
        self.write_list[1] = buf
        self.i2c.writevto(self.addr, self.write_list)

# end

Thanks for all comments and help
John

[robert-hh]

For the way you have posted the code it is hard to tell, which line caused the error. Please use three backticks ``` to enclose code. You can as well highlight all code lines and push Ctrl-E, which will add the backticks.

Nevertheless, most likely there is a communication error. What is the result of

from machine import I2C, Pin
i2c=I2C(0,sda=Pin(0), scl=Pin(1), freq=400000)
print(i2c.scan())

Do the reported addresses match the I2C addresses used in your code?

[Johnl52]

Sorry, I didn't think that looked right, I have edited my post and it should be clearer now. I ran the scan and got, [60, 104, 118], converting those to hexadecimal is 0x3c, 0x68, 0x76, those are the correct addresses for the OLED, MPU9250 compass module and the BME280 sensor.

I also see that the line numbers didn't print, here's the error with the associated lines from the code and driver

In my code, File "", line 9, in "oled = SH1107_I2C(128, 32, i2c)"
File "/lib/sh1107.py", line 137, in init "super().init(width, height, external_vcc)"
File "/lib/sh1107.py", line 34, in init "raise ValueError"

Is there a way I can highlight those lines within my code to make it easier to see where those lines are?

Thanks for your help

[robert-hh]

So you could answer the questions yourself. The code sequence checks for a support width/height combination. And 128/32 is not supported by the code.

[Johnl52]

Wow, I'm really not paying attention here, and I'm sure you're not impressed. The previous display was a 128 x 32, this one is 128 x 64, I forgot to change that when I switched to the sh1107 driver. Now I get different errors, it has to do with the line that has OLED.show. Here's the errors and the associated code lines

File "", line 29, in "oled.show()"
File "/lib/sh1107.py", line 88, in show "self.show_vert_mode()"
File "/lib/sh1107.py", line 106, in show_vert_mode "self.write_cmd(SET_PAGE_ADDR | (page1 - noffs))"
File "/lib/sh1107.py", line 142, in write_cmd "self.i2c.writeto(self.addr, self.temp)"

thanks again

[robert-hh]

What exactly is the error message you get? Something like IOError 5? If yes, then the communication to the OLED fails. Even if scan shows the right number, transferrring more data may fail. It may be caused by insufficient pull-up resistors. The OLED boards often do not have them, but the BME280 breakout may have them.

Edit: Although i wonder why there should be an communication error if the init() passed successfully.

[Johnl52]

I get this error "OSError: [Errno 5] EIO" looking at the info on Adafruit there are 2.2K pullups on the SDA and SCL pins. There is also a note that if not stacking this on a Feather, I'm using a pico, I should also connect the reset pin, looking at the pinouts for a pico I don't see a reset pin, is there one, do I have to configure a GPIO to be a reset?

[robert-hh]

So it's communication error. The pull-ups are fine. With reset they probably talk about OLED reset. That should be fine. There is a pull-up resistor and a circuit which triggers reset on power on.
Maybe a problem with clock stretching, when all communication during the init phase passed. I do not recall whether the RP2040 HW I2C supports clock stretching. SoftI2C does, so you could try SoftI2C.

from machine import SoftI2C, Pin
i2c=SoftI2C(sda=Pin(0), scl=Pin(1), freq=400000)

[Johnl52]

Same thing, same line references anyways but get this error instead "OSError: [Errno 19] ENODEV"

[robert-hh]

Maybe there is an interference with the other devices on the bus. Could you try to just use the display as a test. To be sure, plug even the other devices off.

Edit: I see that you instantiate bme280 both at the beginning an in the loop.
bme = (bme280.BME280(i2c=i2c))

[Johnl52]

That's a good idea, I'm not home right now, I'll try when I get home. I thought I had moved that instance, I must have copied instead of cut, sloppy

[Johnl52]

I disconnected the other 2 modules, commented out the bme instance and hard coded some values for temp, pressure and humidity, and I get the sane results as far as line references and this error "OSError: [Errno 19] ENODEV"

[robert-hh]

Hmm. So it seems that initialization makes the SH1107 silent.Time to go through the init sequence to understand, what it does. And maybe compare it to a different sh1107 driver.
And latest at that point I would have hooked up my 10$ logic analyzer clone to the bus to see, what happens on the wire.

[robert-hh]

I wonder why it fails at line 29 when calling show(). During instantiation of the display, show() is already called and seems not to fail. How did you configure the device width=128, height=64, or width=64, height=128?

[Johnl52]

I've always had it at width=128 and height=64, although at one point I saw that the error had to do with the vertical function in the driver so I reversed it just as a shot in the dark, it didn't fix it and I didn't think it would but you have to try things, I put it back the way I originally had it. I'm wondering if it's time to go another direction, although this should work, the driver is made for the chip on this display. This was about the only driver I could find online that was compatible with a pico. We, mostly you, have spent a lot of time on it to get it to work, I don't mind continuing with what ever suggestions you have if you wish to continue. I have found another display, it's a hat made for a pico, larger screen, has 4 buttons and a RGB LED on it. I wouldn't want to use it as a hat as I loose access to the remaining GPIO pins but also found a nice breakout board that you put the pico on, the hat and you can use standard Pi hats as well.

[robert-hh]

self.page_mode mode seems not to be consistently used in the driver. e.g.:
super().__init__(self.curr_buffer, self.width, self.height, MONO_VLSB if self.page_mode else MONO_HMSB)
and
SET_MEM_MODE | (0x00 if self.page_mode else 0x01), # 0x00 = page, 0x01 = vertical
And it seems that the setting in lines 29-32 should be the opposite.
I did not look to deep into the data sheet yet and the difference to the sh1106, but for the sh1106 driver I used MONO_VLSB for the page mode, and MONO_HMSB for the vertical mode.

[Johnl52]

If I understand you right, I reversed the states on lines 30 and 32 as shown below, I've added the line numbers. Line 30 should be true as line 29 is how I have the oled configured

26 class SH1107(FrameBuffer):
27 def init(self, width, height, external_vcc):
28 self.external_vcc = external_vcc
29 if width == 128 and height == 64:
30 self.page_mode = True
31 elif (width == 64 and height == 128) or (width == 128 and height == 128):
32 self.page_mode = False
33 else:
34 raise ValueError

If this is what you meant I now get these errors

Temperature: 70.27 Humidity: 90.27 Pressure: 22.34
Traceback (most recent call last):
File "", line 30, in
File "/lib/sh1107.py", line 86, in show
File "/lib/sh1107.py", line 96, in show_page_mode
File "/lib/sh1107.py", line 142, in write_cmd
OSError: [Errno 5] EIO

By the way, I've reconnected the BME280 and put the i2c instance back to how I started. Just so we're both looking at the same code here's is the revised code.

from machine import Pin, I2C
#from machine import SoftI2C, Pin
from ssd1306 import SSD1306_I2C
from sh1107 import SH1107_I2C
from time import sleep
import bme280

i2c=I2C(0,sda=Pin(0), scl=Pin(1), freq=400000)
#i2c=SoftI2C(sda=Pin(0), scl=Pin(1), freq=400000)
#oled = SSD1306_I2C(128, 32, i2c)
oled = SH1107_I2C(128, 64, i2c)
bme = (bme280.BME280(i2c=i2c))


while True:
    temp, pressure, humidity = bme.read_compensated_data()
    temp_f = ((temp * 1.8) / 100) + 32
    press_Hg = (pressure/256) / 3386.39
    humd = humidity/1024
    reading = 'Temperature: ' + f'{(temp_f): .2f}' + '   Humidity: ' + f'{(humd): .2f}' + '   Pressure: ' + f'{(press_Hg): .2f}'
    print(reading)
    oled.fill(0)
    # Show values (data, x, y)
    oled.text("T = ", 0, 2 )
    oled.text(f'{(temp_f): .2f}', 25, 2)
    oled.text("P =: ", 0, 15 )
    oled.text(f'{(press_Hg): .2f}', 25, 15)
    oled.text("H = ", 0, 25 )
    oled.text(f'{(humd): .2f}', 28, 28)
    oled.show()
    sleep(10)

Thanks

[robert-hh]

That's what I meant. It still puzzles me that show() succeeds as part of init_display(), but fails later on. The only thing in between is a call to power_on(), b.t.w.: Is the display sufficiently powered?

[Johnl52]

I have 3.3V going to the display, I'm getting that off of the pico, pin 3.3V(out). If it was a power problem wouldn't I get an error saying it's not seeing the I2C address or if it's enough to see the address, then I would think I'd get no code errors but nothing on the display.

[robert-hh]

The power consumption differs. As long as the display if off or has no pixels set. As soon as pixels are on, the power consumption increases.

[ithinuel]

Hello there. Not sure this is still relevant to you but here's my story:
I have a FeatherWing OLED 128x64 connected via the Qwiic connector to a Sparkfun ProMicro Rp2040 and turning on the display was failing several times after a cold start (power cycle) but was working fine after a warm reset (provided it did turn on before).

It turned out that the Featherwing OLED 128x64 uses a SH1107 controller which is attached to a FAN5331 LED Driver & OLED Supply.
On figure 9 (page 6) of the FAN5331 datasheet, you can see how on power on the inductor's current can go up to 1.2A before stabilizing ~0.4A.
But the power supply for the sparkfun promicro rp2040 is limited to 500mA.

To work around that issue, I tried adding a fairly large capacitor on the power line on the feather board.
I added a delay on startup before powering the display on to let the capacitor build up some charge to absorb the transient.
It seems to have done the trick and now the display always turns on when asked to.

(I'm writing the firmware in Rust but I reproduced the issue with circuitpython)

[Johnl52]

ithinuel, that is very interesting. I have moved on from this project but this is great info, thanks for letting me know, I'll keep this in mind when I get back to it.

Thanks again