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):
# Obtain the full sysfs path of the IIO devices.
self._hdc2010 = Pi_HDC2080.Pi_HDC2080()
self._bmp280 = BMP280(port=1,
mode=BMP280.FORCED_MODE,
oversampling_p=BMP280.OVERSAMPLING_P_x16,
oversampling_t=BMP280.OVERSAMPLING_T_x1,
filter=BMP280.IIR_FILTER_OFF,
standby=BMP280.T_STANDBY_1000)
#self._opt3002 = _get_path('opt3001')
self._tla2021 = _get_path('ads1015')
# Create SSD1306 OLED instance, with SPI as the interface.
plat = platform.platform()
if 'mendel' in plat:
from .rpi_gpio_periphery import pGPIO
# Values for the Coral Dev Board (running Mendel Linux).
# If running legacy kernel (4.9.51), use port 32766.
port = 32766 if 'Linux-4.9.51-imx' in plat else 0
self._display = ssd1306(serial_interface=spi(gpio=pGPIO(),
port=port,
device=0,
gpio_DC=138,
gpio_RST=140),
gpio=pGPIO(),
height=32,
rotate=2)
else:
# Default to RPi.GPIO in luma and defaults GPIO.
self._display = ssd1306(serial_interface=spi(cs_high=True),
gpio=noop(),
height=32,
rotate=2)
def initOLEDScreen():
global oleddisp
global oledfont
global oledimage
global oleddraw
if oleddisp == None:
from luma.core.interface.serial import i2c
from luma.core.render import canvas
from luma.oled.device import ssd1306
from PIL import Image, ImageDraw, ImageFont
RESET = 21
GPIO.setup(RESET, GPIO.OUT)
GPIO.output(RESET, 0)
time.sleep(0.01)
GPIO.output(RESET, 1)
serial = i2c(port=1, address=0x3C)
oleddisp = ssd1306(serial, width=oledwidth, height=oledheight)
oleddisp.cleanup = lambda _: True
oledfont = ImageFont.load_default()
# oledfont = ImageFont.truetype(font="tiny.ttf", size=8)
oledimage = Image.new('1', (oledwidth, oledheight))
oleddraw = ImageDraw.Draw(oledimage)
oleddisp.display(oledimage)
def init_display():
logging.info('initializing displays for the script')
port_index = 0
global serial_array
global display_array
try:
for row in range(3):
for column in range(3):
logging.info(
'initializing display no : {}x{}'.format(row+1, column+1))
serial_array[row][column] = i2c(
port=i2c_port[port_index], address=0x3C)
logging.debug(
'{}x{} no port is initialized'.format(row+1, column+1))
display_array[row][column] = ssd1306(serial_array[row][column])
logging.debug(
'{}x{} no display is initialized'.format(row+1, column+1))
port_index = port_index+1
pass
pass
except Exception as client_error:
logging.error('display initializing failed : {}'.format(client_error))
pass
port_index = 0
pass
def _DisplayText(self,
font_path,
text1,
text2=None,
text3=None,
text4=None,
size=12):
'''
显示多行文本
最少显示一行,最多显示四行
非特殊情况,请勿修改字体大小
'''
self.next.clear()
serial = i2c(port=1, address=0x3c)
device = ssd1306(serial) #挂载设备
Text_font = ImageFont.truetype(font_path, size) #设置文本字体
while not self.next.is_set():
with canvas(device) as draw:
draw.text((0, 0), text1, font=Text_font, fill="white")
if text2 != None:
draw.text((0, 14), text2, font=Text_font, fill="white")
if text3 != None:
draw.text((0, 26), text3, font=Text_font, fill="white")
if text4 != None:
draw.text((0, 38),
text4,
font=Text_font,
fill="white")
def _initialize_hardware(self):
"""
Initializes the widget hardware.
"""
# Import
try:
from luma.core.interface.serial import i2c
from luma.core.render import canvas
from luma.oled.device import ssd1306
except Exception as ex:
logging.error('\n *** ERROR importing Luma: {}'.format(ex))
# Things failed, must be running locally, not on a widget, so don't
# bother initializing I2C
return
# Now initialize I2C
try:
serial = i2c(port=1, address=0x3C)
self._device = ssd1306(serial)
except Exception as ex:
logging.error(
'\n *** ERROR initializing I2C/SSD1306: {}'.format(ex, ), )
return
self._canvas = canvas(self._device)
self._initialize_id_led()
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 find_devices():
boxnum = 1
dev = 0
dev1 = 0
for i in busses:
try:
calibration_params = bme280.load_calibration_params(i[0], 0x76)
data = bme280.sample(i[0], 0x76, calibration_params)
dev = 1
except:
dev = 0
try:
device = ssd1306(i[1], rotate=0)
dev1 = 1
except:
dev1 = 0
if dev == 1:
b = 'box' + str(boxnum)
BME280[b] = i[0]
BMEAVG[b] = [0, 0, 0]
if dev1 == 1:
b = 'box' + str(boxnum)
Displays[b] = device
DisplayInfo[b] = 'stats'
boxnum = boxnum + 1
def __init__(self):
self.serial = i2c(port=1, address=0x3C)
self.device = ssd1306(self.serial)
self.DisplaySplash()
time.sleep(
3
) # Keep the splash up for three seconds on boot-up - you can certainly disable this if you want
def __init__(self, settings):
self.modem_thread = ModemControlThread(settings['Modem'],
self.changes_queue,
self.ws_cmd_queue,
self.ws_res_queue)
self.modem_thread.create_serial()
self.modem_thread.setName("MC")
self.websock_thread = None
self.url = "http://" + settings['Server']['url']
self.ws_url = "ws://" + settings['Server']['url']
self.imsi = "imsi1"
create_db(settings['Db'])
self.dbo = DbOperations(settings['Db'])
self.rest_fail_time = 0
self.rest_success_time = 0
self.rest_last_action_success = False
if int(settings['Main']['oled']) == 1:
self.oled = ssd1306(i2c(port=1, address=0x3C))
self.oled_status = 0
self.status_time = 0
self.use_oled = True
# self.draw = canvas(self.oled)
with canvas(self.oled) as draw:
draw.text((10, 10), "PySimMonitor", fill="white")
draw.text((10, 20), "Starting...", fill="white")
self.essid = ""
self.operator = ""
self.csq = 0
self.modem_status_string = "-"
def main():
serial = i2c(port=1, address=0x3C)
device = ssd1306(serial)
device.cleanup = do_nothing
DHT_SENSOR = Adafruit_DHT.DHT22
DHT_PIN = 22
#font = ImageFont.load_default()
custom_font = ImageFont.truetype("VCR_OSD_MONO.ttf", 21)
while True:
humidity, temperature = Adafruit_DHT.read_retry(DHT_SENSOR, DHT_PIN)
with canvas(device) as draw:
draw.rectangle(device.bounding_box, outline="white", fill="black")
if humidity is not None and temperature is not None:
str_temp = ' {0:0.2f} *C'.format(temperature)
str_hum = ' {0:0.2f} %'.format(humidity)
string = "Temp={0:0.1f}*C Humidity={1:0.1f}%".format(
temperature, humidity)
print(string)
draw.text((4, 10), str_temp, font=custom_font, fill=255)
draw.text((4, 31), str_hum, font=custom_font, fill=255)
else:
print("Failed to retrieve data from humidity sensor")
sleep(10)
def init_display(self, **kwargs):
"""Initializes SSD1306 controller. """
self.rotate = kwargs.pop("rotate", self.default_rotate)
self.device = ssd1306(self.serial,
width=self.width,
height=self.height,
rotate=self.rotate)
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 main():
time_counter = 0
# define our i2c LED location
serial = i2c(port=1, address=0x3C)
# We have an ssd1306 device so we initialize it at the
# serial address we created.
oled_device = ssd1306(serial)
# This line keeps the display from immediately turning off once the
# script is complete.
oled_device.cleanup = do_nothing
while True:
# Update our LED
stats(oled_device)
# Every 5 minutes post up to our production site.
# Feel free to change this or eliminate this during testing.
if (time_counter % 300 == 0):
report()
# Increment a counter (1 per second. 5 here since we sleep 5 below)
time_counter += 5
# Sleep 5 seconds
time.sleep(5)
def setup(self, i2c_address=0x3C):
self.serial = i2c(port=1, address=i2c_address)
self.device = ssd1306(self.serial)
# font configuration
self.ttf = '/usr/share/fonts/truetype/04B_03__.TTF'
basedir = os.path.dirname(os.path.realpath(__file__))
self.imagedir = os.path.join(basedir, 'images')
self.font8 = ImageFont.truetype(self.ttf, 8)
self.font16 = ImageFont.truetype(self.ttf, 16)
self.font32 = ImageFont.truetype(self.ttf, 32)
self.tempFont32 = ImageFont.truetype("/usr/share/fonts/truetype/noto/NotoMono-Regular.ttf", 32)
# logging
self.lines = []
self.lineNumber = 0
# target user found.
self.name = ""
self.temp = ""
self.measureProgress = 0 # 0 to 100 %
self.result = None
# flags
self.isShutdown = False
self.status = "BOOT"
#start the screen refresh thread
self.th = threading.Thread(target=self.refreshThread, args=())
self.th.start()
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):
serial = i2c(port=1, address=0x3c)
self.device = ssd1306(serial, height=32)
self.device.persist = True
self.font = self.make_font("arial.ttf", 11)
print("OLEDbar.__init__> all set. Max bars = ", OLEDbar.bars)
self.regulator = framerate_regulator(fps=60)
self.readtime = []
def test_init_96x16():
ssd1306(serial, width=96, height=16)
serial.command.assert_has_calls([
# Initial burst are initialization commands
call(174, 213, 96, 168, 15, 211, 0, 64, 141, 20, 32, 0,
161, 200, 218, 2, 217, 241, 219, 64, 164, 166),
# set contrast
call(129, 207),
# reset the display
call(33, 0, 95, 34, 0, 1),
# called last, is a command to show the screen
call(175)
])
# Next 192 are all data: zero's to clear the RAM
# (192 = 96 * 16 / 8)
serial.data.assert_called_once_with([0] * (96 * 16 // 8))
def test_init_128x32():
ssd1306(serial, width=128, height=32)
serial.command.assert_has_calls([
# Initial burst are initialization commands
call(174, 213, 128, 168, 31, 211, 0, 64, 141, 20, 32, 0,
161, 200, 218, 2, 217, 241, 219, 64, 164, 166),
# set contrast
call(129, 207),
# reset the display
call(33, 0, 127, 34, 0, 3),
# called last, is a command to show the screen
call(175)
])
# Next 512 are all data: zero's to clear the RAM
# (512 = 128 * 32 / 8)
serial.data.assert_called_once_with([0] * (128 * 32 // 8))
def _init_display_device(self): # Init Device self.serial = i2c(port=1, address=0x3C) self.device = ssd1306(self.serial) # Setup & Start Display Loop Thread display_thread = threading.Thread(target=self._display_loop) display_thread.start()
def test_show():
"""
SSD1306 OLED screen content can be displayed.
"""
device = ssd1306(serial)
serial.reset_mock()
device.show()
serial.command.assert_called_once_with(175)
def test_hide():
"""
SSD1306 OLED screen content can be hidden.
"""
device = ssd1306(serial)
serial.reset_mock()
device.hide()
serial.command.assert_called_once_with(174)
def test_init_128x64():
ssd1306(serial)
serial.command.assert_has_calls([
# Initial burst are initialization commands
call(174, 213, 128, 168, 63, 211, 0, 64, 141, 20, 32, 0,
161, 200, 218, 18, 217, 241, 219, 64, 164, 166),
# set contrast
call(129, 207),
# reset the display
call(33, 0, 127, 34, 0, 7),
# called last, is a command to show the screen
call(175)
])
# Next 1024 are all data: zero's to clear the RAM
# (1024 = 128 * 64 / 8)
serial.data.assert_called_once_with([0] * (128 * 64 // 8))
def print_result(indent, result):
serial = i2c(port=1, address=0x3C)
device = ssd1306(serial)
device.clear()
with canvas(device) as draw:
draw.rectangle(device.bounding_box, outline="white", fill="black")
x = device.bounding_box[2]
y = device.bounding_box[3]
draw.text((int(x / 2) - indent, int(y / 2)), result, fill="white")
def __init__(self):
if import_success:
serial = i2c(port=1, address=0x3C)
self.disp = ssd1306(serial, rotate=0, height=32, width=128)
self.disp.cleanup = do_nothing
self.disp.clear()
else:
logger.warning("No display modules found, running in dummy mode")
def init_display():
try:
global serial
global device
serial = i2c(port=1, address=0x3C)
device = ssd1306(serial, rotate=0)
return True
except Exception as e:
return str(e)
def __init__():
# rev.1 users set port=0
# substitute spi(device=0, port=0) below if using that interface
serial = i2c(port=I2CPORT, address=I2CADDRESS)
# substitute ssd1331(...) or sh1106(...) below if using that device
device = ssd1306(serial)
t_greating = threading.Thread(target=showText(30, 40, "DACSYS"))
t_greating.start()
def __init__(self):
# init device
serial = i2c(port=1, address=0x3C)
self.device = ssd1306(serial, width=128, height=32, rotate=0)
# init fonts
font_path = '/usr/share/fonts/truetype/ttf-dejavu/DejaVuSansMono.ttf'
self.font = ImageFont.truetype(font_path, 16)
self.font_medium = ImageFont.truetype(font_path, 12)
self.font_small = ImageFont.truetype(font_path, 8)
def test_init_64x32():
"""
SSD1306 OLED with a 64 x 32 resolution works correctly.
"""
ssd1306(serial, width=64, height=32)
serial.command.assert_has_calls([
# Initial burst are initialization commands
call(174, 213, 128, 168, 31, 211, 0, 64, 141, 20, 32, 0,
161, 200, 218, 18, 217, 241, 219, 64, 164, 166),
# set contrast
call(129, 207),
# reset the display
call(33, 32, 95, 34, 0, 3),
# called last, is a command to show the screen
call(175)
])
# Next bytes are all data: zero's to clear the RAM
serial.data.assert_called_once_with([0] * (64 * 32 // 8))
def __init_ssd1306(self, height):
'''
Memo
====
Use device=0 when connecting CS of display to P01-24 (GPIO 8 [CE0]).
'''
serial = spi(device=0, port=0)
device = ssd1306(serial, width=self.width, height=height)
return device
def __init__(self, rows=64, cols=128, i2c_address=0x3d, i2c_port=1):
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)
self.device = ssd1306(serial)
def run(self):
font2 = ImageFont.truetype('/etc/stratux-screen/CnC_Red_Alert.ttf', 12)
serial = i2c(port=1, address=0x3c)
oled = ssd1306(serial)
with canvas(oled) as draw:
logo = Image.open('/etc/stratux-screen/stratux-logo-64x64.bmp')
draw.bitmap((32, 0), logo, fill=1)
time.sleep(10)
n = 0
while 1:
time.sleep(1)
response = urllib2.urlopen('http://localhost/getStatus')
getStatusHTML = response.read()
getStatusData = json.loads(getStatusHTML)
CPUTemp = getStatusData["CPUTemp"]
uat_current = getStatusData["UAT_messages_last_minute"]
uat_max = getStatusData["UAT_messages_max"]
es_current = getStatusData["ES_messages_last_minute"]
es_max = getStatusData["ES_messages_max"]
response = urllib2.urlopen('http://localhost/getTowers')
getTowersHTML = response.read()
getTowersData = json.loads(getTowersHTML)
NumTowers = 0
for towerLatLng in getTowersData:
print getTowersData[towerLatLng]["Messages_last_minute"]
if (getTowersData[towerLatLng]["Messages_last_minute"] > 0):
NumTowers += 1
with canvas(oled) as draw:
pad = 2 # Two pixels on the left and right.
text_margin = 25
# UAT status.
draw.text((50, 0), "UAT", font=font2, fill=255)
# "Status bar", 2 pixels high.
status_bar_width_max = oled.width - (2 * pad) - (2 * text_margin)
status_bar_width = 0
if uat_max > 0:
status_bar_width = int((float(uat_current) / uat_max) * status_bar_width_max)
draw.rectangle((pad + text_margin, 14, pad + text_margin + status_bar_width, 20), outline=255, fill=255) # Top left, bottom right.
# Draw the current (left) and max (right) numbers.
draw.text((pad, 14), str(uat_current), font=font2, fill=255)
draw.text(((2*pad) + text_margin + status_bar_width_max, 14), str(uat_max), font=font2, fill=255)
# ES status.
draw.text((44, 24), "1090ES", font=font2, fill=255)
status_bar_width = 0
if es_max > 0:
status_bar_width = int((float(es_current) / es_max) * status_bar_width_max)
draw.rectangle((pad + text_margin, 34, pad + text_margin + status_bar_width, 40), outline=255, fill=255) # Top left, bottom right.
# Draw the current (left) and max (right) numbers.
draw.text((pad, 34), str(es_current), font=font2, fill=255)
draw.text(((2*pad) + text_margin + status_bar_width_max, 34), str(es_max), font=font2, fill=255)
# Other stats.
seq = (n / 5) % 2
t = ""
if seq == 0:
t = "CPU: %0.1fC, Towers: %d" % (CPUTemp, NumTowers)
if seq == 1:
t = "GPS Sat: %d/%d/%d" % (getStatusData["GPS_satellites_locked"], getStatusData["GPS_satellites_seen"], getStatusData["GPS_satellites_tracked"])
if getStatusData["GPS_solution"] == "GPS + SBAS (WAAS / EGNOS)":
t = t + " (WAAS)"
#print t
draw.text((pad, 45), t, font=font2, fill=255)
n = n+1
#!/usr/bin/env python
from luma.core.interface.serial import i2c
from luma.core.render import canvas
from luma.oled.device import ssd1306
serial = i2c(port=1, address=0x3C)
device = ssd1306(serial)
device.cleanup = lambda _: None
with canvas(device) as draw:
draw.rectangle(device.bounding_box, outline="white", fill="black")
draw.text((30, 40), "Hello World", fill="white")
def main():
oled = ssd1306(port=1, address=0x3C)
while True:
stats(oled)
time.sleep(5)
