argoneonoled.py

#!/usr/bin/python3


import sys
import datetime
import math

import os
import time

# Initialize I2C Bus
import smbus
import RPi.GPIO as GPIO

rev = GPIO.RPI_REVISION
if rev == 2 or rev == 3:
    bus=smbus.SMBus(1)
else:
    bus=smbus.SMBus(0)


OLED_WD=128
OLED_HT=64
OLED_SLAVEADDRESS=0x6a
ADDR_OLED=0x3c

OLED_NUMFONTCHAR=256

OLED_BUFFERIZE = ((OLED_WD*OLED_HT)>>3)
oled_imagebuffer = [0] * OLED_BUFFERIZE


def oled_getmaxY():
    return OLED_HT

def oled_getmaxX():
    return OLED_WD

def oled_loadbg(bgname):
    if bgname == "bgblack":
        oled_clearbuffer()
        return
    elif bgname == "bgwhite":
        oled_clearbuffer(1)
        return
    try:
        file = open("/etc/argon/oled/"+bgname+".bin", "rb")
        bgbytes = list(file.read())
        file.close()
        ctr = len(bgbytes)
        if ctr == OLED_BUFFERIZE:
            oled_imagebuffer[:] = bgbytes
        elif ctr > OLED_BUFFERIZE:
            oled_imagebuffer[:] = bgbytes[0:OLED_BUFFERIZE]
        else:
            oled_imagebuffer[0:ctr] = bgbytes
            # Clear the rest of the buffer
            while ctr < OLED_BUFFERIZE:
                oled_imagebuffer[ctr] = 0
                ctr=ctr+1
    except FileNotFoundError:
        oled_clearbuffer()


def oled_clearbuffer(value = 0):
    if value != 0:
        value = 0xff
    ctr = 0
    while ctr < OLED_BUFFERIZE:
        oled_imagebuffer[ctr] = value
        ctr=ctr+1

def oled_writebyterow(x,y,bytevalue, mode = 0):
    bufferoffset = OLED_WD*(y>>3) + x
    if mode == 0:
        oled_imagebuffer[bufferoffset] = bytevalue
    elif mode == 1:
        oled_imagebuffer[bufferoffset] = bytevalue^oled_imagebuffer[bufferoffset]
    else:
        oled_imagebuffer[bufferoffset] = bytevalue|oled_imagebuffer[bufferoffset]


def oled_writebuffer(x,y,value, mode = 0):

    yoffset = y>>3
    yshift = y&0x7
    ybit = (1<<yshift)

    ymask = 0xFF^ybit

    if value != 0:
        value = ybit

    bufferoffset = OLED_WD*yoffset + x

    curval = oled_imagebuffer[bufferoffset]
    if mode & 1:
        oled_imagebuffer[bufferoffset] = curval^value
    else:
        oled_imagebuffer[bufferoffset] = curval&ymask|value


def oled_fill(value):
    oled_clearbuffer(value)
    oled_flushimage()

def oled_flushimage(hidescreen = True):
    if hidescreen == True:
        # Reset/Hide screen
        oled_power(False)

    xctr = 0
    while xctr < OLED_WD:
        yctr = 0
        while yctr < OLED_HT:
            oled_flushblock(xctr, yctr)
            yctr = yctr + 8
        xctr = xctr + 32

    if hidescreen == True:
        # Display
        oled_power(True)


def oled_flushblock(xoffset, yoffset):
    yoffset = yoffset>>3
    blocksize = 32
    try:
        # Set COM-H Addressing
        bus.write_byte_data(ADDR_OLED, 0, 0x20)
        bus.write_byte_data(ADDR_OLED, 0, 0x1)

        # Set Column range
        bus.write_byte_data(ADDR_OLED, 0, 0x21)
        bus.write_byte_data(ADDR_OLED, 0, xoffset)
        bus.write_byte_data(ADDR_OLED, 0, xoffset+blocksize-1)

        # Set Row Range
        bus.write_byte_data(ADDR_OLED, 0, 0x22)
        bus.write_byte_data(ADDR_OLED, 0, yoffset)
        bus.write_byte_data(ADDR_OLED, 0, yoffset)

        # Set Display Start Line
        bus.write_byte_data(ADDR_OLED, 0, 0x40)

        bufferoffset = OLED_WD*yoffset + xoffset
        # Write Out Buffer
        bus.write_i2c_block_data(ADDR_OLED, OLED_SLAVEADDRESS, oled_imagebuffer[bufferoffset:(bufferoffset+blocksize)])
    except:
        return

def oled_drawfilledrectangle(x, y, wd, ht, mode = 0):
    ymax = y + ht
    cury = y&0xF8

    xmax = x + wd
    curx = x
    if ((y & 0x7)) != 0:
        yshift = y&0x7
        bytevalue = (0xFF<<yshift)&0xFF

        # If 8 no additional masking needed
        if ymax-cury  < 8:
            yshift = 8-((ymax-cury)&0x7)
            bytevalue = bytevalue & (0xFF>>yshift)

        while curx < xmax:
            oled_writebyterow(curx,cury,bytevalue, mode)
            curx = curx + 1
        cury = cury + 8
    # Draw 8 rows at a time when possible
    while cury + 8 < ymax:
        curx = x
        while curx < xmax:
            oled_writebyterow(curx,cury,0xFF, mode)
            curx = curx + 1
        cury = cury + 8

    if cury < ymax:
        yshift = 8-((ymax-cury)&0x7)
        bytevalue = (0xFF>>yshift)

        curx = x
        while curx < xmax:
            oled_writebyterow(curx,cury,bytevalue, mode)
            curx = curx + 1


def oled_writetextaligned(textdata, x, y, boxwidth, alignmode, charwd = 6, mode = 0):
    leftoffset = 0
    if alignmode == 1:
        # Centered
        leftoffset = (boxwidth-len(textdata)*charwd)>>1
    elif alignmode == 2:
        # Right aligned
        leftoffset = (boxwidth-len(textdata)*charwd)

    oled_writetext(textdata, x+leftoffset, y, charwd, mode)
    

def oled_writetext(textdata, x, y, charwd = 6, mode = 0):
    if charwd < 6:
        charwd = 6

    charht = int((charwd<<3)/6)
    if charht & 0x7:
        charht = (charht&0xF8) + 8

    try:
        file = open("/etc/argon/oled/font"+str(charht)+"x"+str(charwd)+".bin", "rb")
        fontbytes = list(file.read())
        file.close()
    except FileNotFoundError:
        try:
            # Default to smallest
            file = open("/etc/argon/oled/font8x6.bin", "rb")
            fontbytes = list(file.read())
            file.close()
        except FileNotFoundError:
            return

    if ((y & 0x7)) == 0:
        # Use optimized loading
        oled_fastwritetext(textdata, x, y, charht, charwd, fontbytes, mode)
        return

    numfontrow = charht>>3
    ctr = 0
    while ctr < len(textdata):
        fontoffset = ord(textdata[ctr])*charwd
        fontcol = 0
        while fontcol < charwd and x < OLED_WD:
            fontrow = 0
            row = y
            while fontrow < numfontrow and row < OLED_HT and x >= 0:
                curbit = 0x80
                curbyte = (fontbytes[fontoffset + fontcol + (OLED_NUMFONTCHAR*charwd*fontrow)])
                subrow = 0
                while subrow < 8 and row < OLED_HT:
                    value = 0
                    if (curbyte&curbit) != 0:
                        value = 1
                    oled_writebuffer(x,row,value, mode)
                    curbit = curbit >> 1
                    row = row + 1
                    subrow = subrow + 1
                fontrow = fontrow + 1
            fontcol = fontcol + 1
            x = x + 1
        ctr = ctr + 1

def oled_fastwritetext(textdata, x, y, charht, charwd, fontbytes, mode = 0):

    numfontrow = charht>>3
    ctr = 0
    while ctr < len(textdata):
        fontoffset = ord(textdata[ctr])*charwd
        fontcol = 0
        while fontcol < charwd and x < OLED_WD:
            fontrow = 0
            row = y&0xF8
            while fontrow < numfontrow and row < OLED_HT and x >= 0:
                curbyte = (fontbytes[fontoffset + fontcol + (OLED_NUMFONTCHAR*charwd*fontrow)])
                oled_writebyterow(x,row,curbyte, mode)
                fontrow = fontrow + 1
                row = row + 8
            fontcol = fontcol + 1
            x = x + 1
        ctr = ctr + 1    
    return


def oled_power(turnon = True):
    cmd = 0xAE
    if turnon == True:
            cmd = cmd|1
    try:
        bus.write_byte_data(ADDR_OLED, 0, cmd)
    except:
        return


def oled_inverse(enable = True):
    cmd = 0xA6
    if enable == True:
            cmd = cmd|1
    try:
        bus.write_byte_data(ADDR_OLED, 0, cmd)
    except:
        return


def oled_fullwhite(enable = True):
    cmd = 0xA4
    if enable == True:
            cmd = cmd|1
    try:
        bus.write_byte_data(ADDR_OLED, 0, cmd)
    except:
        return



def oled_reset():
    try:
        # Set COM-H Addressing
        bus.write_byte_data(ADDR_OLED, 0, 0x20)
        bus.write_byte_data(ADDR_OLED, 0, 0x1)

        # Set Column range
        bus.write_byte_data(ADDR_OLED, 0, 0x21)
        bus.write_byte_data(ADDR_OLED, 0, 0)
        bus.write_byte_data(ADDR_OLED, 0, OLED_WD-1)

        # Set Row Range
        bus.write_byte_data(ADDR_OLED, 0, 0x22)
        bus.write_byte_data(ADDR_OLED, 0, 0)
        bus.write_byte_data(ADDR_OLED, 0, (OLED_HT>>3)-1)

        # Set Page Addressing
        bus.write_byte_data(ADDR_OLED, 0, 0x20)
        bus.write_byte_data(ADDR_OLED, 0, 0x2)
        # Set GDDRAM Address
        bus.write_byte_data(ADDR_OLED, 0, 0xB0)

        # Set Display Start Line
        bus.write_byte_data(ADDR_OLED, 0, 0x40)
    except:
        return