class MyScreen(Singleton):
def __init__(self):
self.screenMgr = ScreenManager(size=WH)
self.name = "Root Screen"
self.transition = WipeTransition()
# or self.transition = SlideTransition(direction="down")
self.emptyScreen = Screen(name="empty screen")
#self.emptyScreen.add_widget(Label(text="empty.screen"))
self.add_screen(self.emptyScreen)
self.current_screen(self.emptyScreen)
def prev_screen(self):
prev_screen = self.screenMgr.previous()
if prev_screen:
self.screenMgr.current = prev_screen
def add_screen(self, screen):
if screen.name not in self.screenMgr.screen_names:
self.screenMgr.add_widget(screen)
def current_screen(self, screen):
if True or self.screenMgr.current != screen.name and self.screenMgr.has_screen(
screen.name):
self.screenMgr.current = screen.name
def remove_screen(self, screen):
if screen.name in self.screenMgr.screen_names:
self.screenMgr.remove_widget(screen)
self.prev_screen()
def get_current_screen(self):
return self.screenMgr.current
class MyScreen(Singleton):
def __init__(self):
self.screenMgr = ScreenManager(size=WH)
self.name = "Root Screen"
self.transition = WipeTransition()
# or self.transition = SlideTransition(direction="down")
self.emptyScreen = Screen(name = "empty screen")
#self.emptyScreen.add_widget(Label(text="empty.screen"))
self.add_screen(self.emptyScreen)
self.current_screen(self.emptyScreen)
def prev_screen(self):
prev_screen = self.screenMgr.previous()
if prev_screen:
self.screenMgr.current = prev_screen
def add_screen(self, screen):
if screen.name not in self.screenMgr.screen_names:
self.screenMgr.add_widget(screen)
def current_screen(self, screen):
if self.screenMgr.current != screen.name:
if not self.screenMgr.has_screen(screen.name):
self.add_screen(screen)
self.screenMgr.current = screen.name
def remove_screen(self, screen):
if screen.name in self.screenMgr.screen_names:
self.screenMgr.remove_widget(screen)
self.prev_screen()
def get_current_screen(self):
return self.screenMgr.current_screen
class AudiowallSet(BoxLayout):
def __init__(self, **kwargs):
super(AudiowallSet, self).__init__(**kwargs)
self.pages = []
self.active_page = 1
self._container = BoxLayout(orientation='vertical')
self.add_widget(self._container)
self._sm = ScreenManager()
self._sm.transition = SlideTransition()
self._sm.transition.duration = 0.3
self._container.add_widget(self._sm)
self._buttons = BoxLayout(orientation='horizontal', size_hint=(1,0.25))
self._container.add_widget(self._buttons)
self.previous = Button(text='<<')
self.previous.bind(on_press=self.on_previous)
self._buttons.add_widget(self.previous)
self.pages_label = Label()
self._buttons.add_widget(self.pages_label)
self.next = Button(text='>>')
self.next.bind(on_press=self.on_next)
self._buttons.add_widget(self.next)
def add_page(self, id, name):
screen = Screen()
screen.name = id
page = AudiowallPage()
page.name = name
screen.add_widget(page)
self._sm.add_widget(screen)
self.pages.append(page)
self.pages_label.text = 'Page %i of %i' % (self.active_page, len(self.pages))
def on_previous(self, *largs):
self._sm.transition.direction = 'right'
self._sm.current = self._sm.previous()
self.active_page -= 1
if(self.active_page == 0):
self.active_page = len(self.pages)
self.pages_label.text = 'Page %i of %i' % (self.active_page, len(self.pages))
def on_next(self, *largs):
self._sm.transition.direction = 'left'
self._sm.current = self._sm.next()
self.active_page += 1
if(self.active_page > len(self.pages)):
self.active_page = 1
self.pages_label.text = 'Page %i of %i' % (self.active_page, len(self.pages))
class TestApp(App):
title = "My Test App"
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.sm = ScreenManager(transition=SlideTransition())
self.sm.add_widget(BaseScreen(name=PageNames.BACKGROUND.name))
self.sm.add_widget(HomeScreen(name=PageNames.HOME_PAGE.name))
self.sm.add_widget(
ConfigurationScreen(name=PageNames.CONFIGURATION.name))
self._popup_exit = None
# Window.bind(on_keyboard=self.on_key)
def build(self):
self.icon = MyPath.Paths.RABO_ICON.value
Window.clearcolor = (0.25, 0.25, 0.25, 1)
Window.bind(on_keyboard=self.on_key)
Window.bind(on_request_close=self.on_request_close)
self.sm.current = PageNames.BACKGROUND.name
return self.sm
def on_key(self, window, key, *args):
if key in [276] and self.sm.current != PageNames.HOME_PAGE.name:
self.sm.transition.direction = 'right'
self.sm.current = self.sm.previous()
def on_request_close(self, *args, **kwargs):
if kwargs.get("source") != 'keyboard':
self.textpopup(title='Exit', text='Do you want to close the app?')
return True
def textpopup(self, title='', text=''):
box = GridLayout(cols=1, size_hint_x=0.25)
box.add_widget(Label(text=text))
button_grid = GridLayout(cols=2, size_hint_x=0.5, size_hint_y=0.35)
ok_button = Button(text='YES', size_hint=(0.25, 0.3))
ok_button.bind(on_release=self.stop)
button_grid.add_widget(ok_button)
cancel_button = Button(text="NO", size_hint=(0.25, 0.3))
cancel_button.bind(on_release=lambda *args: self._popup_exit.dismiss())
button_grid.add_widget(cancel_button)
box.add_widget(button_grid)
self._popup_exit = Popup(title=title,
content=box,
size_hint=(0.3, 0.4))
self._popup_exit.open()
class DescargarApp(App):
# Desactiva el cuadro de configuración genérico de Kivy
use_kivy_settings = False
# Para que no se cierre al cambiar de aplicación en Android
def on_pause(self):
return True
def build(self):
self.download_thread = None
self.store = JsonStore("descargar-aragontv.json")
if not self.store.exists("target_folder"):
if self.get_platform_name()=="android":
from jnius import autoclass
Environment = autoclass('android.os.Environment')
download_folder = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)
self.store.put("target_folder",value=download_folder.getAbsolutePath() )
else:
self.store.put("target_folder",value=os.path.expanduser("~") )
if not self.store.exists("source_url"):
self.store.put("source_url",value="http://alacarta.aragontelevision.es/programas/chino-chano/por-la-sierra-de-armantes-28022016-1452")
self.screen_manager = ScreenManager(transition=FadeTransition())
self.paso1 = Paso1(name='Paso 1')
self.paso1.ids.target_folder.text = self.store.get("target_folder")["value"]
self.paso1.ids.page_url.text = self.store.get("source_url")["value"]
self.paso2 = Paso2(name='Paso 2')
self.paso3 = Paso3(name='Paso 3')
self.screen_manager.add_widget(self.paso1)
self.screen_manager.add_widget(self.paso2)
self.screen_manager.add_widget(self.paso3)
return self.screen_manager
def dismiss_popup(self):
self._popup.dismiss()
def target_selected(self, path, filename):
self._popup.dismiss()
self.paso1.ids.target_folder.text = path
self.store.put("target_folder",value=self.paso1.ids.target_folder.text)
def target_selection(self):
content = LoadDialog(load=self.target_selected, cancel=self.dismiss_popup)
content.ids.filechooser.path = self.paso1.ids.target_folder.text
self._popup = Popup(title="Elige destino", content=content, size_hint=(0.9, 0.9))
self._popup.open()
def message(self,title,body):
content = MessageDialog()
content.ids.message_body.text = body
self._popup = Popup(title=title, content=content, size_hint=(0.8, 0.8))
self._popup.open()
def url_ready(self,page_url):
print "url_ready"
print self.paso1.ids.page_url.text
if not self.paso1.ids.page_url.text.startswith("http://") and not self.paso1.ids.page_url.text.startswith("https://"):
self.message("Hay un problema...","La URL que has introducido no es válida")
return
self.store.put("target_folder",value=self.paso1.ids.target_folder.text)
self.store.put("source_url",value=self.paso1.ids.page_url.text)
from core.item import Item
item = Item(url=self.paso1.ids.page_url.text)
from channels import aragontv
item = aragontv.detalle_episodio(item)
self.video_title = item.title
self.media_url = item.media_url
if self.media_url=="":
self.message("Hay un problema...","No se puede encontrar un vídeo en esa URL")
return
self.screen_manager.current = self.screen_manager.next()
self.paso2.ids.description.text = "[b]"+item.title+"[/b]\n\n"+item.plot
def start_download(self):
print "start_download"
self.paso3.resultado = "Descargando "+self.media_url+"\n\n"
self.screen_manager.current = self.screen_manager.next()
# Start download in background
from core import downloadtools
clean_file_name = downloadtools.limpia_nombre_caracteres_especiales(self.video_title.decode("utf-8"))+".flv"
#print "clean_file_name="+clean_file_name
self.target_file = os.path.join( self.paso1.ids.target_folder.text , clean_file_name )
#print "target_file="+self.target_file
if self.get_platform_name()=="win":
self.target_file = self.target_file.encode("utf-8")
# get_platform_name es: win, linux, android, macosx, ios or unknown
folder_platform = os.path.join( os.getcwd() , "rtmpdump" , self.get_platform_name() )
print "folder_platform="+folder_platform
if self.get_platform_name()=="win":
rtmpdump = os.path.join(folder_platform,"rtmpdump.exe")
elif self.get_platform_name()=="linux":
rtmpdump = "rtmpdump"
else:
rtmpdump = os.path.join(folder_platform,"rtmpdump")
# En Android hay que darle antes expresamente permisos de ejecución al binario de rtmpdump
if self.get_platform_name()=="android":
subprocess.Popen(["chmod","0755",rtmpdump], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
exe = [rtmpdump]
exe.append("-r")
exe.extend(self.media_url.replace("app=","--app ").replace("playpath=","--playpath ").split(" "))
#exe.append("--live")
exe.append("-o")
exe.append(self.target_file)
self.paso3.ids.cargando.opacity=1
self.download_thread = DownloadThread(exe,self.paso3)
self.download_thread.start()
Clock.schedule_interval(self.check_output_size, 0.5)
def abort_download(self):
print "abort_download"
self.download_thread.abort()
self.screen_manager.current = self.screen_manager.previous()
def check_output_size(self,value):
#print "check_output_size"
if os.path.exists(self.target_file):
statinfo = os.stat(self.target_file)
self.paso3.tamanyo = human_size(statinfo.st_size)
def on_stop(self):
print "on_stop!"
if self.download_thread is not None:
self.download_thread.abort()
def get_platform_name(self):
from kivy import platform
platform_name = str(platform)
print "platform_name="+platform_name
return platform_name
class DownloaderApp(App):
use_kivy_settings = False
def on_pause(self):
return True
def paste(self):
'''
try:
from kivy.core.clipboard import Clipboard
self.main_screen.ids.page_url.text = Clipboard.paste()
except:
logger.error("Could not be pasted to clipboard!")
pass
'''
pass
def copy(self,text):
try:
from kivy.core.clipboard import Clipboard
Clipboard.copy(text)
except:
logger.error("Could not be copied to clipboard: "+text)
pass
def build(self):
self.store = JsonStore("data/store.json")
self.download_thread = None
self.screen_manager = ScreenManager(transition=FadeTransition())
self.main_screen = StartScreen(name='Welcome Screen')
self.download_screen = DownloadScreen(name="Download Screen")
self.screen_manager.add_widget(self.main_screen)
self.screen_manager.add_widget(self.download_screen)
return self.screen_manager
def target_selected(self, path, filename):
self._popup.dismiss()
self.main_screen.ids.target_folder.text = path
self.store.put("target_folder",value=self.main_screen.ids.target_folder.text)
def target_selection(self):
content = LoadDialog(load=self.target_selected, cancel=self.dismiss_popup)
content.ids.filechooser.path = self.main_screen.ids.target_folder.text
self._popup = Popup(title="Choose destination", content=content, size_hint=(0.9, 0.9))
self._popup.open()
def dismiss_popup(self):
self._popup.dismiss()
def url_ready(self,page_url):
if not self.main_screen.ids.page_url.text.startswith("http://") and not self.main_screen.ids.page_url.text.startswith("https://"):
self.message("There is a problem...","URL is not accepted, needs an http/s url")
return
self.store.put("target_folder",value=self.main_screen.ids.target_folder.text)
self.store.put("source_url",value=self.main_screen.ids.page_url.text)
self.media_url = self.main_screen.ids.page_url.text
self.video_title = self.media_url
self.screen_manager.current = self.screen_manager.next()
self.start_download()
def start_download(self):
logger.debug("start_download called")
self.download_screen.result = "downloading "+self.media_url+"\n\n"
self.target_file = os.path.join( self.main_screen.ids.target_folder.text , self.video_title.decode("utf-8") )
self.target_folder = self.main_screen.ids.target_folder.text
self.download_screen.ids.loading.opacity=1
self.download_screen.ids.label_text_message.text="decoding:\n\n"+self.media_url
progressDialog = self.download_screen.ids.progress_bar_download
progressDialoglabel = self.download_screen.ids.label_text_message
self.download_thread = DownloadThread(self.media_url,self.target_folder,self.download_screen,progressDialog,progressDialoglabel)
self.download_thread.start()
def abort_download(self):
logger.debug("abort_download")
try:
self.download_thread.abort()
except:
pass
self.screen_manager.current = self.screen_manager.previous()
def message(self,title,body):
content = MessageDialog()
content.ids.message_body.text = body
self._popup = Popup(title=title, content=content, size_hint=(0.8, 0.8))
self._popup.open()
def on_stop(self):
logger.debug("on_stop event called: goodbye!")
class Gilbert(App):
"""Main class."""
def build(self):
"""
Build and return the root widget.
"""
# The line below is optional. You could leave it out or use one of the
# standard options, such as SettingsWithSidebar, SettingsWithSpinner
# etc.
self.settings_cls = SettingsWithTabbedPanel
# The ScreenManager controls moving between screens
self.screen_manager = ScreenManager()
# Add the screens to the manager and then supply a name
# that is used to switch screens
self.screen_manager.add_widget(MenuScreen(name="menu_screen"))
self.screen_manager.add_widget(StudyScreen(name="study_screen"))
self.screen_manager.add_widget(QuizScreen(name="quiz_screen"))
self.screen_manager.add_widget(OhmScreen(name="ohm_screen"))
self.screen_manager.add_widget(AboutScreen(name="about_screen"))
# We apply the saved configuration settings or the defaults
#root = Builder.load_string(kv)
#MenuScreenButton = root.ids.MenuScreenButton
#label.text = self.config.get('My Label', 'text')
#MenuScreenButton.font_size = float(self.config.get('MenuScreenButton', 'font_size'))
#return root
# Bind to catch the "back" Android button.
self.bind(on_start=self.post_build_init)
return self.screen_manager
def post_build_init(self, event):
"""Hook the keyboard to listen to its behavior."""
EventLoop.window.bind(on_keyboard=self.hook_keyboard)
def hook_keyboard(self, window, key, *largs):
"""Capture behavior for the "back" button in Android."""
# Key 27 is "Esc" in the Keyboard, or "Back" on Android.
if key == 27:
print(self.screen_manager.current)
if self.screen_manager.current == 'menu_screen':
Gilbert.get_running_app().stop()
self.screen_manager.transition.direction = "right"
if isinstance(self.screen_manager.previous, str):
self.screen_manager.current = self.screen_manager.previous
else:
self.screen_manager.current = self.screen_manager.previous()
return_value = True
else:
return_value = False
return return_value
def build_config(self, config):
"""
Set the default values for the configs sections.
"""
config.setdefaults('MenuScreenButton', {'font_size': "15sp"})
def build_settings(self, settings):
"""
Add our custom section to the default configuration object.
"""
# We use the string defined above for our config JSON, but it could also be
# loaded from a file as follows:
# settings.add_json_panel('My Label', self.config, 'settings.json')
settings.add_json_panel('Configuración', self.config, data=CONFIG)
def on_config_change(self, config, section, key, value):
"""
Respond to changes in the configuration.
"""
Logger.info("main.py: App.on_config_change: %s, %s, %s, %s,",
config, section, key, value)
if section == "MenuScreenButton":
if key == 'font_size':
#self.MenuScreenButton.font_size = float(value)
SettingsButton.font_size = float(value)
def close_settings(self, settings=None):
"""
The settings panel has been closed.
"""
Logger.info("main.py: App.close_settings: %s", settings)
super(Gilbert, self).close_settings(settings)
class DoorMonitorApp(MDApp):
"""
Frontend for CatchScanner configuration
"""
connection = ObjectProperty()
current_user = StringProperty()
access_level = NumericProperty(0)
access = ObjectProperty(None)
gui = ObjectProperty()
api_response = ObjectProperty()
timer_cnt = BoundedNumericProperty(5, min=0, max=ACCESS_TIMEOUT)
timer = None
_mqttc = mqtt.Client
def __init__(self, cfg: dict) -> None:
super().__init__()
bell_config = MqttStringConfig(**cfg['bell'])
door_list = []
for door, d_cfg in cfg['doors'].items():
print(f"new_door: {door}")
new_door = Door(door_id=door,
name=d_cfg['name'],
command_topic=d_cfg['command_topic'],
state_topic=d_cfg['state_topic'])
# new_door.set_relay()
door_list.append(new_door)
doors_config = DoorsConfig(doors=door_list)
print(cfg['garage'])
garage_config = MqttStringConfig(**cfg['garage'])
mode_config = MqttStringConfig(**cfg['mode'])
self.kelvin = kelvin_rgb_to_kivy()
self.azure = get_color_from_hex('#f0ffff')
self.theme_cls = ThemeManager()
self.theme_cls.primary_palette = "Blue"
self.theme_cls.primary_hue = "500"
self.theme_cls.accent_palette = "Yellow"
self.theme_cls.accent_palette_hue = "500"
self.theme_cls.theme_style = "Light"
self.doors_config = doors_config
self.bell_config = bell_config
self.garage_config = garage_config
self.mode_config = mode_config
self.backlight = Backlight()
## GUI ##
self.gui = ScreenManager(transition=NoTransition())
try:
self.screens = config.screens
except AttributeError:
self.screens = None
else:
for screen in self.screens:
print(f'New screen: {screen}')
try:
import_statemet = self.screens[screen][
"import"] + ' as NewScreen'
print(import_statemet)
exec(import_statemet)
except Exception as e:
print(e)
else:
screen_kwargs = {}
screen_kwargs.update({'name': screen})
# screen_kwargs.update({'controller':self})
# screen_kwargs.update({'sub':self.screens[screen].get("sub", None)})
# screen_kwargs.update({'memory':kwargs.get(screen,None)})
print(f'SCREEN NAME IS: {screen}')
print(f'with kwargs: {screen_kwargs}')
self.screens[screen]["object"] = eval('NewScreen')(
**screen_kwargs)
self.gui.add_widget(self.screens[screen]["object"])
self.change_screen(self.gui.screen_names[0])
def presence_out_of_bounds(self, am: AccessModel):
print(f"USER OUT OF BOUNDS {am}")
def presence_detected(self, am: AccessModel):
print(f"presence_detected {am}")
if am.name:
self.current_user = am.name
toast(f"Velkommen {am.name}")
if am.access_level > 0:
self.access_level = am.access_level
self.change_screen('Control')
self.screens['DoorBell']["object"].login_feedback(True)
# def detected_beacon_response(self, request, result):
# if result is not None:
# try:
# self.access_level = result
# if self.access_level > 0:
# self.change_screen('Control')
# self.screens['DoorBell']["object"].login_feedback(True)
# else:
# print("Login failed")
# self.screens['DoorBell']["object"].login_feedback(False)
# except ValueError as e:
# print(f"result: {result}")
# print(e)
# else:
# print(f"result: {result}")
# # def detected_beacon(self, devices_discovered, address, packet_type):
# # print(f'found: {devices_discovered} with address {address} aand packet type {packet_type}')
# def detected_beacon(self, uuid, rssi):
# print(f'found uuid: {uuid} with rssi {rssi}')
# detected_beacon(on_success=self.detected_beacon_response,uuid=uuid, rssi=rssi)
def get_door_name(self, door_id, *args):
print(door_id)
door = self.doors_config.get_by_id(door_id)
if door is not None:
return door.name
else:
return ""
# @property
# def access_level(self):
# print(f"current access level: {self.access_level}")
# return self.access_level
def on_door_states(self, *args):
print("on_door_states")
def on_start(self):
self.make_client()
# def try_pin(self, pin):
# """"
# Log in.
# Log in to sw with user and password. Hardcoded for now. Should interact with DB.
# Args:
# user: Username
# password: Password
# """
# success = False
# success = self.api.authenticate_pin(pin)
def next_screen(self):
self.gui.next_screen()
def prev_screen(self):
self.gui.prev_screen()
def on_enter_view(self, *args):
pass
def build(self):
"""
Kivy build.
Function to return Kivy Layout from App class.
Returns:
Widget containing GUI
"""
return self.gui
def try_login_response(self, request, result):
self.access_level = result
if result > 0:
self.change_screen('Control')
self.screens['DoorBell']["object"].login_feedback(True)
else:
print("Login failed")
self.screens['DoorBell']["object"].login_feedback(False)
def log_out(self, *args):
self.access_level = 0
self.change_screen("DoorBell")
print(f"Log out, access level is: {self.access_level}")
# def setaccess_level(self, level):
# self.access_level = level
# print(f"access level is: {self.access_level}")
def start_log_out_timer(self):
if self.access_level > 0:
print(f"access timeout set")
# self.acccess_timeout = Clock.schedule_once(self.acccess_timeout, ACCESS_TIMEOUT)
self.timer_cnt = ACCESS_TIMEOUT
self.timer = Clock.schedule_interval(self.tic, 1)
def cancel_log_out_timer(self):
self.timer.cancel()
def tic(self, dt):
self.timer_cnt -= 1
def on_timer_cnt(self, *args):
if self.timer_cnt == 0:
self.cancel_log_out_timer()
self.log_out()
def extend_log_out_timer(self):
self.timer_cnt = ACCESS_TIMEOUT
# def acccess_timeout(self, dt):
# self.log_out()
# print(f"access level timeout")
# self.acccess_timeout.cancel()
def try_login(self, pin, *args):
try_login(pin=pin, on_success=self.try_login_response)
#### MQTT STUFF ####
def make_client(self):
# parameters = {'self': self}
self._mqttc = mqtt.Client(MQTT_CLIENT_ID)
# self._mqttc = mqtt.Client(MQTT_CLIENT_ID, userdata = parameters)
self._mqttc.on_message = self.mqtt_on_message
self._mqttc.on_connect = self.mqtt_on_connect
self._mqttc.on_publish = self.mqtt_on_publish
self._mqttc.on_subscribe = self.mqtt_on_subscribe
self.mqttc_connect_to_broker()
self.mqttc_subscribe()
self.mqttc_run()
def mqtt_on_connect(self, mqttc, obj, flags, rc):
print("rc: " + str(rc))
print(f"flag: {flags}")
def mqtt_on_message(self, mqttc, obj, msg):
print(msg.topic + " " + str(msg.qos) + " " + str(msg.payload))
topic = msg.topic
payload = msg.payload.decode("utf-8")
door = self.doors_config.get_by_state_topic(topic)
if door is not None:
print(f"state received")
if payload == DOORLOCK_STATUS_PAYLOAD.LOCKED:
door.state = "LOCKED"
self.screens['Control']["object"].update_door_states(
door.door_id, True)
elif payload == DOORLOCK_STATUS_PAYLOAD.UNLOCKED:
door.state = "UNLOCKED"
self.screens['Control']["object"].update_door_states(
door.door_id, False)
elif topic == self.mode_config.command_topic:
print(f"mode received: {payload}")
self.mode_config.state = payload
def mqtt_on_publish(self, mqttc, obj, mid):
print("mid: " + str(mid))
def mqtt_on_subscribe(self, mqttc, obj, mid, granted_qos):
print("Subscribed: " + str(mid) + " " + str(granted_qos))
def mqtt_on_log(self, mqttc, obj, level, string):
print(string)
def tls_set(self):
#TODO: sett ssl and cert for encrypt
pass
def mqttc_connect_to_broker(self):
print(f"connecting to broker {MQTT_BROKER} as {MQTT_CLIENT_ID}")
# broker_parsed = urllib.parse.urlparse(MQTT_BROKER)
self._mqttc.username_pw_set(MQTT_USERNAME, password=MQTT_PASSWORD)
self._mqttc.connect(MQTT_BROKER, port=MQTT_PORT, keepalive=60)
def mqttc_subscribe(self):
for door in self.doors_config.doors:
self._mqttc.subscribe(door.state_topic, qos=0)
self._mqttc.subscribe(self.mode_config.command_topic, qos=0)
def mqttc_run(self):
self._mqttc.loop_start()
def ring_bell(self):
print('ringing that bell')
print(f'self.mode_config.state: {self.mode_config.state}')
self._mqttc.publish(self.bell_config.command_topic,
payload=BELL_COMMAND_PAYLOAD.DO)
if self.mode_config.state == MODE_COMMAND_PAYLOAD.NORMAL:
pass
elif self.mode_config.state == MODE_COMMAND_PAYLOAD.HALLOWEEN:
self.change_screen('Scary')
def toggle_door(self, door, locked, *args):
if locked:
for d in self.doors_config.doors:
if d.name == door:
print(f"mqtt unlock door {door}")
self._mqttc.publish(
d.command_topic,
payload=DOORLOCK_COMMAND_PAYLOAD.UNLOCK)
else:
for d in self.doors_config.doors:
if d.name == door:
print(f"mqtt lock door {door}")
self._mqttc.publish(d.command_topic,
payload=DOORLOCK_COMMAND_PAYLOAD.LOCK)
def garage_open(self, *args):
self._mqttc.publish(self.garage_config.command_topic,
payload=GARAGE_COMMAND_PAYLOAD.OPEN)
def garage_close(self, *args):
self._mqttc.publish(self.garage_config.command_topic,
payload=GARAGE_COMMAND_PAYLOAD.CLOSE)
def garage_stop(self, *args):
self._mqttc.publish(self.garage_config.command_topic,
payload=GARAGE_COMMAND_PAYLOAD.STOP)
def next_screen(self):
self.change_screen(self.gui.next())
def prev_screen(self):
self.change_screen(self.gui.previous())
def change_screen(self, screen_name):
print(f"entering screen {screen_name}")
# if screen_name == self.ids['sm'].screen_names[0]:
# print(f"screen is first")
# self.ids['sm'].current_screen.content.is_first()
# else:
# print(f"screen is inbetween")
# # self.ids['sm'].current_screen.content.override_allow_prev(True)
# if screen_name == self.ids['sm'].screen_names[-1]:
# print(f"screen is last")
# self.ids['sm'].current_screen.content.is_last()
self.gui.current = screen_name
class NeuralNetworkDemoApp(App):
# Application properties
# See https://kivy.org/docs/api-kivy.properties.html
# for available kinds of properties.
# The dataset
dataset_name = OptionProperty("POFA", options=["CAFE", "POFA"])
dataset_cache = {}
def _load_dataset(self):
if self.dataset_name not in NeuralNetworkDemoApp.dataset_cache.keys():
filename = 'data/%s.pkl' % self.dataset_name.lower()
import pickle
Logger.info('Loading data from %s' % filename)
with open(filename, 'r') as f:
NeuralNetworkDemoApp.dataset_cache[self.dataset_name] = pickle.load(f)
return NeuralNetworkDemoApp.dataset_cache[self.dataset_name]
dataset = AliasProperty(_load_dataset, None, bind=['dataset_name'])
maximum_pca_components = AliasProperty(lambda self: min(self.dataset['data'].shape), None, bind=['dataset'])
# PCA transformed data
pca_data = AliasProperty(lambda self: PCAData(self.dataset['data']), None, bind=['dataset'])
# PCA components (the max will be controlled by the maximum_pca_components)
pca_components = BoundedNumericProperty(10, min=1)
# PCA transformer
pca_transformer = AliasProperty(lambda self: PCATransformer(self.pca_data, self.pca_components), None,
bind=['pca_data', 'pca_components'])
# train inputs
num_hidden_units = BoundedNumericProperty(10, min=1)
num_valid_input = BoundedNumericProperty(0, min=0)
num_test_data = BoundedNumericProperty(0.2, min=0, max=1.0)
hidden_units_learning_rate = BoundedNumericProperty(0.1, min=0.001, max=1.0)
output_units_learning_rate = BoundedNumericProperty(0.2, min=0.001, max=1.0)
momentum = BoundedNumericProperty(0.2, min=0, max=1.0)
epochs = BoundedNumericProperty(1000, min=1, max=10000)
minimum_rmse = BoundedNumericProperty(0, min=0.0, max=1.0)
# the categories of training
target_name = OptionProperty('Expression', options=['Gender', 'Expression', 'Identity'])
training_target = OptionProperty('epochs', options=['epochs', 'rmse'])
#
# Main Kivy code for building the application UI.
#
def build(self):
'''Build the application UI.'''
self.manager = ScreenManager()
for i, screen_cls in enumerate(ALL_SCREENS):
self.manager.add_widget(screen_cls(name='Screen %d' % (i + 1)))
self.manager.current = 'Screen 1'
# Dispatch all events in order to initialize UIs
for property_name in self.properties():
Logger.info('Initializing UI for %s' % property_name)
self.property(property_name).dispatch(self)
return self.manager
# Manage the screen transitions
def go_next(self):
'''Go to the next screen.'''
self.manager.transition.direction = 'left'
Logger.info('Moving to ' + self.manager.next())
self.manager.current = self.manager.next()
def go_back(self):
'''Go back one screen.'''
self.manager.transition.direction = 'right'
Logger.info('Moving to ' + self.manager.previous())
self.manager.current = self.manager.previous()
