ST7789 Display Pi Pico

Hey Guys, Today I’m back with another interesting example on Raspberry Pi Pico. ST7789 display Pi Pico, In this we’ll discuss how we can hook our ST7789 display to pico. I have also done a tutorial of the same display on raspberry pi. So if you are interested in that then click here. So let’s jump to our today’s topic.

ST7789 Display:

This display is most common among many users due to its large availability and eases to use. This display comes in various sizes 128×240,240×240 & 240×320. Also in sizes 1.3′, 1.54′, 1.8′ . The one I’m using is 240×240, 1.3′. These are very easy to hook up to any microcontroller and display things you want but due to not much popularity and adequate knowledge, many think not of using it.

Today I’ll trouble all the problems you may face while programming this display using SPI protocol. Also, we’ll see some examples running on this display. the pins which we are going to use today are the same as in my previous article on ST7789 but in place of cs, we’ll change it to BLK pin(if needed). Ras pi pico is a unique controller and the latest in the market.

Material Required:

  • Raspberry Pi Pico
  • ST7789 240×240 IPS display
  • Jumper wires
  • Breadboard

Circuit diagram:

Programming:

For programming the code you didn’t need any special library. Just copy the below code and save it on Pico with name ‘st7789.py’ or download zip file from here

 import time  
 from micropython import const  
 import ustruct as struct  
 # commands  
 ST7789_NOP = const(0x00)  
 ST7789_SWRESET = const(0x01)  
 ST7789_RDDID = const(0x04)  
 ST7789_RDDST = const(0x09)  
 ST7789_SLPIN = const(0x10)  
 ST7789_SLPOUT = const(0x11)  
 ST7789_PTLON = const(0x12)  
 ST7789_NORON = const(0x13)  
 ST7789_INVOFF = const(0x20)  
 ST7789_INVON = const(0x21)  
 ST7789_DISPOFF = const(0x28)  
 ST7789_DISPON = const(0x29)  
 ST7789_CASET = const(0x2A)  
 ST7789_RASET = const(0x2B)  
 ST7789_RAMWR = const(0x2C)  
 ST7789_RAMRD = const(0x2E)  
 ST7789_PTLAR = const(0x30)  
 ST7789_VSCRDEF = const(0x33)  
 ST7789_COLMOD = const(0x3A)  
 ST7789_MADCTL = const(0x36)  
 ST7789_VSCSAD = const(0x37)  
 ST7789_MADCTL_MY = const(0x80)  
 ST7789_MADCTL_MX = const(0x40)  
 ST7789_MADCTL_MV = const(0x20)  
 ST7789_MADCTL_ML = const(0x10)  
 ST7789_MADCTL_BGR = const(0x08)  
 ST7789_MADCTL_MH = const(0x04)  
 ST7789_MADCTL_RGB = const(0x00)  
 ST7789_RDID1 = const(0xDA)  
 ST7789_RDID2 = const(0xDB)  
 ST7789_RDID3 = const(0xDC)  
 ST7789_RDID4 = const(0xDD)  
 COLOR_MODE_65K = const(0x50)  
 COLOR_MODE_262K = const(0x60)  
 COLOR_MODE_12BIT = const(0x03)  
 COLOR_MODE_16BIT = const(0x05)  
 COLOR_MODE_18BIT = const(0x06)  
 COLOR_MODE_16M = const(0x07)  
 # Color definitions  
 BLACK = const(0x0000)  
 BLUE = const(0x001F)  
 RED = const(0xF800)  
 GREEN = const(0x07E0)  
 CYAN = const(0x07FF)  
 MAGENTA = const(0xF81F)  
 YELLOW = const(0xFFE0)  
 WHITE = const(0xFFFF)  
 _ENCODE_PIXEL = ">H"  
 _ENCODE_POS = ">HH"  
 _DECODE_PIXEL = ">BBB"  
 _BUFFER_SIZE = const(256)  
 _BIT7 = const(0x80)  
 _BIT6 = const(0x40)  
 _BIT5 = const(0x20)  
 _BIT4 = const(0x10)  
 _BIT3 = const(0x08)  
 _BIT2 = const(0x04)  
 _BIT1 = const(0x02)  
 _BIT0 = const(0x01)  
 # Rotation tables (width, height, xstart, ystart)[rotation % 4]  
 WIDTH_320 = [(320, 240, 0, 0),  
        (240, 320, 0, 0),  
        (320, 240, 0, 0),  
        (240, 320, 0, 0)]  
 WIDTH_240 = [(240, 240, 0, 0),  
        (240, 240, 0, 0),  
        (240, 240, 0, 80),  
        (240, 240, 80, 0)]  
 WIDTH_135 = [(135, 240, 52, 40),  
        (240, 135, 40, 53),  
        (135, 240, 53, 40),  
        (240, 135, 40, 52)]  
 # MADCTL ROTATIONS[rotation % 4]  
 ROTATIONS = [0x00, 0x60, 0xc0, 0xa0]  
 def color565(red, green=0, blue=0):  
   """  
   Convert red, green and blue values (0-255) into a 16-bit 565 encoding.  
   """  
   try:  
     red, green, blue = red # see if the first var is a tuple/list  
   except TypeError:  
     pass  
   return (red & 0xf8) << 8 | (green & 0xfc) << 3 | blue >> 3  
 def _encode_pos(x, y):  
   """Encode a postion into bytes."""  
   return struct.pack(_ENCODE_POS, x, y)  
 def _encode_pixel(color):  
   """Encode a pixel color into bytes."""  
   return struct.pack(_ENCODE_PIXEL, color)  
 class ST7789():  
   """  
   ST7789 driver class  
   Args:  
     spi (spi): spi object  
     width (int): display width  
     height (int): display height  
     reset (pin): reset pin  
     dc (pin): dc pin  
     cs (pin): cs pin  
     backlight(pin): backlight pin  
     rotation (int): display rotation  
       - 0-Portrait  
       - 1-Landscape  
       - 2-Inverted Portrait  
       - 3-Inverted Landscape  
   """  
   def __init__(self, spi, width, height, reset, dc,  
          cs=None, backlight=None,xstart=0,ystart=0,rotation=0):  
     """  
     Initialize display.  
     """  
     if height != 240 or width not in [320, 240, 135]:  
       raise ValueError(  
         "Unsupported display. 320x240, 240x240 and 135x240 are supported."  
       )  
     self._display_width = self.width = width  
     self._display_height = self.height = height  
     self.xstart = 0  
     self.ystart = 0  
     self.spi = spi  
     self.reset = reset  
     self.dc = dc  
     self.cs = cs  
     self.backlight = backlight  
     self._rotation = rotation % 4  
     self.xstart=xstart  
     self.ystart=ystart  
     self.hard_reset()  
     self.soft_reset()  
     self.sleep_mode(False)  
     self._set_color_mode(COLOR_MODE_65K | COLOR_MODE_16BIT)  
     time.sleep_ms(50)  
     self.rotation(self._rotation)  
     self.inversion_mode(True)  
     time.sleep_ms(10)  
     self._write(ST7789_NORON)  
     time.sleep_ms(10)  
     if backlight is not None:  
       backlight.value(1)  
     self.fill(0)  
     self._write(ST7789_DISPON)  
     time.sleep_ms(500)  
   def _write(self, command=None, data=None):  
     """SPI write to the device: commands and data."""  
     if self.cs:  
       self.cs.off()  
     if command is not None:  
       self.dc.off()  
       self.spi.write(bytes([command]))  
     if data is not None:  
       self.dc.on()  
       self.spi.write(data)  
       if self.cs:  
         self.cs.on()  
   def hard_reset(self):  
     """  
     Hard reset display.  
     """  
     if self.cs:  
       self.cs.off()  
     if self.reset:  
       self.reset.on()  
     time.sleep_ms(50)  
     if self.reset:  
       self.reset.off()  
     time.sleep_ms(50)  
     if self.reset:  
       self.reset.on()  
     time.sleep_ms(150)  
     if self.cs:  
       self.cs.on()  
   def soft_reset(self):  
     """  
     Soft reset display.  
     """  
     self._write(ST7789_SWRESET)  
     time.sleep_ms(150)  
   def sleep_mode(self, value):  
     """  
     Enable or disable display sleep mode.  
     Args:  
       value (bool): if True enable sleep mode. if False disable sleep  
       mode  
     """  
     if value:  
       self._write(ST7789_SLPIN)  
     else:  
       self._write(ST7789_SLPOUT)  
   def inversion_mode(self, value):  
     """  
     Enable or disable display inversion mode.  
     Args:  
       value (bool): if True enable inversion mode. if False disable  
       inversion mode  
     """  
     if value:  
       self._write(ST7789_INVON)  
     else:  
       self._write(ST7789_INVOFF)  
   def _set_color_mode(self, mode):  
     """  
     Set display color mode.  
     Args:  
       mode (int): color mode  
         COLOR_MODE_65K, COLOR_MODE_262K, COLOR_MODE_12BIT,  
         COLOR_MODE_16BIT, COLOR_MODE_18BIT, COLOR_MODE_16M  
     """  
     self._write(ST7789_COLMOD, bytes([mode & 0x77]))  
   def rotation(self, rotation):  
     """  
     Set display rotation.  
     Args:  
       rotation (int):  
         - 0-Portrait  
         - 1-Landscape  
         - 2-Inverted Portrait  
         - 3-Inverted Landscape  
     """  
     rotation %= 4  
     self._rotation = rotation  
     madctl = ROTATIONS[rotation]  
     if self._display_width == 320:  
       table = WIDTH_320  
     elif self._display_width == 240:  
       table = WIDTH_240  
     elif self._display_width == 135:  
       table = WIDTH_135  
     else:  
       raise ValueError(  
         "Unsupported display. 320x240, 240x240 and 135x240 are supported."  
       )  
     self.width, self.height, self.xstart, self.ystart = table[rotation]  
     self._write(ST7789_MADCTL, bytes([madctl]))  
   def _set_columns(self, start, end):  
     """  
     Send CASET (column address set) command to display.  
     Args:  
       start (int): column start address  
       end (int): column end address  
     """  
     if start <= end <= self.width:  
       self._write(ST7789_CASET, _encode_pos(  
         start+self.xstart, end + self.xstart))  
   def _set_rows(self, start, end):  
     """  
     Send RASET (row address set) command to display.  
     Args:  
       start (int): row start address  
       end (int): row end address  
     """  
     if start <= end <= self.height:  
       self._write(ST7789_RASET, _encode_pos(  
         start+self.ystart, end+self.ystart))  
   def _set_window(self, x0, y0, x1, y1):  
     """  
     Set window to column and row address.  
     Args:  
       x0 (int): column start address  
       y0 (int): row start address  
       x1 (int): column end address  
       y1 (int): row end address  
     """  
     self._set_columns(x0, x1)  
     self._set_rows(y0, y1)  
     self._write(ST7789_RAMWR)  
   def vline(self, x, y, length, color):  
     """  
     Draw vertical line at the given location and color.  
     Args:  
       x (int): x coordinate  
       Y (int): y coordinate  
       length (int): length of line  
       color (int): 565 encoded color  
     """  
     self.fill_rect(x, y, 1, length, color)  
   def hline(self, x, y, length, color):  
     """  
     Draw horizontal line at the given location and color.  
     Args:  
       x (int): x coordinate  
       Y (int): y coordinate  
       length (int): length of line  
       color (int): 565 encoded color  
     """  
     self.fill_rect(x, y, length, 1, color)  
   def pixel(self, x, y, color):  
     """  
     Draw a pixel at the given location and color.  
     Args:  
       x (int): x coordinate  
       Y (int): y coordinate  
       color (int): 565 encoded color  
     """  
     self._set_window(x, y, x, y)  
     self._write(None, _encode_pixel(color))  
   def blit_buffer(self, buffer, x, y, width, height):  
     """  
     Copy buffer to display at the given location.  
     Args:  
       buffer (bytes): Data to copy to display  
       x (int): Top left corner x coordinate  
       Y (int): Top left corner y coordinate  
       width (int): Width  
       height (int): Height  
     """  
     self._set_window(x, y, x + width - 1, y + height - 1)  
     self._write(None, buffer)  
   def rect(self, x, y, w, h, color):  
     """  
     Draw a rectangle at the given location, size and color.  
     Args:  
       x (int): Top left corner x coordinate  
       y (int): Top left corner y coordinate  
       width (int): Width in pixels  
       height (int): Height in pixels  
       color (int): 565 encoded color  
     """  
     self.hline(x, y, w, color)  
     self.vline(x, y, h, color)  
     self.vline(x + w - 1, y, h, color)  
     self.hline(x, y + h - 1, w, color)  
   def fill_rect(self, x, y, width, height, color):  
     """  
     Draw a rectangle at the given location, size and filled with color.  
     Args:  
       x (int): Top left corner x coordinate  
       y (int): Top left corner y coordinate  
       width (int): Width in pixels  
       height (int): Height in pixels  
       color (int): 565 encoded color  
     """  
     self._set_window(x, y, x + width - 1, y + height - 1)  
     chunks, rest = divmod(width * height, _BUFFER_SIZE)  
     pixel = _encode_pixel(color)  
     self.dc.on()  
     if chunks:  
       data = pixel * _BUFFER_SIZE  
       for _ in range(chunks):  
         self._write(None, data)  
     if rest:  
       self._write(None, pixel * rest)  
   def fill(self, color):  
     """  
     Fill the entire FrameBuffer with the specified color.  
     Args:  
       color (int): 565 encoded color  
     """  
     self.fill_rect(0, 0, self.width, self.height, color)  
   def line(self, x0, y0, x1, y1, color):  
     """  
     Draw a single pixel wide line starting at x0, y0 and ending at x1, y1.  
     Args:  
       x0 (int): Start point x coordinate  
       y0 (int): Start point y coordinate  
       x1 (int): End point x coordinate  
       y1 (int): End point y coordinate  
       color (int): 565 encoded color  
     """  
     steep = abs(y1 - y0) > abs(x1 - x0)  
     if steep:  
       x0, y0 = y0, x0  
       x1, y1 = y1, x1  
     if x0 > x1:  
       x0, x1 = x1, x0  
       y0, y1 = y1, y0  
     dx = x1 - x0  
     dy = abs(y1 - y0)  
     err = dx // 2  
     if y0 < y1:  
       ystep = 1  
     else:  
       ystep = -1  
     while x0 <= x1:  
       if steep:  
         self.pixel(y0, x0, color)  
       else:  
         self.pixel(x0, y0, color)  
       err -= dy  
       if err < 0:  
         y0 += ystep  
         err += dx  
       x0 += 1  
   def vscrdef(self, tfa, vsa, bfa):  
     """  
     Set Vertical Scrolling Definition.  
     To scroll a 135x240 display these values should be 40, 240, 40.  
     There are 40 lines above the display that are not shown followed by  
     240 lines that are shown followed by 40 more lines that are not shown.  
     You could write to these areas off display and scroll them into view by  
     changing the TFA, VSA and BFA values.  
     Args:  
       tfa (int): Top Fixed Area  
       vsa (int): Vertical Scrolling Area  
       bfa (int): Bottom Fixed Area  
     """  
     struct.pack(">HHH", tfa, vsa, bfa)  
     self._write(ST7789_VSCRDEF, struct.pack(">HHH", tfa, vsa, bfa))  
   def vscsad(self, vssa):  
     """  
     Set Vertical Scroll Start Address of RAM.  
     Defines which line in the Frame Memory will be written as the first  
     line after the last line of the Top Fixed Area on the display  
     Example:  
       for line in range(40, 280, 1):  
         tft.vscsad(line)  
         utime.sleep(0.01)  
     Args:  
       vssa (int): Vertical Scrolling Start Address  
     """  
     self._write(ST7789_VSCSAD, struct.pack(">H", vssa))  
   def _text8(self, font, text, x0, y0, color=WHITE, background=BLACK):  
     """  
     Internal method to write characters with width of 8 and  
     heights of 8 or 16.  
     Args:  
       font (module): font module to use  
       text (str): text to write  
       x0 (int): column to start drawing at  
       y0 (int): row to start drawing at  
       color (int): 565 encoded color to use for characters  
       background (int): 565 encoded color to use for background  
     """  
     for char in text:  
       ch = ord(char)  
       if (font.FIRST <= ch < font.LAST  
           and x0+font.WIDTH <= self.width  
           and y0+font.HEIGHT <= self.height):  
         if font.HEIGHT == 8:  
           passes = 1  
           size = 8  
           each = 0  
         else:  
           passes = 2  
           size = 16  
           each = 8  
         for line in range(passes):  
           idx = (ch-font.FIRST)*size+(each*line)  
           buffer = struct.pack(  
             '>64H',  
             color if font.FONT[idx] & _BIT7 else background,  
             color if font.FONT[idx] & _BIT6 else background,  
             color if font.FONT[idx] & _BIT5 else background,  
             color if font.FONT[idx] & _BIT4 else background,  
             color if font.FONT[idx] & _BIT3 else background,  
             color if font.FONT[idx] & _BIT2 else background,  
             color if font.FONT[idx] & _BIT1 else background,  
             color if font.FONT[idx] & _BIT0 else background,  
             color if font.FONT[idx+1] & _BIT7 else background,  
             color if font.FONT[idx+1] & _BIT6 else background,  
             color if font.FONT[idx+1] & _BIT5 else background,  
             color if font.FONT[idx+1] & _BIT4 else background,  
             color if font.FONT[idx+1] & _BIT3 else background,  
             color if font.FONT[idx+1] & _BIT2 else background,  
             color if font.FONT[idx+1] & _BIT1 else background,  
             color if font.FONT[idx+1] & _BIT0 else background,  
             color if font.FONT[idx+2] & _BIT7 else background,  
             color if font.FONT[idx+2] & _BIT6 else background,  
             color if font.FONT[idx+2] & _BIT5 else background,  
             color if font.FONT[idx+2] & _BIT4 else background,  
             color if font.FONT[idx+2] & _BIT3 else background,  
             color if font.FONT[idx+2] & _BIT2 else background,  
             color if font.FONT[idx+2] & _BIT1 else background,  
             color if font.FONT[idx+2] & _BIT0 else background,  
             color if font.FONT[idx+3] & _BIT7 else background,  
             color if font.FONT[idx+3] & _BIT6 else background,  
             color if font.FONT[idx+3] & _BIT5 else background,  
             color if font.FONT[idx+3] & _BIT4 else background,  
             color if font.FONT[idx+3] & _BIT3 else background,  
             color if font.FONT[idx+3] & _BIT2 else background,  
             color if font.FONT[idx+3] & _BIT1 else background,  
             color if font.FONT[idx+3] & _BIT0 else background,  
             color if font.FONT[idx+4] & _BIT7 else background,  
             color if font.FONT[idx+4] & _BIT6 else background,  
             color if font.FONT[idx+4] & _BIT5 else background,  
             color if font.FONT[idx+4] & _BIT4 else background,  
             color if font.FONT[idx+4] & _BIT3 else background,  
             color if font.FONT[idx+4] & _BIT2 else background,  
             color if font.FONT[idx+4] & _BIT1 else background,  
             color if font.FONT[idx+4] & _BIT0 else background,  
             color if font.FONT[idx+5] & _BIT7 else background,  
             color if font.FONT[idx+5] & _BIT6 else background,  
             color if font.FONT[idx+5] & _BIT5 else background,  
             color if font.FONT[idx+5] & _BIT4 else background,  
             color if font.FONT[idx+5] & _BIT3 else background,  
             color if font.FONT[idx+5] & _BIT2 else background,  
             color if font.FONT[idx+5] & _BIT1 else background,  
             color if font.FONT[idx+5] & _BIT0 else background,  
             color if font.FONT[idx+6] & _BIT7 else background,  
             color if font.FONT[idx+6] & _BIT6 else background,  
             color if font.FONT[idx+6] & _BIT5 else background,  
             color if font.FONT[idx+6] & _BIT4 else background,  
             color if font.FONT[idx+6] & _BIT3 else background,  
             color if font.FONT[idx+6] & _BIT2 else background,  
             color if font.FONT[idx+6] & _BIT1 else background,  
             color if font.FONT[idx+6] & _BIT0 else background,  
             color if font.FONT[idx+7] & _BIT7 else background,  
             color if font.FONT[idx+7] & _BIT6 else background,  
             color if font.FONT[idx+7] & _BIT5 else background,  
             color if font.FONT[idx+7] & _BIT4 else background,  
             color if font.FONT[idx+7] & _BIT3 else background,  
             color if font.FONT[idx+7] & _BIT2 else background,  
             color if font.FONT[idx+7] & _BIT1 else background,  
             color if font.FONT[idx+7] & _BIT0 else background  
           )  
           self.blit_buffer(buffer, x0, y0+8*line, 8, 8)  
         x0 += 8  
   def _text16(self, font, text, x0, y0, color=WHITE, background=BLACK):  
     """  
     Internal method to draw characters with width of 16 and heights of 16  
     or 32.  
     Args:  
       font (module): font module to use  
       text (str): text to write  
       x0 (int): column to start drawing at  
       y0 (int): row to start drawing at  
       color (int): 565 encoded color to use for characters  
       background (int): 565 encoded color to use for background  
     """  
     for char in text:  
       ch = ord(char)  
       if (font.FIRST <= ch < font.LAST  
           and x0+font.WIDTH <= self.width  
           and y0+font.HEIGHT <= self.height):  
         if font.HEIGHT == 16:  
           passes = 2  
           size = 32  
           each = 16  
         else:  
           passes = 4  
           size = 64  
           each = 16  
         for line in range(passes):  
           idx = (ch-font.FIRST)*size+(each*line)  
           buffer = struct.pack(  
             '>128H',  
             color if font.FONT[idx] & _BIT7 else background,  
             color if font.FONT[idx] & _BIT6 else background,  
             color if font.FONT[idx] & _BIT5 else background,  
             color if font.FONT[idx] & _BIT4 else background,  
             color if font.FONT[idx] & _BIT3 else background,  
             color if font.FONT[idx] & _BIT2 else background,  
             color if font.FONT[idx] & _BIT1 else background,  
             color if font.FONT[idx] & _BIT0 else background,  
             color if font.FONT[idx+1] & _BIT7 else background,  
             color if font.FONT[idx+1] & _BIT6 else background,  
             color if font.FONT[idx+1] & _BIT5 else background,  
             color if font.FONT[idx+1] & _BIT4 else background,  
             color if font.FONT[idx+1] & _BIT3 else background,  
             color if font.FONT[idx+1] & _BIT2 else background,  
             color if font.FONT[idx+1] & _BIT1 else background,  
             color if font.FONT[idx+1] & _BIT0 else background,  
             color if font.FONT[idx+2] & _BIT7 else background,  
             color if font.FONT[idx+2] & _BIT6 else background,  
             color if font.FONT[idx+2] & _BIT5 else background,  
             color if font.FONT[idx+2] & _BIT4 else background,  
             color if font.FONT[idx+2] & _BIT3 else background,  
             color if font.FONT[idx+2] & _BIT2 else background,  
             color if font.FONT[idx+2] & _BIT1 else background,  
             color if font.FONT[idx+2] & _BIT0 else background,  
             color if font.FONT[idx+3] & _BIT7 else background,  
             color if font.FONT[idx+3] & _BIT6 else background,  
             color if font.FONT[idx+3] & _BIT5 else background,  
             color if font.FONT[idx+3] & _BIT4 else background,  
             color if font.FONT[idx+3] & _BIT3 else background,  
             color if font.FONT[idx+3] & _BIT2 else background,  
             color if font.FONT[idx+3] & _BIT1 else background,  
             color if font.FONT[idx+3] & _BIT0 else background,  
             color if font.FONT[idx+4] & _BIT7 else background,  
             color if font.FONT[idx+4] & _BIT6 else background,  
             color if font.FONT[idx+4] & _BIT5 else background,  
             color if font.FONT[idx+4] & _BIT4 else background,  
             color if font.FONT[idx+4] & _BIT3 else background,  
             color if font.FONT[idx+4] & _BIT2 else background,  
             color if font.FONT[idx+4] & _BIT1 else background,  
             color if font.FONT[idx+4] & _BIT0 else background,  
             color if font.FONT[idx+5] & _BIT7 else background,  
             color if font.FONT[idx+5] & _BIT6 else background,  
             color if font.FONT[idx+5] & _BIT5 else background,  
             color if font.FONT[idx+5] & _BIT4 else background,  
             color if font.FONT[idx+5] & _BIT3 else background,  
             color if font.FONT[idx+5] & _BIT2 else background,  
             color if font.FONT[idx+5] & _BIT1 else background,  
             color if font.FONT[idx+5] & _BIT0 else background,  
             color if font.FONT[idx+6] & _BIT7 else background,  
             color if font.FONT[idx+6] & _BIT6 else background,  
             color if font.FONT[idx+6] & _BIT5 else background,  
             color if font.FONT[idx+6] & _BIT4 else background,  
             color if font.FONT[idx+6] & _BIT3 else background,  
             color if font.FONT[idx+6] & _BIT2 else background,  
             color if font.FONT[idx+6] & _BIT1 else background,  
             color if font.FONT[idx+6] & _BIT0 else background,  
             color if font.FONT[idx+7] & _BIT7 else background,  
             color if font.FONT[idx+7] & _BIT6 else background,  
             color if font.FONT[idx+7] & _BIT5 else background,  
             color if font.FONT[idx+7] & _BIT4 else background,  
             color if font.FONT[idx+7] & _BIT3 else background,  
             color if font.FONT[idx+7] & _BIT2 else background,  
             color if font.FONT[idx+7] & _BIT1 else background,  
             color if font.FONT[idx+7] & _BIT0 else background,  
             color if font.FONT[idx+8] & _BIT7 else background,  
             color if font.FONT[idx+8] & _BIT6 else background,  
             color if font.FONT[idx+8] & _BIT5 else background,  
             color if font.FONT[idx+8] & _BIT4 else background,  
             color if font.FONT[idx+8] & _BIT3 else background,  
             color if font.FONT[idx+8] & _BIT2 else background,  
             color if font.FONT[idx+8] & _BIT1 else background,  
             color if font.FONT[idx+8] & _BIT0 else background,  
             color if font.FONT[idx+9] & _BIT7 else background,  
             color if font.FONT[idx+9] & _BIT6 else background,  
             color if font.FONT[idx+9] & _BIT5 else background,  
             color if font.FONT[idx+9] & _BIT4 else background,  
             color if font.FONT[idx+9] & _BIT3 else background,  
             color if font.FONT[idx+9] & _BIT2 else background,  
             color if font.FONT[idx+9] & _BIT1 else background,  
             color if font.FONT[idx+9] & _BIT0 else background,  
             color if font.FONT[idx+10] & _BIT7 else background,  
             color if font.FONT[idx+10] & _BIT6 else background,  
             color if font.FONT[idx+10] & _BIT5 else background,  
             color if font.FONT[idx+10] & _BIT4 else background,  
             color if font.FONT[idx+10] & _BIT3 else background,  
             color if font.FONT[idx+10] & _BIT2 else background,  
             color if font.FONT[idx+10] & _BIT1 else background,  
             color if font.FONT[idx+10] & _BIT0 else background,  
             color if font.FONT[idx+11] & _BIT7 else background,  
             color if font.FONT[idx+11] & _BIT6 else background,  
             color if font.FONT[idx+11] & _BIT5 else background,  
             color if font.FONT[idx+11] & _BIT4 else background,  
             color if font.FONT[idx+11] & _BIT3 else background,  
             color if font.FONT[idx+11] & _BIT2 else background,  
             color if font.FONT[idx+11] & _BIT1 else background,  
             color if font.FONT[idx+11] & _BIT0 else background,  
             color if font.FONT[idx+12] & _BIT7 else background,  
             color if font.FONT[idx+12] & _BIT6 else background,  
             color if font.FONT[idx+12] & _BIT5 else background,  
             color if font.FONT[idx+12] & _BIT4 else background,  
             color if font.FONT[idx+12] & _BIT3 else background,  
             color if font.FONT[idx+12] & _BIT2 else background,  
             color if font.FONT[idx+12] & _BIT1 else background,  
             color if font.FONT[idx+12] & _BIT0 else background,  
             color if font.FONT[idx+13] & _BIT7 else background,  
             color if font.FONT[idx+13] & _BIT6 else background,  
             color if font.FONT[idx+13] & _BIT5 else background,  
             color if font.FONT[idx+13] & _BIT4 else background,  
             color if font.FONT[idx+13] & _BIT3 else background,  
             color if font.FONT[idx+13] & _BIT2 else background,  
             color if font.FONT[idx+13] & _BIT1 else background,  
             color if font.FONT[idx+13] & _BIT0 else background,  
             color if font.FONT[idx+14] & _BIT7 else background,  
             color if font.FONT[idx+14] & _BIT6 else background,  
             color if font.FONT[idx+14] & _BIT5 else background,  
             color if font.FONT[idx+14] & _BIT4 else background,  
             color if font.FONT[idx+14] & _BIT3 else background,  
             color if font.FONT[idx+14] & _BIT2 else background,  
             color if font.FONT[idx+14] & _BIT1 else background,  
             color if font.FONT[idx+14] & _BIT0 else background,  
             color if font.FONT[idx+15] & _BIT7 else background,  
             color if font.FONT[idx+15] & _BIT6 else background,  
             color if font.FONT[idx+15] & _BIT5 else background,  
             color if font.FONT[idx+15] & _BIT4 else background,  
             color if font.FONT[idx+15] & _BIT3 else background,  
             color if font.FONT[idx+15] & _BIT2 else background,  
             color if font.FONT[idx+15] & _BIT1 else background,  
             color if font.FONT[idx+15] & _BIT0 else background  
           )  
           self.blit_buffer(buffer, x0, y0+8*line, 16, 8)  
       x0 += font.WIDTH  
   def text(self, font, text, x0, y0, color=WHITE, background=BLACK):  
     """  
     Draw text on display in specified font and colors. 8 and 16 bit wide  
     fonts are supported.  
     Args:  
       font (module): font module to use.  
       text (str): text to write  
       x0 (int): column to start drawing at  
       y0 (int): row to start drawing at  
       color (int): 565 encoded color to use for characters  
       background (int): 565 encoded color to use for background  
     """  
     if font.WIDTH == 8:  
       self._text8(font, text, x0, y0, color, background)  
     else:  
       self._text16(font, text, x0, y0, color, background)  
   def bitmap(self, bitmap, x, y, index=0):  
     """  
     Draw a bitmap on display at the specified column and row  
     Args:  
       bitmap (bitmap_module): The module containing the bitmap to draw  
       x (int): column to start drawing at  
       y (int): row to start drawing at  
       index (int): Optional index of bitmap to draw from multiple bitmap  
         module  
     """  
     bitmap_size = bitmap.HEIGHT * bitmap.WIDTH  
     buffer_len = bitmap_size * 2  
     buffer = bytearray(buffer_len)  
     bs_bit = bitmap.BPP * bitmap_size * index if index > 0 else 0  
     for i in range(0, buffer_len, 2):  
       color_index = 0  
       for bit in range(bitmap.BPP):  
         color_index <<= 1  
         color_index |= (bitmap.BITMAP[bs_bit // 8]  
                 & 1 << (7 - (bs_bit % 8))) > 0  
         bs_bit += 1  
       color = bitmap.PALETTE[color_index]  
       buffer[i] = color & 0xff00 >> 8  
       buffer[i + 1] = color_index & 0xff  
     to_col = x + bitmap.WIDTH - 1  
     to_row = y + bitmap.HEIGHT - 1  
     if self.width > to_col and self.height > to_row:  
       self._set_window(x, y, to_col, to_row)  
       self._write(None, buffer)  
   # @micropython.native  
   def write(self, font, string, x, y, fg=WHITE, bg=BLACK):  
     """  
     Write a string using a converted true-type font on the display starting  
     at the specified column and row  
     Args:  
       font (font): The module containing the converted true-type font  
       s (string): The string to write  
       x (int): column to start writing  
       y (int): row to start writing  
       fg (int): foreground color, optional, defaults to WHITE  
       bg (int): background color, optional, defaults to BLACK  
     """  
     buffer_len = font.HEIGHT * font.MAX_WIDTH * 2  
     buffer = bytearray(buffer_len)  
     fg_hi = (fg & 0xff00) >> 8  
     fg_lo = fg & 0xff  
     bg_hi = (bg & 0xff00) >> 8  
     bg_lo = bg & 0xff  
     for character in string:  
       try:  
         char_index = font.MAP.index(character)  
         offset = char_index * font.OFFSET_WIDTH  
         bs_bit = font.OFFSETS[offset]  
         if font.OFFSET_WIDTH > 1:  
           bs_bit = (bs_bit << 8) + font.OFFSETS[offset + 1]  
         if font.OFFSET_WIDTH > 2:  
           bs_bit = (bs_bit << 8) + font.OFFSETS[offset + 2]  
         char_width = font.WIDTHS[char_index]  
         buffer_needed = char_width * font.HEIGHT * 2  
         for i in range(0, buffer_needed, 2):  
           if font.BITMAPS[bs_bit // 8] & 1 << (7 - (bs_bit % 8)) > 0:  
             buffer[i] = fg_hi  
             buffer[i + 1] = fg_lo  
           else:  
             buffer[i] = bg_hi  
             buffer[i + 1] = bg_lo  
           bs_bit += 1  
         to_col = x + char_width - 1  
         to_row = y + font.HEIGHT - 1  
         if self.width > to_col and self.height > to_row:  
           self._set_window(x, y, to_col, to_row)  
           self._write(None, buffer[0:buffer_needed])  
         x += char_width  
       except ValueError:  
         pass  
   def write_width(self, font, string):  
     """  
     Returns the width in pixels of the string if it was written with the  
     specified font  
     Args:  
       font (font): The module containing the converted true-type font  
       string (string): The string to measure  
     """  
     width = 0  
     for character in string:  
       try:  
         char_index = font.MAP.index(character)  
         width += font.WIDTHS[char_index]  
       except ValueError:  
         pass  
     return width  

After this just change the connection if you want and you are ready to code

Code:

Now open Thonny IDE on your system:

For running the code you’ll need some fonts to be installed. From this page download font you want.

First we import Pin and SPi function from machine module. Along with this we also import st7789 module we have just saved onto our pico.

After this we define spi communication port of pico with some minor setting. These setting seem to be minor but actually they are most important.

If you have visited RPI article on ST7789 display then you may got that there we have used spi.mode=3 which finally makes the diaply work. Here we define the settings of polarity and phase of same spi mode 3. For more information on SPI modes configuration click here. With this we also create a display object for initializing the display. Here we have not used backlight pin as we didn’t use it to swith diaplay on or off.


 spi=SPI(0,62500000,sck=Pin(18),mosi=Pin(19),polarity=1,phase=0)  
 display=st7789.ST7789(spi,240,240,reset=Pin(20),dc=Pin(17),xstart=0,ystart=0,rotation=0)  

Then we clear the display by settying all pixels to 0(zero) or black. We also import fonts which we have used in this code. W also import time for delay functions.

Then for testing purpose I have set differnt colors to display.

for i in range(255):  
   display.fill(st7789.color565(i,0,0))  
 display.fill(0)  
 for i in range(255):  
   display.fill(st7789.color565(0,i,0))  
 display.fill(0)  
 for i in range(255):  
   display.fill(st7789.color565(0,0,i))  
   display.fill(0)

Now in infinite loop and using try exception I have displayed the text ‘HELLO WORD’ on screen. display.text funtion is used with vga2_16x32 or ROM fonts and display.write function is used with ttf fonts like chango_16.

Here is the main code (also available in xip file):

 from machine import Pin,SPI  
 import st7789  
 spi=SPI(0,62500000,sck=Pin(18),mosi=Pin(19),polarity=1,phase=0)  
 display=st7789.ST7789(spi,240,240,reset=Pin(20),dc=Pin(17),xstart=0,ystart=0,rotation=0)  
 display.fill(0)  
 #import vga2_16x32  
 import chango_16  
 from time import sleep  
 '''for i in range(255):  
   display.fill(st7789.color565(i,0,0))  
 display.fill(0)  
 for i in range(255):  
   display.fill(st7789.color565(0,i,0))  
 display.fill(0)  
 for i in range(255):  
   display.fill(st7789.color565(0,0,i))  
 display.fill(0)'''  
 while True:  
   try:  
     display.write(chango_16,"HELLO WORLD",50,50,0xffff,0)  
     #display.text(vga2_16x32,"HELLO WORLD",50,50,0xffff,0)  #display.text/write(font,string,x,y,fg,bg)
     #sleep(0.001)  
     display.fill(0)  
   except KeyboardInterrupt:  
     break  

with this we have completed our tutorial on ST7789 display pi pico. I hope you like it and if you found any problem ask me down below.