Where to get the Cubenano driver lib?

[jedld]

Where do I get the CubeNano OLED driver library, there is no link anywhere in this repo

[kitplummer]

@YahboomTechnology - where is it??

[agplusman]

same damn problem

[jedld]

Forget where I got it (I had to dig so deep to find these files I forgot it), but Here are python files for reference to get all the features of the case working. Enjoy:

Fan control and RGB

#!/usr/bin/env python3
# coding: utf-8

#!/usr/bin/env python3
#coding: utf-8
import smbus
import time

# V1.0.1
class CubeNano(object):

    def __init__(self, i2c_bus=7, delay=0.002, debug=False):
        self.__debug = debug
        self.__delay = delay
        self.__i2c_bus = smbus.SMBus(int(i2c_bus))
        
        self.__Addr = 0x0E
        self.__REG_FAN = 0x08
        self.__REG_RGB_Effect = 0x04
        self.__REG_RGB_Speed = 0x05
        self.__REG_RGB_Color = 0x06

    def __del__(self):
        print("CubeNano End!")

    # 控制风扇 start=0 关闭风扇  start=1 打开风扇
    # control Fan  start=0 close  start=1 open
    def set_Fan(self, state):
        if state > 0:
            state = 1
        try:
            self.__i2c_bus.write_byte_data(self.__Addr, self.__REG_FAN, state)
            if self.__delay > 0:
                time.sleep(self.__delay)
        except:
            if self.__debug:
                print("---set_Fan Error---")

    # 控制RGB灯特效: 0关闭特效,1呼吸灯,2跑马灯,3彩虹灯,4炫彩灯,5流水灯，6循环呼吸灯
    # Control RGB light effect:
    # 0 off effect, 1 breathing light, 2 marquee light，3 rainbow light
    # 4 dazzling lights, 5 running water lights，6 Circulation breathing lights
    def set_RGB_Effect(self, effect):
        if effect < 0 or effect > 6:
            effect = 0
        try:
            self.__i2c_bus.write_byte_data(self.__Addr, self.__REG_RGB_Effect, effect)
            if self.__delay > 0:
                time.sleep(self.__delay)
        except:
            if self.__debug:
                print("---set_RGB_Effect Error---")
    
    # 设置RGB灯特效速度 1-3：1低速,2中速,3高速
    # Set RGB light effect speed 1-3:1 low speed, 2 medium speed, 3 high speed
    def set_RGB_Speed(self, speed):
        if speed < 1 or speed > 3:
            speed = 1
        try:
            self.__i2c_bus.write_byte_data(self.__Addr, self.__REG_RGB_Speed, speed)
            if self.__delay > 0:
                time.sleep(self.__delay)
        except:
            if self.__debug:
                print("---set_RGB_Speed Error---")

    # 设置RGB灯特效颜色 0-6:
    # 0红色,1绿色,2蓝色,3黄色,4紫色,5青色,6白色
    # Set RGB light effect color 0-6:
    # 0 red, 1 green, 2 blue, 3 yellow, 4 purple, 5 cyan, 6 white
    def set_RGB_Color(self, color):
        if color < 0 or color > 6:
            color = 0
        try:
            self.__i2c_bus.write_byte_data(self.__Addr, self.__REG_RGB_Color, color)
            if self.__delay > 0:
                time.sleep(self.__delay)
        except:
            if self.__debug:
                print("---set_RGB_Color Error---")
    
    # 设置单个RGB灯颜色
    # Set the individual RGB light color
    # index表示灯珠序号0-13，index=255表示控制所有灯；
    # r代表红色，g代表绿色，b代表蓝色
    # index indicates the serial number of the lamp bead 0-13, index=255 means to control all lamps; 
    # r stands for red, g stands for green, and b stands for blue
    def set_Single_Color(self, index, r, g, b):
        try:
            # 关闭RGB灯特效
            # Turn off RGB light effects
            self.__i2c_bus.write_byte_data(self.__Addr, self.__REG_RGB_Effect, 0)
            if self.__delay > 0:
                time.sleep(self.__delay)
            self.__i2c_bus.write_byte_data(self.__Addr, 0x00, int(index)&0xFF)
            if self.__delay > 0:
                time.sleep(self.__delay)
            self.__i2c_bus.write_byte_data(self.__Addr, 0x01, int(r)&0xFF)
            if self.__delay > 0:
                time.sleep(self.__delay)
            self.__i2c_bus.write_byte_data(self.__Addr, 0x02, int(g)&0xFF)
            if self.__delay > 0:
                time.sleep(self.__delay)
            self.__i2c_bus.write_byte_data(self.__Addr, 0x03, int(b)&0xFF)
            if self.__delay > 0:
                time.sleep(self.__delay)
        except:
            if self.__debug:
                print("---set_Single_Color Error---")
    
    # 获取固件版本号
    # Obtain the firmware version number
    def get_Version(self):
        self.__i2c_bus.write_byte(self.__Addr, 0x00)
        version = self.__i2c_bus.read_byte(self.__Addr)
        return version

OLED control

#!/usr/bin/env python3
# coding=utf-8
import time
import os
import sys
import Adafruit_SSD1306 as SSD

from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont

import subprocess


# V1.0.10
class OLED:
    def __init__(self, i2c_bus=1, clear=False, debug=False):
        self.__debug = debug
        self.__i2c_bus = i2c_bus
        self.__clear = clear
        self.__top = -2
        self.__x = 0

        self.__total_last = 0
        self.__idle_last = 0
        self.__str_CPU = "CPU:0%"

        self.__WIDTH = 128
        self.__HEIGHT = 32
        self.__image = Image.new('1', (self.__WIDTH, self.__HEIGHT))
        self.__draw = ImageDraw.Draw(self.__image)
        self.__font = ImageFont.load_default()

    def __del__(self):
        self.clear(True)
        if self.__debug:
            print("---OLED-DEL---")

    # 初始化OLED，成功返回:True，失败返回:False
    # Initialize OLED, return True on success, False on failure
    def begin(self):
        try:
            self.__oled = SSD.SSD1306_128_32(
                rst=None, i2c_bus=self.__i2c_bus, gpio=1)
            self.__oled.begin()
            self.__oled.clear()
            self.__oled.display()
            if self.__debug:
                print("---OLED begin ok!---")
            return True
        except:
            if self.__debug:
                print("---OLED no found!---")
            return False

    # 清除显示。refresh=True立即刷新，refresh=False不刷新。
    # Clear the display.  Refresh =True Refresh immediately, refresh=False refresh not
    def clear(self, refresh=False):
        self.__draw.rectangle(
            (0, 0, self.__WIDTH, self.__HEIGHT), outline=0, fill=0)
        if refresh:
            try:
                self.refresh()
                return True
            except:
                return False

    # 增加字符。start_x start_y表示开始的点。text是要增加的字符。
    # refresh=True立即刷新，refresh=False不刷新。
    # Add characters.  Start_x Start_y indicates the starting point.  Text is the character to be added
    # Refresh =True Refresh immediately, refresh=False refresh not
    def add_text(self, start_x, start_y, text, refresh=False):
        if start_x > self.__WIDTH or start_x < 0 or start_y < 0 or start_y > self.__HEIGHT:
            if self.__debug:
                print("oled text: x, y input error!")
            return
        x = int(start_x + self.__x)
        y = int(start_y + self.__top)
        self.__draw.text((x, y), str(text), font=self.__font, fill=255)
        if refresh:
            self.refresh()

    # 写入一行字符text。refresh=True立即刷新，refresh=False不刷新。
    # line=[1, 4]
    # Write a line of character text.  Refresh =True Refresh immediately, refresh=False refresh not.
    def add_line(self, text, line=1, refresh=False):
        if line < 1 or line > 4:
            if self.__debug:
                print("oled line input error!")
            return
        y = int(8 * (line - 1))
        self.add_text(0, y, text, refresh)

    # 刷新OLED，显示内容
    # Refresh the OLED to display the content
    def refresh(self):
        self.__oled.image(self.__image)
        self.__oled.display()


    # 读取CPU占用率
    # Read the CPU usage rate
    def getCPULoadRate(self, index):
        count = 10
        if index == 0:
            f1 = os.popen("cat /proc/stat", 'r')
            stat1 = f1.readline()
            data_1 = []
            for i in range(count):
                data_1.append(int(stat1.split(' ')[i+2]))
            self.__total_last = data_1[0]+data_1[1]+data_1[2]+data_1[3] + \
                data_1[4]+data_1[5]+data_1[6]+data_1[7]+data_1[8]+data_1[9]
            self.__idle_last = data_1[3]
        elif index == 4:
            f2 = os.popen("cat /proc/stat", 'r')
            stat2 = f2.readline()
            data_2 = []
            for i in range(count):
                data_2.append(int(stat2.split(' ')[i+2]))
            total_now = data_2[0]+data_2[1]+data_2[2]+data_2[3] + \
                data_2[4]+data_2[5]+data_2[6]+data_2[7]+data_2[8]+data_2[9]
            idle_now = data_2[3]
            total = int(total_now - self.__total_last)
            idle = int(idle_now - self.__idle_last)
            usage = int(total - idle)
            usageRate = int(float(usage / total) * 100)
            self.__str_CPU = "CPU:" + str(usageRate) + "%"
            self.__total_last = 0
            self.__idle_last = 0
            # if self.__debug:
            #     print(self.__str_CPU)
        return self.__str_CPU

    # 读取系统时间
    # Read system time
    def getSystemTime(self):
        cmd = "date +%H:%M:%S"
        date_time = subprocess.check_output(cmd, shell=True)
        str_Time = str(date_time).lstrip('b\'')
        str_Time = str_Time.rstrip('\\n\'')
        # print(date_time)
        return str_Time

    # 读取内存占用率 和 总内存
    # Read the memory usage and total memory
    def getUsagedRAM(self):
        cmd = "free | awk 'NR==2{printf \"RAM:%2d%% -> %.1fGB \", 100*($2-$7)/$2, ($2/1048576.0)}'"
        FreeRam = subprocess.check_output(cmd, shell=True)
        str_FreeRam = str(FreeRam).lstrip('b\'')
        str_FreeRam = str_FreeRam.rstrip('\'')
        return str_FreeRam

    # 读取空闲的内存 / 总内存
    # Read free memory/total memory
    def getFreeRAM(self):
        cmd = "free -h | awk 'NR==2{printf \"RAM: %.1f/%.1fGB \", $7,$2}'"
        FreeRam = subprocess.check_output(cmd, shell=True)
        str_FreeRam = str(FreeRam).lstrip('b\'')
        str_FreeRam = str_FreeRam.rstrip('\'')
        return str_FreeRam

    # 读取TF卡空间占用率 / TF卡总空间
    # Read the TF card space usage/TOTAL TF card space
    def getUsagedDisk(self):
        cmd = "df -h | awk '$NF==\"/\"{printf \"SDC:%s -> %.1fGB\", $5, $2}'"
        Disk = subprocess.check_output(cmd, shell=True)
        str_Disk = str(Disk).lstrip('b\'')
        str_Disk = str_Disk.rstrip('\'')
        return str_Disk

    # 读取空闲的TF卡空间 / TF卡总空间
    # Read the free TF card space/total TF card space
    def getFreeDisk(self):
        cmd = "df -h | awk '$NF==\"/\"{printf \"Disk:%.1f/%.1fGB\", $4,$2}'"
        Disk = subprocess.check_output(cmd, shell=True)
        str_Disk = str(Disk).lstrip('b\'')
        str_Disk = str_Disk.rstrip('\'')
        return str_Disk

    # 获取本机IP
    # Read the local IP address
    def getLocalIP(self):
        ip = os.popen(
            "/sbin/ifconfig eth0 | grep 'inet' | awk '{print $2}'").read()
        ip = ip[0: ip.find('\n')]
        # ip = ''
        if(ip == '' or len(ip) > 15):
            ip = os.popen(
                "/sbin/ifconfig wlan0 | grep 'inet' | awk '{print $2}'").read()
            ip = ip[0: ip.find('\n')]
            if(ip == ''):
                ip = 'x.x.x.x'
        if len(ip) > 15:
            ip = 'x.x.x.x'
        return ip


    # oled主要运行函数，在while循环里调用，可实现热插拔功能。
    # Oled mainly runs functions that are called in a while loop and can be hot-pluggable
    def main_program(self):
        try:
            cpu_index = 0
            state = self.begin()
            while state:
                self.clear()
                if self.__clear:
                    self.refresh()
                    return True
                str_CPU = self.getCPULoadRate(cpu_index)
                str_Time = self.getSystemTime()
                if cpu_index == 0:
                    str_FreeRAM = self.getUsagedRAM()
                    str_Disk = self.getUsagedDisk()
                    str_IP = "IPA:" + self.getLocalIP()
                self.add_text(0, 0, str_CPU)
                self.add_text(50, 0, str_Time)
                self.add_line(str_FreeRAM, 2)
                self.add_line(str_Disk, 3)
                self.add_line(str_IP, 4)
                # Display image.
                self.refresh()
                cpu_index = cpu_index + 1
                if cpu_index >= 5:
                    cpu_index = 0
                time.sleep(.1)
            return False
        except:
            if self.__debug:
                print("!!!---OLED refresh error---!!!")
            return False

def close_rgb_fan():
    try:
        bus.write_byte_data(0x0E, 0x08, 0)
        time.sleep(.01)
        bus.write_byte_data(0x0E, 0x07, 0)
    except:
        pass


if __name__ == "__main__":
    try:
        oled_clear = False
        oled_debug = False
        state = False
        if len(sys.argv) > 1:
            if str(sys.argv[1]) == "clear":
                oled_clear = True
            elif str(sys.argv[1]) == "debug":
                oled_debug = True
        oled = OLED(clear=oled_clear, debug=oled_debug)
        try:
            import smbus
            bus = smbus.SMBus(7)
            if not oled_clear:
                start = 1    # 风扇开关
                bus.write_byte_data(0x0E, 0x08, start)
                time.sleep(.05)
                effect = 3   # 灯光效果1-5
                bus.write_byte_data(0x0E, 0x04, effect)
                time.sleep(.05)
        except:
            pass

        while True:
            state = oled.main_program()
            oled.clear(True)
            if state:
                del oled
                print("---OLED CLEARED!---")
                close_rgb_fan()
                break
            time.sleep(1)
    except KeyboardInterrupt:
        del oled
        close_rgb_fan()
        print("---Program closed!---")