Python - OLED 128x64 Bricklet¶

#!/usr/bin/env python
# -*- coding: utf-8 -*-

HOST = "localhost"
PORT = 4223
UID = "XYZ" # Change XYZ to the UID of your OLED 128x64 Bricklet

from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_oled_128x64 import BrickletOLED128x64

if __name__ == "__main__":
    ipcon = IPConnection() # Create IP connection
    oled = BrickletOLED128x64(UID, ipcon) # Create device object

    ipcon.connect(HOST, PORT) # Connect to brickd
    # Don't use device before ipcon is connected

    # Clear display
    oled.clear_display()

    # Write "Hello World" starting from upper left corner of the screen
    oled.write_line(0, 0, "Hello World")

    input("Press key to exit\n") # Use raw_input() in Python 2
    ipcon.disconnect()

#!/usr/bin/env python
# -*- coding: utf-8 -*-

HOST = "localhost"
PORT = 4223
UID = "XYZ" # Change XYZ to the UID of your OLED 128x64 Bricklet
WIDTH = 128 # Columns (each 1 pixel wide)
HEIGHT = 8 # Rows (each 8 pixels high)

from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_oled_128x64 import BrickletOLED128x64

def draw_matrix(oled, start_column, start_row, column_count, row_count, pixels):
    pages = []

    # Convert pixel matrix into 8bit pages
    for row in range(row_count):
        pages.append([])

        for column in range(column_count):
            page = 0

            for bit in range(8):
                if pixels[(row * 8) + bit][column]:
                    page |= 1 << bit

            pages[row].append(page)

    # Merge page matrix into single page array
    data = []

    for row in range(row_count):
        for column in range(column_count):
            data.append(pages[row][column])

    # Set new window
    oled.new_window(start_column, start_column + column_count - 1,
                    start_row, start_row + row_count - 1)

    # Write page data in 64 byte blocks
    for i in range(0, len(data), 64):
        block = data[i:i + 64]
        oled.write(block + [0] * (64 - len(block)))

if __name__ == "__main__":
    ipcon = IPConnection() # Create IP connection
    oled = BrickletOLED128x64(UID, ipcon) # Create device object

    ipcon.connect(HOST, PORT) # Connect to brickd
    # Don't use device before ipcon is connected

    # Clear display
    oled.clear_display()

    # Draw checkerboard pattern
    pixels = []

    for row in range(HEIGHT * 8):
        pixels.append([])

        for column in range(WIDTH):
            pixels[row].append((row // 8) % 2 == (column // 8) % 2)

    draw_matrix(oled, 0, 0, WIDTH, HEIGHT, pixels)

    input("Press key to exit\n") # Use raw_input() in Python 2
    ipcon.disconnect()

#!/usr/bin/env python
# -*- coding: utf-8 -*-

HOST = "localhost"
PORT = 4223
UID = "XYZ" # Change XYZ to the UID of your OLED 128x64 Bricklet
WIDTH = 128 # Columns (each 1 pixel wide)
HEIGHT = 8 # Rows (each 8 pixels high)

import sys
from PIL import Image
from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_oled_128x64 import BrickletOLED128x64

def draw_matrix(oled, start_column, start_row, column_count, row_count, pixels):
    pages = []

    # Convert pixel matrix into 8bit pages
    for row in range(row_count):
        pages.append([])

        for column in range(column_count):
            page = 0

            for bit in range(8):
                if pixels[(row * 8) + bit][column]:
                    page |= 1 << bit

            pages[row].append(page)

    # Merge page matrix into single page array
    data = []

    for row in range(row_count):
        for column in range(column_count):
            data.append(pages[row][column])

    # Set new window
    oled.new_window(start_column, start_column + column_count - 1,
                    start_row, start_row + row_count - 1)

    # Write page data in 64 byte blocks
    for i in range(0, len(data), 64):
        block = data[i:i + 64]
        oled.write(block + [0] * (64 - len(block)))

if __name__ == "__main__":
    ipcon = IPConnection() # Create IP connection
    oled = BrickletOLED128x64(UID, ipcon) # Create device object

    ipcon.connect(HOST, PORT) # Connect to brickd
    # Don't use device before ipcon is connected

    # Clear display
    oled.clear_display()

    # Convert image to black/white pixels
    image = Image.open(sys.argv[1])
    image_data = image.load()
    pixels = []

    for row in range(HEIGHT * 8):
        pixels.append([])

        for column in range(WIDTH):
            if column < image.size[0] and row < image.size[1]:
                pixel = image_data[column, row] > 0
            else:
                pixel = False

            pixels[row].append(pixel)

    draw_matrix(oled, 0, 0, WIDTH, HEIGHT, pixels)

    input("Press key to exit\n") # Use raw_input() in Python 2
    ipcon.disconnect()

#!/usr/bin/env python
# -*- coding: utf-8 -*-

HOST = "localhost"
PORT = 4223
UID = "XYZ" # Change XYZ to the UID of your OLED 128x64 Bricklet
WIDTH = 128 # Columns (each 1 pixel wide)
HEIGHT = 8 # Rows (each 8 pixels high)

import math
import time
from PIL import Image, ImageDraw
from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_oled_128x64 import BrickletOLED128x64

def draw_image(oled, start_column, start_row, column_count, row_count, image):
    image_data = image.load()
    pages = []

    # Convert image pixels into 8bit pages
    for row in range(row_count):
        pages.append([])

        for column in range(column_count):
            page = 0

            for bit in range(8):
                if image_data[column, (row * 8) + bit]:
                    page |= 1 << bit

            pages[row].append(page)

    # Merge page matrix into single page array
    data = []

    for row in range(row_count):
        for column in range(column_count):
            data.append(pages[row][column])

    # Set new window
    oled.new_window(start_column, start_column + column_count - 1,
                    start_row, start_row + row_count - 1)

    # Write page data in 64 byte blocks
    for i in range(0, len(data), 64):
        block = data[i:i + 64]
        oled.write(block + [0] * (64 - len(block)))

if __name__ == "__main__":
    ipcon = IPConnection() # Create IP connection
    oled = BrickletOLED128x64(UID, ipcon) # Create device object

    ipcon.connect(HOST, PORT) # Connect to brickd
    # Don't use device before ipcon is connected

    # Clear display
    oled.clear_display()

    # Draw rotating line
    image = Image.new("1", (WIDTH, HEIGHT * 8), 0)
    draw = ImageDraw.Draw(image)
    origin_x = WIDTH // 2
    origin_y = HEIGHT * 8 // 2
    length = HEIGHT * 8 // 2 - 2
    angle = 0

    print("Press ctrl+c to exit")

    try:
        while True:
            radians = math.pi * angle / 180.0
            x = (int)(origin_x + length * math.cos(radians))
            y = (int)(origin_y + length * math.sin(radians))

            draw.rectangle((0, 0, WIDTH, HEIGHT * 8), 0, 0)
            draw.line((origin_x, origin_y, x, y), 1, 1)

            draw_image(oled, 0, 0, WIDTH, HEIGHT, image)
            time.sleep(0.025)

            angle += 1
    except KeyboardInterrupt:
        pass

    ipcon.disconnect()

#!/usr/bin/env python
# -*- coding: utf-8 -*-

#
# This example uses a Servo Brick, a Rotary Poti Bricklet and
# a OLED 128x64 Bricklet.
#
# The position of the Rotary Poti Bricklet is drawn on the OLED
# display (as text, as a bar graph and as a dial indicator).
# At the same time the servo moves to an angle that is equivalent
# of the position of the Rotary Poti Bricklet.
#

HOST = "localhost"
PORT = 4223
SCREEN_WIDTH = 128
SCREEN_HEIGHT = 64

from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_oled_128x64 import BrickletOLED128x64
from tinkerforge.bricklet_rotary_poti import BrickletRotaryPoti
from tinkerforge.brick_servo import BrickServo

from PIL import Image, ImageDraw, ImageFont

import sys
import math
import time

def draw_matrix(pixels):
    column_index = 0
    column = []

    for i in range(SCREEN_HEIGHT//8 - 1): # We use last 8 pixels for text
        for j in range(SCREEN_WIDTH):
            page = 0
            for k in range(8):
                if pixels[i*8 + k][j] == 1:
                    page |= 1 << k

            if len(column) <= column_index:
                column.append([])

            column[column_index].append(page)
            if len(column[column_index]) == SCREEN_HEIGHT:
                column_index += 1

        oled.new_window(0, SCREEN_WIDTH-1, 0, 6)

    for i in range(len(column)):
        oled.write(column[i])

def line_at_angle(startx, starty, angle, length):
   radian_angle = math.pi * angle / 180.0
   x = startx + length * math.cos(radian_angle)
   y = starty + length * math.sin(radian_angle)
   return (startx, starty, x, y)

if __name__ == "__main__":
    # Create Brick/Bricklet objects
    ipcon = IPConnection()
    oled = BrickletOLED128x64('x5U', ipcon)
    poti = BrickletRotaryPoti('8Co', ipcon)
    servo = BrickServo('6e8MF1', ipcon)

    # Connect to brickd
    ipcon.connect(HOST, PORT)

    # Configure Servo so that it rotates 180°
    servo.set_pulse_width(6, 650, 2350)
    servo.enable(6)

    # Clear display
    oled.clear_display()

    # Draw text once at beginning, the window in draw_matrix does not overwrite
    # the last line of the display
    oled.write_line(7, 5, "tinkerforge.com")

    # We just use an endless loop here, press ctrl + c to abort the script
    while True:
        # With position 110 poti is at 90°
        angle = poti.get_position()*90//110
        if angle > 90:
            angle = 90
        elif angle < -90:
            angle = -90

        # Set servo position according to angle
        servo.set_position(6, angle*100)

        # Create angle text
        angle_str = str(angle) + u'°'
        if angle >= 0:
            angle_str = ' ' + angle_str

        # Draw servo position line
        img = Image.new('1', (128, 64), 0)
        draw = ImageDraw.Draw(img)
        draw.line(line_at_angle(32, 32, angle - 90, 32), 1, 6)

        # Draw bar graph
        draw.line((90, 4, 90 + angle*30//90, 4), 1, 6)

        # Draw angle text
        font = ImageFont.truetype("./share/fonts/truetype/dejavu/DejaVuSans.ttf", 25)
        draw.text((70, 22), angle_str, font=font, fill=1)

        # Move data from PIL image into matrix of bools
        data = img.load()
        pixel_matrix = [[False]*SCREEN_WIDTH for i in range(SCREEN_HEIGHT)]
        for x in range(SCREEN_WIDTH):
            for y in range(SCREEN_HEIGHT):
                pixel_matrix[y][x] = data[x, y] == 1

        # Draw everything to display
        draw_matrix(pixel_matrix)

        # Framerate of ~40 FPS
        time.sleep(0.04)

    ipcon.disconnect()