516 lines
18 KiB
Python
516 lines
18 KiB
Python
# Many thanks to https://stackoverflow.com/questions/18923321/making-a-clock-in-kivy
|
|
import collections
|
|
import datetime
|
|
import math
|
|
import sys
|
|
import traceback
|
|
|
|
from kivy.app import App
|
|
from kivy.uix.floatlayout import FloatLayout
|
|
from kivy.uix.label import Label
|
|
from kivy.uix.slider import Slider
|
|
from kivy.clock import Clock
|
|
from kivy.lang import Builder
|
|
from kivy.graphics import Color, Line, Rectangle
|
|
|
|
from multiprocessing import Process
|
|
from playsound import playsound
|
|
|
|
Builder.load_string('''
|
|
<MyClockWidget>:
|
|
on_pos: self.update_display()
|
|
on_size: self.update_display()
|
|
|
|
FloatLayout
|
|
id: face
|
|
size_hint: None, None
|
|
pos_hint: {"center_x":0.5, "center_y":0.5}
|
|
size: 0.9*min(root.size), 0.9*min(root.size)
|
|
canvas:
|
|
Color:
|
|
rgb: 0.1, 0.1, 0.1
|
|
Ellipse:
|
|
size: self.size
|
|
pos: self.pos
|
|
|
|
FloatLayout
|
|
id: hands
|
|
size_hint: None, None
|
|
pos_hint: {"center_x":0.5, "center_y":0.5}
|
|
size: 0.9*min(root.size), 0.9*min(root.size)
|
|
|
|
FloatLayout
|
|
id: set_alarm_button
|
|
size_hint: None, None
|
|
pos_hint: {"center_x":0.9, "center_y":0.1}
|
|
size: 0.1*min(root.size), 0.1*min(root.size)
|
|
|
|
FloatLayout
|
|
id: settings_button
|
|
size_hint: None, None
|
|
pos_hint: {"center_x":0.9, "center_y":0.9}
|
|
size: 0.1*min(root.size), 0.1*min(root.size)
|
|
|
|
FloatLayout
|
|
id: settings_menu
|
|
size_hint: None, None
|
|
pos_hint: {"center_x":0.5, "center_y":0.5}
|
|
size: 0.7*min(root.size), 0.7*min(root.size)
|
|
canvas:
|
|
Color:
|
|
rgb: 0.1, 0.1, 0.1
|
|
Rectangle:
|
|
size: self.size
|
|
pos: self.pos
|
|
GridLayout:
|
|
rows: 6
|
|
cols: 2
|
|
Label:
|
|
text:"Volume"
|
|
Slider:
|
|
id: volume_slider
|
|
min: 0
|
|
max: 20
|
|
value: 4
|
|
on_value: root.volume_slider_value(*args)
|
|
Label:
|
|
text:"Wake up brightness"
|
|
Slider:
|
|
id: wake_up_bightness_slider
|
|
min: 0
|
|
max: 20
|
|
value: 20
|
|
Label:
|
|
text:"Reading light brightness"
|
|
Slider:
|
|
id: reading_light_brightness_slider
|
|
min: 0
|
|
max: 20
|
|
value: 1
|
|
Label:
|
|
text:"Wifi network"
|
|
Label:
|
|
text:"wifi name"
|
|
Label:
|
|
text:"Wifi password"
|
|
Label:
|
|
text:"wifi password"
|
|
Label:
|
|
text:"Calendar URL"
|
|
Label:
|
|
text:"calendar url"
|
|
''')
|
|
|
|
Position = collections.namedtuple('Position', 'x y')
|
|
|
|
global sound_process
|
|
sound_process = None
|
|
|
|
def play_sound(source):
|
|
while True:
|
|
print("beep beep!")
|
|
playsound(source)
|
|
|
|
class AlarmSettings():
|
|
alarm_time = datetime.datetime(2022, 12, 10, 7, 30, 0, 0)
|
|
alarm_activated = False
|
|
|
|
alarm_modified = False
|
|
led_color = [0, 0, 0]
|
|
# sound_source = "https://icecast.omroep.nl/radio1-bb-mp3"
|
|
sound_source = "Woodpecker Chirps - QuickSounds.com.mp3"
|
|
seconds_to_sunrise = 30 * 60
|
|
|
|
volume = 4
|
|
wake_up_brightness = 20
|
|
reading_light_brightness = 1
|
|
|
|
class MyClockWidget(FloatLayout):
|
|
grabbed = ""
|
|
face_numbers = []
|
|
|
|
# if not grabbed, set_alarm_timeout_counter is incremented at every update call (ie: 60 Hz);
|
|
# this is used to blink the hands at 1 Hz when setting the alarm and releasing the hand
|
|
set_alarm_timeout_counter = 0
|
|
seconds_to_next_alarm = 0
|
|
led_color = [0, 0, 0]
|
|
|
|
# view can be "clock" "set_alarm" "settings" or "calendar"
|
|
view = "clock"
|
|
|
|
def hide_widget(self, widget, hide=True):
|
|
if hasattr(widget, 'saved_attrs'):
|
|
if not hide:
|
|
widget.height, widget.size_hint_y, widget.opacity, widget.disabled = widget.saved_attrs
|
|
del widget.saved_attrs
|
|
elif hide:
|
|
widget.saved_attrs = widget.height, widget.size_hint_y, widget.opacity, widget.disabled
|
|
widget.height, widget.size_hint_y, widget.opacity, widget.disabled = 0, None, 0, True
|
|
|
|
def draw_face(self):
|
|
"""
|
|
Add number labels when added in widget hierarchy
|
|
"""
|
|
|
|
alarm_settings = App.get_running_app().alarm_settings
|
|
|
|
if self.view == "set_alarm":
|
|
time = alarm_settings.alarm_time
|
|
else:
|
|
time = datetime.datetime.now()
|
|
|
|
for i in range(1, 13):
|
|
if time.hour < 12:
|
|
offset = 0
|
|
else:
|
|
offset = 12
|
|
|
|
self.face_numbers.append(Label(
|
|
text=str(i + offset),
|
|
pos_hint={
|
|
# pos_hint is a fraction in range (0, 1)
|
|
"center_x": 0.5 + 0.45*math.sin(2 * math.pi * i/12),
|
|
"center_y": 0.5 + 0.45*math.cos(2 * math.pi * i/12),
|
|
}
|
|
))
|
|
self.ids["face"].add_widget(self.face_numbers[i - 1])
|
|
|
|
def draw_settings(self):
|
|
Color(1, 1, 1)
|
|
# self.ids["settings_menu"].add_widget(Rectangle(pos=(10, 10), size=(500, 500)))
|
|
return
|
|
|
|
def update_face(self):
|
|
alarm_settings = App.get_running_app().alarm_settings
|
|
|
|
if self.view == "set_alarm":
|
|
time = alarm_settings.alarm_time
|
|
else:
|
|
time = datetime.datetime.now()
|
|
|
|
for i in range(0, 12):
|
|
if time.hour < 12:
|
|
offset = 0
|
|
else:
|
|
offset = 12
|
|
|
|
self.face_numbers[i].text=str(i + 1 + offset)
|
|
|
|
|
|
def on_parent(self, myclock, parent):
|
|
self.draw_face()
|
|
self.draw_settings()
|
|
|
|
def position_on_clock(self, fraction, length):
|
|
"""
|
|
Calculate position in the clock using trygonometric functions
|
|
"""
|
|
center_x = self.size[0]/2
|
|
center_y = self.size[1]/2
|
|
return Position(
|
|
center_x + length * math.sin(2 * math.pi * fraction),
|
|
center_y + length * math.cos(2 * math.pi * fraction),
|
|
)
|
|
|
|
def update_set_alarm_button(self):
|
|
app = App.get_running_app()
|
|
alarm_settings = app.alarm_settings
|
|
|
|
if (self.view == "set_alarm") or alarm_settings.alarm_activated:
|
|
source = 'alarm_on.png'
|
|
rgb = [0.9, 0.0, 0.0]
|
|
else:
|
|
source = 'alarm_off.png'
|
|
rgb = [1.0, 1.0, 1.0]
|
|
|
|
set_alarm_button = self.ids["set_alarm_button"]
|
|
set_alarm_button.canvas.clear()
|
|
with set_alarm_button.canvas:
|
|
Color(rgb[0], rgb[1], rgb[2])
|
|
Rectangle(size=set_alarm_button.size, pos=set_alarm_button.pos, source=source)
|
|
|
|
def update_settings_button(self):
|
|
app = App.get_running_app()
|
|
alarm_settings = app.alarm_settings
|
|
|
|
if (self.view == "settings"):
|
|
source = 'settings_visible.png'
|
|
rgb = [0.9, 0.0, 0.0]
|
|
else:
|
|
source = 'settings_not_visible.png'
|
|
rgb = [1.0, 1.0, 1.0]
|
|
|
|
settings_button = self.ids["settings_button"]
|
|
settings_button.canvas.clear()
|
|
with settings_button.canvas:
|
|
Color(rgb[0], rgb[1], rgb[2])
|
|
Rectangle(size=settings_button.size, pos=settings_button.pos, source=source)
|
|
|
|
def sun_rise(self):
|
|
alarm_settings = App.get_running_app().alarm_settings
|
|
|
|
# to do: calculate brightness and color according to sun rise instead of linear increment
|
|
intensity = math.floor((1.0 - self.seconds_to_next_alarm / alarm_settings.seconds_to_sunrise) * 256.0)
|
|
if intensity < 0:
|
|
intensity = 0
|
|
|
|
led_color = [0, 0, 0]
|
|
for i in range(3):
|
|
led_color[i] = intensity
|
|
|
|
if self.led_color != led_color:
|
|
self.led_color = led_color
|
|
|
|
def check_sun_rise(self):
|
|
alarm_settings = App.get_running_app().alarm_settings
|
|
|
|
if alarm_settings.alarm_activated == False:
|
|
return
|
|
|
|
if self.seconds_to_next_alarm < alarm_settings.seconds_to_sunrise:
|
|
self.sun_rise()
|
|
|
|
def check_play_sound(self):
|
|
global sound_process
|
|
alarm_settings = App.get_running_app().alarm_settings
|
|
|
|
if alarm_settings.alarm_activated == False:
|
|
return
|
|
|
|
if self.seconds_to_next_alarm < 0.1 and sound_process is None:
|
|
sound_process = Process(target=play_sound, args=(alarm_settings.sound_source,))
|
|
sound_process.start()
|
|
|
|
def calc_seconds_to_next_alarm(self):
|
|
alarm_settings = App.get_running_app().alarm_settings
|
|
|
|
if alarm_settings.alarm_activated == False:
|
|
return
|
|
|
|
# Make sure alarm_time is in the future but not more than 24 h from now
|
|
now = datetime.datetime.now()
|
|
d = alarm_settings.alarm_time - now
|
|
alarm_settings.alarm_time -= datetime.timedelta(days=d.days)
|
|
|
|
# Calculate number of seconds until next alarm
|
|
d = alarm_settings.alarm_time - now
|
|
self.seconds_to_next_alarm = d.days * 24 * 3600 + d.seconds + d.microseconds / 1000000.0
|
|
|
|
def check_alarm(self):
|
|
self.calc_seconds_to_next_alarm()
|
|
self.check_sun_rise()
|
|
self.check_play_sound()
|
|
|
|
def update_clock(self):
|
|
self.hide_widget(self.ids["face"], False)
|
|
self.hide_widget(self.ids["hands"], False)
|
|
self.check_alarm()
|
|
"""
|
|
Redraw clock hands
|
|
"""
|
|
alarm_settings = App.get_running_app().alarm_settings
|
|
if self.view == "set_alarm":
|
|
time = alarm_settings.alarm_time
|
|
else:
|
|
time = datetime.datetime.now()
|
|
|
|
hands = self.ids["hands"]
|
|
seconds_hand = self.position_on_clock(time.second/60, length=0.45*hands.size[0])
|
|
minutes_hand = self.position_on_clock(time.minute/60+time.second/3600, length=0.40*hands.size[0])
|
|
hours_hand = self.position_on_clock(time.hour/12 + time.minute/720, length=0.35*hands.size[0])
|
|
|
|
self.update_face()
|
|
|
|
hands.canvas.clear()
|
|
with hands.canvas:
|
|
if self.view == "set_alarm":
|
|
if self.grabbed != "" or self.set_alarm_timeout_counter < 1 * 60 or \
|
|
self.set_alarm_timeout_counter % 60 <= 30 or alarm_settings.alarm_modified == False:
|
|
Color(0.9, 0.0, 0.0)
|
|
Line(points=[hands.center_x, hands.center_y, hours_hand.x, hours_hand.y], width=3, cap="round")
|
|
Color(0.8, 0.0, 0.0)
|
|
Line(points=[hands.center_x, hands.center_y, minutes_hand.x, minutes_hand.y], width=2, cap="round")
|
|
|
|
if self.grabbed == "":
|
|
self.set_alarm_timeout_counter += 1
|
|
|
|
if self.set_alarm_timeout_counter >= 4 * 60 + 30:
|
|
self.view = "clock"
|
|
self.set_alarm_timeout_counter = 0
|
|
|
|
if alarm_settings.alarm_modified:
|
|
alarm_settings.alarm_activated = True
|
|
alarm_settings.alarm_modified = False
|
|
else:
|
|
Color(0.9, 0.9, 0.9)
|
|
Line(points=[hands.center_x, hands.center_y, hours_hand.x, hours_hand.y], width=3, cap="round")
|
|
Color(0.8, 0.8, 0.8)
|
|
Line(points=[hands.center_x, hands.center_y, minutes_hand.x, minutes_hand.y], width=2, cap="round")
|
|
Color(0.7, 0.7, 0.7)
|
|
Line(points=[hands.center_x, hands.center_y, seconds_hand.x, seconds_hand.y], width=1, cap="round")
|
|
|
|
def update_settings(self):
|
|
self.hide_widget(self.ids["settings_menu"], False)
|
|
|
|
def update_display(self, *args):
|
|
# Hide all dynamic widgets; will be enabled when updating respecive view
|
|
self.hide_widget(self.ids["face"], True)
|
|
self.hide_widget(self.ids["hands"], True)
|
|
self.hide_widget(self.ids["settings_menu"], True)
|
|
|
|
self.update_set_alarm_button()
|
|
self.update_settings_button()
|
|
if self.view == "clock" or self.view == "set_alarm":
|
|
self.update_clock()
|
|
elif self.view == "settings":
|
|
self.update_settings()
|
|
|
|
def volume_slider_value(self, *args):
|
|
alarm_settings = App.get_running_app().alarm_settings
|
|
alarm_settings.volume = int(args[1])
|
|
print(str(int(args[1])))
|
|
|
|
def on_alarm_button_pressed(self):
|
|
alarm_settings = App.get_running_app().alarm_settings
|
|
alarm_settings.alarm_modified = False
|
|
self.set_alarm_timeout_counter = 0
|
|
|
|
if self.view == "set_alarm":
|
|
self.view = "clock"
|
|
alarm_settings.alarm_activated = False
|
|
else:
|
|
self.view = "set_alarm"
|
|
alarm_settings.alarm_activated = True
|
|
|
|
def on_settings_button_pressed(self):
|
|
print("settings button pressed from view " + self.view)
|
|
if self.view != "settings":
|
|
self.view = "settings"
|
|
else:
|
|
self.view = "clock"
|
|
print("view updated to " + self.view)
|
|
|
|
def on_touch_up(self, touch):
|
|
self.grabbed = ""
|
|
alarm_settings = App.get_running_app().alarm_settings
|
|
|
|
if (self.view == "set_alarm") and (self.grabbed == "hour" or self.grabbed == "minute"):
|
|
self.set_alarm_timeout_counter = 0
|
|
|
|
super(MyClockWidget, self).on_touch_up(touch)
|
|
|
|
def on_touch_move(self, touch):
|
|
alarm_settings = App.get_running_app().alarm_settings
|
|
self.alarm_set_timeout = 0
|
|
x = touch.pos[0] - self.size[0]/2
|
|
y = touch.pos[1] - self.size[1]/2
|
|
angle = math.atan2(y, x) / math.pi; # angle is between -1 and 1
|
|
if self.grabbed == "minute":
|
|
alarm_settings.alarm_modified = True
|
|
self.set_alarm_timeout_counter = 0
|
|
minute = round(-angle * 30 + 15)
|
|
if minute < 0:
|
|
minute += 60
|
|
if minute == 60:
|
|
minute = 59
|
|
|
|
# hour correction
|
|
hour = alarm_settings.alarm_time.hour
|
|
if alarm_settings.alarm_time.minute >= 55 and minute <= 5:
|
|
hour += 1
|
|
elif alarm_settings.alarm_time.minute <= 5 and minute >= 55:
|
|
hour -= 1
|
|
|
|
if hour == 24:
|
|
hour = 0
|
|
elif hour == -1:
|
|
hour = 23
|
|
|
|
alarm_settings.alarm_time = datetime.datetime(alarm_settings.alarm_time.year, \
|
|
alarm_settings.alarm_time.month, alarm_settings.alarm_time.day, \
|
|
hour, minute, alarm_settings.alarm_time.second, 0)
|
|
elif self.grabbed == "hour":
|
|
alarm_settings.alarm_modified = True
|
|
self.set_alarm_timeout_counter = 0
|
|
hour = round(-angle * 6 + 3)
|
|
if hour < 0:
|
|
hour += 12
|
|
if hour == 12:
|
|
hour = 0
|
|
|
|
if alarm_settings.alarm_time.hour >= 12:
|
|
hour += 12
|
|
|
|
# AM / PM correction
|
|
if alarm_settings.alarm_time.hour == 11 and hour == 0:
|
|
hour = 12
|
|
elif alarm_settings.alarm_time.hour == 23 and hour == 12:
|
|
hour = 0
|
|
elif alarm_settings.alarm_time.hour == 0 and hour == 11:
|
|
hour = 23
|
|
elif alarm_settings.alarm_time.hour == 12 and hour == 23:
|
|
hour = 11
|
|
|
|
# AM / PM boundary
|
|
alarm_settings.alarm_time = datetime.datetime(alarm_settings.alarm_time.year, \
|
|
alarm_settings.alarm_time.month, alarm_settings.alarm_time.day, \
|
|
hour, alarm_settings.alarm_time.minute, alarm_settings.alarm_time.second, 0)
|
|
|
|
super(MyClockWidget, self).on_touch_move(touch)
|
|
|
|
def on_touch_down(self, touch):
|
|
global sound_process
|
|
|
|
alarm_settings = App.get_running_app().alarm_settings
|
|
time = alarm_settings.alarm_time
|
|
hands = self.ids["hands"]
|
|
minutes_hand = self.position_on_clock(time.minute/60+time.second/3600, length=0.40*hands.size[0])
|
|
hours_hand = self.position_on_clock(time.hour/12 + time.minute/720, length=0.35*hands.size[0])
|
|
|
|
self.grabbed = ""
|
|
app = App.get_running_app()
|
|
alarm_settings = app.alarm_settings
|
|
|
|
if (0.85 <= touch.spos[0] <= 0.95) and (0.05 <= touch.spos[1] <= 0.15):
|
|
self.on_alarm_button_pressed()
|
|
elif (0.85 <= touch.spos[0] <= 0.95) and (0.85 <= touch.spos[1] <= 0.95):
|
|
self.on_settings_button_pressed()
|
|
elif sound_process is not None:
|
|
kill_sound_process()
|
|
elif self.view == "set_alarm":
|
|
self.set_alarm_timeout_counter = 0
|
|
if (minutes_hand.x - 0.1 * self.size[0] <= touch.pos[0] <= minutes_hand.x + 0.1 * self.size[0]) and \
|
|
(minutes_hand.y - 0.1 * self.size[1] <= touch.pos[1] <= minutes_hand.y + 0.1 * self.size[1]):
|
|
self.grabbed = "minute"
|
|
elif (hours_hand.x - 0.1 * self.size[0] <= touch.pos[0] <= hours_hand.x + 0.1 * self.size[0]) and \
|
|
(hours_hand.y - 0.1 * self.size[1] <= touch.pos[1] <= hours_hand.y + 0.1 * self.size[1]):
|
|
self.grabbed = "hour"
|
|
|
|
super(MyClockWidget, self).on_touch_down(touch)
|
|
|
|
|
|
class MyApp(App):
|
|
alarm_settings = AlarmSettings()
|
|
|
|
def build(self):
|
|
clock_widget = MyClockWidget()
|
|
# update initially, just after construction of the widget is complete
|
|
Clock.schedule_once(clock_widget.update_display, 0)
|
|
# then update 60 times per second
|
|
Clock.schedule_interval(clock_widget.update_display, 1.0/60.0)
|
|
return clock_widget
|
|
|
|
def kill_sound_process():
|
|
global sound_process
|
|
if sound_process is not None:
|
|
sound_process.kill()
|
|
sound_process = None
|
|
|
|
def except_hook(type, value, tb):
|
|
kill_sound_process()
|
|
|
|
if __name__ == '__main__':
|
|
# sys.excepthook = except_hook
|
|
MyApp().run()
|
|
|