def __init__(self):
self.name = 'ScrollPhat'
log_str('init {}'.format(self.__module__))
self.rotation = SCROLL_ROTATION
scrollphat.set_rotate(self.rotation)
self.hour = int(datetime.now().strftime("%H"))
if 9 <= self.hour <= 17:
self.brightness = HIGH.scrollphat
self.brightness_setting = 'day'
elif 18 <= self.hour <= 23 or 0 <= self.hour <= 8:
self.brightness = LOW.scrollphat
self.brightness_setting = 'night'
else:
self.brightness = self.brightness
log_str('scrollphat brightness: {} - {}: {}'.format(
self.brightness, self.brightness_setting, self.hour))
scrollphat.set_brightness(self.brightness)
def get_rain_forecast(self):
percentage_list = []
color = False
forecast_range_hour = 8
color_list = []
for item in self.hourly_data:
rain_percentage = item['precipProbability'] * 100
percentage_list.append(round(rain_percentage))
for percentage in percentage_list[:forecast_range_hour]:
if percentage == 0:
color = "G" # GREEN
elif 0 < percentage <= 15:
color = "Y" # YELLOW
elif 16 < percentage <= 30:
color = "O"
elif 31 <= percentage <= 100:
color = "R" # RED
color_list.append(color)
log_str('precip probability 8h: {}'.format(percentage_list[:forecast_range_hour]))
log_str('colors on display: {}'.format(color_list))
return color_list
def draw_animation(self, image=Image.open(TEST_IMAGE)):
# this is the original pimoroni function for drawing sprites
log_str('start image loop')
for o_x in range(int(image.size[0] / self.width)):
for o_y in range(int(image.size[1] / self.height)):
valid = False
for x in range(self.width):
for y in range(self.height):
pixel = image.getpixel(((o_x * self.width) + y, (o_y * self.height) + x))
r, g, b = int(pixel[0]), int(pixel[1]), int(pixel[2])
if r or g or b:
valid = True
unicorn.set_pixel(x, y, r, g, b)
if valid:
unicorn.show()
sleep(0.25)
log_str('image loop done')
def __init__(self):
self.name = 'Data'
if path.isfile(DATA_PATH):
with lock_func:
log_str('locking {}'.format(self.name))
try:
self.data = load(open(DATA_PATH))
self.icon = self.data['currently']['icon']
self.temp = self.data['currently']['sensor_temp_outside']
self.summary = self.data['currently']['summary']
self.hourly_data = self.data['hourly']['data']
log_str('init {}'.format(self.__module__))
except Exception as e:
log_str('*** DATA-ERROR: {}'.format(e))
finally:
log_str('releasing {}'.format(self.name))
else:
log_str('*** DATA-ERROR: No File')
def __init__(self):
self.name = 'UniCorn'
log_str('init {}'.format(self.__module__))
self.rotation = UNICORN_ROTATION
unicorn.rotation(self.rotation)
self.width, self.height = unicorn.get_shape()
self.hour = int(datetime.now().strftime("%H"))
if 9 <= self.hour <= 17:
self.brightness = HIGH.unicorn
self.brightness_setting = 'day'
elif 18 <= self.hour <= 23 or 0 <= self.hour <= 8:
self.brightness = LOW.unicorn
self.brightness_setting = 'night'
else:
self.brightness = self.brightness
log_str('unicorn brightness: {} - {}: {}'.format(self.brightness, self.brightness_setting, self.hour))
unicorn.brightness(self.brightness)
def set_scroll_brightness(cls, level=brightness):
cls.brightness = level
log_str('set scrollphat brightness: {}'.format(cls.brightness))
scrollphat.set_brightness(cls.brightness)
return cls.brightness
def quit_all(self):
log_str('kill all timers')
try:
for timer in TIMER:
timer.cancel()
finally:
self.clear_all(False)
def set_unicorn_brightness(cls, level=brightness):
cls.brightness = level
log_str('unicorn brightness: {}'.format(cls.brightness))
unicorn.brightness(cls.brightness)
return cls.brightness
def clear(self, fast):
log_str('clear blinkt')
if not fast:
for i in reversed(range(8)):
blinkt.set_pixel(i, 0, 0, 0)
self.fade()
blinkt.clear()
blinkt.show()
def clear(fast=False):
log_str('clear scroll')
if not fast:
for x in range(11):
for y in range(5):
scrollphat.set_pixel(x, y, 0)
sleep(0.015)
scrollphat.update()
scrollphat.clear_buffer()
scrollphat.clear()
scrollphat.update()
def clear(self, fast=False):
log_str('clear unicorn')
if not fast:
for x in range(self.width):
for y in range(self.height):
unicorn.set_pixel(x, y, 0, 0, 0)
sleep(0.025)
unicorn.show()
unicorn.clear()
unicorn.show()
unicorn.off()
def __init__(self):
self.name = 'Blinkt'
log_str('init {}'.format(self.__module__))
self.hour = int(datetime.now().strftime("%H"))
if 9 <= self.hour <= 17:
self.brightness = HIGH.blinkt
self.brightness_setting = 'day'
elif 18 <= self.hour <= 23 or 0 <= self.hour <= 8:
self.brightness = LOW.blinkt
self.brightness_setting = 'night'
else:
self.brightness = self.brightness
log_str('blinkt brightness: {} - {}: {}'.format(
self.brightness, self.brightness_setting, self.hour))
blinkt.set_brightness(self.brightness)
def data_loop(self):
t = Timer(60, self.data_loop)
TIMER.append(t)
t.start()
try:
log_str('trying contact url: {}'.format(self.API_ENDPOINT))
connection = get(self.API_ENDPOINT, timeout=15)
data = connection.json()
log_str('status: {} | url: {}'.format(connection.status_code,
connection.url))
log_str('Update done!')
with lock_func:
log_str('locking thread {}'.format(t.name))
try:
with open(DATA_PATH, 'w') as outputfile:
json.dump(data, outputfile, indent=2, sort_keys=True)
log_str('json file saved to {}'.format(DATA_PATH))
except FileNotFoundError as error:
log_str('*** Update-Error: {}'.format(error, DATA_PATH))
finally:
log_str('releasing thread {}'.format(t.name))
except Exception as exception:
log_str('*** Update-Exception: {}'.format(exception))
def __init__(self):
self.name = 'Update'
log_str('init {}'.format(self.__module__))
self.API_ENDPOINT = API_ENDPOINT
def image(self):
image = ICON_PATH + self.icon + ICON_EXTENSION
log_str(image)
return image
def show_str(string=TEST_STRING):
log_str(string)
scrollphat.clear_buffer()
scrollphat.write_string(string)
rain_percentage = item['precipProbability'] * 100
percentage_list.append(round(rain_percentage))
for percentage in percentage_list[:forecast_range_hour]:
if percentage == 0:
color = "G" # GREEN
elif 0 < percentage <= 15:
color = "Y" # YELLOW
elif 16 < percentage <= 30:
color = "O"
elif 31 <= percentage <= 100:
color = "R" # RED
color_list.append(color)
log_str('precip probability 8h: {}'.format(percentage_list[:forecast_range_hour]))
log_str('colors on display: {}'.format(color_list))
return color_list
if __name__ == '__main__':
myData = Data()
myData.image()
log_str(myData.summary_str)
log_str(myData.temp_str)
log_str(myData.output_str())
log_str(myData.get_rain_forecast())
def clear_all(self, fast=True):
log_str('clear all {}'.format(self.name))
Blinkt().clear(fast)
ScrollPhat().clear(fast)
UniCorn().clear(fast)
def run(self):
log_str('run {}'.format(self.name))
self.start()
def stop(self):
log_str('stop {}'.format(self.name))
self.quit_all()
def start(self):
log_str('start {}'.format(self.name))
log_str('still alive {}'.format(self.running))
# do init stuff here
self.clear_all(True)
Blinkt().show_graph()
ScrollPhat().show_str()
UniCorn().draw_animation()
try:
log_str('still alive {}'.format(self.running))
# start all loops
Update().data_loop()
ScrollPhat().show_str(Data().output_str())
Blinkt().show_graph(Data().get_rain_forecast())
UniCorn().icon_loop()
log_str('after the image loop')
Blinkt().led_loop()
log_str('after the led loop')
ScrollPhat().str_loop()
log_str('after the scroll loop')
while self.running:
time.sleep(1)
log_str('still alive {}'.format(self.running))
log_str('still alive {}'.format(self.running))
except KeyboardInterrupt:
log_str('*** quit: {}'.format(self.name))
atexit._run_exitfuncs()
def __init__(self):
self.name = 'myApp'
log_str('init {}'.format(self.name))
self.running = True
atexit.register(self.stop)