radio-alarm-clock-feature

README.md

@@ -8,4 +8,5 @@ pinned: false
 short_description: Listen to the radio with Reachy Mini !
 tags:
  - reachy_mini
+ - reachy_mini_python_app
 ---

reachy_mini_radio/alarm_manager.py

@@ -0,0 +1,78 @@
+import json
+from pathlib import Path
+from datetime import datetime
+
+
+class AlarmManager:
+    def __init__(self, config_path: Path):
+        self.config_path = config_path
+        self.settings = {
+            "enabled": False,
+            "alarm_mode": False,
+            "time": "08:00", # HH:MM 24h format
+
+            "station_url": "",
+            "station_name": "",
+        }
+        self.load_settings()
+        self._triggered_today = False
+        self._last_check_date = None
+
+    def load_settings(self):
+        if self.config_path.exists():
+            try:
+                data = json.loads(self.config_path.read_text("utf-8"))
+                self.settings.update(data)
+            except Exception as e:
+                print(f"[AlarmManager] Error loading settings: {e}")
+        
+        # Force alarm to be disabled on startup
+        self.settings["enabled"] = False
+        self.settings["alarm_mode"] = False
+
+    def save_settings(self, new_settings=None):
+        if new_settings:
+            # Reset trigger flag if we are enabling the alarm or changing the time
+            if new_settings.get("enabled") is True:
+                self._triggered_today = False
+            elif "time" in new_settings and new_settings["time"] != self.settings.get("time"):
+                self._triggered_today = False
+
+            self.settings.update(new_settings)
+
+        try:
+            self.config_path.write_text(
+                data=json.dumps(self.settings, indent=2), 
+                encoding="utf-8"
+                )
+        except Exception as e:
+            print(f"[AlarmManager] Error saving settings: {e}")
+
+        return self.settings
+
+    def get_settings(self):
+        return self.settings
+
+    def check_alarm(self):
+        if not self.settings["enabled"]:
+            return False
+
+        if self._triggered_today:
+            return False
+
+        now = datetime.now()
+        current_date = now.date()
+
+        if self._last_check_date != current_date:
+            self._triggered_today = False
+            self._last_check_date = current_date
+
+        if self._triggered_today:
+            return False
+
+        current_time_str = now.strftime("%H:%M")
+        if current_time_str == self.settings["time"]:
+            self._triggered_today = True
+            return True
+
+        return False

reachy_mini_radio/alarm_settings.json

@@ -0,0 +1,8 @@
+{
+  "enabled": false,
+  "alarm_mode": false,
+  "time": "07:20",
+  "station_url": "https://streaming.smartradio.ch:9502/stream",
+  "station_name": "A Fine Jazz Gumbo Radio",
+  "timezone": "America/Los_Angeles"
+}

reachy_mini_radio/main.py

@@ -6,14 +6,17 @@ import json
 
 import sounddevice as sd
 import numpy as np
+import bisect
 import av
 from reachy_mini import ReachyMini, ReachyMiniApp
 from reachy_mini_radio.antenna_button import AntennaButton
+from reachy_mini_radio.alarm_manager import AlarmManager
 
 # -----------------------------
 # Config
 # -----------------------------
 RADIOS_FILE = Path(__file__).parent / "webradios.json"
+ALARM_FILE = Path(__file__).parent / "alarm_settings.json"
 
 sr = 48000
 channels = 2
@@ -79,42 +82,48 @@ class RadioDecoder:
         self.thread.join()
 
     def _run(self):
-        try:
-            container = av.open(self.url, timeout=5.0)
-            audio_stream = next(s for s in container.streams if s.type == "audio")
+        while not self.stop_event.is_set():
+            try:
+                container = av.open(self.url, timeout=5.0)
+                audio_stream = next(s for s in container.streams if s.type == "audio")
 
-            resampler = av.audio.resampler.AudioResampler(
-                format="flt",
-                layout="stereo",
-                rate=self.sr,
-            )
+                resampler = av.audio.resampler.AudioResampler(
+                    format="flt",
+                    layout="stereo",
+                    rate=self.sr,
+                )
 
-            for packet in container.demux(audio_stream):
-                if self.stop_event.is_set():
-                    break
-
-                for frame in packet.decode():
-                    for out_frame in resampler.resample(frame):
-                        arr = out_frame.to_ndarray()
-                        if arr.ndim == 1:
-                            arr = arr[np.newaxis, :]
-
-                        pcm = arr.T  # (samples, channels)
-
-                        i = 0
-                        n = pcm.shape[0]
-                        while i < n and not self.stop_event.is_set():
-                            chunk = pcm[i : i + blocksize, :]
-                            i += blocksize
-                            try:
-                                self.queue.put(chunk, timeout=0.1)
-                            except queue.Full:
-                                # drop if output can't keep up
-                                break
-        except Exception as e:
-            print(f"[RadioDecoder] {self.name} error: {e}")
-        finally:
-            print(f"[RadioDecoder] {self.name} stopped")
+                for packet in container.demux(audio_stream):
+                    if self.stop_event.is_set():
+                        break
+
+                    for frame in packet.decode():
+                        for out_frame in resampler.resample(frame):
+                            arr = out_frame.to_ndarray()
+                            if arr.ndim == 1:
+                                arr = arr[np.newaxis, :]
+
+                            pcm = arr.T  # (samples, channels)
+
+                            i = 0
+                            n = pcm.shape[0]
+                            while i < n and not self.stop_event.is_set():
+                                chunk = pcm[i : i + blocksize, :]
+                                i += blocksize
+                                try:
+                                    self.queue.put(chunk, timeout=0.1)
+                                except queue.Full:
+                                    # drop if output can't keep up
+                                    break
+            except Exception as e:
+                if not self.stop_event.is_set():
+                    print(f"[RadioDecoder] {self.name} error: {e}. Retrying in 5s...")
+                    time.sleep(5.0)
+            finally:
+                # Cleanup if needed
+                pass
+        
+        print(f"[RadioDecoder] {self.name} stopped")
 
     def get_samples(self, frames):
         out = np.zeros((frames, self.channels), dtype=np.float32)
@@ -268,8 +277,7 @@ def between_angles(angle, _angles):
         else:
             return sorted_angles[0], sorted_angles[0]
 
-    # Insert angle into sorted list to find position
-    import bisect
+    # Insert angle into sorted list to find positio
 
     idx = bisect.bisect_left(sorted_angles, angle)
     if idx > 0 and abs(sorted_angles[idx - 1] - angle) < 0.05:
@@ -291,110 +299,44 @@ def between_angles(angle, _angles):
 
     return prev_angle, next_angle
 
+def closest_equivalent_angle(target, current):
+    diff = target - current
+    # wrap diff to [-pi, pi)
+    diff = (diff + np.pi) % (2 * np.pi) - np.pi
+    return current + diff
 
 class ReachyMiniRadio(ReachyMiniApp):
     # If your webradio selector serves the UI at this URL:
     custom_app_url: str | None = "http://0.0.0.0:8042"
 
     def run(self, reachy_mini: ReachyMini, stop_event: threading.Event):
+        self.reachy_mini = reachy_mini
+        self.stop_event = stop_event
+        
         # Shared radio set
-        radioset = RadioSet()
-
-        @self.settings_app.get("/api/webradios")
-        async def get_webradios():
-            """Expose the current list of stations to the settings UI."""
-            return load_stations_from_file(RADIOS_FILE)
-
-        @self.settings_app.post("/api/webradios")
-        async def save_webradios(payload: list[dict[str, str]]):
-            """Persist the stations selected in the settings UI."""
-            cleaned = save_stations_to_file(RADIOS_FILE, payload)
-            return {"ok": True, "count": len(cleaned)}
-
+        self.radioset = RadioSet()
         self.antenna_button = AntennaButton(reachy_mini, stop_event)
+        self.alarm_manager = AlarmManager(ALARM_FILE)
+        self.rng = np.random.default_rng()
+        
+        # State
+        self.state = {"angle": 0.0}
+
+        self._setup_routes()
 
         # Initial load of stations
         initial_stations = load_stations_from_file(RADIOS_FILE)
-        radioset.update(initial_stations)
+        self.radioset.update(initial_stations)
 
         # Start watcher thread that reloads stations when JSON changes
         watcher_thread = threading.Thread(
             target=stations_watcher,
-            args=(stop_event, radioset, RADIOS_FILE),
+            args=(stop_event, self.radioset, RADIOS_FILE),
             daemon=True,
         )
         watcher_thread.start()
 
-        # Antenna calibration
-        state = {"angle": 0.0}
-        # calib = {"center": None, "range": 2 * np.pi}  # very rough mapping
-
-        def update_angle():
-            raw = reachy_mini.get_present_antenna_joint_positions()[1]
-            return raw % (2 * np.pi)
-
-        reachy_mini.enable_motors(["left_antenna"])
-        reachy_mini.goto_target(np.eye(4), antennas=[0, 0])
-        reachy_mini.disable_motors(["left_antenna"])
-
-        rng = np.random.default_rng()
-
-        def audio_callback(outdata, frames, time_info, status):
-            if status:
-                print(status, flush=True)
-
-            angle = state["angle"]
-
-            with radioset.lock:
-                station_angles = radioset.station_angles
-                decoders = list(radioset.decoders)
-
-            # Always produce some output (static), even with no stations
-            if station_angles.size == 0 or not decoders:
-                noise = rng.normal(0.0, noise_std, size=(frames, channels)).astype(
-                    np.float32
-                )
-                np.clip(noise, -1.0, 1.0, out=noise)
-                outdata[:] = noise
-                return
-
-            # Find nearest station
-            dists = circular_distance(angle, station_angles)
-            nearest_idx = int(np.argmin(dists))
-            d_min = float(dists[nearest_idx])
-
-            # Station gain (0 outside bandwidth, 1 at station)
-            if d_min >= station_bandwidth:
-                station_gain = 0.0
-            else:
-                station_gain = 1.0 - (d_min / station_bandwidth)
-
-            # Get radio samples for nearest station only
-            decoder = decoders[nearest_idx]
-            radio = decoder.get_samples(frames)
-
-            # Noise gain with "sweet spot"
-            if d_min <= station_sweetspot:
-                # In sweet spot: no static at all
-                noise_gain = 0.0
-            elif d_min >= station_bandwidth:
-                # Completely off any station: maximum noise
-                noise_gain = max_noise_gain
-            else:
-                # Between sweet spot and bandwidth: ramp from 0 to max_noise_gain
-                t = (d_min - station_sweetspot) / (
-                    station_bandwidth - station_sweetspot
-                )
-                t = max(0.0, min(1.0, t))
-                noise_gain = t * max_noise_gain
-
-            noise = rng.normal(0.0, noise_std, size=(frames, channels)).astype(
-                np.float32
-            )
-
-            mix = station_gain * radio + noise_gain * noise
-            np.clip(mix, -1.0, 1.0, out=mix)
-            outdata[:] = mix
+        self._calibrate_antenna()
 
         # Start audio output
         with sd.OutputStream(
@@ -402,70 +344,16 @@ class ReachyMiniRadio(ReachyMiniApp):
             channels=channels,
             dtype="float32",
             blocksize=blocksize,
-            callback=audio_callback,
+            callback=self._audio_callback,
         ):
             print(
                 "ReachyMiniRadio running. Move the left antenna to tune stations (hot-reload from webradios.json)."
             )
+
             try:
                 while not stop_event.is_set():
-                    state["angle"] = update_angle()  # 0 to 2pi range
-                    triggered, direction = self.antenna_button.is_triggered()
-                    if triggered:
-                        print(f"[AntennaButton] Triggered! Direction: {direction}")
-                        # use radioset.station_angles to get the next angle to jump to depending on direction "left" or "right"
-                        with radioset.lock:
-                            if (
-                                radioset.station_angles.size == 0
-                                or radioset.station_angles.size == 1
-                            ):
-                                continue
-                            current_angle = state["angle"]  # 0 to 2pi range
-                            before_angle, after_angle = between_angles(
-                                current_angle, radioset.station_angles.copy()
-                            )
-
-                            if before_angle > np.pi:
-                                before_angle -= 2 * np.pi
-                            if before_angle < -np.pi:
-                                before_angle += 2 * np.pi
-                            if after_angle > np.pi:
-                                after_angle -= 2 * np.pi
-                            if after_angle < -np.pi:
-                                after_angle += 2 * np.pi
-                            if current_angle > np.pi:
-                                current_angle -= 2 * np.pi
-                            if current_angle < -np.pi:
-                                current_angle += 2 * np.pi
-
-                            print(
-                                "before:",
-                                before_angle,
-                                "current angle:",
-                                current_angle,
-                                "after:",
-                                after_angle,
-                            )
-                            if direction == "right":
-                                target_angle = after_angle
-                                print("after")
-                            else:
-                                target_angle = before_angle
-                                print("before")
-                            # target_angle = target_angle % (2 * np.pi)
-                            # target_angle is in -pi to +pi range
-                            # if target_angle > np.pi:
-                            #     target_angle -= 2 * np.pi
-                            print(
-                                f"[AntennaButton] Jumping to angle: {target_angle:.2f} rad"
-                            )
-                            reachy_mini.enable_motors(["left_antenna"])
-                            reachy_mini.set_target_antenna_joint_positions(
-                                [0.0, float(target_angle)]
-                            )
-                            time.sleep(0.3)  # wait for movement
-                            reachy_mini.disable_motors(["left_antenna"])
-
+                    self._handle_alarm()
+                    self._handle_antenna_button()
                     time.sleep(0.01)
             finally:
                 # Stop watcher
@@ -473,14 +361,215 @@ class ReachyMiniRadio(ReachyMiniApp):
                 watcher_thread.join(timeout=1.0)
 
                 # Stop decoders
-                with radioset.lock:
-                    decoders = list(radioset.decoders)
+                with self.radioset.lock:
+                    decoders = list(self.radioset.decoders)
                 for d in decoders:
                     d.stop()
 
+    def _setup_routes(self):
+        @self.settings_app.get("/api/webradios")
+        def get_webradios():
+            """Expose the current list of stations to the settings UI."""
+            return load_stations_from_file(RADIOS_FILE)
+
+        @self.settings_app.post("/api/webradios")
+        def save_webradios(payload: list[dict[str, str]]):
+            """Persist the stations selected in the settings UI."""
+            cleaned = save_stations_to_file(RADIOS_FILE, payload)
+            return {"ok": True, "count": len(cleaned)}
+
+        @self.settings_app.get("/api/alarm")
+        def get_alarm():
+            return self.alarm_manager.get_settings()
+
+        @self.settings_app.post("/api/alarm")
+        def save_alarm(payload: dict):
+            return self.alarm_manager.save_settings(payload)
+
+    def _calibrate_antenna(self):
+        self.reachy_mini.enable_motors(["left_antenna"])
+        self.reachy_mini.goto_target(np.eye(4), antennas=[0, 0])
+        self.reachy_mini.disable_motors(["left_antenna"])
+
+    def _update_angle(self):
+        raw = self.reachy_mini.get_present_antenna_joint_positions()[1]
+        return raw % (2 * np.pi)
+
+    def _audio_callback(self, outdata, frames, time_info, status):
+        if status:
+            print(status, flush=True)
+
+        settings = self.alarm_manager.get_settings()
+        if settings.get("enabled") and settings.get("alarm_mode"):
+            outdata.fill(0)
+            return
+
+        angle = self.state["angle"]
+
+        with self.radioset.lock:
+            station_angles = self.radioset.station_angles
+            decoders = list(self.radioset.decoders)
+
+        # Always produce some output (static), even with no stations
+        if station_angles.size == 0 or not decoders:
+            noise = self.rng.normal(0.0, noise_std, size=(frames, channels)).astype(
+                np.float32
+            )
+            np.clip(noise, -1.0, 1.0, out=noise)
+            outdata[:] = noise
+            return
+
+        # Find nearest station
+        dists = circular_distance(angle, station_angles)
+        nearest_idx = int(np.argmin(dists))
+        d_min = float(dists[nearest_idx])
+
+        # Station gain (0 outside bandwidth, 1 at station)
+        if d_min >= station_bandwidth:
+            station_gain = 0.0
+        else:
+            station_gain = 1.0 - (d_min / station_bandwidth)
+
+        # Get radio samples for nearest station only
+        decoder = decoders[nearest_idx]
+        radio = decoder.get_samples(frames)
+
+        # Noise gain with "sweet spot"
+        if d_min <= station_sweetspot:
+            # In sweet spot: no static at all
+            noise_gain = 0.0
+        elif d_min >= station_bandwidth:
+            # Completely off any station: maximum noise
+            noise_gain = max_noise_gain
+        else:
+            # Between sweet spot and bandwidth: ramp from 0 to max_noise_gain
+            t = (d_min - station_sweetspot) / (
+                station_bandwidth - station_sweetspot
+            )
+            t = max(0.0, min(1.0, t))
+            noise_gain = t * max_noise_gain
+
+        noise = self.rng.normal(0.0, noise_std, size=(frames, channels)).astype(
+            np.float32
+        )
+
+        mix = station_gain * radio + noise_gain * noise
+        np.clip(mix, -1.0, 1.0, out=mix)
+        outdata[:] = mix
+
+    def _move_antenna(self, target_angle):
+        print(f"[Tuning] Jumping to angle: {target_angle:.2f} rad")
+        self.reachy_mini.enable_motors(["left_antenna"])
+        self.reachy_mini.set_target_antenna_joint_positions(
+            [0.0, float(target_angle)]
+        )
+        time.sleep(0.3)  # wait for movement
+        self.reachy_mini.disable_motors(["left_antenna"])
+
+    def _handle_alarm(self):
+        is_alarm_triggered = self.alarm_manager.check_alarm()
+        settings = self.alarm_manager.get_settings()
+        
+        if settings.get("enabled") and settings.get("alarm_mode"):
+            if not self.state.get("is_sleeping", False):
+                print("[AlarmManager] Entering Alarm Mode: Going to sleep...")
+                self.reachy_mini.goto_sleep()
+                self.state["is_sleeping"] = True
+                self.state["ignore_antenna"] = True
+        
+        # Check if alarm was cancelled while sleeping
+        if self.state.get("is_sleeping", False) and not settings.get("alarm_mode"):
+            print("[AlarmManager] Alarm cancelled. Waking up...")
+            self.reachy_mini.wake_up()
+            self.state["is_sleeping"] = False
+            self.state["ignore_antenna"] = False
+
+        if is_alarm_triggered:
+            print("[AlarmManager] Alarm Triggered!")
+            self.state["ignore_antenna"] = True
+
+            if self.state.get("is_sleeping", False):
+                print("[AlarmManager] Waking up...")
+                self.reachy_mini.wake_up()
+                self.state["is_sleeping"] = False
+
+            self.alarm_manager.save_settings({"alarm_mode": False})
+            settings = self.alarm_manager.get_settings()
+            target_url = settings.get("station_url")
+
+            if target_url:
+                found_angle = None
+                with self.radioset.lock:
+                    for i, decoder in enumerate(self.radioset.decoders):
+                        if decoder.url == target_url:
+                            found_angle = self.radioset.station_angles[i]
+                            break
+
+                if found_angle is not None:
+                    print(f"[AlarmManager] Found target station at angle: {found_angle:.2f}")
+                    
+                    # Use closest equivalent angle logic but execute with _move_antenna
+                    current_pos = self.reachy_mini.get_present_antenna_joint_positions()[1]
+                    target_angle = closest_equivalent_angle(float(found_angle), current_pos)
+                    print(f"[AlarmManager] Current pos: {current_pos:.2f}, Target: {target_angle:.2f}")
+
+                    self._move_antenna(target_angle)
+                else:
+                    print(f"[AlarmManager] Station URL {target_url} not found in current radio set.")
+            else:
+                print("[AlarmManager] No target URL found.")
+            
+            self.state["ignore_antenna"] = False
+
+    def _handle_antenna_button(self):
+        if not self.state.get("ignore_antenna", False):
+            self.state["angle"] = self._update_angle()  # 0 to 2pi range
+            triggered, direction = self.antenna_button.is_triggered()
+            if triggered:
+                print(f"[AntennaButton] Triggered! Direction: {direction}")
+                # use radioset.station_angles to get the next angle to jump to depending on direction "left" or "right"
+                with self.radioset.lock:
+                    if (
+                        self.radioset.station_angles.size == 0
+                        or self.radioset.station_angles.size == 1
+                    ):
+                        return
+                    current_angle = self.state["angle"]  # 0 to 2pi range
+                    before_angle, after_angle = between_angles(
+                        current_angle, self.radioset.station_angles.copy()
+                    )
+
+                    if before_angle > np.pi:
+                        before_angle -= 2 * np.pi
+                    if before_angle < -np.pi:
+                        before_angle += 2 * np.pi
+                    if after_angle > np.pi:
+                        after_angle -= 2 * np.pi
+                    if after_angle < -np.pi:
+                        after_angle += 2 * np.pi
+                    if current_angle > np.pi:
+                        current_angle -= 2 * np.pi
+                    if current_angle < -np.pi:
+                        current_angle += 2 * np.pi
+
+                    print(
+                        "before:",
+                        before_angle,
+                        "current angle:",
+                        current_angle,
+                        "after:",
+                        after_angle,
+                    )
+                    if direction == "right":
+                        target_angle = after_angle
+                        print("after")
+                    else:
+                        target_angle = before_angle
+                        print("before")
+                    
+                    self._move_antenna(target_angle)
 
 if __name__ == "__main__":
-    # You can run the app directly from this script
     with ReachyMini() as mini:
         app = ReachyMiniRadio()
         stop = threading.Event()
@@ -492,4 +581,4 @@ if __name__ == "__main__":
             print("App has stopped.")
         except KeyboardInterrupt:
             print("Stopping the app...")
-            stop.set()
+            stop.set()

reachy_mini_radio/static/index.html

@@ -37,6 +37,25 @@
                     <button id="saveBtn" style="margin-left: auto;">Save</button>
                 </div>
                 <div class="status" id="saveStatus"></div>
+                
+                <div class="panel-title" style="margin-top: 2rem;">Alarm Clock</div>
+                <div class="alarm-box">
+                    <div class="form-row">
+                        <label>Time</label>
+                        <input type="time" id="alarmTime" />
+                    </div>
+
+                    <div class="form-row">
+                        <label>Station</label>
+                        <select id="alarmStation"></select>
+                    </div>
+                    <div class="search-row" style="margin-top: 16px; gap: 10px;">
+                        <button id="setAlarmBtn" class="primary" style="flex: 1;">Set Alarm & Sleep</button>
+                        <button id="cancelAlarmBtn" class="secondary" style="flex: 1; display: none;">Cancel
+                            Alarm</button>
+                    </div>
+                    <div class="status" id="alarmStatus"></div>
+                </div>
             </div>
         </div>
     </div>

reachy_mini_radio/static/main.js

@@ -9,6 +9,12 @@ const saveBtn = document.getElementById("saveBtn");
 const clearBtn = document.getElementById("clearBtn");
 const countBadge = document.getElementById("countBadge");
 
+const alarmTime = document.getElementById("alarmTime");
+const alarmStation = document.getElementById("alarmStation");
+const setAlarmBtn = document.getElementById("setAlarmBtn");
+const cancelAlarmBtn = document.getElementById("cancelAlarmBtn");
+const alarmStatus = document.getElementById("alarmStatus");
+
 const currentUrl = new URL(window.location.href);
 if (!currentUrl.pathname.endsWith("/")) {
     currentUrl.pathname += "/";
@@ -30,141 +36,143 @@ function updateCountBadge() {
 function renderSelected() {
     selectedBox.innerHTML = "";
     if (!selectedStations.length) {
-    selectedBox.textContent = "No stations selected yet.";
-    updateCountBadge();
-    return;
+        selectedBox.textContent = "No stations selected yet.";
+        updateCountBadge();
+        if (typeof updateAlarmStationDropdown === "function") updateAlarmStationDropdown();
+        return;
     }
     selectedStations.forEach((st, idx) => {
-    const item = document.createElement("div");
-    item.className = "item";
+        const item = document.createElement("div");
+        item.className = "item";
 
-    const main = document.createElement("div");
-    main.className = "item-main";
+        const main = document.createElement("div");
+        main.className = "item-main";
 
-    const name = document.createElement("div");
-    name.className = "item-name";
-    name.textContent = st.name || "(unnamed station)";
+        const name = document.createElement("div");
+        name.className = "item-name";
+        name.textContent = st.name || "(unnamed station)";
 
-    const meta = document.createElement("div");
-    meta.className = "item-meta";
-    meta.textContent = st.url;
+        const meta = document.createElement("div");
+        meta.className = "item-meta";
+        meta.textContent = st.url;
 
-    main.appendChild(name);
-    main.appendChild(meta);
+        main.appendChild(name);
+        main.appendChild(meta);
 
-    const btn = document.createElement("button");
-    btn.className = "secondary small-btn";
-    btn.textContent = "Remove";
-    btn.onclick = () => {
-        selectedStations.splice(idx, 1);
-        renderSelected();
-    };
+        const btn = document.createElement("button");
+        btn.className = "secondary small-btn";
+        btn.textContent = "Remove";
+        btn.onclick = () => {
+            selectedStations.splice(idx, 1);
+            renderSelected();
+        };
 
-    item.appendChild(main);
-    item.appendChild(btn);
-    selectedBox.appendChild(item);
+        item.appendChild(main);
+        item.appendChild(btn);
+        selectedBox.appendChild(item);
     });
     updateCountBadge();
+    if (typeof updateAlarmStationDropdown === "function") updateAlarmStationDropdown();
 }
 
 function renderResults(stations) {
     resultsBox.innerHTML = "";
     if (!stations.length) {
-    resultsBox.textContent = "No results.";
-    return;
+        resultsBox.textContent = "No results.";
+        return;
     }
     stations.forEach(st => {
-    const url = st.url_resolved || st.url;
-    if (!url) return;
-
-    const item = document.createElement("div");
-    item.className = "item";
-
-    const main = document.createElement("div");
-    main.className = "item-main";
-
-    const name = document.createElement("div");
-    name.className = "item-name";
-    name.textContent = st.name || "(unnamed)";
-
-    const meta = document.createElement("div");
-    meta.className = "item-meta";
-    const parts = [];
-    if (st.country) parts.push(st.country);
-    if (st.codec) parts.push(st.codec.toUpperCase());
-    if (st.bitrate) parts.push(st.bitrate + " kbps");
-    meta.textContent = parts.join(" · ") || url;
-
-    main.appendChild(name);
-    main.appendChild(meta);
-
-    const btn = document.createElement("button");
-    btn.className = "secondary small-btn";
-    btn.textContent = "Add";
-    btn.onclick = () => {
-        selectedStations.push({ name: st.name || "(unnamed)", url });
-        // dedupe on url
-        const seen = new Set();
-        selectedStations = selectedStations.filter(s => {
-        const key = (s.url || "").toLowerCase();
-        if (!key || seen.has(key)) return false;
-        seen.add(key);
-        return true;
-        });
-        renderSelected();
-        saveStatus.textContent = "Not saved yet.";
-        saveStatus.className = "status";
-    };
+        const url = st.url_resolved || st.url;
+        if (!url) return;
+
+        const item = document.createElement("div");
+        item.className = "item";
+
+        const main = document.createElement("div");
+        main.className = "item-main";
+
+        const name = document.createElement("div");
+        name.className = "item-name";
+        name.textContent = st.name || "(unnamed)";
+
+        const meta = document.createElement("div");
+        meta.className = "item-meta";
+        const parts = [];
+        if (st.country) parts.push(st.country);
+        if (st.codec) parts.push(st.codec.toUpperCase());
+        if (st.bitrate) parts.push(st.bitrate + " kbps");
+        meta.textContent = parts.join(" · ") || url;
 
-    item.appendChild(main);
-    item.appendChild(btn);
-    resultsBox.appendChild(item);
+        main.appendChild(name);
+        main.appendChild(meta);
+
+        const btn = document.createElement("button");
+        btn.className = "secondary small-btn";
+        btn.textContent = "Add";
+        btn.onclick = () => {
+            selectedStations.push({ name: st.name || "(unnamed)", url });
+            // dedupe on url
+            const seen = new Set();
+            selectedStations = selectedStations.filter(s => {
+                const key = (s.url || "").toLowerCase();
+                if (!key || seen.has(key)) return false;
+                seen.add(key);
+                return true;
+            });
+            renderSelected();
+            saveStatus.textContent = "Not saved yet.";
+            saveStatus.className = "status";
+        };
+
+        item.appendChild(main);
+        item.appendChild(btn);
+        resultsBox.appendChild(item);
     });
 }
 
 async function doSearch() {
     const q = searchInput.value.trim();
     if (!q) {
-    searchStatus.textContent = "Type something to search.";
-    searchStatus.className = "status err";
-    resultsBox.innerHTML = "";
-    return;
+        searchStatus.textContent = "Type something to search.";
+        searchStatus.className = "status err";
+        resultsBox.innerHTML = "";
+        return;
     }
     searchStatus.textContent = "Searching…";
     searchStatus.className = "status";
     resultsBox.innerHTML = "";
 
     try {
-    const url = "https://de1.api.radio-browser.info/json/stations/search?name=" +
-                encodeURIComponent(q) +
-                "&limit=25&hidebroken=true";
-    const res = await fetch(url);
-    if (!res.ok) throw new Error("HTTP " + res.status);
-    const data = await res.json();
-    renderResults(data);
-    searchStatus.textContent = "Found " + data.length + " stations.";
-    searchStatus.className = "status ok";
+        const url = "https://de1.api.radio-browser.info/json/stations/search?name=" +
+            encodeURIComponent(q) +
+            "&limit=25&hidebroken=true";
+        const res = await fetch(url);
+        if (!res.ok) throw new Error("HTTP " + res.status);
+        const data = await res.json();
+        renderResults(data);
+        searchStatus.textContent = "Found " + data.length + " stations.";
+        searchStatus.className = "status ok";
     } catch (err) {
-    console.error(err);
-    searchStatus.textContent = "Search failed.";
-    searchStatus.className = "status err";
+        console.error(err);
+        searchStatus.textContent = "Search failed.";
+        searchStatus.className = "status err";
     }
 }
 
 async function loadSelectedFromServer() {
     try {
-    const res = await fetch(buildApiUrl("api/webradios"));
-    if (!res.ok) return;
-    const data = await res.json();
-    if (Array.isArray(data)) {
-        selectedStations = data.map(s => ({
-        name: s.name || "",
-        url: s.url || ""
-        }));
-        renderSelected();
-    }
+        const res = await fetch(buildApiUrl("api/webradios"));
+        if (!res.ok) return;
+        const data = await res.json();
+        if (Array.isArray(data)) {
+            selectedStations = data.map(s => ({
+                name: s.name || "",
+                url: s.url || ""
+            }));
+            renderSelected();
+        }
     } catch (err) {
-    console.error(err);
+        console.error(err);
     }
 }
 
@@ -172,28 +180,28 @@ async function saveToServer() {
     saveStatus.textContent = "Saving…";
     saveStatus.className = "status";
     try {
-    const res = await fetch(buildApiUrl("api/webradios"), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(selectedStations)
-    });
-    if (!res.ok) throw new Error("HTTP " + res.status);
-    const data = await res.json();
-    if (!data.ok) throw new Error("Server error");
-    saveStatus.textContent = "Saved (" + data.count + " stations).";
-    saveStatus.className = "status ok";
+        const res = await fetch(buildApiUrl("api/webradios"), {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(selectedStations)
+        });
+        if (!res.ok) throw new Error("HTTP " + res.status);
+        const data = await res.json();
+        if (!data.ok) throw new Error("Server error");
+        saveStatus.textContent = "Saved (" + data.count + " stations).";
+        saveStatus.className = "status ok";
     } catch (err) {
-    console.error(err);
-    saveStatus.textContent = "Save failed.";
-    saveStatus.className = "status err";
+        console.error(err);
+        saveStatus.textContent = "Save failed.";
+        saveStatus.className = "status err";
     }
 }
 
 searchBtn.onclick = () => doSearch();
 searchInput.addEventListener("keydown", e => {
     if (e.key === "Enter") {
-    e.preventDefault();
-    doSearch();
+        e.preventDefault();
+        doSearch();
     }
 });
 
@@ -205,5 +213,135 @@ clearBtn.onclick = () => {
     saveStatus.className = "status";
 };
 
+
+
+function updateAlarmStationDropdown() {
+    // Save current selection
+    const currentVal = alarmStation.value;
+
+    alarmStation.innerHTML = "";
+    const defaultOpt = document.createElement("option");
+    defaultOpt.value = "";
+    defaultOpt.textContent = "-- Select Station --";
+    alarmStation.appendChild(defaultOpt);
+
+    selectedStations.forEach(st => {
+        const opt = document.createElement("option");
+        opt.value = st.url;
+        opt.textContent = st.name || st.url;
+        alarmStation.appendChild(opt);
+    });
+
+    // Restore selection if possible
+    if (currentVal) {
+        alarmStation.value = currentVal;
+    }
+}
+
+
+
+function updateAlarmUI(enabled) {
+    if (enabled) {
+        setAlarmBtn.style.display = "none";
+        cancelAlarmBtn.style.display = "inline-block";
+        alarmStatus.textContent = "Alarm is set. Reachy is sleeping.";
+        alarmStatus.className = "status ok";
+        // Disable inputs
+        alarmTime.disabled = true;
+
+        alarmStation.disabled = true;
+    } else {
+        setAlarmBtn.style.display = "inline-block";
+        cancelAlarmBtn.style.display = "none";
+        alarmStatus.textContent = "Alarm not set.";
+        alarmStatus.className = "status";
+        // Enable inputs
+        alarmTime.disabled = false;
+
+        alarmStation.disabled = false;
+    }
+}
+
+async function loadAlarmSettings() {
+    try {
+        const res = await fetch(buildApiUrl("api/alarm"));
+        if (!res.ok) return;
+        const data = await res.json();
+
+        if (data.time) alarmTime.value = data.time;
+
+        if (data.station_url) alarmStation.value = data.station_url;
+
+        updateAlarmUI(data.enabled);
+
+    } catch (err) {
+        console.error("Failed to load alarm settings", err);
+    }
+}
+
+async function setAlarm() {
+    if (!alarmTime.value || !alarmStation.value) {
+        alarmStatus.textContent = "Please select time and station.";
+        alarmStatus.className = "status err";
+        return;
+    }
+
+    alarmStatus.textContent = "Setting alarm...";
+    alarmStatus.className = "status";
+
+    const settings = {
+        enabled: true,
+        alarm_mode: true, // Always enable sleep mode when setting alarm this way
+        time: alarmTime.value,
+
+        station_url: alarmStation.value,
+        station_name: alarmStation.options[alarmStation.selectedIndex]?.textContent || ""
+    };
+
+    try {
+        const res = await fetch(buildApiUrl("api/alarm"), {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(settings)
+        });
+        if (!res.ok) throw new Error("HTTP " + res.status);
+
+        updateAlarmUI(true);
+    } catch (err) {
+        console.error(err);
+        alarmStatus.textContent = "Failed to set alarm.";
+        alarmStatus.className = "status err";
+    }
+}
+
+async function cancelAlarm() {
+    alarmStatus.textContent = "Cancelling...";
+
+    const settings = {
+        enabled: false,
+        alarm_mode: false
+    };
+
+    try {
+        const res = await fetch(buildApiUrl("api/alarm"), {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(settings)
+        });
+        if (!res.ok) throw new Error("HTTP " + res.status);
+
+        updateAlarmUI(false);
+    } catch (err) {
+        console.error(err);
+        alarmStatus.textContent = "Failed to cancel alarm.";
+        alarmStatus.className = "status err";
+    }
+}
+
+setAlarmBtn.onclick = setAlarm;
+cancelAlarmBtn.onclick = cancelAlarm;
+
 // Initial load
-loadSelectedFromServer();
+loadSelectedFromServer().then(() => {
+    loadAlarmSettings();
+});

reachy_mini_radio/static/style.css

@@ -138,6 +138,63 @@ button:active {
     border-radius: 999px;
 }
 
+@media (max-width: 768px) {
+    .hero {
+        padding: 2rem 1rem;
+    }
+
+    .hero h1 {
+        font-size: 2rem;
+    }
+
+    .container {
+        padding: 0 1rem;
+    }
+
+    .app-details,
+    .download-card {
+        padding: 2rem;
+    }
+
+    .features-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .download-options {
+        grid-template-columns: 1fr;
+    }
+}
+
+.alarm-box {
+    background: #090d1c;
+    padding: 1rem;
+    border-radius: 8px;
+    border: 1px solid #272f4a;
+}
+
+.form-row {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: 0.75rem;
+}
+
+.form-row label {
+    font-weight: 500;
+    color: #475569;
+}
+
+.form-row input[type="time"],
+.form-row select {
+    background: #080c1a;
+    color: #f5f5f8;
+    border: 1px solid #272f4a;
+    border-radius: 8px;
+    padding: 8px 10px;
+    outline: none;
+    font-size: 0.9rem;
+}
+
 .status {
     margin-top: 4px;
     font-size: 12px;
@@ -164,4 +221,14 @@ button:active {
 .badge {
     font-size: 11px;
     color: #9ca3c7;
+}
+
+input:disabled,
+select:disabled {
+    opacity: 1 !important;
+    color: #ffffff !important;
+    -webkit-text-fill-color: #ffffff !important;
+    background: #262c45 !important;
+    border-color: #475569 !important;
+    cursor: not-allowed;
 }

reachy_mini_radio/webradios.json

@@ -1,14 +1,14 @@
 [
   {
-    "name": "FIP",
-    "url": "http://icecast.radiofrance.fr/fip-hifi.aac"
+    "name": "A Fine Jazz Gumbo Radio",
+    "url": "https://streaming.smartradio.ch:9502/stream"
   },
   {
-    "name": "FIP Rock",
-    "url": "http://icecast.radiofrance.fr/fiprock-hifi.aac"
+    "name": "100.5 The Fox",
+    "url": "https://cloud-proxy-hls.revma.ihrhls.com/zc2938/hls.m3u8?rj-org=n0bb-e2&rj-ttl=5&rj-tok=AAABmuU8gY4AmS-J09808GxN2g"
   },
   {
-    "name": "FIP JAZZ",
-    "url": "http://icecast.radiofrance.fr/fipjazz-hifi.aac"
+    "name": "92.5 The Breeze",
+    "url": "https://cloud.revma.ihrhls.com/zc4366?rj-org=n2eb-e2&rj-ttl=5&rj-tok=AAABmuV3vVIAOF5UGGE1WgcYeA"
   }
 ]