def main(i2c): # Initialize LED matrix. matrix = ht16k33_matrix.Matrix16x8(i2c) # Initialize font renderer using a helper function to flip the Y axis # when rendering so the origin is in the upper left. def matrix_pixel(x, y): matrix.pixel(x, DISPLAY_HEIGHT - 1 - y, 1) with bitmapfont.BitmapFont(DISPLAY_WIDTH, DISPLAY_HEIGHT, matrix_pixel) as bf: # Global state: pos = DISPLAY_WIDTH # X position of the message start. message_width = bf.width(MESSAGE) # Message width in pixels. last = utime.ticks_ms() # Last frame millisecond tick time. speed_ms = SPEED / 1000.0 # Scroll speed in pixels/ms. # Main loop: while True: # Compute the time delta in milliseconds since the last frame. current = utime.ticks_ms() delta_ms = utime.ticks_diff(current, last) last = current # Compute position using speed and time delta. pos -= speed_ms * delta_ms if pos < -message_width: pos = DISPLAY_WIDTH # Clear the matrix and draw the text at the current position. matrix.fill(0) bf.text(MESSAGE, int(pos), 0) # Update the matrix LEDs. matrix.show() # Sleep a bit to give USB mass storage some processing time (quirk # of SAMD21 firmware right now). utime.sleep_ms(20)
def main(i2c): # Initialize Charlieplex matrix wing. matrix = is31fl3731.CharlieWing(i2c) matrix.fill(0) # Initialize font renderer. with bitmapfont.BitmapFont(DISPLAY_WIDTH, DISPLAY_HEIGHT, matrix.pixel) as bf: # Global state: pos = DISPLAY_WIDTH # X position of the message start. message_width = bf.width(MESSAGE) # Message width in pixels. frame = 0 # Currently displayed frame. last = utime.ticks_ms() # Last frame millisecond tick time. speed_ms = SPEED / 1000.0 # Scroll speed in pixels/ms. while True: # Compute the time delta in milliseconds since the last frame. current = utime.ticks_ms() delta_ms = utime.ticks_diff(current, last) last = current # Compute position using speed and time delta. pos -= speed_ms * delta_ms if pos < -message_width: pos = DISPLAY_WIDTH # Swap frames to start drawing on a non-visible frame (double buffering). frame = (frame + 1) % 2 matrix.frame(frame, show=False) # Clear the frame and draw the text at the current position. matrix.fill(0) bf.text(MESSAGE, int(pos), 0, INTENSITY) # Swap to the new frame on the display. matrix.frame(frame) # Sleep a bit to give USB mass storage some processing time (quirk # of SAMD21 firmware right now). utime.sleep_ms(20)
def main(): # Initialize LED matrix. matrix = neopixel.NeoPixel(machine.Pin(DIN_PIN, machine.Pin.OUT), DISPLAY_WIDTH * DISPLAY_HEIGHT) # Initialize font renderer using a helper function to # calculate the index in the neopixel-array def matrix_pixel(x, y, color): #matrix[y * DISPLAY_WIDTH + x] = color matrix[y * DISPLAY_HEIGHT + x] = color with bitmapfont.BitmapFont(DISPLAY_HEIGHT, DISPLAY_WIDTH, matrix_pixel) as bf: bf.init() # Global state: pos = DISPLAY_WIDTH # X position of the message start. message_width = bf.width(MESSAGE) # Message width in pixels. last = utime.ticks_ms() # Last frame millisecond tick time. speed_ms = SPEED / 1000.0 # Scroll speed in pixels/ms. # Main loop: while True: # Compute the time delta in milliseconds since the last frame. current = utime.ticks_ms() delta_ms = utime.ticks_diff(current, last) last = current # Compute position using speed and time delta. pos -= speed_ms * delta_ms if pos < -message_width: pos = DISPLAY_WIDTH # Clear the matrix and draw the text at the current position. matrix.fill((0, 0, 0)) bf.text(MESSAGE, int(pos), 0, (MAX_BRIGHT, 0, MAX_BRIGHT)) # added color # Update the matrix LEDs. matrix.write() # Sleep a bit to give USB mass storage some processing time (quirk # of SAMD21 firmware right now). utime.sleep_ms(20)
def main(): # Initialize NeoPixel 8*8 matrix. matrix = neopixel.NeoPixel(machine.Pin(13, machine.Pin.OUT), 64) matrix.fill((0, 0, 0)) # PePo changed matrix.write() # define the pixel function, which has to convert a 2-dimensional # X, Y location into a 1-dimensional location in the NeoPixel array... def matrix_pixel(x, y, color): matrix[y * DISPLAY_HEIGHT + x - 1] = color with bitmapfont.BitmapFont(DISPLAY_WIDTH, DISPLAY_HEIGHT, matrix_pixel) as bf: # Global state: pos = DISPLAY_WIDTH # X position of the message start. message_width = bf.width(MESSAGE) # Message width in pixels. #print('MESSAGE is {} pixels wide.'.format(message_width)) #PePo added - debugging last = utime.ticks_ms() # Last frame millisecond tick time. speed_ms = SPEED / 1000.0 # Scroll speed in pixels/ms. WAS: 1000 # Main loop: while True: # Compute the time delta in milliseconds since the last frame. current = utime.ticks_ms() delta_ms = utime.ticks_diff(current, last) last = current # Compute position using speed and time delta. pos -= speed_ms * delta_ms if pos < -message_width: pos = DISPLAY_WIDTH # Clear the matrix and draw the text at the current position. matrix.fill((0, 0, 0)) # PePo changed utime.sleep_ms(20) #PePo added - not much improvement bf.text(MESSAGE, int(pos), 0, (INTENSITY, 0, 0)) #PePo changed: added color # Update the matrix. matrix.write() #PePo changed was: matrix.show() # Sleep a bit to give USB mass storage some processing time (quirk # of SAMD21 firmware right now). utime.sleep_ms(20)
import board import busio from adafruit_ht16k33 import matrix import bitmapfont import time i2c = busio.I2C(board.SCL, board.SDA) mx = matrix.Matrix8x8(i2c, auto_write=False) bf = bitmapfont.BitmapFont(8, 8, mx.pixel) mx.fill(0) mx.show() bf.init() while True: for i in range(15, -30, -1): mx.fill(0) bf.text('IKEA', i, 0, 100) mx.show() time.sleep(0.025)
def draw_in_Matrix(x, y, matrix, color=(255, 0, 0)): matrix[y][x] = color return matrix # ++++ Debug stuff and test display +++++++++++++++++++++++++++++++++++++++ def display_image(image): plt.imshow(image) plt.show() #alternativ einfach .show von pil benutzen # ==== Main code ========================================================== resolutuion = 16 im = pil.Image.open('img/fox.jpg') nim = to_pix(im, resolutuion) #displayImage(nim) matrix = new_canvas(resolutuion) with bitmapfont.BitmapFont(resolutuion, resolutuion, draw_in_Matrix) as bf: bf.text('hallo Welt', 2, 0, matrix, (94, 94, 2)) #drawLine(matrix, (8,8), (8, 13), (255, 50, 87) ) #drawCircle(matrix, (8,8), 6, (32, 64, 128)) display_image(matrix) # ============= exit(0)
# OLED helper: blank oled screen def eraseOled(): oled.fill(0) oled.show() # OLED helper: specify display_pixel function including oled.show() def display_pixel(x, y, color): oled.pixel(x, y, color) oled.show() # generate bitmap font from font5x8.bin import bitmapfont # 128 and 64 are the OLED dimensions! bf = bitmapfont.BitmapFont(_DISPLAY_WIDTH, _DISPLAY_HEIGHT, display_pixel) bf.init() # distance value dist = 0 # main program: # 1. measure distance # 2. show on OLED # 3. dump on serial to other systems def run(): while True: eraseOled() # Get reading from sensor #PePo TODO: dist = hc.distance_in_cm()
def __setitem__(self, coords, color): self.pixel(coords[0], coords[1], color) def text(self, str, x, y, color): if self.type == 'i2c': font.text(str, x, y, color) elif self.type == 'spi': _matrix.text(str, x, y, color) try: i2c = busio.I2C(board.SCL, board.SDA) from adafruit_ht16k33.matrix import Matrix8x8 import bitmapfont _matrix = Matrix8x8(i2c, auto_write=False) font = bitmapfont.BitmapFont(8, 8, _matrix.pixel) font.init() type = 'i2c' except: from adafruit_max7219.matrices import Matrix8x8 cs = digitalio.DigitalInOut(board.D2) spi = busio.SPI( board.SCK, MOSI=board.MOSI, ) _matrix = Matrix8x8(spi, cs) _matrix.brightness(9) type = 'spi' matrix = Matrix(type) joystick = Joystick(board)
# 2016-1219 draw text on neopixel matrix # https://learn.adafruit.com/micropython-displays-drawing-text/software import neopixel import machine matrix = neopixel.NeoPixel(machine.Pin(13, machine.Pin.OUT), 64) # define the pixel function, which has to convert a 2-dimensional # X, Y location into a 1-dimensional location in the NeoPixel array... def matrix_pixel(x, y, color): matrix[y * 8 + x] = color # Finally create the font class and pass it the pixel function created above... import bitmapfont bf = bitmapfont.BitmapFont(8, 8, matrix_pixel) bf.init() # Then draw some text! # tuple-color is passed to the pixel function bf.text('A', 0, 0, (64, 0, 64)) # Peter: I must write the text-buffer to the neopixel matrix! matrix.write() width = bf.width('A') print('A is {} pixels wide.'.format(width))
from adafruit_rgb_display import ili9341, color565 import bitmapfont spi = busio.SPI(clock=board.SCK, MOSI=board.MOSI, MISO=board.MISO) # For the Metro cs = digitalio.DigitalInOut(board.D10) dc = digitalio.DigitalInOut(board.D9) display = ili9341.ILI9341(spi, cs=cs, dc=dc, width=320, height=240) display.write(0x36, b'\x3E') bf = bitmapfont.BitmapFont(320, 240, display.pixel) # (240, 320, display.pixel) bf.init() led = simpleio.DigitalOut(board.D13) GoButton = DigitalInOut(board.D4) # pin 4 gets 3.3v to start the party. GoButton.direction = Direction.INPUT GoButton.pull = Pull.UP def Rounder(IntInput, MaxNum): if (IntInput > MaxNum): # print("number over " + (str(MaxNum)) + "! Lowered " + (str(IntInput))) IntInput /= 2 IntInput = int(round(IntInput)) # print(" to:" + (str(IntInput))) # print("") return(IntInput)
from micropython import const import machine import myssd1306 as ssd1306 #includes draw_bitmap #import ssd1306 #excludes draw_bitmap # OLED dimensions _DISPLAY_WIDTH = const(128) # Width of display in pixels. _DISPLAY_HEIGHT = const(64) # LoLin-ESP32-OLED height of display. # generate OLED object i2c = machine.I2C(scl=machine.Pin(4), sda=machine.Pin(5)) #test: i2c.scan() oled = ssd1306.SSD1306_I2C(128, 64, i2c) # helper: specify display_pixel function including oled.show() def display_pixel(x, y, color): oled.pixel(x, y, color) oled.show() # generate bitmap font from font5x8.bin import bitmapfont # 128 and 64 are the OLED dimensions! bf = bitmapfont.BitmapFont(128, 64, display_pixel) bf.init() # text on screen with font5*8 bf.text('Dat is een hele kluif!!', 0, 30, 1)
# for console output if debug: print('\nTemperature: {} degrees C'.format(sensor.temperature)) print('Pressure: {}hPa'.format(sensor.pressure)) print('Altitude: {} meters'.format(sensor.altitude)) gc.collect() ### OLED bounds - bottom left/right, top left/right oled.pixel(0, 31, 100) oled.pixel(127, 31, 100) oled.pixel(0, 0, 100) oled.pixel(127, 0, 100) gc.collect() # free mem print("\nfree mem:", gc.mem_free()) bf = bitmapfont.BitmapFont(128, 32, oled.pixel) bf.init() def welcome(): oled.fill(0) bf.text(" - MicroVario - ", 0, 0, 100) bf.text("version 0.1", 0, 12, 100) bf.text("bmosley - 2018", 0, 22, 100) oled.show() # Startup tune buzzer.duty_cycle = DUTY_ON for i in range(len(TONE_FREQ)): buzzer.frequency = TONE_FREQ[i] time.sleep(.1)