Comments

• Unsoundcode Posts: 1,532

  2022-06-01 18:00

  2 Methods

  With everything we do with the microbit conserving program and storage space should be at the back of our mind, initialization of the module and its associated methods is a necessity any other modules are more likely to be program dependent.

  The following is a list of methods I have been using in the TFT module, the list is not set in stone they are just the functions I have found most useful for me.

  init_lcd(spi):
  Initializes the LCD takes spi as argument

  clear():
  Clears the whole display and takes a 16 bit color value as an argument, if no argument is passed the color defaults to white.

  set_backlight():
  Sets the lcd backlight level and takes an int value from 0 – 1024, if no value is passed the value defaults to 1000.

  set_window(Xstart, Ystart, Xend, Yend):
  Defines a window (rectangle) as a drawing area.

  set_color(color, width, height)
  Fills a rectangle defined by "set_window()" with color, width and height are the dimensions of the window.

  draw_pixel(x, y, color):
  Draws a pixel at coordinates x y with the defined color.

  draw_point(Xpoint, Ypoint, color, Dot_Pixel):
  Draws a group of 1 to 4 pixels at x y with the defined color and the group number defined by Dot_Pixel

  draw_hline(x_0, y_0, length, color):
  Draws a horizontal line starting at x_0 y_0, the length is defined by length and color is defined by color. The line should be drawn left to right.

  draw_vline(x_0, y_0, length, color):
  Draws a verticall line starting at x_0 y_0, the length is defined by length and color is defined by color. The line should be drawn top to bottom.

  draw_char(x_0, y_0, char_id=0):
  Draws a font character at point x_0 y_0, the char_id references the characters position in ram.
• Unsoundcode Posts: 1,532

  2022-06-01 18:05 edited 2022-06-01 18:06

  3 Images and Utility

  With the information we have so far we can initialize our LCD and draw some graphics maybe even create a few stick fonts. Images take things to another level and over the next two posts I would like to show how we can display our own images. First we need somewhere to store the images so using the Waveshare microbit device I will use the onboard SRAM.

  This will involve extracting the image data from an image file and saving this data to a new file. Then we can use our micropython editor to read and write this new data file to the SRAM memory.

  There a a couple of things to consider before we create this new file. First lets keep the file size below 15 Kbytes so that we dont run into out of memory issues with the microbit. The number of bytes our file will be is proportional to the number of pixels our image has. Here are two examples, the first image is 160 pixels wide and 45 pixels high, 160 x 45 = 7200, there are two color bytes for each pixel so the final file size for image 1 is 14400 bytes which is within the 15 K range, the second image is a full screen 160 x 128 which equals 20,480 pixels so that is 40960 bytes, way over limit. There are ways to get around this but for now lets keep within the 15 K range.

  The microbit micropython editor won't be able create the new image data file so you will need to run the following code on a computer that has the full version of Python.

  Usage is straight forward, I try to stick with source files that have the .png extension and I usually name the destination file with the .bin extension.
  The following code is very basic so keep source and destination files in the same folder as the utility, there is no need to type in the full path. The libraries used in the app are very common modules and most come packaged with Python.

  Utility

  from tkinter import *
  from tkinter import ttk
  from tkinter import messagebox
  from PIL import Image
  import numpy as np
  
  root=Tk()
  
  screen_width= root.winfo_screenwidth()
  screen_height= root.winfo_screenheight()
  
  root_width=270
  root_height=150
  
  x_location=(screen_width/2) - (root_width/2)
  y_location=(screen_height/2) - (root_height/2)
  
  root.geometry(f"{root_width}x{root_height}+{int(x_location)}+{int(y_location)}")
  
  root.title("Data from Image")
  root.resizable(False,False)
  
  var_list=[]
  source_var = StringVar()
  destination_var = StringVar()
  
  def get_params():
      source_var=source_entry.get()
      destination_var=destination_entry.get()
  
      var_list.append(source_var)
      var_list.append(destination_var)
  
      create_img_data(var_list)
  
  def rgb_hex565(red, green, blue):
     return "0x%0.4X" % ((int(red / 255 * 31) << 11) | (int(green / 255 * 63) << 5) | (int(blue / 255 * 31)))
  
  def create_img_data(var_list):
      var_list=var_list
      src_file=var_list[0]
      destination=var_list[1]
  
      if src_file=="" or destination =="":
          img_msg()
          return
  
      try:
          bin_img = Image.open(src_file)
      except:
          bad_file_msg()
          return
  
      img_map = np.array(bin_img)
  
      f = open(destination, 'wb')
  
      for y in range(bin_img.height):
          for x in range(bin_img.width):
              pix_color=img_map[y][x]
              value = pix_color[0]
              value2=pix_color[1]
              value3=pix_color[2]
              newcolor=rgb_hex565(value,value2,value3)
              bin1=int(newcolor,base=16)>>8 & 0xFF
              bin2=int(newcolor,base=16) & 0xFF
  
              f.write(bin1.to_bytes(1,"big"))
  
              f.write(bin2.to_bytes(1,"big"))
  
      f.close()
      messagebox.showinfo("Info", "File Operation Completed")
      close_app()
  
  def img_msg():
      messagebox.showerror("Error", "Source and Destination must contain a valid filename")
  
  def bad_file_msg():
      messagebox.showerror("Error", "Source not found")
  
  def close_app():
      root.destroy()
  
  def on_closing():
  
      if messagebox.askokcancel("Quit", "Are you sure you want to exit?"):
  
         close_app()
  
  root.protocol("WM_DELETE_WINDOW", on_closing)
  
  btn_CreateFile=Button(root,text="Create File",width=10,command=lambda:get_params())
  btn_CreateFile.grid(row=4,column=1,pady=15,sticky='w')
  
  btn_Exit=Button(root,text="Exit",width=10,command=lambda:on_closing())
  btn_Exit.grid(row=5,column=1,sticky='w')
  
  source_entry=Entry(root)
  source_entry.grid(row=0,column=1)
  
  destination_entry=Entry(root)
  destination_entry.grid(row=1,column=1)
  
  lbl_source=Label(root,text="Source File",pady=10,padx=20)
  lbl_source.grid(row=0,column=0)
  
  lbl_destination=Label(root,text="Destination")
  lbl_destination.grid(row=1,column=0)
  
  root.mainloop()
  
  
• Unsoundcode Posts: 1,532

  2022-06-01 18:10

  Loader

  Hopefully you now have a binary file containing the data for your image. I am posting here the micropython code we need to write the image data file to SRAM, I will refer to this code as the "Loader", also I am posting a small micropython code to test the success of loading the image to SRAM.

  As long as we maintain power to the microbit and don't over write the image data we can switch between program sketches and access our image at any time.

  I will describe the actions in a step by step fashion and hopefully it will be easy to understand.

  step #1 Remove all files from the microbit file system

  step #2 Copy the image file (mine is called logo.bin and is 14400 bytes) onto the microbit file system.

  step #3 Close the file system and copy the "Loader" code into the micropython code editor.

  step #4 At the very top of "Loader" are three fields we must fill in, FILENAME , START_ADDRESS and END_ADDRESS. For now this info has already been filled in but its important to note that END_ADDRESS = START_ADDRESS + the file length which in my case is 50000 + 14400 = 64400

  step #5 Flash "Loader" to the microbit

  step #6 Open REPL then press the microbit reset button, the program will start to run. REPL lets you see when the program has finished.

  step #7 It takes a minute but eventually you willl see the text "*********** Write Finished ***********"

  step #8 Close REPL and open the microbit file system

  step #9 Remove the image file and replace it with the TFT class module

  step #10 Flash the test program to the microbit and hopefully your image will load

  Loader

  # Loader.py .... writes files to sram
  
  from microbit import *
  import machine
  
  # *********************************************************************************************
  FILENAME = "logo.bin"
  START_ADDRESS = 50000
  # The end address will be the sum of the start address + the number of bytes to write
  END_ADDRESS = 64400
  # *********************************************************************************************
  
  spi.init(baudrate=10000000, bits=8, mode=0, sclk=pin13, mosi=pin15, miso=pin14)
  # SRAM opcodes
  SRAM_CMD_WRMR = const(0x01)  # write mode register
  SRAM_CMD_WRITE = const(0x02)
  SRAM_CMD_READ = const(0x03)
  
  # SRAM modes
  SRAM_BYTE_MODE = const(0x00)
  SRAM_SEQUENTIAL_MODE = const(0x40)
  SRAM_PAGE_MODE = const(0x80)
  
  def ram_write(addr, buff):
      address = bytearray(3)
      address = addr.to_bytes(3, "big")
      pin2.write_digital(0)  # CS fram
      spi.write(bytearray([SRAM_CMD_WRITE]))
      spi.write(bytearray([address[0]]))
      spi.write(bytearray([address[1]]))
      spi.write(bytearray([address[2]]))
      spi.write(bytearray([buff]))
      pin2.write_digital(1)  # remove fram CS
  
  def ram_set_mode(mode):
      pin2.write_digital(0)  # CS fram
      spi.write(bytearray([SRAM_CMD_WRMR]))
      spi.write(bytearray([mode]))
      pin2.write_digital(1)  # remove fram CS
  
  ram_set_mode(SRAM_SEQUENTIAL_MODE)
  
  with open(FILENAME, mode='rb') as file:
      for idx in range(START_ADDRESS, END_ADDRESS):
          data = file.read(1)
          int_val = int.from_bytes(data, "big")
          ram_write(idx, int_val)
  
  print('\r')
  print("***********  Write Finished  ***********")
  print('\r')
  
  

  Test

  from microbit import *
  from TFT import LCD
  
  spi.init(baudrate=10000000, bits=8, mode=0, sclk=pin13, mosi=pin15, miso=pin14)
  
  lcd=LCD(spi)
  
  
  WHITE = 0xFFFF
  BLACK = 0x0000
  BLUE = 0x001F
  RED = 0xF800
  MAGENTA = 0xF81F
  GREEN = 0x07E0
  CYAN = 0x07FF
  YELLOW = 0xFFE0
  
  lcd.set_backlight(1000)
  lcd.clear(BLUE)
  
  lcd.set_window(0, 0, 160, 45) # create a window the same size and position as the image
  buffer = lcd.ram_read(50000, 14400) # read the image data from ram into buffer
  lcd.lcd_fast_write(buffer) # sequentially write image data to window
  buffer=None # free buffer space