ssd1306OLED Chinese display - micropthon-esp32 - using GB2312 font library (non manual mold taking)

preface:

Ah, in order to make my * * "mobile phone abstinence device" (the functions of each subsystem of this project are about to be completed!)** I've really paid too much for this OLED with more than ten yuan.
Baidu couldn't find a reliable tutorial. Last night, baidu searched Google and finally found a big man's blog for 17 years, Upycraft ide micro Python supports Chinese!

The bad news is that there is no step by step step~

The good news is: there is a micro Python group number - 619558168;

I immediately added a group;

The good news is: there are many videos that successfully display Chinese

The bad news is: there are too many firmware files and python scripts in it. I don't know which one to use, and I haven't found a nanny tutorial;

Then I asked the big man in the group, and the big man told me to download such a file:
fb enhanced firmware and font rar file.

The good news is: I can brush the firmware

The bad news is: I don't know how to upload the files on my notebook to ESP32, and how to import the font library in python script and display it.

So the next step is the tutorial of step by step.

1. Install thorny and basic operation:

Reference tutorial: Install Thonny software environment development PI Pico

Replace PI Pico with ESP32.

2. Brush fastener:

The official firmware can be downloaded directly from the official website, but the official functions are a little less, so we take the firmware that can be displayed in Chinese as an example.

1. Plug in USB and confirm that the LED of esp32 board flashes;
2. Click the stop/restart button to ensure the following effect. If it is always a horizontal line, click the mouse below the horizontal line and press the enter button; The > > > character appears, indicating that the connection is normal.
   
3. Click tools to enter the thorny options interface, select interpreter, select device ESP32 and port COM5.
   
4. Finally, choose the firmware to brush. If you are 4m esp32, choose esp32_1.15_fb_boost_4M_ULAB.bin, others about flash, the default is OK. Every time you brush the firmware, the script files previously saved in esp32 will be emptied. This must be backed up!
   

3. Upload fonts from windows10 notebook to micropthon device:

1. Click View and select files. The following figure will appear in the left column: This computer on the top and micro Python device on the bottom. Select the file to upload and select upload to upload it to esp32.
2. This method is better than any fancy ampy -- port com5 put gb2312-12 Fon is much more reliable. You need to PIP install adafruit ampy first, and then upload the file. You can't see the progress bar. You don't know when you can finish uploading this slightly larger file~
   

4. Example python script:

4.1. ssd1306.py script code:

# MicroPython SSD1306 OLED driver, I2C and SPI interfaces

from micropython import const
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)

# Subclassing FrameBuffer provides support for graphics primitives
# http://docs.micropython.org/en/latest/pyboard/library/framebuf.html
class SSD1306(framebuf.FrameBuffer):
    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)
        super().__init__(self.buffer, self.width, self.height, framebuf.MONO_VLSB, self.width)
        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.width > 2 * self.height 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 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):
        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)


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)
        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)


class SSD1306_SPI(SSD1306):
    def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
        self.rate = 10 * 1024 * 1024
        dc.init(dc.OUT, value=0)
        res.init(res.OUT, value=0)
        cs.init(cs.OUT, value=1)
        self.spi = spi
        self.dc = dc
        self.res = res
        self.cs = cs
        import time

        self.res(1)
        time.sleep_ms(1)
        self.res(0)
        time.sleep_ms(10)
        self.res(1)
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs(1)
        self.dc(0)
        self.cs(0)
        self.spi.write(bytearray([cmd]))
        self.cs(1)

    def write_data(self, buf):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs(1)
        self.dc(1)
        self.cs(0)
        self.spi.write(buf)
        self.cs(1)

4.2. OLED_show.py script code:

'''
Experiment Name: OLED Display screen( I2C Bus)
edition: v1.0
 Date: 2019.4
 Author: 01 Studio
'''

from machine import I2C,Pin         #Import I2C and Pin sub modules from machine module
from ssd1306 import SSD1306_I2C     #Import ssd1306 from ssd1306 module_ I2C sub module

i2c = I2C(sda=Pin(5), scl=Pin(4))   #pyBoard I2C initialization: SDA -- > Y8, SCL -- > y6
oled = SSD1306_I2C(128, 64, i2c, addr=0x3c) #OLED display initialization: 128 * 64 resolution, I2C address of OLED is 0x3c

oled.font_load("GB2312-12.fon")
oled.fill(0)

for i in range(4):
#     oled.font_set(0x24, i, 1, 0)
    oled.text("Hello World!", 0,  0)      #Write line 1
    oled.text("MicroPython",  0, 20)      #Write line 2
    oled.text("By 01Studio",  0, 30)      #Write line 3
    oled.text("chinese",  0, 40)

    oled.show()   #OLED execution display

5. Display effect:

The Chinese in the picture is very comfortable~
Of course, there are some font size settings that have not been adjusted, but this is not important~

6. Codes and resources

https://github.com/kaixindelele/ssd1306-MicroPython-ESP32-Chinese/
Welcome to star~