class MyApp(App):
def build(self):
self.icon = 'myicon.png'
self.name = ""
self.title = ""
#self.atlas = Atlas("./tdpatlas.atlas")
#print (self.atlas['Chiocciola_1'])
self.sm = ScreenManager()
screens = [Screen(name='Title {}'.format(i)) for i in range(4)]
self.sm.add_widget(screens[0])
img_tufo = Image(source="pictures/tufo.png")
screens[0].add_widget(img_tufo)
self.sm.add_widget(screens[1])
img_palazzo = Image(source="pictures/palazzo_comunale.png")
screens[0].add_widget(img_palazzo)
#root.add_widget(img)
#img.add_widget(Image(source="pictures/Istrice_1.gif", pos=(100, 100)))
#c = CustomLayout()
#root.add_widget(c)
#c.add_widget(
# Image(
# source="pictures/palazzo_comunale.png"))
#root.add_widget(Image(source="pictures/Chiocciola_1.gif"))
#c = CustomLayout()
#c.add_widget(
# Image(source="pictures/Chiocciola_1.gif",
# size_hint= (1, .5),
# pos_hint={'center_x':.5, 'center_y':.5}))
#root.add_widget(c)
return self.sm
#filename = "pictures/Chiocciola_1.gif"
#m = Image(source=filename)
def loginPopup(self):
box = BoxLayout(orientation='vertical')
box.add_widget(Label(text="Username", size_hint=(1., None), size=(1., 30)))
box.add_widget(TextInput(multiline=False, size_hint=(1., None), size=(1., 30)))
box.add_widget(Label(text="Password", size_hint=(1., None), size=(1., 30)))
box.add_widget(TextInput(multiline=False, size_hint=(1., None), size=(1., 30), password=True))
# manca il bottone
popup = Popup(title='Login', content=box, size_hint=(.5, .3), )
popup.open()
return
def estrazione(self, list_):
self.sm.next()
pass
class IlanPanosuUyg(App):
def build(self):
self.py=ScreenManager()
Builder.load_file("duyuru.kv")
Builder.load_file("atasozu.kv")
Builder.load_file("resim.kv")
self.py.add_widget(duyuruPenceresi(name='ilan'))
self.py.add_widget(atasozuPenceresi(name='atasozu'))
self.py.add_widget(resimPenceresi(name='resim'))
Clock.schedule_interval(self.pencereDegistir, 2)
return self.py
def pencereDegistir(self, *args):
sonraki = self.py.next()
pcr = self.py.get_screen(sonraki)
if sonraki == 'duyuru':
pcr.ids['duyuru_etiketi'].text = ' *Önümüzdeki hafta sonu veli toplantısı yapılacaktır.\n *Yarın gezi kolu Pamukkale\'ye gidecektir.'
elif sonraki == 'atasozu':
pcr.ids['atasozu_etiketi'].text = random.choice(atasozleri)
elif sonraki == 'resim':
res = random.choice(resimler)
pcr.ids['resim'].source = res[0]
pcr.ids['resim_etiketi'].text = res[1]
self.py.current = sonraki
class IlanPanosuUyg(App):
def build(self):
self.py = ScreenManager()
Builder.load_file("duyuru.kv")
Builder.load_file("atasozu.kv")
Builder.load_file("resim.kv")
self.py.add_widget(duyuruPenceresi(name='ilan'))
self.py.add_widget(atasozuPenceresi(name='atasozu'))
self.py.add_widget(resimPenceresi(name='resim'))
Clock.schedule_interval(self.pencereDegistir, 2)
return self.py
def pencereDegistir(self, *args):
sonraki = self.py.next()
pcr = self.py.get_screen(sonraki)
if sonraki == 'duyuru':
pcr.ids[
'duyuru_etiketi'].text = ' *Önümüzdeki hafta sonu veli toplantısı yapılacaktır.\n *Yarın gezi kolu Pamukkale\'ye gidecektir.'
elif sonraki == 'atasozu':
pcr.ids['atasozu_etiketi'].text = random.choice(atasozleri)
elif sonraki == 'resim':
res = random.choice(resimler)
pcr.ids['resim'].source = res[0]
pcr.ids['resim_etiketi'].text = res[1]
self.py.current = sonraki
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 PencereUyg(App):
def build(self):
self.py = ScreenManager()
for i in range(4):
p = Screen(name="pncr%d" % i)
p.add_widget(Label(text="Pencere %d" % i))
self.py.add_widget(p)
self.py.current = 'pncr2'
Clock.schedule_interval(self.pencereDegistir, 2)
return self.py
def pencereDegistir(self, *args):
sonraki = self.py.next()
self.py.current = sonraki
class PencereUyg(App):
def build(self):
self.py=ScreenManager()
for i in range(4):
p=Screen(name="pncr%d" % i)
p.add_widget(Label(text="Pencere %d" % i))
self.py.add_widget(p)
self.py.current = 'pncr2'
Clock.schedule_interval(self.pencereDegistir, 2)
return self.py
def pencereDegistir(self, *args):
sonraki = self.py.next()
self.py.current = sonraki
class NodeApp(App):
def build(self):
self.sm = ScreenManager()
self.ms = MainScreen(name="MainScreen")
self.ss = SettingsScreen(name="SettingsScreen")
self.sm.add_widget(self.ss)
self.sm.add_widget(self.ms)
self.next_screen = 1
print(self.sm.screen_names)
Clock.schedule_interval(lambda *t: self.switch_screens(), 5)
return self.sm
def switch_screens(self):
self.sm.current = self.sm.next()
def changeScreen(self):
sm = ScreenManager()
sm.add_widget(HomeTab(name='hometab'))
sm.add_widget(WorkoutTab(name='workouttab'))
sm.add_widget(SettingsTab(name='settingstab'))
sm.next()
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 QuestionnairesApp(App):
sm = None
qf = None
float_layout = None
cei2 = None
bfi = None
def build(self):
# initialize logger
#KL.start([DataMode.file, DataMode.communication]) #, "/sdcard/curiosity/", the_ip='127.0.0.1')#self.user_data_dir)
KL.start([DataMode.file, DataMode.communication, DataMode.ros],
self.user_data_dir)
self.sm = ScreenManager()
screen = ZeroScreen()
screen.start()
screen.ids['subject_id'].bind(
text=screen.ids['subject_id'].on_text_change)
self.sm.add_widget(screen)
return self.sm
def add_all(self):
self.qf = []
self.add_questionnaire('questionnaires/BFI.json')
self.qf.append(MiddleForm(self))
self.add_questionnaire('questionnaires/Need for Cognition.json')
self.qf.append(MiddleForm(self))
self.add_questionnaire('questionnaires/Questionnaire3.json')
self.qf.append(MiddleForm(self))
self.add_questionnaire('questionnaires/Questionnaire4.json')
for kqf in range(0, len(self.qf)):
screen = Screen(name="question" + str(kqf))
screen.add_widget(self.qf[kqf])
self.sm.add_widget(screen)
screen = Screen(name='final_form')
screen.add_widget(FinalForm(self))
self.sm.add_widget(screen)
self.start()
def add_questionnaire(self, filename=""):
new_questionnaire = Questionnaire(filename)
for p in range(0, len(new_questionnaire.page_dict)):
self.qf.append(
QuestionsForm(self, new_questionnaire.page_dict[p],
new_questionnaire.questionnaire_name))
def start(self):
KL.start([DataMode.file, DataMode.communication, DataMode.ros],
self.user_data_dir)
for qf in self.qf:
qf.start()
def on_pause(self):
return True
def press_start(self, pre_post):
print(self.sm.size)
self.add_all()
self.sm.current = self.sm.next()
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!")
def load_next_screen(self):
self.current = ScreenManager.next(self)
class FacultyGameApp(App):
sm = None
cg = None
cf = None
qf = None
lf = None
dfp = None
dff = None
dfg = None
ff = None
framing_form = None
score = None
float_layout = None
cei2 = None
bfi = None
learn = None
the_condition = ''
# game_mode:
# True: game, no framing, no stop, no details
# False: Keren's study
game_mode = True
original_size = [1920, 1128]
def build(self):
# initialize logger
self.init_communication()
self.cg = CuriosityGame(self)
self.cf = ConsentForm(self)
self.framing_form = FramingForm(self)
self.cei2 = CEI2('questions.json')
self.bfi = CEI2('more_questions.json')
self.qf = []
for p in range(0, len(self.cei2.page_dict)):
self.qf.append(QuestionsForm(self, self.cei2.page_dict[p]))
for p in range(0, len(self.bfi.page_dict)):
self.qf.append(QuestionsForm(self, self.bfi.page_dict[p]))
self.learn = Learning(self)
self.lf = [LearningForm(self)]
for i in range(1, self.learn.max_number_questions /
self.lf[0].q_per_page):
self.lf.append(LearningForm(self))
self.dfp = DetailsFormPersonal(self)
self.dff = DetailsFormFaculty(self)
self.dfg = DetailsFormGrades(self)
self.ff = FinalForm(self)
self.score = CuriosityScore(self.cg.game_duration, len(self.cg.items),
self.user_data_dir)
self.sm = ScreenManager()
if self.game_mode:
screen = ZeroScreen()
screen.start()
screen.ids['subject_id'].bind(
text=screen.ids['subject_id'].on_text_change)
self.sm.add_widget(screen)
else:
screen = ConsentScreen(name='consent')
screen.add_widget(self.cf)
self.sm.add_widget(screen)
if not self.game_mode:
screen = Screen(name='framing')
screen.add_widget(self.framing_form)
self.sm.add_widget(screen)
screen = Screen(name='thegame')
screen.add_widget(self.cg.the_widget)
self.sm.add_widget(screen)
for kqf in range(0, len(self.qf)):
screen = Screen(name="question" + str(kqf))
screen.add_widget(self.qf[kqf])
self.sm.add_widget(screen)
for i, ilf in enumerate(self.lf):
screen = Screen(name="learning_" + str(i))
screen.add_widget(ilf)
screen.bind(on_pre_enter=self.learn.start)
self.sm.add_widget(screen)
if not self.game_mode:
screen = Screen(name="details_personal")
screen.add_widget(self.dfp)
self.sm.add_widget(screen)
screen = DetailsScreenFaculty(name="details_faculty")
screen.add_widget(self.dff)
self.sm.add_widget(screen)
screen = Screen(name="details_grades")
screen.add_widget(self.dfg)
self.sm.add_widget(screen)
screen = Screen(name="final")
screen.bind(on_enter=self.ff.start)
screen.add_widget(self.ff)
self.sm.add_widget(screen)
if self.game_mode:
self.sm.current = 'zero_screen'
else:
self.sm.current = 'consent'
return self.sm
def on_start(self):
self.start()
def start(self):
self.cf.start(self)
for qf in self.qf:
qf.start()
self.dfp.start()
self.dff.start()
self.dfg.start()
self.score.init_score()
self.choose_condition()
if self.game_mode:
self.sm.current = 'zero_screen'
else:
self.sm.current = 'consent'
def choose_condition(self):
if self.game_mode:
self.the_condition = 'no_framing/no_stop'
else:
self.the_condition = random.choice(conditions)
KL.log.insert(action=LogAction.data,
obj='condition',
comment=self.the_condition)
self.framing_form.set_text(self.the_condition)
self.cg.set_stop_button(self.the_condition)
def on_pause(self):
return True
def init_communication(self):
KC.start(the_ip='192.168.1.254', the_parents=[self]) # 127.0.0.1
KL.start(mode=[DataMode.file], pathname=self.user_data_dir)
def press_start(self, *args):
self.cg.start()
self.sm.current = self.sm.next()
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()
