Ejemplo n.º 1
0
"""
noto_fonts Writes the names of three Noto fonts centered on the display
    using the font. The fonts were converted from True Type fonts using
    the font2bitmap utility.
"""

import st7789
import tft_config
import NotoSans_32 as noto_sans
import NotoSerif_32 as noto_serif
import NotoSansMono_32 as noto_mono

tft = tft_config.config(1, buffer_size=16 * 32 * 2)


def center(font, s, row, color=st7789.WHITE):
    screen = tft.width()  # get screen width
    width = tft.write_len(font, s)  # get the width of the string
    if width and width < screen:  # if the string < display
        col = tft.width() // 2 - width // 2  # find the column to center
    else:  # otherwise
        col = 0  # left justify

    tft.write(font, s, col, row, color)  # and write the string


def main():
    # init display
    tft.init()
    tft.fill(st7789.BLACK)
Ejemplo n.º 2
0
fonts.py

    Cycles through all characters of four bitmap fonts on the display

"""

import utime
import st7789
import tft_config
import vga1_8x8 as font1
import vga1_8x16 as font2
import vga1_bold_16x16 as font3
import vga1_bold_16x32 as font4


tft = tft_config.config(0)


def main():
    tft.init()

    while True:
        for font in (font1, font2, font3, font4):
            tft.fill(st7789.BLUE)
            line = 0
            col = 0
            for char in range(font.FIRST, font.LAST):
                tft.text(font, chr(char), col, line, st7789.WHITE, st7789.BLUE)
                col += font.WIDTH
                if col > tft.width() - font.WIDTH:
                    col = 0
Ejemplo n.º 3
0
"""
chango.py proportional font test for font2bitmap converter.
"""

import time
import gc
import st7789
import tft_config

tft = tft_config.config(1)

#
# Large fonts take alot of memory, they should be frozen in the
# firmaware or compiled using the mpy-cross compiler.
#

import chango_16 as font_16
import chango_32 as font_32
import chango_64 as font_64

gc.collect()

def display_font(font):

    tft.fill(st7789.BLUE)                       # clear the screen
    column = 0                                  # first column
    row = 0                                     # first row

    for char in font.MAP:                       # for each character in the font map
        width = tft.write_len(font, char)       # get the width of the character
Ejemplo n.º 4
0
def main():
    '''
    The big show!
    '''

    tft = tft_config.config(1)  # configure driver to rotate screen 90 degrees
    tft.init()                  # initialize display

    height = tft.height()       # height of display in pixels
    width = tft.width()         # width if display in pixels

    tfa = tft_config.TFA	    # top free area when scrolling
    bfa = tft_config.BFA	    # bottom free area when scrolling

    scroll = 0                  # scroll position
    wheel = 0                   # color wheel position

    tft.vscrdef(tfa, width, bfa)    # set scroll area
    tft.vscsad(scroll + tfa)        # set scroll position
    tft.fill(st7789.BLACK)          # clear screen

    half = (height >> 1) - 1    # half the height of the dislay
    interval = 0                # steps between new points
    increment = 0               # increment per step
    counter = 1                 # step counter, overflow to start
    current_y = 0               # current_y value (right point)
    last_y = 0                  # last_y value (left point)

    # segment offsets
    x_offsets = [x * (width // 8) -1 for x in range(2,9)]

    while True:
        # when the counter exceeds the interval, save current_y to last_y,
        # choose a new random value for current_y between 0 and 1/2 the
        # height of the display, choose a new random interval then reset
        # the counter to 0

        if counter > interval:
            last_y = current_y
            current_y = random.randint(0, half)
            counter = 0
            interval = random.randint(10, 100)
            increment = 1 / interval

        # clear the first column of the display and scroll it
        tft.vline(scroll, 0, height, st7789.BLACK)
        tft.vscsad(scroll + tfa)

        # get the next point between last_y and current_y
        tween = int(between(last_y, current_y, counter * increment))

        # draw mirrored pixels across the display at the offsets using the color_wheel effect
        for i, x_offset in enumerate(x_offsets):
            tft.pixel((scroll + x_offset) % width, half + tween, color_wheel(wheel+(i<<2)))
            tft.pixel((scroll + x_offset) % width, half - tween, color_wheel(wheel+(i<<2)))

        # increment scroll, counter, and wheel
        scroll = (scroll + 1) % width
        wheel = (wheel + 1) % 256
        counter += 1

        # pause to slow down scrolling
        utime.sleep(0.005)
Ejemplo n.º 5
0
def main():
    class Toast():
        '''
        Toast class to keep track of toaster and toast sprites
        '''
        def __init__(self, sprites, bitmaps, frames):
            '''create new sprite in random location that does not overlap other sprites'''
            self.num = len(sprites)
            self.bitmaps = bitmaps
            self.frames = frames
            self.steps = len(frames)
            self.col, self.row = random_start(tft, sprites, bitmaps, self.num)
            self.width = bitmaps.WIDTH
            self.height = bitmaps.HEIGHT
            self.last_col = self.col
            self.last_row = self.row
            self.step = random.randint(0, self.steps)
            self.dir_col = -random.randint(2, 5)
            self.dir_row = 2
            self.prev_dir_col = self.dir_col
            self.prev_dir_row = self.dir_row
            self.iceberg = 0

        def clear(self):
            '''clear above and behind sprite'''
            tft.fill_rect(self.col, self.row - 1, self.width, self.dir_row + 1,
                          st7789.BLACK)

            tft.fill_rect(self.col + self.width + self.dir_col, self.row,
                          -self.dir_col, self.height, st7789.BLACK)

        def erase(self):
            '''erase last postion of sprite'''
            tft.fill_rect(self.last_col, self.last_row, self.width,
                          self.height, st7789.BLACK)

        def move(self, sprites):
            '''step frame and move sprite'''

            if self.steps:
                self.step = (self.step + 1) % self.steps

            self.last_col = self.col
            self.last_row = self.row
            new_col = self.col + self.dir_col
            new_row = self.row + self.dir_row

            # if new location collides with another sprite, change direction for 32 frames

            for sprite in sprites:
                if (self.num != sprite.num and collide(
                        new_col,
                        new_row,
                        self.width,
                        self.height,
                        sprite.col,
                        sprite.row,
                        sprite.width,
                        sprite.height,
                ) and (self.col > sprite.col)):

                    self.iceberg = 32
                    self.dir_col = -1
                    self.dir_row = 3
                    new_col = self.col + self.dir_col
                    new_row = self.row + self.dir_row

            self.col = new_col
            self.row = new_row

            # if new location touches edge of screen, erase then set new start location
            if self.col <= 0 or self.row > tft.height() - self.height:
                self.erase()
                self.dir_col = -random.randint(2, 5)
                self.dir_row = 2
                self.col, self.row = random_start(tft, sprites, self.bitmaps,
                                                  self.num)

            # Track post collision direction change
            if self.iceberg:
                self.iceberg -= 1
                if self.iceberg == 1:
                    self.dir_col = self.prev_dir_col
                    self.dir_row = self.prev_dir_row

        def draw(self):
            '''if the location is not 0,0 draw current frame of sprite at it's location'''
            if self.col and self.row:
                tft.bitmap(self.bitmaps, self.col, self.row,
                           self.frames[self.step])

    tft = tft_config.config(1, buffer_size=64 * 62 *
                            2)  # configure display driver

    # init and clear screen
    tft.init()
    tft.fill(st7789.BLACK)

    # create toast spites and set animation frames
    sprites = []
    sprites.append(Toast(sprites, toast_bitmaps, TOAST_FRAMES))
    sprites.append(Toast(sprites, toast_bitmaps, TOASTER_FRAMES))
    sprites.append(Toast(sprites, toast_bitmaps, TOASTER_FRAMES))

    # move and draw sprites

    while True:
        for sprite in sprites:
            sprite.clear()
            sprite.move(sprites)
            sprite.draw()

        gc.collect()
        time.sleep(0.05)
Ejemplo n.º 6
0
"""
roids.py - Asteroids style game demo using polygons.
"""

import math
import random
import utime
import micropython
import st7789
import tft_config
import tft_buttons as Buttons

tft = tft_config.config(1, buffer_size=64 * 64 * 2)
buttons = Buttons.Buttons()


def main():
    '''
    Game on!
    '''
    class Poly():
        '''
        Poly class to keep track of a polygon based sprite
        '''
        def __init__(
                self,
                # list (x,y) tuples of convex polygon, must be closed
                polygon,
                x=None,  # x location of polygon
                y=None,  # y location of polygon
                v_x=None,  # velocity in x axis