I2C LCD: code inside

Jiemde

Very interested by your code version, thanks in advance.

rskoniec

This post is deleted!

DVE

Got the 128x64 display this week. Stupid chinese seller sent SPI version instead of I2C.
But I was able to add SPI support as well :)
alt text

Will update code soon.

rskoniec

@brotherdust Thank you very much for quick reply. :o)

brotherdust

@rskoniec said in I2C LCD: code inside:

@brotherdust Any chance for a code and answers for @DVE questions?

@rskoniec, my apologies. I thought that I had answered this and didn't give it any more thought.

The commit I referenced enables the I2C primitives. You'll need to recompile the firmware and upload it. Then the code will work.

After reviewing the code a bit more, I think it can be refactored not to use the primitives (I2C.start, stop, etc). The primitives are already a part of other, more high-level routines. But the easiest way to get the driver going was just to enable those functions. =) I'm too lazy to re-factor and go through all the pull requests and justifications to get it included upstream.

rskoniec

@brotherdust Any chance for a code and answers for @DVE questions?

DVE

@brotherdust Its great :)

I ordered 128x64 display too on Ebay, will be able to test next week.

@brotherdust said in I2C LCD: code inside:

The driver was using I2C "primitives" that were disabled in the esp32 version of machine_i2c

How it works? Do you need to reload a firmware with enabled primitives?

brotherdust

It works! Yay! Code later. Sleep now.

brotherdust

@DVE Update on using the built-in framebuffer and SSD1306 driver:
The driver was using I2C "primitives" that were disabled in the esp32 version of machine_i2c. The recent commits I've made on my relevant github repo:
https://github.com/brotherdust/pycom-micropython/commits/i2c-framebuf

I've made progress; but still learning how to use this stuff!

brotherdust

Here's what I'm putting in:

# MicroPython SSD1306 OLED driver, I2C and SPI interfaces

from micropython import const
import time
import framebuf


# register definitions
SET_CONTRAST        = const(0x81)
SET_ENTIRE_ON       = const(0xa4)
SET_NORM_INV        = const(0xa6)
SET_DISP            = const(0xae)
SET_MEM_ADDR        = const(0x20)
SET_COL_ADDR        = const(0x21)
SET_PAGE_ADDR       = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP       = const(0xa0)
SET_MUX_RATIO       = const(0xa8)
SET_COM_OUT_DIR     = const(0xc0)
SET_DISP_OFFSET     = const(0xd3)
SET_COM_PIN_CFG     = const(0xda)
SET_DISP_CLK_DIV    = const(0xd5)
SET_PRECHARGE       = const(0xd9)
SET_VCOM_DESEL      = const(0xdb)
SET_CHARGE_PUMP     = const(0x8d)


class SSD1306:
    def __init__(self, width, height, external_vcc):
        self.width = width
        self.height = height
        self.external_vcc = external_vcc
        self.pages = self.height // 8
        self.buffer = bytearray(self.pages * self.width)
        self.framebuf = framebuf.FrameBuffer1(self.buffer, self.width, self.height)
        self.poweron()
        self.init_display()

    def init_display(self):
        for cmd in (
            SET_DISP | 0x00, # off
            # address setting
            SET_MEM_ADDR, 0x00, # horizontal
            # resolution and layout
            SET_DISP_START_LINE | 0x00,
            SET_SEG_REMAP | 0x01, # column addr 127 mapped to SEG0
            SET_MUX_RATIO, self.height - 1,
            SET_COM_OUT_DIR | 0x08, # scan from COM[N] to COM0
            SET_DISP_OFFSET, 0x00,
            SET_COM_PIN_CFG, 0x02 if self.height == 32 else 0x12,
            # timing and driving scheme
            SET_DISP_CLK_DIV, 0x80,
            SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,
            SET_VCOM_DESEL, 0x30, # 0.83*Vcc
            # display
            SET_CONTRAST, 0xff, # maximum
            SET_ENTIRE_ON, # output follows RAM contents
            SET_NORM_INV, # not inverted
            # charge pump
            SET_CHARGE_PUMP, 0x10 if self.external_vcc else 0x14,
            SET_DISP | 0x01): # on
            self.write_cmd(cmd)
        self.fill(0)
        self.show()

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

    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):
        x0 = 0
        x1 = self.width - 1
        if self.width == 64:
            # displays with width of 64 pixels are shifted by 32
            x0 += 32
            x1 += 32
        self.write_cmd(SET_COL_ADDR)
        self.write_cmd(x0)
        self.write_cmd(x1)
        self.write_cmd(SET_PAGE_ADDR)
        self.write_cmd(0)
        self.write_cmd(self.pages - 1)
        self.write_data(self.buffer)

    def fill(self, col):
        self.framebuf.fill(col)

    def pixel(self, x, y, col):
        self.framebuf.pixel(x, y, col)

    def scroll(self, dx, dy):
        self.framebuf.scroll(dx, dy)

    def text(self, string, x, y, col=1):
        self.framebuf.text(string, x, y, col)


class SSD1306_I2C(SSD1306):
    def __init__(self, width, height, i2c, addr=0x3c, external_vcc=False):
        self.i2c = i2c
        self.addr = addr
        self.temp = bytearray(2)
        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.temp[0] = self.addr << 1
        self.temp[1] = 0x40 # Co=0, D/C#=1
        self.i2c.start()
        self.i2c.write(self.temp)
        self.i2c.write(buf)
        self.i2c.stop()

    def poweron(self):
        pass

from machine import I2C
i2c = I2C(0, I2C.MASTER, baudrate=1000000)
display = SSD1306_I2C(width=128, height=64, i2c=i2c, addr=0x3d)

The 128x64 display has hardware address of 0x3d. Anyway, here's what comes out:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 109, in __init__
  File "<stdin>", line 37, in __init__
  File "<stdin>", line 64, in init_display
  File "<stdin>", line 89, in show
  File "<stdin>", line 119, in write_data
AttributeError: 'I2C' object has no attribute 'start'

The display turns on, but it's full of what looks like random noise. I looked through the source code for the I2C module and the start method is there:
https://github.com/pycom/pycom-micropython/blob/master/esp32/mods/machine_i2c.c#L348

STATIC mp_obj_t machine_i2c_start(mp_obj_t self_in) {
    machine_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
    mp_hal_i2c_start(self);
    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_1(machine_i2c_start_obj, machine_i2c_start);

>>> help(machine.I2C)
<class 'I2C'>object  is of type type
  init -- <function>
  scan -- <function>
  readfrom -- <function>
  readfrom_into -- <function>
  writeto -- <function>
  readfrom_mem -- <function>
  readfrom_mem_into -- <function>
  writeto_mem -- <function>
  MASTER -- 0

I don't get why it's not present in the list of available methods for this class. =/

brotherdust

@rskoniec said in I2C LCD: code inside:

@brotherdust Waiting for the news. :o)

Sorry! I was hacking on NyQuil last night. I got the framebuf code to compile and loaded it up on to one of my LoPy's. Tried the driver code, but all I got was the same result: a screen full of static. Same result as when I used @DVE 's code. Maybe my module is defective? Not sure. Anyway, tried a few things, couldn't get it to do anything different, then rage-quit because I wasn't clear-headed enough to figure out what the LoPy was telling me on the console. heh. Either of you have any luck?

DVE

@brotherdust, thanks for the link. I can test this driver also.

rskoniec

@brotherdust Waiting for the news. :o)

brotherdust

@DVE So, I tried your code on my 128x64. It just shows up as a bunch of random noise on the display. =( I dug through the MP codebase and found this: https://github.com/pycom/pycom-micropython/blob/master/drivers/display/ssd1306.py

Lo and behold! It's for the same display driver as what we have! Wait.. no framebuf module.

Twiddled with the make configurations and managed to make a build with framebuf included. Trying it now. It's late so I might not report back until tomorrow.

brotherdust

@brotherdust said in I2C LCD: code inside:

@DVE said in I2C LCD: code inside:
Strings support added:

Usage is easy, example:
    import sys,  machine
    
    initialize()
    set_contrast(128) # 1-255
    displayOn()
    clearBuffer()
    addString(0, 0,  sys.platform + " " + sys.version)
    addString(0, 1,  "---")
    addString(0, 2,  "CPU: {} MHz".format(machine.freq()[0]/1000000))
    drawBuffer()
@DVE Thanks for the code! I ordered a 128x96 display from Adafruit last week and expect to get it on Wednesday. When I have it in-hand, I will test your code and send a pull request over if I can get working. =)

ahem Sorry. 128x64.

brotherdust

@DVE said in I2C LCD: code inside:

Strings support added:
alt text

Usage is easy, example:

    import sys,  machine
    
    initialize()
    set_contrast(128) # 1-255
    displayOn()
    clearBuffer()
    addString(0, 0,  sys.platform + " " + sys.version)
    addString(0, 1,  "---")
    addString(0, 2,  "CPU: {} MHz".format(machine.freq()[0]/1000000))
    drawBuffer()

@DVE Thanks for the code! I ordered a 128x96 display from Adafruit last week and expect to get it on Wednesday. When I have it in-hand, I will test your code and send a pull request over if I can get working. =)

rskoniec

@DVE OK, thanks. I've just ordered one so I'll have the chance to check and let you know.

DVE

128x64 display support was added to the source code, but I don't have a real display to test. So, you can try, but no guarantee :)

rskoniec

@DVE Great! What about 128x64 version, because I saw some references in the code? Is it working?

daniel

@DVE Awesome!, thanks for sharing :-)

Explore Pybytes | Official Documentation | Report a Firmware Bug/Issue | GitHub

I2C LCD: code inside

Pycom on Twitter