From 493a271d0eaded34ca2acf18b4afb55534101aad Mon Sep 17 00:00:00 2001
From: void <harry.coldmirror@gmail.com>
Date: Sat, 24 Jan 2026 07:21:24 +0100
Subject: [PATCH] =?UTF-8?q?Weckerfunktoin=20vollst=C3=A4ndig=20implementie?=
 =?UTF-8?q?rt?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 __pycache__/timer_control.cpython-310.pyc  | Bin 2917 -> 2917 bytes
 __pycache__/wecker_control.cpython-310.pyc | Bin 0 -> 3381 bytes
 main.py                                    |  70 +++++++++-
 wecker_control.py                          | 147 +++++++++++++++++++++
 4 files changed, 212 insertions(+), 5 deletions(-)
 create mode 100644 __pycache__/wecker_control.cpython-310.pyc
 create mode 100644 wecker_control.py

diff --git a/__pycache__/timer_control.cpython-310.pyc b/__pycache__/timer_control.cpython-310.pyc
index bd6f71c97c2db1f64d48ed10ee4cfc24a0b6ee80..35954e504fa7642f9b0717b3fd652c8e5c299e46 100644
GIT binary patch
delta 18
YcmaDV_Ed~BpO=@50SNjwa>j52054PoLI3~&

delta 18
YcmaDV_Ed~BpO=@50SJONa>j5204^v51^@s6

diff --git a/__pycache__/wecker_control.cpython-310.pyc b/__pycache__/wecker_control.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a6820b1fcc8714c0355ecfc0b9be2465d699ea32
GIT binary patch
literal 3381
zcma)8&2Jn@74Pb<?&+EFSDdV4$H``d_{ap}f$Ty=h?32+Sz*GO6%HHi5Hz%>%ASsU
zx~-}jOsw%KIT9gp4J+BlJ?#Z?<G<ikS1$Oxw;UpVue!${3yYXhSJiv<s@|*je(zNk
z)6)$PzrSyo^lvks_fH~D{~{3Y;nV*@^J`Cdf@NN}>{*wA_A`GNbb}%9@?qEw8O;S*
zG^}-NZp^cI7<c1gy<2xQ%NpH=+o#!W3YJVsb})VDb!SAF%z~biv0(3e@|=k7c%mla
z7hZQ>)a7~6z}J-VW+bM>^b6j-AZ8%jl;=0Om=$y2yd}<I-WT)YJg9}bSNFsP@fLQt
zC>F#;^owFqETLZ#m&7vqOX9M)f__=NEv}-!EZDl&ZXMyY-da1bv5|i;H}lcZ)>GX>
zzaf>K(lR$P?@O9!Gh5%ul4rUY<)ZD|SR_W8bSQ0|S|Kx&Se}YZ+WB4C-<GOp6162w
zkEZ*KG*v%xc8u?*`1D`VjJ*Tz&^us<-o9u2gFvvccj)i4G1GIxTldE7fD8YS?fY&N
zU=-}lm~iYrXZw5{sBd8$JZCu*d_R2b<ulwf(X$^hkN&16!sm>6pCV-I-mW+1f^U2J
z9{OmTtNTtv=y<E+P}IPCNIX-6MEr`2I=JXRg9e7x<8af5^BQY=ttT7Te)DAax8H3)
z(bq=<b?x453@TRp-jj_ZI`)x|M$u^R>cb+3OIsq9t!^^NT6x+Zn3h!AGS6kca&(d8
ze}cva-@hqdv)k?1hFP(TXoT9RbjSKi+DOYp^#?ZGQpIRT(f+paNs^7^1EmUx?x-|3
z?Z|Qps||;VfpmRPj1Uy!G>2(EGO{E%@oiMHKKIlWZ1?($&Y&2|j!E;P^Fh%c4FLt+
z>75MM`-4#?JMXq0r`bSe!`4U1vyG%bXjKz8-+#E;`gt-?t(%?u8@fNpMq2Nv;;Gy=
z9V4}AC0eK2B)RGIvm%%GC*=JsTg`u&%g(P7{c+m+q)7X+cRYLJ#^cqGI~BtEMQ&7)
zt?WFr=XMgMaUy`NSI*Aj9Qxa6ru-?NGtL@*gZV+sF0d&Uvxxa`<~V0_m|5^+rmjL%
zEmLzDjg6EvBbE2byOSTsfY9rZ`z{8iM6EyepZa6qRM6jl$@hbCF!r~ZS{w%^5P{$?
z*)5N_Ku);k(9q_mwP}gN2#QQ!6(ymlW+CsmK-xi?G}|CAc5O{b<YHf{8cCemM}3oI
zqB8SbB+KS)VlVZRtUt<-x0BSI<nVP&Ytk08c|Z1N828n8Kq_+IncO9BkQbZ>XxDM&
zgGKMaNB%Ms9B}f(vUf-&#$P+S1F3fCtS`-*Hib#DUU^7uIp8_4yf4$N?K_ROR?U6&
z1k)u*b#IiLH2Wbo)?~~aELJx#u+6WlIcMy?3sHj-zwN6?AeRjz+mYK|g4&ayunYcz
z&cdIDI7=v^mwpnN=%7YYBE-3BYY4(9&(nPC!#=h<{!yL>_}201+h|O+JscEJfg6)z
zPt6F1V#g0clscxD1u3WrS7NC6(AVZAP;9)J=BXY?v3IV7b}QM~l36m^lzBT=b!a(p
zuWEy|%_>8*DRwO1O;Tg0k6DQsX|({cHdEiD#gy`=fD+(j55Us6D&gGN<qk*I@Hcx)
zNLgj76kEBI6#$jKyMh&uCee#TB8LT8_73g)12i`5XQ)}uR9qMXB@+SH+31lQ9@|#V
zP_2U!?6*Q2P@;X+#HrI}P{GvmXySmg*yTDv+#tIZ&7BDlXphj~5KQUfkPxVbLFQ70
z7sye%g<PyT&_MBy)>H?wdlw$cG;dW=*g_eTS!O;2VBzN-DIOsi-J!|5<;epr%_-}h
zt6e%aX-(zG-$7hYp^2Th%QGm#>3`Tx;BvN8m8xv7qxVJd7hqX1oWqR>K4f!QY<%1r
z#s!{y3fDR_9du5je`4I^4lmdA(tNXcigi_yKpo{ii{7aBz&lePLNJc+_J4q=;66R}
zUcp8K`Z;^$eFh)X%q3(Q^$Q-|?IJ*8+#371i%|&1ki!bR0*+Ul;RxLS)t-nO_N>uM
z!6nxR|81?)7LWwAarX-F)u-dY?cvk=p|a}?2U>V#2cKvmG+e{kUbEH_Rn78p4_kN{
zweXl~metGMuIduaFQGvRq+GMLs)kt(F>OP-eW?hhxjqFGhmhILLZLYJ#7HG3#a)N>
znr2X@f%DjX^XwbwCp1y&XAn6P6)H*-%zrrt!bPR3euQ_z3Z2A8AGw!-t(AT5O!}Nz
zR*p&w$pm+>KVtADZ9K;u{k2NfDuj-e)Yj!Td?jsM4XVw5LHnMd(WxP*|B3i()DZQ5
zDv8#O(@`t?|Dl4S^XFp~E>>6YbizwQ-2&S-CXZtw-CIjh3M#sIY~%Pz{Ei~%mt~l4
zWkvN!U8m;9Xl(f4_jp3Nl5moGcDC0`@*LM8g;)1_?h#@Gyxz+Dmo7C|!dxwI>E@za
z!iv1%uyx95Cn+4?85RO>w7V32O<CUnaOm+fhvyH9qboHS2Mf#d&6&u*=*MvsH}GGK
HgQ?)(KdAbk

literal 0
HcmV?d00001

diff --git a/main.py b/main.py
index 48e7c9c..7bbaeca 100644
--- a/main.py
+++ b/main.py
@@ -9,6 +9,7 @@ import re
 import asyncio 
 from weather_jetzt import get_weather_for_location
 from timer_control import parse_time, start_timer, stop_timer, timer_status_info, format_duration
+from wecker_control import parse_time_wecker, minutes_until, start_wecker, stop_wecker, wecker_status_info, calculate_target_datetime
 
 #test
 
@@ -93,7 +94,7 @@ INTENTS = {
   #                  "duration": r"(\w+)\s*(sekunden|sekunde|minuten|minute|stunden|stunde)"      
                     "duration": r"((?:\w+)\s*(?:sekunden|sekunde|minuten|minute|stunden|stunde))"
 
-                }
+                },
             },
             "stop": {
                 "keywords": ["stopp", "stoppe", "beende"],
@@ -104,6 +105,25 @@ INTENTS = {
                 "required_slots": {}
             }
         }
+    },
+    "wecker": {
+        "keywords": ["wecker", "timer"],
+        "actions": {
+            "start": {
+                "keywords": ["erstelle", "stelle"],
+                "required_slots": {
+                    "timeSet": r"\b([\w]+)\s*uhr(?:\s*([\w]+))?\b"
+                },
+            },
+            "stop": {
+                "keywords": ["stopp", "stoppe", "entferne"],
+                "required_slots": {}
+            },
+            "status": {
+                "keywords": ["status", "läuft", "noch"],
+                "required_slots": {}
+            }
+        }
     }
 }
 
@@ -122,7 +142,7 @@ def detect_intent(text):
 # =========================
 
 
-
+## WEATHER
 def weather_skill(slots):
     location = slots["location"]
     result = asyncio.run(get_weather_for_location(location))
@@ -133,6 +153,7 @@ def weather_skill(slots):
         return f"Keine Wetterdaten verfügbar"
     #return f"Das Wetter in {location} ist sonnig bei 20 Grad."
 
+## TIMER
 def start_timer_skill(slots):
     duration = slots["duration"]
     seconds = parse_time(duration)
@@ -162,7 +183,40 @@ def status_timer_skill(slots):
     else:
         return f"Es läuft kein Timer"
 
+#ALARM
+def start_wecker_skill(slots):
+    parsed = parse_time_wecker(slots["timeSet"])
+
+    if not parsed:
+        return "Die Uhrzeit konnte nicht erkannt werden."
+
+    hour, minute = parsed 
+    target = calculate_target_datetime(hour, minute)
     
+    start_wecker(target)
+    minutes = minutes_until(target)
+
+    return f"Wecker für {hour:02d}:{minute:02d} wurde gestellt er klingelt in {minutes} minuten"
+
+def stopp_wecker_skill(slots):
+    stop_wecker()
+    print("Wecker wurde gestoppt")
+    return f"Wecker wurde gestoppt"
+
+def status_wecker_skill(slots):
+
+    info = wecker_status_info()
+
+    if info["status"] == "running":
+        target_time = info["target_time"] 
+        return f"Ein Wecker wurde bereits auf {wecker_target_time} gestellt"
+    elif info["status"] == "finished":
+        return f"Der Wecker ist abgelaufen"
+    elif info["status"] == "stopped":
+        return f"Der Wecker wurde gestoppt, es ist kein Wecker gestellt"
+    else:
+        return f"Es ist kein Wecker gestellt"
+        
 
 
 SKILLS = {
@@ -170,7 +224,12 @@ SKILLS = {
     "timer": {
         "start": start_timer_skill,
         "stop": stopp_timer_skill,
-        "status": status_timer_skill
+        "status": status_timer_skill,
+    },
+    "wecker": {
+        "start": start_wecker_skill,
+        "stop": stopp_wecker_skill,
+        "status": status_wecker_skill
     }
 }   
 
@@ -246,7 +305,7 @@ def check_required(text):
         if slot not in context["slots"]:
             match = re.search(pattern, text)
             if match:
-                context["slots"][slot] = match.group(1) # schau an
+                context["slots"][slot] = match.group(0) #alles slots
             else:
                 context["pending_slot"] = slot
                 ask_for_slot(slot)
@@ -268,7 +327,8 @@ def check_required(text):
 def ask_for_slot(slot):
     questions = {
         "location": "Für welchen Ort?",
-        "duration": "Wie lange soll der Timer laufen?"
+        "duration": "Wie lange soll der Timer laufen?",
+        "timeSet": "Zu welcher Uhrzeit soll der Wecker klingeln?"
     }
     speak(questions.get(slot, "Bitte spezifizieren."))
 
diff --git a/wecker_control.py b/wecker_control.py
new file mode 100644
index 0000000..4fb864f
--- /dev/null
+++ b/wecker_control.py
@@ -0,0 +1,147 @@
+import time
+import threading
+from text2numde import text2num, is_number, sentence2num 
+from playsound3 import playsound
+from datetime import datetime, timedelta
+import re
+import math
+
+wecker_thread = None 
+wecker_stop = threading.Event()
+wecker_status = "idle"
+wecker_target_time: datetime | None = None
+
+
+def parse_time_wecker(text):
+
+    text = text.lower().strip()
+
+    match = re.search(r"\b([\w]+)\s*uhr(?:\s*([\w]+))?\b", text)
+    if not match: 
+        return None
+
+    hour_text = match.group(1)
+    minute_text= match.group(2)
+
+
+    try:
+        hour = text2num(hour_text)
+        minute = text2num(minute_text) if minute_text else 0
+    except ValueError:
+        print("Konnte die Zahl nicht erkennen.")
+        return None
+
+    if hour < 0 or hour > 23:
+        return None
+    if minute < 0 or minute > 59:
+        return None
+    
+    print(f"{hour:02d}:{minute:02d}")
+    return hour, minute
+    
+def calculate_target_datetime(hour: int, minute: int) -> datetime:
+    now = datetime.now()
+
+    target = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
+
+    if target <= now:
+        target += timedelta(days=1)
+
+    return target
+
+
+def minutes_until(target: datetime) -> int:
+     #return int(((target - now)).total_seconds() // 60) hatte das davor aber das hat abgerundet
+    seconds = (target - datetime.now()).total_seconds()
+    return math.ceil(seconds / 60)
+
+
+def start_wecker(target_time: datetime):
+    global wecker_thread, wecker_status, wecker_target_time
+
+    if wecker_status == "running":
+        return False # wecker läuft bereits
+    
+    wecker_stop.clear()
+    wecker_target_time = target_time
+    wecker_status = "running"
+
+    def run():
+        global wecker_status
+        seconds = (wecker_target_time - datetime.now()).total_seconds()
+        if seconds < 0:
+            seconds = 0
+
+        if not wecker_stop.wait(seconds):
+            wecker_status = "finished"
+            print("wecker abgelaufen") # """ TTS """
+    
+    wecker_thread = threading.Thread(target=run, daemon=True)
+    wecker_thread.start()
+    return True
+""" 
+    print(f"wecker startet für {seconds} Sekunden...")
+    time.sleep(seconds)
+    print("wecker abgelaufen!")
+    playsound("/home/tino/Desktop/Abschlussprojekt/test assistant/cloneAssistantAllInOne/RasPi_Voice_Assistant--WIP/clock-alarm-8761.mp3")
+    sound.stop()
+     """
+    
+""" # Beispielnutzung
+spoken_input = "eine sekunde"  # This could come from a voice assistant
+seconds = parse_time(spoken_input)
+if seconds:
+    start_wecker(seconds) """
+
+def stop_wecker():
+    global wecker_status
+    if wecker_status != "running":
+        print("Kein wecker gestellt")
+        return False
+
+    wecker_stop.set()
+    wecker_status = "stopped"
+    return True  
+
+def wecker_status_info():
+    if wecker_status != "running":
+        return {"status": wecker_status, "target_time": 0}
+
+
+    return {
+        "status": "running",
+        "target_time": wecker_target_time 
+    }
+
+def format_duration(seconds):
+    if seconds < 60:
+        return f"{seconds} {second_text(seconds)}"
+
+    minutes = seconds // 60
+    secs = seconds % 60
+
+    if minutes < 10:
+        if secs == 0:
+            return f"{minutes} {minute_text(minutes)}"
+        return f"{minutes} {minute_text(minutes)} und {secs} {second_text(secs)}"
+
+    if minutes < 60:
+        return f"{minutes} {minute_text(minutes)}"
+    
+    hours = minutes // 60
+    mins = minutes % 60
+
+    if mins == 0:
+        return f"{hours} {hour_text(hours)}"
+    return f"{hours} {hour_text(hours)} und {mins} {minute_text(mins)}"
+
+
+
+def minute_text(n):
+    return "Minute" if n == 1 else "Minuten"
+
+def second_text(n):
+    return "Sekunde" if n == 1 else "Sekunden"
+
+def hour_text(n):
+    return "Stunde" if n == 1 else "Stunden"