# state.py import threading import json import os import logging logger = logging.getLogger(__name__) class AppState: def __init__(self): # Private variables for properties self._current_playing_file = None self._pause_requested = False self._speed = 100 self._current_playlist = None self._current_playlist_name = None # New variable for playlist name # Regular state variables self.stop_requested = False self.pause_condition = threading.Condition() self.execution_progress = None self.is_clearing = False self.current_theta = 0 self.current_rho = 0 self.current_playlist_index = 0 self.playlist_mode = "loop" self.pause_time_remaining = 0 # Machine position variables self.machine_x = 0.0 self.machine_y = 0.0 self.x_steps_per_mm = 0.0 self.y_steps_per_mm = 0.0 self.gear_ratio = 10 # Homing mode: 0 = crash homing, 1 = sensor homing ($H) self.homing = 0 # Homing state tracking (for sensor mode) self.homed_x = False # Set to True when [MSG:Homed:X] is received self.homed_y = False # Set to True when [MSG:Homed:Y] is received # Angular homing compass reference point # This is the angular offset in degrees where the sensor is placed # After homing, theta will be set to this value self.angular_homing_offset_degrees = 0.0 # Auto-homing settings for playlists # When enabled, performs homing after X patterns during playlist execution self.auto_home_enabled = False self.auto_home_after_patterns = 5 # Number of patterns after which to auto-home self.patterns_since_last_home = 0 # Counter for patterns played since last home self.STATE_FILE = "state.json" self.mqtt_handler = None # Will be set by the MQTT handler self.conn = None self.port = None self.preferred_port = None # User's preferred port for auto-connect self.wled_ip = None self.led_provider = "none" # "wled", "dw_leds", or "none" self.led_controller = None # DW LED settings self.dw_led_num_leds = 60 # Number of LEDs in strip self.dw_led_gpio_pin = 12 # GPIO pin (12, 13, 18, or 19) self.dw_led_pixel_order = "GRB" # Pixel color order for WS281x (GRB, RGB, BGR, etc.) self.dw_led_brightness = 35 # Brightness 0-100 self.dw_led_speed = 128 # Effect speed 0-255 self.dw_led_intensity = 128 # Effect intensity 0-255 # Idle effect settings (all parameters) self.dw_led_idle_effect = None # Full effect configuration dict or None # Playing effect settings (all parameters) self.dw_led_playing_effect = None # Full effect configuration dict or None # Idle timeout settings self.dw_led_idle_timeout_enabled = False # Enable automatic LED turn off after idle period self.dw_led_idle_timeout_minutes = 30 # Idle timeout duration in minutes self.dw_led_last_activity_time = None # Last activity timestamp (runtime only, not persisted) self.skip_requested = False self.table_type = None self._playlist_mode = "loop" self._pause_time = 0 self._clear_pattern = "none" self._clear_pattern_speed = None # None means use state.speed as default self.custom_clear_from_in = None # Custom clear from center pattern self.custom_clear_from_out = None # Custom clear from perimeter pattern # Application name setting self.app_name = "Dune Weaver" # Default app name # auto_play mode settings self.auto_play_enabled = False self.auto_play_playlist = None # Playlist to auto-play in auto_play mode self.auto_play_run_mode = "loop" # "single" or "loop" self.auto_play_pause_time = 5.0 # Pause between patterns in seconds self.auto_play_clear_pattern = "adaptive" # Clear pattern option self.auto_play_shuffle = False # Shuffle playlist # Still Sands settings self.scheduled_pause_enabled = False self.scheduled_pause_time_slots = [] # List of time slot dictionaries self.scheduled_pause_control_wled = False # Turn off WLED during pause periods self.scheduled_pause_finish_pattern = False # Finish current pattern before pausing self.scheduled_pause_timezone = None # User-selected timezone (None = use system timezone) # MQTT settings (UI-configurable, overrides .env if set) self.mqtt_enabled = False # Master enable/disable for MQTT self.mqtt_broker = "" # MQTT broker IP/hostname self.mqtt_port = 1883 # MQTT broker port self.mqtt_username = "" # MQTT authentication username self.mqtt_password = "" # MQTT authentication password self.mqtt_client_id = "dune_weaver" # MQTT client ID self.mqtt_discovery_prefix = "homeassistant" # Home Assistant discovery prefix self.mqtt_device_id = "dune_weaver" # Device ID for Home Assistant self.mqtt_device_name = "Dune Weaver" # Device display name self.load() @property def current_playing_file(self): return self._current_playing_file @current_playing_file.setter def current_playing_file(self, value): self._current_playing_file = value # force an empty string (and not None) if we need to unset if value == None: value = "" if self.mqtt_handler: is_running = bool(value and not self._pause_requested) self.mqtt_handler.update_state(current_file=value, is_running=is_running) @property def pause_requested(self): return self._pause_requested @pause_requested.setter def pause_requested(self, value): self._pause_requested = value if self.mqtt_handler: is_running = bool(self._current_playing_file and not value) self.mqtt_handler.update_state(is_running=is_running) @property def speed(self): return self._speed @speed.setter def speed(self, value): self._speed = value if self.mqtt_handler and self.mqtt_handler.is_enabled: self.mqtt_handler.client.publish(f"{self.mqtt_handler.speed_topic}/state", value, retain=True) @property def current_playlist(self): return self._current_playlist @current_playlist.setter def current_playlist(self, value): self._current_playlist = value # force an empty string (and not None) if we need to unset if value == None: value = "" # Also clear the playlist name when playlist is cleared self._current_playlist_name = None if self.mqtt_handler: self.mqtt_handler.update_state(playlist=value, playlist_name=None) @property def current_playlist_name(self): return self._current_playlist_name @current_playlist_name.setter def current_playlist_name(self, value): self._current_playlist_name = value if self.mqtt_handler: self.mqtt_handler.update_state(playlist_name=value) @property def playlist_mode(self): return self._playlist_mode @playlist_mode.setter def playlist_mode(self, value): self._playlist_mode = value @property def pause_time(self): return self._pause_time @pause_time.setter def pause_time(self, value): self._pause_time = value @property def clear_pattern(self): return self._clear_pattern @clear_pattern.setter def clear_pattern(self, value): self._clear_pattern = value @property def clear_pattern_speed(self): return self._clear_pattern_speed @clear_pattern_speed.setter def clear_pattern_speed(self, value): self._clear_pattern_speed = value def to_dict(self): """Return a dictionary representation of the state.""" return { "stop_requested": self.stop_requested, "pause_requested": self._pause_requested, "current_playing_file": self._current_playing_file, "execution_progress": self.execution_progress, "is_clearing": self.is_clearing, "current_theta": self.current_theta, "current_rho": self.current_rho, "speed": self._speed, "machine_x": self.machine_x, "machine_y": self.machine_y, "x_steps_per_mm": self.x_steps_per_mm, "y_steps_per_mm": self.y_steps_per_mm, "gear_ratio": self.gear_ratio, "homing": self.homing, "angular_homing_offset_degrees": self.angular_homing_offset_degrees, "auto_home_enabled": self.auto_home_enabled, "auto_home_after_patterns": self.auto_home_after_patterns, "current_playlist": self._current_playlist, "current_playlist_name": self._current_playlist_name, "current_playlist_index": self.current_playlist_index, "playlist_mode": self._playlist_mode, "pause_time": self._pause_time, "clear_pattern": self._clear_pattern, "clear_pattern_speed": self._clear_pattern_speed, "custom_clear_from_in": self.custom_clear_from_in, "custom_clear_from_out": self.custom_clear_from_out, "port": self.port, "preferred_port": self.preferred_port, "wled_ip": self.wled_ip, "led_provider": self.led_provider, "dw_led_num_leds": self.dw_led_num_leds, "dw_led_gpio_pin": self.dw_led_gpio_pin, "dw_led_pixel_order": self.dw_led_pixel_order, "dw_led_brightness": self.dw_led_brightness, "dw_led_speed": self.dw_led_speed, "dw_led_intensity": self.dw_led_intensity, "dw_led_idle_effect": self.dw_led_idle_effect, "dw_led_playing_effect": self.dw_led_playing_effect, "dw_led_idle_timeout_enabled": self.dw_led_idle_timeout_enabled, "dw_led_idle_timeout_minutes": self.dw_led_idle_timeout_minutes, "app_name": self.app_name, "auto_play_enabled": self.auto_play_enabled, "auto_play_playlist": self.auto_play_playlist, "auto_play_run_mode": self.auto_play_run_mode, "auto_play_pause_time": self.auto_play_pause_time, "auto_play_clear_pattern": self.auto_play_clear_pattern, "auto_play_shuffle": self.auto_play_shuffle, "scheduled_pause_enabled": self.scheduled_pause_enabled, "scheduled_pause_time_slots": self.scheduled_pause_time_slots, "scheduled_pause_control_wled": self.scheduled_pause_control_wled, "scheduled_pause_finish_pattern": self.scheduled_pause_finish_pattern, "scheduled_pause_timezone": self.scheduled_pause_timezone, "mqtt_enabled": self.mqtt_enabled, "mqtt_broker": self.mqtt_broker, "mqtt_port": self.mqtt_port, "mqtt_username": self.mqtt_username, "mqtt_password": self.mqtt_password, "mqtt_client_id": self.mqtt_client_id, "mqtt_discovery_prefix": self.mqtt_discovery_prefix, "mqtt_device_id": self.mqtt_device_id, "mqtt_device_name": self.mqtt_device_name, } def from_dict(self, data): """Update state from a dictionary.""" self.stop_requested = data.get("stop_requested", False) self._pause_requested = data.get("pause_requested", False) self._current_playing_file = data.get("current_playing_file", None) self.execution_progress = data.get("execution_progress") self.is_clearing = data.get("is_clearing", False) self.current_theta = data.get("current_theta", 0) self.current_rho = data.get("current_rho", 0) self._speed = data.get("speed", 150) self.machine_x = data.get("machine_x", 0.0) self.machine_y = data.get("machine_y", 0.0) self.x_steps_per_mm = data.get("x_steps_per_mm", 0.0) self.y_steps_per_mm = data.get("y_steps_per_mm", 0.0) self.gear_ratio = data.get('gear_ratio', 10) self.homing = data.get('homing', 0) self.angular_homing_offset_degrees = data.get('angular_homing_offset_degrees', 0.0) self.auto_home_enabled = data.get('auto_home_enabled', False) self.auto_home_after_patterns = data.get('auto_home_after_patterns', 5) self._current_playlist = data.get("current_playlist", None) self._current_playlist_name = data.get("current_playlist_name", None) self.current_playlist_index = data.get("current_playlist_index", None) self._playlist_mode = data.get("playlist_mode", "loop") self._pause_time = data.get("pause_time", 0) self._clear_pattern = data.get("clear_pattern", "none") self._clear_pattern_speed = data.get("clear_pattern_speed", None) self.custom_clear_from_in = data.get("custom_clear_from_in", None) self.custom_clear_from_out = data.get("custom_clear_from_out", None) self.port = data.get("port", None) self.preferred_port = data.get("preferred_port", None) self.wled_ip = data.get('wled_ip', None) self.led_provider = data.get('led_provider', "none") self.dw_led_num_leds = data.get('dw_led_num_leds', 60) self.dw_led_gpio_pin = data.get('dw_led_gpio_pin', 12) self.dw_led_pixel_order = data.get('dw_led_pixel_order', "GRB") self.dw_led_brightness = data.get('dw_led_brightness', 35) self.dw_led_speed = data.get('dw_led_speed', 128) self.dw_led_intensity = data.get('dw_led_intensity', 128) # Load effect settings (handle both old string format and new dict format) idle_effect_data = data.get('dw_led_idle_effect', None) if isinstance(idle_effect_data, str): # Old format: just effect name self.dw_led_idle_effect = None if idle_effect_data == "off" else {"effect_id": 0} else: # New format: full dict or None self.dw_led_idle_effect = idle_effect_data playing_effect_data = data.get('dw_led_playing_effect', None) if isinstance(playing_effect_data, str): # Old format: just effect name self.dw_led_playing_effect = None if playing_effect_data == "off" else {"effect_id": 0} else: # New format: full dict or None self.dw_led_playing_effect = playing_effect_data # Load idle timeout settings self.dw_led_idle_timeout_enabled = data.get('dw_led_idle_timeout_enabled', False) self.dw_led_idle_timeout_minutes = data.get('dw_led_idle_timeout_minutes', 30) self.app_name = data.get("app_name", "Dune Weaver") self.auto_play_enabled = data.get("auto_play_enabled", False) self.auto_play_playlist = data.get("auto_play_playlist", None) self.auto_play_run_mode = data.get("auto_play_run_mode", "loop") self.auto_play_pause_time = data.get("auto_play_pause_time", 5.0) self.auto_play_clear_pattern = data.get("auto_play_clear_pattern", "adaptive") self.auto_play_shuffle = data.get("auto_play_shuffle", False) self.scheduled_pause_enabled = data.get("scheduled_pause_enabled", False) self.scheduled_pause_time_slots = data.get("scheduled_pause_time_slots", []) self.scheduled_pause_control_wled = data.get("scheduled_pause_control_wled", False) self.scheduled_pause_finish_pattern = data.get("scheduled_pause_finish_pattern", False) self.scheduled_pause_timezone = data.get("scheduled_pause_timezone", None) self.mqtt_enabled = data.get("mqtt_enabled", False) self.mqtt_broker = data.get("mqtt_broker", "") self.mqtt_port = data.get("mqtt_port", 1883) self.mqtt_username = data.get("mqtt_username", "") self.mqtt_password = data.get("mqtt_password", "") self.mqtt_client_id = data.get("mqtt_client_id", "dune_weaver") self.mqtt_discovery_prefix = data.get("mqtt_discovery_prefix", "homeassistant") self.mqtt_device_id = data.get("mqtt_device_id", "dune_weaver") self.mqtt_device_name = data.get("mqtt_device_name", "Dune Weaver") def save(self): """Save the current state to a JSON file.""" try: with open(self.STATE_FILE, "w") as f: json.dump(self.to_dict(), f) except Exception as e: print(f"Error saving state to {self.STATE_FILE}: {e}") def load(self): """Load state from a JSON file. If the file doesn't exist, create it with default values.""" if not os.path.exists(self.STATE_FILE): # File doesn't exist: create one with the current (default) state. self.save() return try: with open(self.STATE_FILE, "r") as f: data = json.load(f) self.from_dict(data) except Exception as e: print(f"Error loading state from {self.STATE_FILE}: {e}") def update_steps_per_mm(self, x_steps, y_steps): """Update and save steps per mm values.""" self.x_steps_per_mm = x_steps self.y_steps_per_mm = y_steps self.save() def reset_state(self): """Reset all state variables to their default values.""" self.__init__() # Reinitialize the state self.save() # Create a singleton instance that you can import elsewhere: state = AppState()