def test_init_128x64(): """ SH1106 OLED with a 128 x 64 resolution works correctly. """ sh1106(serial) serial.command.assert_has_calls([ # Initial burst are initialization commands call(174, 32, 16, 176, 200, 0, 16, 64, 161, 166, 168, 63, 164, 211, 0, 213, 240, 217, 34, 218, 18, 219, 32, 141, 20), # set contrast call(129, 127), # reset the display call(176, 2, 16), call(177, 2, 16), call(178, 2, 16), call(179, 2, 16), call(180, 2, 16), call(181, 2, 16), call(182, 2, 16), call(183, 2, 16) ]) # Next 1024 are all data: zero's to clear the RAM # (1024 = 128 * 64 / 8) serial.data.assert_has_calls([call([0] * 128)] * 8)
def __init__(self, rows=64, cols=128, spi_device=0, spi_port=0, gpio_DC=24, gpio_RST=25,devicetype=u'ssd1306'): self.spi_port = spi_port self.spi_device = spi_device self.gpio_DC = gpio_DC self.gpio_RST = gpio_RST self.rows = rows self.cols = cols self.fb = [[]] # Initialize the default font font = fonts.bmfont.bmfont('latin1_5x8_fixed.fnt') self.fp = font.fontpkg #serial = i2c(port=spi_port, address=spi_device) serial = spi (port = spi_port, device = spi_device, gpio_DC = gpio_DC, gpio_RST = gpio_RST) if devicetype.lower() == u'ssd1306': self.device = ssd1306(serial) elif devicetype.lower() == u'sh1106': self.device = sh1106(serial) elif devicetype.lower() == u'ssd1322': self.device = ssd1322(serial) elif devicetype.lower() == u'ssd1325': self.device = ssd1325(serial) elif devicetype.lower() == u'ssd1331': self.device = ssd1331(serial) else: raise ValueError('{0} not a recognized luma device type'.format(devicetype))
def from_config(self, config) -> 'LevelDisplay': # Temporary Variables active = config["LevelDisplay"]["active"] address = config["LevelDisplay"]["i2c_address"] port = config["LevelDisplay"]["i2c_port"] left = config["LevelDisplay"]["left"] right = config["LevelDisplay"]["right"] if "db_markers" in config["LevelDisplay"].keys(): db_markers = config["LevelDisplay"]["db_markers"] scale = [db_to_fader(db) for db in db_markers] else: db_markers = None # Set the initial values self.active = active if self.active: self.serial = i2c(port=port, address=address) self.device = sh1106(self.serial) self.font = ImageFont.truetype("fonts/Inter-Medium.ttf", 10) self.font_small = ImageFont.truetype("fonts/Inter-Light.ttf", 7) self.left = left self.right = right self.db_markers = db_markers self.scale = scale print("Setting up LevelDisplay at i2c address {}".format(address)) return self
def test_display(): """ SH1106 OLED screen can draw and display an image. """ device = sh1106(serial) serial.reset_mock() recordings = [] def data(data): recordings.append({'data': data}) def command(*cmd): recordings.append({'command': list(cmd)}) serial.command = Mock(side_effect=command, unsafe=True) serial.data = Mock(side_effect=data, unsafe=True) # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) serial.data.assert_called() serial.command.assert_called() assert recordings == get_json_data('demo_sh1106')
def initDisplay(self, address): display = self.getConnectedDisplayData(address, self._settings.displays2) # print("initDisplay") # print(display) # print(type(display)) if (display and display['type'] == 'OLED'): # if OLED serial = i2c(port=1, address=display['address']) # substitute ssd1331(...) or sh1106(...) below if using that device # device = ssd1306(serial) device = sh1106(serial) device.clear() return device if (display and display['type'] == 'LCD'): # if LCD device = CharLCD(i2c_expander='PCF8574', address=int(display['address'], 0), port=1, cols=display['width'], rows=display['height'], dotsize=8, charmap='A02', auto_linebreaks=True, backlight_enabled=True) # substitute ssd1331(...) or sh1106(...) below if using that device # device = ssd1306(serial) device.clear() return device return False
def init_display(self, **kwargs): """Initializes SH1106 controller. """ self.rotate = kwargs.pop("rotate", self.default_rotate) self.device = sh1106(self.serial, width=self.width, height=self.height, rotate=self.rotate)
def test_display(): """ SH1106 OLED screen can draw and display an image. """ device = sh1106(serial) serial.reset_mock() recordings = [] def data(data): recordings.append({'data': data}) def command(*cmd): recordings.append({'command': list(cmd)}) serial.command = Mock(side_effect=command, unsafe=True) serial.data = Mock(side_effect=data, unsafe=True) # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) serial.data.assert_called() serial.command.assert_called() # To regenerate test data, uncomment the following (remember not to commit though) # ================================================================================ # from baseline_data import save_reference_data # save_reference_data("demo_sh1106", recordings) assert recordings == get_reference_data('demo_sh1106')
def main(): cmd = "ps -ef | grep 'show_info.py' | grep -v 'grep' | grep python3 | awk '{print $2}'" p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE) output = p.stdout.readlines() pids = [int(x.decode()) for x in output] pids.remove(os.getpid()) ppid = os.getppid() if ppid in pids: pids.remove(os.getppid()) if len(pids) > 0: print("already running...") print(pids) return while True: serial = i2c(port=1, address=0x3C) device = sh1106(serial) with canvas(device) as draw: draw.rectangle(device.bounding_box, outline="white", fill="black") #draw.text((30, 40), "Hello World", fill="white") #draw.text((30, 40), "Hello World", fill="white") #draw.text((0, 0), "Hello World", fill="white") local_ip = get_ip_address("wlan0") draw.text((0, 0), "ip: %s" % local_ip, fill="white") time.sleep(10)
class SetupClass: # setup logs to be used in all python files, reset on each run logging.basicConfig(filename='logging.log', filemode='w', encoding='utf-8', level=logging.DEBUG) GPIO.setwarnings(False) serial = spi(device=0, port=0, bus_speed_hz=8000000, transfer_size=4096, gpio_DC=24, gpio_RST=25) device = sh1106(serial, rotate=2) # sh1106 GPIO.setmode(GPIO.BCM) # key pins defined in constant.py GPIO.setup(config.KEY_CANCEL_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.setup(config.KEY_UP_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.setup(config.KEY_SELECT_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.setup(config.KEY_DOWN_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP) logging.info("SetupClass Initialized")
def set_address(self, address): super(terrariumOLED, self).set_address(address) try: address = i2c(port=int(self.bus), address=int('0x' + str(self.address), 16)) if self.get_type() == terrariumOLEDSSD1306.TYPE: self.device = ssd1306(address) elif self.get_type() == terrariumOLEDSSD1309.TYPE: self.device = ssd1309(address) elif self.get_type() == terrariumOLEDSSD1322.TYPE: self.device = ssd1322(address) elif self.get_type() == terrariumOLEDSSD1325.TYPE: self.device = ssd1325(address) elif self.get_type() == terrariumOLEDSSD1327.TYPE: self.device = ssd1327(address) elif self.get_type() == terrariumOLEDSSD1331.TYPE: self.device = ssd1331(address) elif self.get_type() == terrariumOLEDSSD1351.TYPE: self.device = ssd1351(address) elif self.get_type() == terrariumOLEDSH1106.TYPE: self.device = sh1106(address) except DeviceNotFoundError as ex: print( '%s - WARNING - terrariumDisplay - %s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S,%f')[:23], ex)) self.device = None self.init()
def __init__(self, width, height, fontFile, largeFontSize, smallFontSize): Video.device = sh1106(spi(), width=width, height=height, mode="1", rotate=2) super().__init__(width, height, fontFile, largeFontSize, smallFontSize)
def __init__(self, rows=64, cols=128, i2c_address=0x3d, i2c_port=1, devicetype='ssd1306'): self.i2c_address = i2c_address self.i2c_port = i2c_port self.rows = rows self.cols = cols self.fb = [[]] # Initialize the default font font = fonts.bmfont.bmfont('latin1_5x8_fixed.fnt') self.fp = font.fontpkg serial = i2c(port=i2c_port, address=i2c_address) if devicetype.lower() == 'ssd1306': self.device = ssd1306(serial) elif devicetype.lower() == 'sh1106': self.device = sh1106(serial) elif devicetype.lower() == 'ssd1322': self.device = ssd1322(serial) elif devicetype.lower() == 'ssd1325': self.device = ssd1325(serial) elif devicetype.lower() == 'ssd1331': self.device = ssd1331(serial) else: raise ValueError('{0} not a recognized luma device type'.format(devicetype))
def __init__(self): self.busy=False self.s4='' self.s5='' self.s6='' # Parse config for display settings driver = gv.cp.get(gv.cfg,"OLED_DRIVER".lower()) RST = gv.cp.getint(gv.cfg,"OLED_RST".lower()) CS = gv.cp.getint(gv.cfg,"OLED_CS".lower()) DC = gv.cp.getint(gv.cfg,"OLED_DC".lower()) port = gv.cp.getint(gv.cfg,"OLED_PORT".lower()) # Load default font. self.font = ImageFont.load_default() # self.largeFont = ImageFont.truetype("arial.ttf",16) # Create blank image for drawing. # Make sure to create image with mode '1' for 1-bit color. self.width = gv.cp.getint(gv.cfg,"OLED_WIDTH".lower()) self.height = gv.cp.getint(gv.cfg,"OLED_HEIGHT".lower()) self.image = Image.new('1', (self.width, self.height)) # First define some constants to allow easy resizing of shapes. self.padding = gv.cp.getint(gv.cfg,"OLED_PADDING".lower()) self.top = self.padding self.bottom = self.height-self.padding # Move left to right keeping track of the current x position for drawing shapes. self.x = 0 serial = spi(device=port, port=port, bus_speed_hz = 8000000, transfer_size = 4096, gpio_DC = DC, gpio_RST = RST) if driver=="SH1106": self.device = sh1106(serial, rotate=2) else: print("Wrong driver") self.canvas = canvas(self.device)
class sh1106_screen: """ Object for interacting with sh1106 board controlled screen display """ # setup screen display # variables are the same for every instance setup, so not inside __init__ display = sh1106(spi()) def display_time(self, times: List[datetime.datetime], min_clock_display: int = 0) -> None: """ Pulls in times and pushes the information to the screen display :times: list of departure times :min_clock_display: the minimum difference in minutes to display on the countdown clock """ # Display times on the SPI sh1106 screen with canvas(self.display) as draw: draw.rectangle(self.display.bounding_box, outline="white", fill="black") draw.text((25, 10), "Schedule: ", fill="white") # For up to 3 train times, display their schedule for x in range(min(3, len(times))): train_num = x + 1 display_y = (train_num * 10) + 10 # Display train number and departure time draw.text((25, display_y), f"{train_num}: {times[x].strftime('%H:%M')}", fill="white") def clear_display(self): """ Creates new instance of display in order to clear the current display """ self.display = sh1106(spi())
def __init__(self, config, core): super(oledScreen, self).__init__() self.menu = False self.core = core self.config = config if config['oledScreen']['bus'] and config['oledScreen']['address']: self.serial = i2c(bus=SMBus(config['oledScreen']['bus']), address=config['oledScreen']['address']) else: self.serial = i2c(bus=SMBus(2), address=0x3c) self.driver = config['oledScreen']['driver'] if self.driver == 'ssd1306': self.device = ssd1306(self.serial) elif self.driver == 'ssd1322': self.device = ssd1322(self.serial) elif self.driver == 'ssd1325': self.device = ssd1325(self.serial) elif self.driver == 'ssd1331': self.device = ssd1331(self.serial) elif self.driver == 'sh1106': self.device = sh1106(self.serial) else: self.device = ssd1306(self.serial) self.font = self.make_font('Vera.ttf', 26) self.fontSmall = self.make_font('Vera.ttf', 15) self.set_image('radio.gif')
def __init__(self, statusFunctions=[], framerate: int = 10): serial = spi(device=0, port=0) self.device = sh1106(serial, rotate=2) self.buttons = Buttons() if statusFunctions is None: statusFunctions = [] self.statusFunctions = statusFunctions self.stopEvent = Event() self.frameBuffer = Queue() resourcePath = Path(__file__).parent.parent resourcePath = resourcePath.joinpath("resources") im = Image.open(resourcePath / "coOP_logo.bmp").convert( self.device.mode) self.frameBuffer.put(Frame(im, True)) self.lastFrame = None self.fullscreenOffset = 10 self.timeToNextFrame = 1 / framerate self.__updateScreen()
def __init__(self): self.running = False # set the oled screen height self.screen_width = SCREEN_WIDTH self.screen_height = SCREEN_HEIGHT self.btn1Pin = LEFT_BTN_PIN self.btn2Pin = RIGHT_BTN_PIN # configure interrups for buttons GPIO.setup(self.btn1Pin, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.setup(self.btn2Pin, GPIO.IN, pull_up_down=GPIO.PUD_UP) # configure screen # spi_bus = 0 # spi_device = 0 # gpio = gaugette.gpio.GPIO() # spi = gaugette.spi.SPI(spi_bus, spi_device) serial = i2c(port=1, address=0x3C) device = sh1106(serial) # Very important... This lets py-gaugette 'know' what pins to use in order to reset the display # self.led = gaugette.ssd1306.SSD1306(gpio, spi, reset_pin=OLED_RESET_PIN, dc_pin=OLED_DC_PIN, rows=self.screen_height, cols=self.screen_width) # Change rows & cols values depending on your display dimensions. self.led = device self.oled_font = ImageFont.truetype('FreeSans.ttf', 12) # self.led.begin() # self.led.clear_display() # self.led.display() # self.led.invert_display() # time.sleep(0.5) # self.led.normal_display() time.sleep(0.5) # load the pump configuration from file self.pump_configuration = Bartender.readPumpConfiguration() for pump in self.pump_configuration.keys(): GPIO.setup(self.pump_configuration[pump]["pin"], GPIO.OUT, initial=GPIO.HIGH) # setup pixels: self.numpixels = NUMBER_NEOPIXELS # Number of LEDs in strip # Here's how to control the strip from any two GPIO pins: datapin = NEOPIXEL_DATA_PIN clockpin = NEOPIXEL_CLOCK_PIN #self.strip = Adafruit_DotStar(self.numpixels, datapin, clockpin) #self.strip.begin() # Initialize pins for output # Limit brightness to ~1/4 duty cycle #self.strip.setBrightness(NEOPIXEL_BRIGHTNESS) # turn everything off # for i in range(0, self.numpixels): # self.strip.setPixelColor(i, 0) # self.strip.show() print("Done initializing")
def open(self): i2c_busio = busio.I2C(board.SCL, board.SDA) self.sensor_mag = adafruit_lsm303dlh_mag.LSM303DLH_Mag(i2c_busio) self.sensor_accel = adafruit_lsm303_accel.LSM303_Accel(i2c_busio) i2c_luma = luma_i2c(port=1, address=0x3c) self.lcd = sh1106(i2c_luma, width=128, height=64) self.font = ImageFont.truetype("FreeSans.ttf", 16) print("Opened interface")
def __init__(self, statusFunctions: Optional[List[Callable[[], bool]]] = []): if statusFunctions is None: statusFunctions = [] serial = spi(device=0, port=0) self.device = sh1106(serial,rotate=2) self.statusFunctions = statusFunctions #print logo to device self.__initgpio()
def init(): #inicializar lcd global device global font serial = i2c(port=1, address=0x3C) #puerto de raspberry y address del dispositivo device = sh1106(serial, rotate=0) #seleccion del driver del lcd font = ImageFont.truetype( "/usr/share/fonts/truetype/freefont/FreeSerif.ttf", 16) #tipo de letra(direccion) y tamaño
def display(a, b="ZZULI"): # rev.1 users set port=0 # substitute spi(device=0, port=0) below if using that interface serial = i2c(port=1, address=0x3C) # substitute ssd1331(...) or sh1106(...) below if using that device device = sh1106(serial) #这里改ssd1306, ssd1325, ssd1331, sh1106 with canvas(device) as draw: draw.rectangle(device.bounding_box, outline="white", fill="black") draw.text((55, 16), b, fill="white") draw.text((40, 36), "QRcode:" + a, fill="white")
def __init__(self, init_menu): super(Screen, self).__init__() self.sleep_timer = None self.state = 'OFF' self.oled = sh1106(i2c(port=1, address=0x3C)) if is_pi() else pygame( width=128, height=64) self._welcome() time.sleep(1) self.draw_menu(init_menu) atexit.register(self.cleanup)
def __init__(self): self._initialize_buttons() self._initialize_button_events() self.device = sh1106(spi(device=0, port=0), rotate=2) self.device.contrast(255) self.automata = Automata(rules_list.current_rule(), self.DIMENSIONS) self._repopulate() self.start_time = time.time() self.paused = False self.average_fps = 0 self.last_measured_time = time.time()
def mainscales(): #setup local OLED screen fontname = "ProggyTiny.ttf" size = 48 # 48 gives 7chars x 2lines font = make_font(fontname, size) if fontname else None # if i2c then use i2c() serial = spi(device=0, port=0) # change device type here if needed, this also rotates display 180 - i.e. if gpio connector on bottom of display device = sh1106(serial, rotate=2) term = terminal(device, font) # term.clear() term.animate = True processor = EventProcessor() board = Wiiboard(processor, term) dispTime = DispTime(term) while 1: address = Discover(board) didwegrabit = True if (address != None): print "Trying to connect..." term.animate = False try: board.connect( address) # The wii board must be in sync mode at this time board.wait(200) board.setLight(False) board.wait(500) board.setLight(True) # go weigh :) board.receive() except KeyboardInterrupt: #time.sleep(5) exit() except: # likely no board connected, print "No board connected" didwegrabit = False # display time during this idle phase dispTime.putToScreen() # need to sleep for a while to allow BT stack to not be hammered # and allow time for board to go into discover mode again # if we have a good address, then discovery is quicker, so add a longer sleep # if did have sucessfull weighing, then also can add longer sleep time.sleep(3) if (didwegrabit or (address != None)): time.sleep(3)
def main(): logging.basicConfig( level=logging.DEBUG, format='%(asctime)s -- %(name)s %(levelname)s - %(message)s') connection_builder: ISConnectionBuilder = ISConnectionBuilder() connection_builder.set_mac_address(get_mac_address()) connection_builder.set_baseurl(config['Connection']['baseurl']) connection_builder.set_url(config['Connection']['url']) AttendanceRecorder(OLEDdisplay(sh1106(i2c())), CardReader(), connection_builder.build(), Buzzer(), ButtonController()).start()
def __init__(self, is_debug, callback): if is_debug: self._image = Image.new("RGB", (self.WIDTH, self.HEIGHT), "BLACK") self._draw = ImageDraw.Draw(self._image) else: from luma.core.interface.serial import i2c, spi from luma.core.render import canvas from luma.oled.device import sh1106 serial = spi(device=0, port=0) device = sh1106(serial, rotate=2) while True: with canvas(device) as draw: callback(draw) sleep(0.05)
def __init__(self): rospy.init_node('display') rate = rospy.Rate(10) # 10hz self.modeSub = rospy.Subscriber("/mode", String, self.modeCallback) self.mode = 'System Check' serial = i2c(port=1, address=0x3c) self.device = sh1106(serial) self.font = ImageFont.truetype('Ubuntu-B.ttf', 18) while not rospy.is_shutdown(): with canvas(self.device) as draw: draw.text((0, 20), self.mode, fill='white', font=self.font) rate.sleep() rospy.spin()
def __init__(self): """Set up Screen object. """ serial = i2c(port=I2C_PORT, address=I2C_ADDRESS) if DISPLAY_TYPE == 'sh1106': self.oled = sh1106(serial) else: self.oled = ssd1306(serial) self.bar_length = self.oled.width - ((PADDING + TEXT_MARGIN) * 2) self.font = ImageFont.truetype(FONT_PATH, FONT_SIZE) # Required by daemon runner self.pidfile_path = PIDFILE_PATH self.pidfile_timeout = PIDFILE_TIMEOUT self.stdin_path = STDIN_PATH self.stdout_path = STDOUT_PATH self.stderr_path = STDERR_PATH
def get_device(): DC = 24 RST = 25 try: from luma.oled.device import sh1106 from luma.core.interface.serial import spi except ImportError: print("Libs needed.") except Exception as e: print(e) serial = spi(device=0, port=0, bus_speed_hz=8000000, transfer_size=4096, gpio_DC=DC, gpio_RST=RST) return (sh1106(serial, rotate=0))
def cleanup(): serial = i2c(port=8, address=0x3C) device = sh1106(serial) GPIO.cleanup(gpio_led) GPIO.cleanup(gpio_sw_1) GPIO.cleanup(gpio_sw_10) GPIO.cleanup(gpio_sw_60) GPIO.cleanup(gpio_sw_res) GPIO.cleanup(gpio_sw_st) GPIO.setmode(GPIO.BCM) GPIO.setup(gpio_led, GPIO.OUT) GPIO.setup(gpio_sw_1, GPIO.IN) GPIO.setup(gpio_sw_10, GPIO.IN) GPIO.setup(gpio_sw_60, GPIO.IN) GPIO.setup(gpio_sw_res, GPIO.IN) GPIO.setup(gpio_sw_st, GPIO.IN) GPIO.output(gpio_led, 0)