technicalkiwi/lighting-controller
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: technicalkiwi:7f43b93cb7f243fceae05efc22b6459f0f68e92e
Branches Tags
technicalkiwi:dev technicalkiwi:basic technicalkiwi:ui technicalkiwi:pi technicalkiwi:full technicalkiwi:kat
technicalkiwi:1.0
...
compare: technicalkiwi:basic
Branches Tags
technicalkiwi:basic technicalkiwi:ui technicalkiwi:pi technicalkiwi:full technicalkiwi:kat technicalkiwi:dev
technicalkiwi:1.0

4 Commits
7f43b93cb7 ... basic

Author SHA1 Message Date
jimmy
e8cb204c0f Remove unneeded packages 2025-11-22 16:20:19 +13:00
jimmy
2a72432c1a Fix RuntimeError: schedule async updates through root.after() to ensure event loop is running 2025-11-22 16:18:10 +13:00
jimmy
e803dd4243 Update main 2025-11-21 16:18:08 +13:00
jimmy
baf3d0b0ff Update settings 2025-11-21 16:17:42 +13:00
3 changed files with 416 additions and 109 deletions
Expand all files Collapse all files

6
Pipfile
View File

@@ -7,16 +7,12 @@ name = "pypi"
websockets = "*" websockets = "*"
watchfiles = "*" watchfiles = "*"
async-tkinter-loop = "*" async-tkinter-loop = "*"
mido = "*"
python-rtmidi = "*"
pyaudio = "*"
aubio = "*"
websocket-client = "*" websocket-client = "*"
[dev-packages] [dev-packages]
[requires] [requires]
python_version = "3.12" python_version = "3"
[scripts] [scripts]
main = "python main.py" main = "python main.py"

283
settings.json
View File

@@ -7,13 +7,91 @@
], ],
"settings": { "settings": {
"colors": [ "colors": [
"#0000ff", "#968a00"
"#c30074",
"#00ff00"
], ],
"brightness": 9, "brightness": 21,
"pattern": "off", "pattern": "off",
"delay": 50 "delay": 99,
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10,
"n5": 10,
"n6": 10,
"patterns": {
"pulse": {
"colors": [
"#000000"
],
"delay": 99,
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10,
"n5": 10,
"n6": 10
},
"n_chase": {
"colors": [
"#000000"
],
"delay": 99,
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10,
"n5": 10,
"n6": 10
},
"on": {
"colors": [
"#968a00"
],
"delay": 99,
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10,
"n5": 10,
"n6": 10
},
"rainbow": {
"colors": [
"#000000"
],
"delay": 99,
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10,
"n5": 10,
"n6": 10
},
"off": {
"colors": [
"#000000"
],
"delay": 99,
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10,
"n5": 10,
"n6": 10
},
"blink": {
"colors": [
"#000000"
],
"delay": 99,
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10,
"n5": 10,
"n6": 10
}
}
} }
}, },
"dj": { "dj": {
@@ -23,13 +101,104 @@
"settings": { "settings": {
"colors": [ "colors": [
"#0000ff", "#0000ff",
"#c30074", "#ff0000"
"#00ff00", ],
"brightness": 73,
"pattern": "transition",
"delay": 10000,
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10,
"n5": 10,
"n6": 10,
"patterns": {
"rainbow": {
"colors": [
"#00006a"
],
"delay": 17,
"n1": 1,
"n2": 10,
"n3": 10,
"n4": 10,
"n5": 10,
"n6": 10
},
"on": {
"colors": [
"#ffff00",
"#0000ff"
],
"delay": 99,
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10,
"n5": 10,
"n6": 10
},
"blink": {
"colors": [
"#0000d0"
],
"delay": 99,
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10,
"n5": 10,
"n6": 10
},
"pulse": {
"delay": 1002,
"colors": [
"#006600",
"#0000ff"
],
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10,
"n5": 10,
"n6": 10
},
"transition": {
"colors": [
"#0000ff",
"#ff0000"
],
"delay": 10000,
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10,
"n5": 10,
"n6": 10
},
"n_chase": {
"n1": 11,
"n2": 11,
"n3": 10,
"n4": 10,
"n5": 10,
"n6": 10,
"delay": 99,
"colors": [
"#0000ff"
]
},
"off": {
"colors": [
"#000000" "#000000"
], ],
"brightness": 6, "delay": 99,
"pattern": "flicker", "n1": 10,
"delay": 520 "n2": 10,
"n3": 10,
"n4": 10
}
}
} }
}, },
"middle": { "middle": {
@@ -48,7 +217,19 @@
], ],
"brightness": 6, "brightness": 6,
"pattern": "flicker", "pattern": "flicker",
"delay": 520 "delay": 520,
"patterns": {
"flicker": {
"colors": [
"#000000"
],
"delay": 99,
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10
}
}
} }
}, },
"sides": { "sides": {
@@ -65,7 +246,19 @@
], ],
"brightness": 6, "brightness": 6,
"pattern": "on", "pattern": "on",
"delay": 520 "delay": 520,
"patterns": {
"on": {
"colors": [
"#000000"
],
"delay": 99,
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10
}
}
} }
}, },
"outside": { "outside": {
@@ -80,8 +273,36 @@
"#000000" "#000000"
], ],
"brightness": 6, "brightness": 6,
"pattern": "on", "pattern": "transition",
"delay": 520 "delay": 520,
"n1": -17,
"n2": 10,
"n3": 10,
"n4": 10,
"n5": 10,
"n6": 10,
"patterns": {
"on": {
"colors": [
"#000000"
],
"delay": 99,
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10
},
"transition": {
"colors": [
"#000000"
],
"delay": 99,
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10
}
}
} }
}, },
"middle1": { "middle1": {
@@ -97,7 +318,16 @@
], ],
"brightness": 6, "brightness": 6,
"pattern": "flicker", "pattern": "flicker",
"delay": 520 "delay": 520,
"n1": 10,
"n2": 10,
"n3": 10,
"n4": 10,
"n5": 10,
"n6": 10,
"patterns": {
"flicker": {}
}
} }
}, },
"middle2": { "middle2": {
@@ -113,7 +343,10 @@
], ],
"brightness": 6, "brightness": 6,
"pattern": "flicker", "pattern": "flicker",
"delay": 520 "delay": 520,
"patterns": {
"flicker": {}
}
} }
}, },
"middle3": { "middle3": {
@@ -129,7 +362,10 @@
], ],
"brightness": 6, "brightness": 6,
"pattern": "flicker", "pattern": "flicker",
"delay": 520 "delay": 520,
"patterns": {
"flicker": {}
}
} }
}, },
"middle4": { "middle4": {
@@ -145,18 +381,19 @@
], ],
"brightness": 6, "brightness": 6,
"pattern": "flicker", "pattern": "flicker",
"delay": 520 "delay": 520,
"patterns": {
"flicker": {}
}
} }
} }
}, },
"patterns": [ "patterns": [
"on", "on",
"off", "off",
"blink", "rainbow",
"rainbow_cycle", "transition",
"color_transition", "n_chase",
"theater_chase",
"flicker",
"pulse" "pulse"
] ]
} }

234
src/main.py
View File

@@ -95,6 +95,42 @@ class App:
async_mainloop(self.root) async_mainloop(self.root)
def get_pattern_settings(self, tab_name, pattern_name):
"""Get pattern-specific settings (colors, delay, n params). Returns defaults if not found."""
light_settings = self.settings["lights"][tab_name]["settings"]
if "patterns" not in light_settings:
light_settings["patterns"] = {}
if pattern_name not in light_settings["patterns"]:
light_settings["patterns"][pattern_name] = {}
pattern_settings = light_settings["patterns"][pattern_name]
return {
"colors": pattern_settings.get("colors", ["#000000"]),
"delay": pattern_settings.get("delay", 100),
"n1": pattern_settings.get("n1", 10),
"n2": pattern_settings.get("n2", 10),
"n3": pattern_settings.get("n3", 10),
"n4": pattern_settings.get("n4", 10),
}
def save_pattern_settings(self, tab_name, pattern_name, colors=None, delay=None, n_params=None):
"""Save pattern-specific settings."""
light_settings = self.settings["lights"][tab_name]["settings"]
if "patterns" not in light_settings:
light_settings["patterns"] = {}
if pattern_name not in light_settings["patterns"]:
light_settings["patterns"][pattern_name] = {}
pattern_settings = light_settings["patterns"][pattern_name]
if colors is not None:
pattern_settings["colors"] = colors
if delay is not None:
pattern_settings["delay"] = delay
if n_params is not None:
for i in range(1, 5):
if f"n{i}" in n_params:
pattern_settings[f"n{i}"] = n_params[f"n{i}"]
def on_closing(self): def on_closing(self):
print("Closing application...") print("Closing application...")
asyncio.create_task(self.websocket_client.close()) asyncio.create_task(self.websocket_client.close())
@@ -115,18 +151,19 @@ class App:
slider_length = 600 slider_length = 600
slider_width = 50 slider_width = 50
# Extract initial color, brightness, and delay # Get initial pattern and load pattern-specific settings
initial_colors = initial_settings.get("colors", ["#000000"])
initial_hex_color = initial_colors[0] if initial_colors else "#000000"
initial_brightness = initial_settings.get("brightness", 127)
initial_delay = initial_settings.get("delay", 0)
initial_pattern = initial_settings.get("pattern", "on") initial_pattern = initial_settings.get("pattern", "on")
initial_n1 = initial_settings.get("n1", 10) initial_brightness = initial_settings.get("brightness", 127) # Global brightness
initial_n2 = initial_settings.get("n2", 10) pattern_settings = self.get_pattern_settings(tab_name, initial_pattern)
initial_n3 = initial_settings.get("n3", 10)
initial_n4 = initial_settings.get("n4", 10) # Extract initial color, delay, and n params from pattern-specific settings
initial_n5 = initial_settings.get("n5", 10) initial_colors = pattern_settings["colors"]
initial_n6 = initial_settings.get("n6", 10) initial_hex_color = initial_colors[0] if initial_colors else "#000000"
initial_delay = pattern_settings["delay"]
initial_n1 = pattern_settings["n1"]
initial_n2 = pattern_settings["n2"]
initial_n3 = pattern_settings["n3"]
initial_n4 = pattern_settings["n4"]
initial_r, initial_g, initial_b = color_utils.hex_to_rgb(initial_hex_color) initial_r, initial_g, initial_b = color_utils.hex_to_rgb(initial_hex_color)
@@ -241,11 +278,11 @@ class App:
"buttonbackground": active_bg_color, "buttonbackground": active_bg_color,
} }
# Create n1-n6 inputs in a grid with arrows on both sides # Create n1-n4 inputs in a grid with arrows on both sides
n_inputs = {} n_inputs = {}
for i in range(1, 7): for i in range(1, 5):
n_frame = tk.Frame(n_inputs_inner_frame, bg=bg_color) n_frame = tk.Frame(n_inputs_inner_frame, bg=bg_color)
n_frame.grid(row=(i-1)//3, column=(i-1)%3, padx=10, pady=10) n_frame.grid(row=(i-1)//2, column=(i-1)%2, padx=10, pady=10)
tk.Label(n_frame, text=f"n{i}", font=("Arial", 20), bg=bg_color, fg=fg_color).pack(pady=(0, 5)) tk.Label(n_frame, text=f"n{i}", font=("Arial", 20), bg=bg_color, fg=fg_color).pack(pady=(0, 5))
@@ -340,10 +377,6 @@ class App:
"n3_var": n_inputs["n3_var"], "n3_var": n_inputs["n3_var"],
"n4": n_inputs["n4"], "n4": n_inputs["n4"],
"n4_var": n_inputs["n4_var"], "n4_var": n_inputs["n4_var"],
"n5": n_inputs["n5"],
"n5_var": n_inputs["n5_var"],
"n6": n_inputs["n6"],
"n6_var": n_inputs["n6_var"],
"selected_color_index": 0, # Default to the first color "selected_color_index": 0, # Default to the first color
} }
tab.colors_in_palette = initial_colors.copy() # Store the list of hex colors for this tab tab.colors_in_palette = initial_colors.copy() # Store the list of hex colors for this tab
@@ -571,7 +604,7 @@ class App:
# If not in 'transition' mode, but a color is selected, update sliders to that. # If not in 'transition' mode, but a color is selected, update sliders to that.
# Or, if this is a fresh load/tab change, ensure it's the first color. # Or, if this is a fresh load/tab change, ensure it's the first color.
# This ensures the sliders consistently show the color that will be sent # This ensures the sliders consistently show the color that will be sent
# for 'on'/'blink' based on the palette's first entry. # for 'on' based on the palette's first entry.
hex_color = tab.colors_in_palette[tab.widgets["selected_color_index"]] hex_color = tab.colors_in_palette[tab.widgets["selected_color_index"]]
r, g, b = color_utils.hex_to_rgb(hex_color) r, g, b = color_utils.hex_to_rgb(hex_color)
tab.widgets["red_slider"].set(r) tab.widgets["red_slider"].set(r)
@@ -608,8 +641,12 @@ class App:
# In a full reload, create_tabs ensures it is. # In a full reload, create_tabs ensures it is.
return return
# Get current pattern and load pattern-specific settings
current_pattern = initial_settings.get("pattern", "on")
pattern_settings = self.get_pattern_settings(selected_tab_name, current_pattern)
# Update the local colors_in_palette list for the tab # Update the local colors_in_palette list for the tab
current_tab_widget.colors_in_palette = initial_settings.get("colors", ["#000000"]).copy() current_tab_widget.colors_in_palette = pattern_settings["colors"].copy()
current_tab_widget.widgets["selected_color_index"] = 0 # Default to first color current_tab_widget.widgets["selected_color_index"] = 0 # Default to first color
# Refresh the color palette display and select the first color # Refresh the color palette display and select the first color
@@ -621,19 +658,19 @@ class App:
current_tab_widget.widgets["green_slider"].set(0) current_tab_widget.widgets["green_slider"].set(0)
current_tab_widget.widgets["blue_slider"].set(0) current_tab_widget.widgets["blue_slider"].set(0)
# Update brightness and delay sliders # Update brightness (global) and delay (pattern-specific) sliders
current_tab_widget.widgets["brightness_slider"].set(initial_settings.get("brightness", 127)) current_tab_widget.widgets["brightness_slider"].set(initial_settings.get("brightness", 127))
# Convert delay to slider position using logarithmic scale # Convert delay to slider position using logarithmic scale
initial_delay = initial_settings.get("delay", 0) initial_delay = pattern_settings["delay"]
initial_delay_slider_pos = delay_to_slider(initial_delay) initial_delay_slider_pos = delay_to_slider(initial_delay)
current_tab_widget.widgets["delay_slider"].set(initial_delay_slider_pos) current_tab_widget.widgets["delay_slider"].set(initial_delay_slider_pos)
# Update the delay value label to show the actual delay value # Update the delay value label to show the actual delay value
if "delay_value_label" in current_tab_widget.widgets: if "delay_value_label" in current_tab_widget.widgets:
current_tab_widget.widgets["delay_value_label"].config(text=f"{initial_delay}") current_tab_widget.widgets["delay_value_label"].config(text=f"{initial_delay}")
# Update n parameter inputs # Update n parameter inputs (pattern-specific)
for i in range(1, 7): for i in range(1, 5):
current_tab_widget.widgets[f"n{i}_var"].set(str(initial_settings.get(f"n{i}", 10))) current_tab_widget.widgets[f"n{i}_var"].set(str(pattern_settings[f"n{i}"]))
# Highlight the active pattern button # Highlight the active pattern button
initial_pattern = initial_settings.get("pattern", "on") initial_pattern = initial_settings.get("pattern", "on")
@@ -657,13 +694,16 @@ class App:
if self.pending_rgb_update_id: if self.pending_rgb_update_id:
self.root.after_cancel(self.pending_rgb_update_id) self.root.after_cancel(self.pending_rgb_update_id)
self.pending_rgb_update_id = None self.pending_rgb_update_id = None
self.update_rgb(tab) # Use root.after() to ensure the async event loop is running
# A delay of 0 will execute on the next event loop iteration
self.root.after(0, lambda: self.update_rgb(tab))
self.last_rgb_update_time = current_time self.last_rgb_update_time = current_time
elif current_time - self.last_rgb_update_time >= self.rgb_update_interval_ms: elif current_time - self.last_rgb_update_time >= self.rgb_update_interval_ms:
if self.pending_rgb_update_id: if self.pending_rgb_update_id:
self.root.after_cancel(self.pending_rgb_update_id) self.root.after_cancel(self.pending_rgb_update_id)
self.pending_rgb_update_id = None self.pending_rgb_update_id = None
self.update_rgb(tab) # Use root.after() to ensure the async event loop is running
self.root.after(0, lambda: self.update_rgb(tab))
self.last_rgb_update_time = current_time self.last_rgb_update_time = current_time
else: else:
if self.pending_rgb_update_id: if self.pending_rgb_update_id:
@@ -677,13 +717,15 @@ class App:
if self.pending_brightness_update_id: if self.pending_brightness_update_id:
self.root.after_cancel(self.pending_brightness_update_id) self.root.after_cancel(self.pending_brightness_update_id)
self.pending_brightness_update_id = None self.pending_brightness_update_id = None
self.update_brightness(tab) # Use root.after() to ensure the async event loop is running
self.root.after(0, lambda: self.update_brightness(tab))
self.last_brightness_update_time = current_time self.last_brightness_update_time = current_time
elif current_time - self.last_brightness_update_time >= self.brightness_update_interval_ms: elif current_time - self.last_brightness_update_time >= self.brightness_update_interval_ms:
if self.pending_brightness_update_id: if self.pending_brightness_update_id:
self.root.after_cancel(self.pending_brightness_update_id) self.root.after_cancel(self.pending_brightness_update_id)
self.pending_brightness_update_id = None self.pending_brightness_update_id = None
self.update_brightness(tab) # Use root.after() to ensure the async event loop is running
self.root.after(0, lambda: self.update_brightness(tab))
self.last_brightness_update_time = current_time self.last_brightness_update_time = current_time
else: else:
if self.pending_brightness_update_id: if self.pending_brightness_update_id:
@@ -697,13 +739,15 @@ class App:
if self.pending_delay_update_id: if self.pending_delay_update_id:
self.root.after_cancel(self.pending_delay_update_id) self.root.after_cancel(self.pending_delay_update_id)
self.pending_delay_update_id = None self.pending_delay_update_id = None
self.update_delay(tab) # Use root.after() to ensure the async event loop is running
self.root.after(0, lambda: self.update_delay(tab))
self.last_delay_update_time = current_time self.last_delay_update_time = current_time
elif current_time - self.last_delay_update_time >= self.delay_update_interval_ms: elif current_time - self.last_delay_update_time >= self.delay_update_interval_ms:
if self.pending_delay_update_id: if self.pending_delay_update_id:
self.root.after_cancel(self.pending_delay_update_id) self.root.after_cancel(self.pending_delay_update_id)
self.pending_delay_update_id = None self.pending_delay_update_id = None
self.update_delay(tab) # Use root.after() to ensure the async event loop is running
self.root.after(0, lambda: self.update_delay(tab))
self.last_delay_update_time = current_time self.last_delay_update_time = current_time
else: else:
if self.pending_delay_update_id: if self.pending_delay_update_id:
@@ -717,13 +761,15 @@ class App:
if self.pending_n_params_update_id: if self.pending_n_params_update_id:
self.root.after_cancel(self.pending_n_params_update_id) self.root.after_cancel(self.pending_n_params_update_id)
self.pending_n_params_update_id = None self.pending_n_params_update_id = None
self.update_n_params(tab) # Use root.after() to ensure the async event loop is running
self.root.after(0, lambda: self.update_n_params(tab))
self.last_n_params_update_time = current_time self.last_n_params_update_time = current_time
elif current_time - self.last_n_params_update_time >= self.n_params_update_interval_ms: elif current_time - self.last_n_params_update_time >= self.n_params_update_interval_ms:
if self.pending_n_params_update_id: if self.pending_n_params_update_id:
self.root.after_cancel(self.pending_n_params_update_id) self.root.after_cancel(self.pending_n_params_update_id)
self.pending_n_params_update_id = None self.pending_n_params_update_id = None
self.update_n_params(tab) # Use root.after() to ensure the async event loop is running
self.root.after(0, lambda: self.update_n_params(tab))
self.last_n_params_update_time = current_time self.last_n_params_update_time = current_time
else: else:
if self.pending_n_params_update_id: if self.pending_n_params_update_id:
@@ -761,7 +807,7 @@ class App:
if current_pattern == "transition": if current_pattern == "transition":
colors_to_send = tab.colors_in_palette.copy() colors_to_send = tab.colors_in_palette.copy()
elif current_pattern in ["on", "blink", "theater_chase", "flicker"]: # Add other patterns that use a single color elif current_pattern in ["on", "theater_chase", "flicker"]: # Add other patterns that use a single color
if tab.colors_in_palette: if tab.colors_in_palette:
# For non-transition patterns, the device typically uses only the first color. # For non-transition patterns, the device typically uses only the first color.
# However, if a user picks a color from the palette, we want THAT color to be the one # However, if a user picks a color from the palette, we want THAT color to be the one
@@ -788,19 +834,23 @@ class App:
"n2": int(tab.widgets["n2_var"].get()), "n2": int(tab.widgets["n2_var"].get()),
"n3": int(tab.widgets["n3_var"].get()), "n3": int(tab.widgets["n3_var"].get()),
"n4": int(tab.widgets["n4_var"].get()), "n4": int(tab.widgets["n4_var"].get()),
"n5": int(tab.widgets["n5_var"].get()),
"n6": int(tab.widgets["n6_var"].get()),
}, },
} }
# Update the settings object with the new color list (and potentially other synced values) # Update the settings object - save pattern-specific settings
self.settings["lights"][selected_server]["settings"]["colors"] = tab.colors_in_palette.copy() current_pattern = self.settings["lights"][selected_server]["settings"].get("pattern", "on")
self.settings["lights"][selected_server]["settings"]["brightness"] = tab.widgets["brightness_slider"].get()
# Convert slider position to actual delay using logarithmic scale
slider_value = tab.widgets["delay_slider"].get() slider_value = tab.widgets["delay_slider"].get()
self.settings["lights"][selected_server]["settings"]["delay"] = slider_to_delay(slider_value) delay = slider_to_delay(slider_value)
for i in range(1, 7): n_params = {f"n{i}": int(tab.widgets[f"n{i}_var"].get()) for i in range(1, 5)}
self.settings["lights"][selected_server]["settings"][f"n{i}"] = int(tab.widgets[f"n{i}_var"].get())
# Save pattern-specific settings
self.save_pattern_settings(selected_server, current_pattern,
colors=tab.colors_in_palette.copy(),
delay=delay,
n_params=n_params)
# Brightness is global
self.settings["lights"][selected_server]["settings"]["brightness"] = tab.widgets["brightness_slider"].get()
self.settings.save() self.settings.save()
await self.websocket_client.send_data(payload) await self.websocket_client.send_data(payload)
@@ -851,8 +901,9 @@ class App:
"delay": delay, "delay": delay,
}, },
} }
# Update the settings object with the new delay # Update pattern-specific delay setting
self.settings["lights"][selected_server]["settings"]["delay"] = delay current_pattern = self.settings["lights"][selected_server]["settings"].get("pattern", "on")
self.save_pattern_settings(selected_server, current_pattern, delay=delay)
self.settings.save() self.settings.save()
await self.websocket_client.send_data(payload) await self.websocket_client.send_data(payload)
print(f"Sent delay payload: {payload}") print(f"Sent delay payload: {payload}")
@@ -863,7 +914,7 @@ class App:
async def update_n_params(self, tab): async def update_n_params(self, tab):
try: try:
n_params = {} n_params = {}
for i in range(1, 7): for i in range(1, 5):
n_var = tab.widgets[f"n{i}_var"] n_var = tab.widgets[f"n{i}_var"]
n_params[f"n{i}"] = int(n_var.get()) n_params[f"n{i}"] = int(n_var.get())
@@ -876,9 +927,9 @@ class App:
"names": names, "names": names,
"settings": n_params, "settings": n_params,
} }
# Update the settings object with the new n params # Update pattern-specific n params
for key, value in n_params.items(): current_pattern = self.settings["lights"][selected_server]["settings"].get("pattern", "on")
self.settings["lights"][selected_server]["settings"][key] = value self.save_pattern_settings(selected_server, current_pattern, n_params=n_params)
self.settings.save() self.settings.save()
await self.websocket_client.send_data(payload) await self.websocket_client.send_data(payload)
print(f"Sent n params payload: {payload}") print(f"Sent n params payload: {payload}")
@@ -902,30 +953,52 @@ class App:
current_settings_for_tab = self.settings["lights"][tab_name]["settings"] current_settings_for_tab = self.settings["lights"][tab_name]["settings"]
# Save current pattern's settings before switching
old_pattern = current_settings_for_tab.get("pattern", "on")
current_delay = slider_to_delay(current_tab_widget.widgets["delay_slider"].get())
current_n_params = {f"n{i}": int(current_tab_widget.widgets[f"n{i}_var"].get()) for i in range(1, 5)}
self.save_pattern_settings(tab_name, old_pattern,
colors=current_tab_widget.colors_in_palette.copy(),
delay=current_delay,
n_params=current_n_params)
# Load the new pattern's settings
new_pattern_settings = self.get_pattern_settings(tab_name, pattern_name)
# Update UI with new pattern's settings
current_tab_widget.colors_in_palette = new_pattern_settings["colors"].copy()
self.refresh_color_palette_display(current_tab_widget)
# Update delay slider
delay_slider_pos = delay_to_slider(new_pattern_settings["delay"])
current_tab_widget.widgets["delay_slider"].set(delay_slider_pos)
if "delay_value_label" in current_tab_widget.widgets:
current_tab_widget.widgets["delay_value_label"].config(text=f"{new_pattern_settings['delay']}")
# Update n params
for i in range(1, 5):
current_tab_widget.widgets[f"n{i}_var"].set(str(new_pattern_settings[f"n{i}"]))
# Update RGB sliders to first color
if current_tab_widget.colors_in_palette:
hex_color = current_tab_widget.colors_in_palette[0]
r, g, b = color_utils.hex_to_rgb(hex_color)
current_tab_widget.widgets["red_slider"].set(r)
current_tab_widget.widgets["green_slider"].set(g)
current_tab_widget.widgets["blue_slider"].set(b)
current_tab_widget.widgets["selected_color_index"] = 0
self._highlight_selected_color_swatch(current_tab_widget)
payload_settings = { payload_settings = {
"pattern": pattern_name, "pattern": pattern_name,
"brightness": current_settings_for_tab.get("brightness", 127), "brightness": current_settings_for_tab.get("brightness", 127), # Global brightness
"delay": slider_to_delay(current_tab_widget.widgets["delay_slider"].get()), # Convert from logarithmic slider "delay": new_pattern_settings["delay"],
"colors": new_pattern_settings["colors"],
} }
# Include n parameters # Include n parameters
for i in range(1, 7): for i in range(1, 5):
payload_settings[f"n{i}"] = int(current_tab_widget.widgets[f"n{i}_var"].get()) payload_settings[f"n{i}"] = new_pattern_settings[f"n{i}"]
# Determine colors to send based on the *newly selected* pattern
if pattern_name == "transition":
payload_settings["colors"] = current_tab_widget.colors_in_palette.copy()
elif pattern_name in ["on", "blink"]: # Add other patterns that use a single color here
# When switching TO 'on' or 'blink', ensure the color sent is the one
# currently displayed on the sliders (which reflects the selected palette color).
r = current_tab_widget.widgets["red_slider"].get()
g = current_tab_widget.widgets["green_slider"].get()
b = current_tab_widget.widgets["blue_slider"].get()
hex_color_from_sliders = f"#{r:02x}{g:02x}{b:02x}"
payload_settings["colors"] = [hex_color_from_sliders]
else:
# For other patterns, send the full palette, device might ignore or use default
payload_settings["colors"] = current_tab_widget.colors_in_palette.copy()
payload = { payload = {
"save": True, "save": True,
@@ -933,12 +1006,8 @@ class App:
"settings": payload_settings, "settings": payload_settings,
} }
# Update the settings object with the new pattern and current colors/brightness/delay # Update the current pattern
self.settings["lights"][tab_name]["settings"]["pattern"] = pattern_name self.settings["lights"][tab_name]["settings"]["pattern"] = pattern_name
# Always save the full current palette state in settings.
self.settings["lights"][tab_name]["settings"]["colors"] = current_tab_widget.colors_in_palette.copy()
for i in range(1, 7):
self.settings["lights"][tab_name]["settings"][f"n{i}"] = int(current_tab_widget.widgets[f"n{i}"].get())
self.settings.save() self.settings.save()
self.highlight_pattern_button(current_tab_widget, pattern_name) self.highlight_pattern_button(current_tab_widget, pattern_name)
@@ -957,15 +1026,20 @@ class App:
if not hasattr(current_tab_widget, "colors_in_palette"): if not hasattr(current_tab_widget, "colors_in_palette"):
return # Tab not fully initialized yet return # Tab not fully initialized yet
# Update settings for the current tab in the self.settings object # Update settings for the current tab - save pattern-specific settings
self.settings["lights"][selected_server]["settings"]["colors"] = current_tab_widget.colors_in_palette current_pattern = self.settings["lights"][selected_server]["settings"].get("pattern", "on")
self.settings["lights"][selected_server]["settings"]["brightness"] = current_tab_widget.widgets["brightness_slider"].get()
# Convert slider position to actual delay using logarithmic scale
slider_value = current_tab_widget.widgets["delay_slider"].get() slider_value = current_tab_widget.widgets["delay_slider"].get()
delay = slider_to_delay(slider_value) delay = slider_to_delay(slider_value)
self.settings["lights"][selected_server]["settings"]["delay"] = delay n_params = {f"n{i}": int(current_tab_widget.widgets[f"n{i}_var"].get()) for i in range(1, 5)}
for i in range(1, 7):
self.settings["lights"][selected_server]["settings"][f"n{i}"] = int(current_tab_widget.widgets[f"n{i}"].get()) # Save pattern-specific settings
self.save_pattern_settings(selected_server, current_pattern,
colors=current_tab_widget.colors_in_palette,
delay=delay,
n_params=n_params)
# Brightness is global
self.settings["lights"][selected_server]["settings"]["brightness"] = current_tab_widget.widgets["brightness_slider"].get()
# The pattern is updated in send_pattern already, but ensure consistency # The pattern is updated in send_pattern already, but ensure consistency
# For simplicity, we assume send_pattern is the primary way to change pattern. # For simplicity, we assume send_pattern is the primary way to change pattern.