Mix forward-only and bidirectional n_chase patterns

- Updated n_chase to support bidirectional movement with n3 and n4 parameters
- n3 controls forward steps per direction change
- n4 controls backward steps per direction change
- Pattern alternates between moving forward n3 steps and backward n4 steps
- Each direction repeats for the specified number of steps before switching
- Added test/9.py with n1=20, n2=20, n3=20, n4=-5 parameters
- Updated to run as a thread-based pattern similar to other patterns

.gitignore

@@ -1 +1,2 @@
-settings.json
+settings.json
+.venv

8_BAR_SETUP.md

@@ -0,0 +1,71 @@
+# 8-LED Bar System Setup
+
+This system supports 8 LED bars working together, each with unique names "100" through "107".
+
+## Quick Setup
+
+### 1. Configure Each LED Bar
+Each LED bar needs a unique name. Run the configuration script on each bar:
+
+```bash
+python configure_bar.py
+```
+
+Then enter the bar name (100, 101, 102, etc.) when prompted.
+
+### 2. Update Bar Names (Optional)
+To change the bar names, edit `/home/jimmy/projects/lighting-controller/src/bar_config.py`:
+
+```python
+LED_BAR_NAMES = [
+    "100",  # Bar 1
+    "101",  # Bar 2
+    "102",  # Bar 3
+    "103",  # Bar 4
+    "104",  # Bar 5
+    "105",  # Bar 6
+    "106",  # Bar 7
+    "107",  # Bar 8
+]
+```
+
+### 3. Default Settings
+All bars use the same default settings defined in `bar_config.py`:
+
+```python
+DEFAULT_BAR_SETTINGS = {
+    "pattern": "pulse",
+    "delay": 100,
+    "colors": [(0, 255, 0)],  # Default green
+    "brightness": 100,
+    "num_leds": 200,
+    "n1": 10,
+    "n2": 10,
+    "n3": 1,
+    "n": 0,
+}
+```
+
+## How It Works
+
+1. **Lighting Controller** sends ESP-NOW messages to all bars simultaneously
+2. **Each LED Bar** listens for messages addressed to its unique name
+3. **All bars** receive the same pattern/color/brightness settings
+4. **Synchronized effects** across all 8 bars
+
+## Current Features
+
+- ✅ All bars show the same pattern simultaneously
+- ✅ Individual bar addressing (100-107)
+- ✅ Optimized JSON payloads with defaults deduplication
+- ✅ Easy configuration via `bar_config.py`
+- ✅ MIDI control for all bars
+- ✅ n3 step rate functionality
+
+## Future Enhancements
+
+- Sequential patterns (bar 1 → bar 2 → bar 3...)
+- Wave effects across bars
+- Individual bar control
+- Master/slave synchronization
+- Physical arrangement awareness

Pipfile

@@ -0,0 +1,19 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+mpremote = "*"
+pyserial = "*"
+esptool = "*"
+watchfiles = "*"
+uvicorn = "*"
+
+[dev-packages]
+
+[requires]
+python_version = "3.12"
+
+[scripts]
+dev = "./dev.py"

Pipfile.lock

@@ -0,0 +1,625 @@
+{
+    "_meta": {
+        "hash": {
+            "sha256": "53809b70ded7a2b3e577a8a4263fbadbb722d1e8d92eb016e134b0776fd40f6b"
+        },
+        "pipfile-spec": 6,
+        "requires": {
+            "python_version": "3.12"
+        },
+        "sources": [
+            {
+                "name": "pypi",
+                "url": "https://pypi.org/simple",
+                "verify_ssl": true
+            }
+        ]
+    },
+    "default": {
+        "anyio": {
+            "hashes": [
+                "sha256:3f3fae35c96039744587aa5b8371e7e8e603c0702999535961dd336026973ba6",
+                "sha256:60e474ac86736bbfd6f210f7a61218939c318f43f9972497381f1c5e930ed3d1"
+            ],
+            "markers": "python_version >= '3.9'",
+            "version": "==4.10.0"
+        },
+        "bitarray": {
+            "hashes": [
+                "sha256:002b73bf4a9f7b3ecb02260bd4dd332a6ee4d7f74ee9779a1ef342a36244d0cf",
+                "sha256:01e3ba46c2dee6d47a4ab22561a01d8ee6772f681defc9fcb357097a055e48cf",
+                "sha256:03dc877ec286b7f2813185ea6bc5f1f5527fd859e61038d38768883b134e06b3",
+                "sha256:03eeab48f376c3cd988add2b75c20d2d084b6fcc9a164adb0dc390ef152255b4",
+                "sha256:05ee46a734b5110c5ac483815da4379f7622f4316362872ec7c0ed16db4b0148",
+                "sha256:0751596f60f33df66245b2dafa3f7fbe13cb7ac91dd14ead87d8c2eec57cb3ed",
+                "sha256:08c114cf02a63e13ce6d70bc5b9e7bdcfa8d5db17cece207cfa085c4bc4a7a0c",
+                "sha256:0ed4a87eda16e2f95d536152c5acccae07841fbdda3b9a752f3dbf43e39f4d6b",
+                "sha256:101230b8074919970433ef79866570989157ade3421246d4c3afb7a994fdc614",
+                "sha256:11fcfdf272549a3d876f10d8422bcd5f675750aa746ce04ff04937ec3bb2329e",
+                "sha256:160f449bb91686f8fc9984200e78b8d793b79e382decf7eb1dc9948d7c21b36f",
+                "sha256:16426a843b1bc9c552a7c97d6d7555e69730c2de1e2f560503d3fc0e7f6d8005",
+                "sha256:1f1575cc0f66aa70a0bb5cb57c8d9d1b7d541d920455169c6266919bf804dc20",
+                "sha256:1f7a8fc5085450635a539c47c9fce6d441b4a973686f88fc220aa20e3921fe55",
+                "sha256:1fb0a46ae4b8d244a3fb80c3055717baa3dec6be17938e6871042a8d5b4ce670",
+                "sha256:2965fd8ba31b04c42e4b696fad509dc5ab50663efca6eb06bb3b6d08587f3a09",
+                "sha256:2b524306104c1296f1e91d74ee4ccbeeea621f6a13e44addf0bb630a1839fd72",
+                "sha256:2db04b165a57499fbcfe0eaa2f7752f118552bbcfab2163a43fef8d95f4ae745",
+                "sha256:3092f6bbf4a75b1e6f14a5b1030e27c435f341afeb23987115e45a25cc68ba91",
+                "sha256:30a2fc37698820cbf9b51d5f801219ef4bed828a04f3307072b8f983dc422a0e",
+                "sha256:3110b98c5dfb31dc1cf82d8b0c32e3fa6d6d0b268ff9f2a1599165770c1af80f",
+                "sha256:33f604bffd06b170637f8a48ddcf42074ed1e1980366ac46058e065ce04bfe2a",
+                "sha256:340c524c7c934b61d1985d805bffe7609180fb5d16ece6ce89b51aa535b936f2",
+                "sha256:37a6a8382864a1defb5b370b66a635e04358c7334054457bbbb8645610cd95b2",
+                "sha256:3875578748b484638f6ea776f534e9088cfb15eee131aac051036cba40fd5d05",
+                "sha256:38b0261483c59bb39ae9300ad46bf0bbf431ab604266382d986a349c96171b36",
+                "sha256:3b9a2eb7d2e0e9c2f25256d2663c0a2a4798fe3110e3ddbbb1a7b71740b4de08",
+                "sha256:3bb3cf22c3c03ae698647e6766314149c9cf04aa2018d9f48d5efddc3ced2764",
+                "sha256:3db0648536f3e08afa7ceb928153c39913f98fd50a5c3adf92a4d0d4268f213e",
+                "sha256:3dc654da62b3a3027b7c922f7e9f4b27feaabd5d38b2a98ea98de5e8107c72f2",
+                "sha256:4079857566077f290d35e23ff0e8ba593069c139ae85b0d152b9fa476494f50a",
+                "sha256:44f468fb4857fff86c65bec5e2fb67067789e40dad69258e9bb78fc6a6df49e7",
+                "sha256:45660e2fabcdc1bab9699a468b312f47956300d41d6a2ea91c8f067572aaf38a",
+                "sha256:477b9456eb7d70f385dc8f097a1d66ee40771b62e47b3b3e33406dcfbc1c6a3b",
+                "sha256:481239cd0966f965c2b8fa78b88614be5f12a64e7773bb5feecc567d39bb2dd5",
+                "sha256:4a83d247420b147d4b3cba0335e484365e117dc1cfe5ab35acd6a0817ad9244f",
+                "sha256:53d2abeabb91a822e9d76420c9b44980edd2d6b21767c7bb9cb2b1b4cf091049",
+                "sha256:55c31bc3d2c9e48741c812ee5ce4607c6f33e33f339831c214d923ffc7777d21",
+                "sha256:567d6891cb1ddbfd0051fcff3cb1bb86efc82ec818d9c5f98c37d59c1d23cc96",
+                "sha256:57b9df5d38ab49c13eaa9e0152fdfa8501fc23987f6dcf421b73484bfe573918",
+                "sha256:59ddb8a9f47ec807009c69e582d0de1c86c005f9f614557f4cebc7b8ac9b7d28",
+                "sha256:61b9f3cf3a55322baed8f0532b73bce77d688a01446c179392c4056ab74eb551",
+                "sha256:639389b023315596e0293f85999645f47ec3dc28c892e51242dde6176c91486b",
+                "sha256:64d1143e90299ba8c967324840912a63a903494b1870a52f6675bda53dc332f7",
+                "sha256:6542e1cfe060badd160cd383ad93a84871595c14bb05fb8129f963248affd946",
+                "sha256:69687ef16d501c9217675af36fa3c68c009c03e184b07d22ba245e5c01d47e6b",
+                "sha256:6f7e1cdf0abb11718e655bb258920453b1e89c2315e9019f60f0775704b12a8c",
+                "sha256:7378055c9f456c5bb034ac313d9a9028fc6597619a0b16584099adba5a589fdb",
+                "sha256:78103afbd0a94ac4c1f0b4014545fd149b968d5ea423aaa3b1f6e2c3fc19423e",
+                "sha256:79038bf1a7b13d243e51f4b6909c6997c2ba2bffc45bcae264704308a2d17198",
+                "sha256:795b1760418ab750826420ae24f06f392c08e21dc234f0a369a69cc00444f8ec",
+                "sha256:7998dfb1e9e0255fb8553abb019c3e7f558925de4edc8604243775ff9dd3898d",
+                "sha256:7afc740ad45ee0e0cef055765faf64789c2c183eb4aa3ecb8cecdb4b607396b3",
+                "sha256:7b4a41dc183d7d16750634f65566205990f94144755a39f33da44c0350c3e1a8",
+                "sha256:7f825ebedcad87a2825ddb6cf62f6d7d5b7a56ddaf7c93eef4b974e7ddc16408",
+                "sha256:7f9f9bb2c5cc1f679605ebbeb72f46fc395d850b93fa7de7addd502a1dc66e99",
+                "sha256:7fdf059d4e3acec44f512ebe247718ae511fde632e2b06992022df8e637385a6",
+                "sha256:81e4648c09103bc18f488957c1e0863d2397bab6625c0e6771891f151ee0bd96",
+                "sha256:8489bff00a1f81ac0754355772e76775878c32a42f16f01d427c3645546761c4",
+                "sha256:851398428f5604c53371b72c5e0a28163274264ada4a08cd1eafe65fde1f68d0",
+                "sha256:87a29b8a4cc72af6118954592dcd4e49223420470ccc3f8091c255f6c7330bb1",
+                "sha256:8b8e07374d60040b24d1a158895d9758424db13be63d4b2fe1870e37f9dec009",
+                "sha256:8d4aa56782368269eb9402caf7378b2a5ada6f05eb9c7edc2362be258973fd7e",
+                "sha256:97c448a20aded59727261468873d9b11dfdcce5a6338a359135667d5e3f1d070",
+                "sha256:98373c273e01a5a7c17103ecb617de7c9980b7608351d58c72198e3525f0002e",
+                "sha256:98e4a17f55f3cbf6fe06cc79234269572f234467c8355b6758eb252073f78e6b",
+                "sha256:99124e39658b2f72d296819ec03418609dd4f1b275b00289c2f278a19da6f9c0",
+                "sha256:9ad0df7886cb9d6d2ff75e87d323108a0e32bdca5c9918071681864129ce8ea8",
+                "sha256:9bfdfe2e2af434d3f4e47250f693657334e34a7ec557cd703b129a814422b4b8",
+                "sha256:9faa4c6fcb19a31240ad389426699a99df481b6576f7286471e24efbf1b44dfc",
+                "sha256:a048e41e1cb0c1a37021269d02698e30d2a7cc9a0205dd3390e0807745b76dae",
+                "sha256:a05982bb49c73463cb0f0f4bed2d8da82631708a2c2d1926107ba99651b419ec",
+                "sha256:a23b5f13f9b292004e94b0b13fead4dae79c7512db04dc817ff2c2478298e04a",
+                "sha256:a393b0f881eff94440f72846a6f0f95b983594a0a50af81c41ed18107420d6a7",
+                "sha256:a3b6bd81c77d9925809b714980cd30b1831a86bd090316d37cab124d92af1daf",
+                "sha256:a43f4631ecb87bedc510568fef67db53f2a20c4a5953a9d1e07457e7b1d14911",
+                "sha256:a569c993942ac26c6c590639ed6712c6c9c3f0c8d287a067bf2a60eb615f3c6b",
+                "sha256:a5b89349f05431270d1ccc7321aaab91c42ff33f463868779e502438b7f0e668",
+                "sha256:ac39319e6322c2c093a660c02cea6bb3b1ae53d049b573d4781df8896e443e04",
+                "sha256:acc56700963f63307ac096689d4547e8061028a66bb78b90e42c5da2898898fb",
+                "sha256:b723f9d10f7d8259f010b87fa66e924bb4d67927d9dcff4526a755e9ee84fef4",
+                "sha256:b99a0347bc6131046c19e056a113daa34d7df99f1f45510161bc78bc8461a470",
+                "sha256:bc0880011b86f81c5353ce4abaeb2472d942ba2320985166a2a3dd4f783563a9",
+                "sha256:be2f40045432e8aa33d9fd5cb43c91b0c61d77d3d8810f88e84e2e46411c27a7",
+                "sha256:bebb17125373c499beea009cc5bced757bde52bcb3fa1d6335650e6c2d8111d7",
+                "sha256:befac6644c6f304a1b6a7948a04095682849c426cebcc44cb2459aa92d3e1735",
+                "sha256:c1f4880bcb6fb7a8e2ab89128032b3dcf59e1e877ff4493b11c8bf7c3a5b3df2",
+                "sha256:c3e014f7295b9327fa6f0b3e55a3fd485abac98be145b9597e0cdbb05c44ad07",
+                "sha256:c427dfcce13a8c814556dfe7c110b8ef61b8fab5fca0d856d4890856807321dc",
+                "sha256:c44cf0059633470c6bb415091def546adbeb5dcfa91cc3fcb1ac16593f14e52a",
+                "sha256:c4e04c12f507942f1ddf215cb3a08c244d24051cdd2ba571060166ce8a92be16",
+                "sha256:c65257899bb8faf6a111297b4ff0066324a6b901318582c0453a01422c3bcd5a",
+                "sha256:c6c48cf5a92244ef3df4161c8625ee1890bb3d931db9a9f3b699e61a037cd58a",
+                "sha256:c9bf2bf29854f165a47917b8782b6cf3a7d602971bf454806208d0cbb96f797a",
+                "sha256:ca4b6298c89b92d6b0a67dfc5f98d68ae92b08101d227263ef2033b9c9a03a72",
+                "sha256:cc76ad7453816318d794248fba4032967eaffd992d76e5d1af10ef9d46589770",
+                "sha256:cd7f6bfa2a36fb91b7dec9ddf905716f2ed0c3675d2b63c69b7530c9d211e715",
+                "sha256:d12c45da97b2f31d0233e15f8d68731cfa86264c9f04b2669b9fdf46aaf68e1f",
+                "sha256:d160173efdad8a57c22e422a034196df3d84753672c497aee2f94bd5b128f8dd",
+                "sha256:d2b1ed363a4ef5622dccbf7822f01b51195062c4f382b28c9bd125d046d0324c",
+                "sha256:d30e7daaf228e3d69cdd8b02c0dd4199cec034c4b93c80109f56f4675a6db957",
+                "sha256:d3f38373d9b2629dedc559e647010541cc4ec4ad9bea560e2eb1017e6a00d9ef",
+                "sha256:d7e274ac1975e55ebfb8166cce27e13dc99120c1d6ce9e490d7a716b9be9abb5",
+                "sha256:d877759842ff9eb16d9c2b8b497953a7d994d4b231c171515f0bf3a2ae185c0c",
+                "sha256:da3dfd2776226e15d3288a3a24c7975f9ee160ba198f2efa66bc28c5ba76d792",
+                "sha256:db0441e80773d747a1ed9edfb9f75e7acb68ce8627583bbb6f770b7ec49f0064",
+                "sha256:dbbaa147cf28b3e87738c624d390a3a9e2a5dfef4316f4c38b4ecaf3155a3eab",
+                "sha256:ddc646cec4899a137c134b13818469e4178a251d77f9f4b23229267e3da78cfb",
+                "sha256:df7cc9584614f495f474a5ded365cf72decbcee4efcdc888d2943f8a794c789e",
+                "sha256:dfde50ae55e075dcd5801e2c3ea0e749c849ed2cbbee991af0f97f1bdbadb2a6",
+                "sha256:e15e70a3cf5bb519e2448524d689c02ff6bcd4750587a517e2bffee06065bf27",
+                "sha256:e3572889fcb87e5ca94add412d8b365dbb7b59773a4362e52caa556e5fd98643",
+                "sha256:e39f5e85e1e3d7d84ac2217cd095b3678306c979e991532df47012880e02215d",
+                "sha256:e501bd27c795105aaba02b5212ecd1bb552ca2ee2ede53e5a8cb74deee0e2052",
+                "sha256:e62892645f6a214eefb58a42c3ed2501af2e40a797844e0e09ec1e400ce75f3d",
+                "sha256:e75eb1734046291c554d9addecca9a8785bdf5d53a64f525569f8549da863dde",
+                "sha256:e84cff8e8fe71903a6cf873fb3c8731df8bd7c1dac878e7a0fe19d8e2ef39aa9",
+                "sha256:ea60cf85b4e5a78b5a41eed3a65abc3839a50d915c6e0f6966cbcf81b85991bd",
+                "sha256:ec3fd30622180cbe2326d48c14a4ab7f98a504b104bdca7dda88b134adad6e31",
+                "sha256:eccc6829035c8b7b391a0aa124fade54932bb937dd1079f2740b9f1bde829226",
+                "sha256:eda67136343db96752e58ef36ac37116f36cba40961e79fd0e9bd858f5a09b38",
+                "sha256:ef5a99a8d1a5c47b4cf85925d1420fc4ee584c98be8efc548651447b3047242f",
+                "sha256:f0795e2be2aa8afd013635f30ffe599cc00f1bbaca2d1d19b6187b4d1c58fb44",
+                "sha256:f31d8c2168bf2a52e4539232392352832c2296e07e0e14b6e06a44da574099ba",
+                "sha256:f41a4b57cbc128a699e9d716a56c90c7fc76554e680fe2962f49cc4d8688b051",
+                "sha256:f583a1fb180a123c00064fab1a3bfb9d43e574b6474be1be3f6469e0331e3e2e",
+                "sha256:f7c531722e8c3901f6bb303db464cac98ab44ed422c0fd0c762baa4a8d49ffa1",
+                "sha256:f8ab90410b2ba5b8276657c66941bcaae556a38be8dd81630a7647e8735f0a20",
+                "sha256:fa05460dc4f57358680b977b4a254d331b24c8beb501319b998625fd6a22654b",
+                "sha256:fbe1ef622748d2edb3dd4fef933b934e90e479f9831dfe31bda3fdc16bf5287f",
+                "sha256:fdb7af369df317527d697c5bb37ab944bb9a17ea1a5e82e47d5c7c638f3ccdd6",
+                "sha256:fe1f1f4010244cb07f6a079854a12e1627e4fb9ea99d672f2ceccaf6653ca514",
+                "sha256:fe2493d3f49e314e573022ead4d8c845c9748979b7eb95e815429fe947c4bde2",
+                "sha256:ffd112646486a31ea5a45aa1eca0e2cd90b6a12f67e848e50349e324c24cc2e7"
+            ],
+            "version": "==3.7.1"
+        },
+        "bitstring": {
+            "hashes": [
+                "sha256:69d1587f0ac18dc7d93fc7e80d5f447161a33e57027e726dc18a0a8bacf1711a",
+                "sha256:a08bc09d3857216d4c0f412a1611056f1cc2b64fd254fb1e8a0afba7cfa1a95a"
+            ],
+            "markers": "python_version >= '3.8'",
+            "version": "==4.3.1"
+        },
+        "cffi": {
+            "hashes": [
+                "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb",
+                "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b",
+                "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f",
+                "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9",
+                "sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44",
+                "sha256:0f6084a0ea23d05d20c3edcda20c3d006f9b6f3fefeac38f59262e10cef47ee2",
+                "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c",
+                "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75",
+                "sha256:1cd13c99ce269b3ed80b417dcd591415d3372bcac067009b6e0f59c7d4015e65",
+                "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e",
+                "sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a",
+                "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e",
+                "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25",
+                "sha256:2081580ebb843f759b9f617314a24ed5738c51d2aee65d31e02f6f7a2b97707a",
+                "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe",
+                "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b",
+                "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91",
+                "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592",
+                "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187",
+                "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c",
+                "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1",
+                "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94",
+                "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba",
+                "sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb",
+                "sha256:3f4d46d8b35698056ec29bca21546e1551a205058ae1a181d871e278b0b28165",
+                "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529",
+                "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca",
+                "sha256:4647afc2f90d1ddd33441e5b0e85b16b12ddec4fca55f0d9671fef036ecca27c",
+                "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6",
+                "sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c",
+                "sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0",
+                "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743",
+                "sha256:61d028e90346df14fedc3d1e5441df818d095f3b87d286825dfcbd6459b7ef63",
+                "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5",
+                "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5",
+                "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4",
+                "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d",
+                "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b",
+                "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93",
+                "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205",
+                "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27",
+                "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512",
+                "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d",
+                "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c",
+                "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037",
+                "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26",
+                "sha256:89472c9762729b5ae1ad974b777416bfda4ac5642423fa93bd57a09204712322",
+                "sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb",
+                "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c",
+                "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8",
+                "sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4",
+                "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414",
+                "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9",
+                "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664",
+                "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9",
+                "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775",
+                "sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739",
+                "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc",
+                "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062",
+                "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe",
+                "sha256:b882b3df248017dba09d6b16defe9b5c407fe32fc7c65a9c69798e6175601be9",
+                "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92",
+                "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5",
+                "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13",
+                "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d",
+                "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26",
+                "sha256:cb527a79772e5ef98fb1d700678fe031e353e765d1ca2d409c92263c6d43e09f",
+                "sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495",
+                "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b",
+                "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6",
+                "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c",
+                "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef",
+                "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5",
+                "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18",
+                "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad",
+                "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3",
+                "sha256:de8dad4425a6ca6e4e5e297b27b5c824ecc7581910bf9aee86cb6835e6812aa7",
+                "sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5",
+                "sha256:e6e73b9e02893c764e7e8d5bb5ce277f1a009cd5243f8228f75f842bf937c534",
+                "sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49",
+                "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2",
+                "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5",
+                "sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453",
+                "sha256:fe562eb1a64e67dd297ccc4f5addea2501664954f2692b69a76449ec7913ecbf"
+            ],
+            "markers": "platform_python_implementation != 'PyPy'",
+            "version": "==2.0.0"
+        },
+        "click": {
+            "hashes": [
+                "sha256:27c491cc05d968d271d5a1db13e3b5a184636d9d930f148c50b038f0d0646202",
+                "sha256:61a3265b914e850b85317d0b3109c7f8cd35a670f963866005d6ef1d5175a12b"
+            ],
+            "markers": "python_version >= '3.10'",
+            "version": "==8.2.1"
+        },
+        "cryptography": {
+            "hashes": [
+                "sha256:06ce84dc14df0bf6ea84666f958e6080cdb6fe1231be2a51f3fc1267d9f3fb34",
+                "sha256:16ede8a4f7929b4b7ff3642eba2bf79aa1d71f24ab6ee443935c0d269b6bc513",
+                "sha256:18fcf70f243fe07252dcb1b268a687f2358025ce32f9f88028ca5c364b123ef5",
+                "sha256:1993a1bb7e4eccfb922b6cd414f072e08ff5816702a0bdb8941c247a6b1b287c",
+                "sha256:1f3d56f73595376f4244646dd5c5870c14c196949807be39e79e7bd9bac3da63",
+                "sha256:258e0dff86d1d891169b5af222d362468a9570e2532923088658aa866eb11130",
+                "sha256:2f641b64acc00811da98df63df7d59fd4706c0df449da71cb7ac39a0732b40ae",
+                "sha256:3808e6b2e5f0b46d981c24d79648e5c25c35e59902ea4391a0dcb3e667bf7443",
+                "sha256:3994c809c17fc570c2af12c9b840d7cea85a9fd3e5c0e0491f4fa3c029216d59",
+                "sha256:3be4f21c6245930688bd9e162829480de027f8bf962ede33d4f8ba7d67a00cee",
+                "sha256:465ccac9d70115cd4de7186e60cfe989de73f7bb23e8a7aa45af18f7412e75bf",
+                "sha256:48c41a44ef8b8c2e80ca4527ee81daa4c527df3ecbc9423c41a420a9559d0e27",
+                "sha256:4a862753b36620af6fc54209264f92c716367f2f0ff4624952276a6bbd18cbde",
+                "sha256:4b1654dfc64ea479c242508eb8c724044f1e964a47d1d1cacc5132292d851971",
+                "sha256:4bd3e5c4b9682bc112d634f2c6ccc6736ed3635fc3319ac2bb11d768cc5a00d8",
+                "sha256:577470e39e60a6cd7780793202e63536026d9b8641de011ed9d8174da9ca5339",
+                "sha256:67285f8a611b0ebc0857ced2081e30302909f571a46bfa7a3cc0ad303fe015c6",
+                "sha256:7285a89df4900ed3bfaad5679b1e668cb4b38a8de1ccbfc84b05f34512da0a90",
+                "sha256:81823935e2f8d476707e85a78a405953a03ef7b7b4f55f93f7c2d9680e5e0691",
+                "sha256:8978132287a9d3ad6b54fcd1e08548033cc09dc6aacacb6c004c73c3eb5d3ac3",
+                "sha256:a20e442e917889d1a6b3c570c9e3fa2fdc398c20868abcea268ea33c024c4083",
+                "sha256:a24ee598d10befaec178efdff6054bc4d7e883f615bfbcd08126a0f4931c83a6",
+                "sha256:b04f85ac3a90c227b6e5890acb0edbaf3140938dbecf07bff618bf3638578cf1",
+                "sha256:b6a0e535baec27b528cb07a119f321ac024592388c5681a5ced167ae98e9fff3",
+                "sha256:bef32a5e327bd8e5af915d3416ffefdbe65ed975b646b3805be81b23580b57b8",
+                "sha256:bfb4c801f65dd61cedfc61a83732327fafbac55a47282e6f26f073ca7a41c3b2",
+                "sha256:c13b1e3afd29a5b3b2656257f14669ca8fa8d7956d509926f0b130b600b50ab7",
+                "sha256:c987dad82e8c65ebc985f5dae5e74a3beda9d0a2a4daf8a1115f3772b59e5141",
+                "sha256:ce7a453385e4c4693985b4a4a3533e041558851eae061a58a5405363b098fcd3",
+                "sha256:d0c5c6bac22b177bf8da7435d9d27a6834ee130309749d162b26c3105c0795a9",
+                "sha256:d97cf502abe2ab9eff8bd5e4aca274da8d06dd3ef08b759a8d6143f4ad65d4b4",
+                "sha256:dad43797959a74103cb59c5dac71409f9c27d34c8a05921341fb64ea8ccb1dd4",
+                "sha256:dd342f085542f6eb894ca00ef70236ea46070c8a13824c6bde0dfdcd36065b9b",
+                "sha256:de58755d723e86175756f463f2f0bddd45cc36fbd62601228a3f8761c9f58252",
+                "sha256:f3df7b3d0f91b88b2106031fd995802a2e9ae13e02c36c1fc075b43f420f3a17",
+                "sha256:f5414a788ecc6ee6bc58560e85ca624258a55ca434884445440a810796ea0e0b",
+                "sha256:fa26fa54c0a9384c27fcdc905a2fb7d60ac6e47d14bc2692145f2b3b1e2cfdbd"
+            ],
+            "markers": "python_version >= '3.7' and python_full_version not in '3.9.0, 3.9.1'",
+            "version": "==45.0.7"
+        },
+        "esptool": {
+            "hashes": [
+                "sha256:05cc4732eb2a9a7766c9e3531f7943d76ff0ca06dc9cd308d1d3d0b72f74aac2"
+            ],
+            "index": "pypi",
+            "markers": "python_version >= '3.10'",
+            "version": "==5.0.2"
+        },
+        "h11": {
+            "hashes": [
+                "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1",
+                "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86"
+            ],
+            "markers": "python_version >= '3.8'",
+            "version": "==0.16.0"
+        },
+        "idna": {
+            "hashes": [
+                "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9",
+                "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"
+            ],
+            "markers": "python_version >= '3.6'",
+            "version": "==3.10"
+        },
+        "intelhex": {
+            "hashes": [
+                "sha256:87cc5225657524ec6361354be928adfd56bcf2a3dcc646c40f8f094c39c07db4",
+                "sha256:892b7361a719f4945237da8ccf754e9513db32f5628852785aea108dcd250093"
+            ],
+            "version": "==2.3.0"
+        },
+        "markdown-it-py": {
+            "hashes": [
+                "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147",
+                "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3"
+            ],
+            "markers": "python_version >= '3.10'",
+            "version": "==4.0.0"
+        },
+        "mdurl": {
+            "hashes": [
+                "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8",
+                "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==0.1.2"
+        },
+        "mpremote": {
+            "hashes": [
+                "sha256:7f347318fb6d3bb8f89401d399a05efba39b51c74f747cebe92d3c6a9a4ee0b4",
+                "sha256:daed9b795fdf98edb0c9c4f7f892bf66f075ec5e728bdcc4ab0915abf23d5d17"
+            ],
+            "index": "pypi",
+            "markers": "python_version >= '3.4'",
+            "version": "==1.26.0"
+        },
+        "platformdirs": {
+            "hashes": [
+                "sha256:abd01743f24e5287cd7a5db3752faf1a2d65353f38ec26d98e25a6db65958c85",
+                "sha256:ca753cf4d81dc309bc67b0ea38fd15dc97bc30ce419a7f58d13eb3bf14c4febf"
+            ],
+            "markers": "python_version >= '3.9'",
+            "version": "==4.4.0"
+        },
+        "pycparser": {
+            "hashes": [
+                "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2",
+                "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934"
+            ],
+            "markers": "implementation_name != 'PyPy'",
+            "version": "==2.23"
+        },
+        "pygments": {
+            "hashes": [
+                "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887",
+                "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b"
+            ],
+            "markers": "python_version >= '3.8'",
+            "version": "==2.19.2"
+        },
+        "pyserial": {
+            "hashes": [
+                "sha256:3c77e014170dfffbd816e6ffc205e9842efb10be9f58ec16d3e8675b4925cddb",
+                "sha256:c4451db6ba391ca6ca299fb3ec7bae67a5c55dde170964c7a14ceefec02f2cf0"
+            ],
+            "index": "pypi",
+            "version": "==3.5"
+        },
+        "pyyaml": {
+            "hashes": [
+                "sha256:01179a4a8559ab5de078078f37e5c1a30d76bb88519906844fd7bdea1b7729ff",
+                "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48",
+                "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086",
+                "sha256:0b69e4ce7a131fe56b7e4d770c67429700908fc0752af059838b1cfb41960e4e",
+                "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133",
+                "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5",
+                "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484",
+                "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee",
+                "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5",
+                "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68",
+                "sha256:24471b829b3bf607e04e88d79542a9d48bb037c2267d7927a874e6c205ca7e9a",
+                "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf",
+                "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99",
+                "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8",
+                "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85",
+                "sha256:3b1fdb9dc17f5a7677423d508ab4f243a726dea51fa5e70992e59a7411c89d19",
+                "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc",
+                "sha256:43fa96a3ca0d6b1812e01ced1044a003533c47f6ee8aca31724f78e93ccc089a",
+                "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1",
+                "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317",
+                "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c",
+                "sha256:6395c297d42274772abc367baaa79683958044e5d3835486c16da75d2a694631",
+                "sha256:688ba32a1cffef67fd2e9398a2efebaea461578b0923624778664cc1c914db5d",
+                "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652",
+                "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5",
+                "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e",
+                "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b",
+                "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8",
+                "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476",
+                "sha256:82d09873e40955485746739bcb8b4586983670466c23382c19cffecbf1fd8706",
+                "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563",
+                "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237",
+                "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b",
+                "sha256:9056c1ecd25795207ad294bcf39f2db3d845767be0ea6e6a34d856f006006083",
+                "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180",
+                "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425",
+                "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e",
+                "sha256:a8786accb172bd8afb8be14490a16625cbc387036876ab6ba70912730faf8e1f",
+                "sha256:a9f8c2e67970f13b16084e04f134610fd1d374bf477b17ec1599185cf611d725",
+                "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183",
+                "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab",
+                "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774",
+                "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725",
+                "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e",
+                "sha256:d7fded462629cfa4b685c5416b949ebad6cec74af5e2d42905d41e257e0869f5",
+                "sha256:d84a1718ee396f54f3a086ea0a66d8e552b2ab2017ef8b420e92edbc841c352d",
+                "sha256:d8e03406cac8513435335dbab54c0d385e4a49e4945d2909a581c83647ca0290",
+                "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44",
+                "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed",
+                "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4",
+                "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba",
+                "sha256:f753120cb8181e736c57ef7636e83f31b9c0d1722c516f7e86cf15b7aa57ff12",
+                "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4"
+            ],
+            "markers": "python_version >= '3.8'",
+            "version": "==6.0.2"
+        },
+        "reedsolo": {
+            "hashes": [
+                "sha256:2b6a3e402a1ee3e1eea3f932f81e6c0b7bbc615588074dca1dbbcdeb055002bd",
+                "sha256:c1359f02742751afe0f1c0de9f0772cc113835aa2855d2db420ea24393c87732"
+            ],
+            "version": "==1.7.0"
+        },
+        "rich": {
+            "hashes": [
+                "sha256:536f5f1785986d6dbdea3c75205c473f970777b4a0d6c6dd1b696aa05a3fa04f",
+                "sha256:e497a48b844b0320d45007cdebfeaeed8db2a4f4bcf49f15e455cfc4af11eaa8"
+            ],
+            "markers": "python_full_version >= '3.8.0'",
+            "version": "==14.1.0"
+        },
+        "rich-click": {
+            "hashes": [
+                "sha256:c3fa81ed8a671a10de65a9e20abf642cfdac6fdb882db1ef465ee33919fbcfe2",
+                "sha256:fd98c0ab9ddc1cf9c0b7463f68daf28b4d0033a74214ceb02f761b3ff2af3136"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==1.8.9"
+        },
+        "sniffio": {
+            "hashes": [
+                "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2",
+                "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"
+            ],
+            "markers": "python_version >= '3.7'",
+            "version": "==1.3.1"
+        },
+        "typing-extensions": {
+            "hashes": [
+                "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466",
+                "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548"
+            ],
+            "markers": "python_version < '3.13'",
+            "version": "==4.15.0"
+        },
+        "uvicorn": {
+            "hashes": [
+                "sha256:197535216b25ff9b785e29a0b79199f55222193d47f820816e7da751e9bc8d4a",
+                "sha256:bc662f087f7cf2ce11a1d7fd70b90c9f98ef2e2831556dd078d131b96cc94a01"
+            ],
+            "index": "pypi",
+            "markers": "python_version >= '3.9'",
+            "version": "==0.35.0"
+        },
+        "watchfiles": {
+            "hashes": [
+                "sha256:00645eb79a3faa70d9cb15c8d4187bb72970b2470e938670240c7998dad9f13a",
+                "sha256:04e4ed5d1cd3eae68c89bcc1a485a109f39f2fd8de05f705e98af6b5f1861f1f",
+                "sha256:0a7d40b77f07be87c6faa93d0951a0fcd8cbca1ddff60a1b65d741bac6f3a9f6",
+                "sha256:0ece16b563b17ab26eaa2d52230c9a7ae46cf01759621f4fbbca280e438267b3",
+                "sha256:11ee4444250fcbeb47459a877e5e80ed994ce8e8d20283857fc128be1715dac7",
+                "sha256:12b0a02a91762c08f7264e2e79542f76870c3040bbc847fb67410ab81474932a",
+                "sha256:12fe8eaffaf0faa7906895b4f8bb88264035b3f0243275e0bf24af0436b27259",
+                "sha256:130fc497b8ee68dce163e4254d9b0356411d1490e868bd8790028bc46c5cc297",
+                "sha256:17ab167cca6339c2b830b744eaf10803d2a5b6683be4d79d8475d88b4a8a4be1",
+                "sha256:199207b2d3eeaeb80ef4411875a6243d9ad8bc35b07fc42daa6b801cc39cc41c",
+                "sha256:20ecc8abbd957046f1fe9562757903f5eaf57c3bce70929fda6c7711bb58074a",
+                "sha256:239736577e848678e13b201bba14e89718f5c2133dfd6b1f7846fa1b58a8532b",
+                "sha256:249590eb75ccc117f488e2fabd1bfa33c580e24b96f00658ad88e38844a040bb",
+                "sha256:27f30e14aa1c1e91cb653f03a63445739919aef84c8d2517997a83155e7a2fcc",
+                "sha256:29e7bc2eee15cbb339c68445959108803dc14ee0c7b4eea556400131a8de462b",
+                "sha256:328dbc9bff7205c215a7807da7c18dce37da7da718e798356212d22696404339",
+                "sha256:32d6d4e583593cb8576e129879ea0991660b935177c0f93c6681359b3654bfa9",
+                "sha256:3366f56c272232860ab45c77c3ca7b74ee819c8e1f6f35a7125556b198bbc6df",
+                "sha256:3434e401f3ce0ed6b42569128b3d1e3af773d7ec18751b918b89cd49c14eaafb",
+                "sha256:37d3d3f7defb13f62ece99e9be912afe9dd8a0077b7c45ee5a57c74811d581a4",
+                "sha256:3a6fd40bbb50d24976eb275ccb55cd1951dfb63dbc27cae3066a6ca5f4beabd5",
+                "sha256:3aba215958d88182e8d2acba0fdaf687745180974946609119953c0e112397dc",
+                "sha256:406520216186b99374cdb58bc48e34bb74535adec160c8459894884c983a149c",
+                "sha256:4281cd9fce9fc0a9dbf0fc1217f39bf9cf2b4d315d9626ef1d4e87b84699e7e8",
+                "sha256:42f92befc848bb7a19658f21f3e7bae80d7d005d13891c62c2cd4d4d0abb3433",
+                "sha256:48aa25e5992b61debc908a61ab4d3f216b64f44fdaa71eb082d8b2de846b7d12",
+                "sha256:5007f860c7f1f8df471e4e04aaa8c43673429047d63205d1630880f7637bca30",
+                "sha256:50a51a90610d0845a5931a780d8e51d7bd7f309ebc25132ba975aca016b576a0",
+                "sha256:51556d5004887045dba3acdd1fdf61dddea2be0a7e18048b5e853dcd37149b86",
+                "sha256:51b81e55d40c4b4aa8658427a3ee7ea847c591ae9e8b81ef94a90b668999353c",
+                "sha256:5366164391873ed76bfdf618818c82084c9db7fac82b64a20c44d335eec9ced5",
+                "sha256:54062ef956807ba806559b3c3d52105ae1827a0d4ab47b621b31132b6b7e2866",
+                "sha256:60022527e71d1d1fda67a33150ee42869042bce3d0fcc9cc49be009a9cded3fb",
+                "sha256:622d6b2c06be19f6e89b1d951485a232e3b59618def88dbeda575ed8f0d8dbf2",
+                "sha256:62cc7a30eeb0e20ecc5f4bd113cd69dcdb745a07c68c0370cea919f373f65d9e",
+                "sha256:693ed7ec72cbfcee399e92c895362b6e66d63dac6b91e2c11ae03d10d503e575",
+                "sha256:6d2404af8db1329f9a3c9b79ff63e0ae7131986446901582067d9304ae8aaf7f",
+                "sha256:7049e52167fc75fc3cc418fc13d39a8e520cbb60ca08b47f6cedb85e181d2f2a",
+                "sha256:7080c4bb3efd70a07b1cc2df99a7aa51d98685be56be6038c3169199d0a1c69f",
+                "sha256:7738027989881e70e3723c75921f1efa45225084228788fc59ea8c6d732eb30d",
+                "sha256:7a7bd57a1bb02f9d5c398c0c1675384e7ab1dd39da0ca50b7f09af45fa435277",
+                "sha256:7b3443f4ec3ba5aa00b0e9fa90cf31d98321cbff8b925a7c7b84161619870bc9",
+                "sha256:7c55b0f9f68590115c25272b06e63f0824f03d4fc7d6deed43d8ad5660cabdbf",
+                "sha256:7fd1b3879a578a8ec2076c7961076df540b9af317123f84569f5a9ddee64ce92",
+                "sha256:8076a5769d6bdf5f673a19d51da05fc79e2bbf25e9fe755c47595785c06a8c72",
+                "sha256:80f811146831c8c86ab17b640801c25dc0a88c630e855e2bef3568f30434d52b",
+                "sha256:8412eacef34cae2836d891836a7fff7b754d6bcac61f6c12ba5ca9bc7e427b68",
+                "sha256:865c8e95713744cf5ae261f3067861e9da5f1370ba91fc536431e29b418676fa",
+                "sha256:86b1e28d4c37e89220e924305cd9f82866bb0ace666943a6e4196c5df4d58dcc",
+                "sha256:891c69e027748b4a73847335d208e374ce54ca3c335907d381fde4e41661b13b",
+                "sha256:8ac164e20d17cc285f2b94dc31c384bc3aa3dd5e7490473b3db043dd70fbccfd",
+                "sha256:8c5701dc474b041e2934a26d31d39f90fac8a3dee2322b39f7729867f932b1d4",
+                "sha256:90ebb429e933645f3da534c89b29b665e285048973b4d2b6946526888c3eb2c7",
+                "sha256:923fec6e5461c42bd7e3fd5ec37492c6f3468be0499bc0707b4bbbc16ac21792",
+                "sha256:935f9edd022ec13e447e5723a7d14456c8af254544cefbc533f6dd276c9aa0d9",
+                "sha256:95ab1594377effac17110e1352989bdd7bdfca9ff0e5eeccd8c69c5389b826d0",
+                "sha256:9974d2f7dc561cce3bb88dfa8eb309dab64c729de85fba32e98d75cf24b66297",
+                "sha256:9c733cda03b6d636b4219625a4acb5c6ffb10803338e437fb614fef9516825ef",
+                "sha256:9dc001c3e10de4725c749d4c2f2bdc6ae24de5a88a339c4bce32300a31ede179",
+                "sha256:9f811079d2f9795b5d48b55a37aa7773680a5659afe34b54cc1d86590a51507d",
+                "sha256:a2726d7bfd9f76158c84c10a409b77a320426540df8c35be172444394b17f7ea",
+                "sha256:a479466da6db5c1e8754caee6c262cd373e6e6c363172d74394f4bff3d84d7b5",
+                "sha256:a543492513a93b001975ae283a51f4b67973662a375a403ae82f420d2c7205ee",
+                "sha256:a89c75a5b9bc329131115a409d0acc16e8da8dfd5867ba59f1dd66ae7ea8fa82",
+                "sha256:a8f6f72974a19efead54195bc9bed4d850fc047bb7aa971268fd9a8387c89011",
+                "sha256:a9ccbf1f129480ed3044f540c0fdbc4ee556f7175e5ab40fe077ff6baf286d4e",
+                "sha256:aa0cc8365ab29487eb4f9979fd41b22549853389e22d5de3f134a6796e1b05a4",
+                "sha256:adb4167043d3a78280d5d05ce0ba22055c266cf8655ce942f2fb881262ff3cdf",
+                "sha256:af06c863f152005c7592df1d6a7009c836a247c9d8adb78fef8575a5a98699db",
+                "sha256:b067915e3c3936966a8607f6fe5487df0c9c4afb85226613b520890049deea20",
+                "sha256:b7c5f6fe273291f4d414d55b2c80d33c457b8a42677ad14b4b47ff025d0893e4",
+                "sha256:b915daeb2d8c1f5cee4b970f2e2c988ce6514aace3c9296e58dd64dc9aa5d575",
+                "sha256:ba0e3255b0396cac3cc7bbace76404dd72b5438bf0d8e7cefa2f79a7f3649caa",
+                "sha256:bda8136e6a80bdea23e5e74e09df0362744d24ffb8cd59c4a95a6ce3d142f79c",
+                "sha256:bfe3c517c283e484843cb2e357dd57ba009cff351edf45fb455b5fbd1f45b15f",
+                "sha256:c588c45da9b08ab3da81d08d7987dae6d2a3badd63acdb3e206a42dbfa7cb76f",
+                "sha256:c600e85f2ffd9f1035222b1a312aff85fd11ea39baff1d705b9b047aad2ce267",
+                "sha256:c68e9f1fcb4d43798ad8814c4c1b61547b014b667216cb754e606bfade587018",
+                "sha256:c9649dfc57cc1f9835551deb17689e8d44666315f2e82d337b9f07bd76ae3aa2",
+                "sha256:cb45350fd1dc75cd68d3d72c47f5b513cb0578da716df5fba02fff31c69d5f2d",
+                "sha256:cbcf8630ef4afb05dc30107bfa17f16c0896bb30ee48fc24bf64c1f970f3b1fd",
+                "sha256:cbd949bdd87567b0ad183d7676feb98136cde5bb9025403794a4c0db28ed3a47",
+                "sha256:cc08ef8b90d78bfac66f0def80240b0197008e4852c9f285907377b2947ffdcb",
+                "sha256:cd17a1e489f02ce9117b0de3c0b1fab1c3e2eedc82311b299ee6b6faf6c23a29",
+                "sha256:d05686b5487cfa2e2c28ff1aa370ea3e6c5accfe6435944ddea1e10d93872147",
+                "sha256:d0e10e6f8f6dc5762adee7dece33b722282e1f59aa6a55da5d493a97282fedd8",
+                "sha256:d181ef50923c29cf0450c3cd47e2f0557b62218c50b2ab8ce2ecaa02bd97e670",
+                "sha256:d1caf40c1c657b27858f9774d5c0e232089bca9cb8ee17ce7478c6e9264d2587",
+                "sha256:d7642b9bc4827b5518ebdb3b82698ada8c14c7661ddec5fe719f3e56ccd13c97",
+                "sha256:d9481174d3ed982e269c090f780122fb59cee6c3796f74efe74e70f7780ed94c",
+                "sha256:d9ba68ec283153dead62cbe81872d28e053745f12335d037de9cbd14bd1877f5",
+                "sha256:da71945c9ace018d8634822f16cbc2a78323ef6c876b1d34bbf5d5222fd6a72e",
+                "sha256:dc44678a72ac0910bac46fa6a0de6af9ba1355669b3dfaf1ce5f05ca7a74364e",
+                "sha256:df32d59cb9780f66d165a9a7a26f19df2c7d24e3bd58713108b41d0ff4f929c6",
+                "sha256:df670918eb7dd719642e05979fc84704af913d563fd17ed636f7c4783003fdcc",
+                "sha256:e78b6ed8165996013165eeabd875c5dfc19d41b54f94b40e9fff0eb3193e5e8e",
+                "sha256:ed8fc66786de8d0376f9f913c09e963c66e90ced9aa11997f93bdb30f7c872a8",
+                "sha256:eff4b8d89f444f7e49136dc695599a591ff769300734446c0a86cba2eb2f9895",
+                "sha256:f21af781a4a6fbad54f03c598ab620e3a77032c5878f3d780448421a6e1818c7",
+                "sha256:f2bcdc54ea267fe72bfc7d83c041e4eb58d7d8dc6f578dfddb52f037ce62f432",
+                "sha256:f2f0498b7d2a3c072766dba3274fe22a183dbea1f99d188f1c6c72209a1063dc",
+                "sha256:f7208ab6e009c627b7557ce55c465c98967e8caa8b11833531fdf95799372633",
+                "sha256:f7590d5a455321e53857892ab8879dce62d1f4b04748769f5adf2e707afb9d4f",
+                "sha256:fa257a4d0d21fcbca5b5fcba9dca5a78011cb93c0323fb8855c6d2dfbc76eb77",
+                "sha256:fba9b62da882c1be1280a7584ec4515d0a6006a94d6e5819730ec2eab60ffe12",
+                "sha256:fe4371595edf78c41ef8ac8df20df3943e13defd0efcb732b2e393b5a8a7a71f"
+            ],
+            "index": "pypi",
+            "markers": "python_version >= '3.9'",
+            "version": "==1.1.0"
+        }
+    },
+    "develop": {}
+}

README.md

@@ -1,2 +1,38 @@
 # led-bar
 
+## Install Pipenv
+
+https://pipenv.pypa.io/en/latest/installation.html
+
+## Download dependencies
+
+```pipenv sync ```
+
+## Install Micropython
+
+https://micropython.org/resources/firmware/ESP32_GENERIC_C3-20241129-v1.24.1.bin
+
+```
+pipenv run esptool.py --port PORTNAME erase_flash
+pipenv run esptool.py --port PORTNAME --baud 460800 write_flash 0 ESP32_GENERIC_C3-20241129-v1.24.1.bin
+```
+
+## Upload libraries and src
+
+```pipenv run ./dev.py PORTNAME lib src```
+
+## Upload src, reset and follow
+
+```pipenv run ./dev.py PORTNAME src reset follow```
+
+
+## Connect 
+
+Connect to wifi nextwork called led-xxxxxx...
+
+http://192.168.4.1/
+
+
+
+![alt text](screenshots/controls.png)
+![alt text](screenshots/settings.png)

configure_bar.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+LED Bar Configuration Script
+Updates the settings.json file for each LED bar with its unique name
+"""
+
+import json
+import os
+
+# LED Bar names/IDs
+LED_BAR_NAMES = ["100", "101", "102", "103", "104", "105", "106", "107"]
+
+def update_bar_settings(bar_name, settings_file="settings.json"):
+    """Update the settings.json file with the bar name"""
+    if not os.path.exists(settings_file):
+        print(f"Error: {settings_file} not found")
+        return False
+    
+    # Read current settings
+    with open(settings_file, 'r') as f:
+        settings = json.load(f)
+    
+    # Update the name
+    settings["name"] = bar_name
+    
+    # Write back to file
+    with open(settings_file, 'w') as f:
+        json.dump(settings, f, indent=4)
+    
+    print(f"Updated {settings_file} with name: {bar_name}")
+    return True
+
+def main():
+    print("LED Bar Configuration Script")
+    print("=" * 40)
+    print("Available bar names:", LED_BAR_NAMES)
+    print()
+    
+    while True:
+        print("Enter bar name to configure (or 'quit' to exit):")
+        bar_name = input("> ").strip()
+        
+        if bar_name.lower() == 'quit':
+            break
+        
+        if bar_name not in LED_BAR_NAMES:
+            print(f"Invalid bar name. Must be one of: {LED_BAR_NAMES}")
+            continue
+        
+        if update_bar_settings(bar_name):
+            print(f"Successfully configured LED bar as '{bar_name}'")
+        else:
+            print("Failed to update settings")
+        
+        print()
+
+if __name__ == "__main__":
+    main()

edit_settings.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""
+Settings editor - copy from device, edit locally, upload back
+Run with: python3 edit_settings.py
+"""
+
+import json
+import subprocess
+import os
+import tempfile
+
+def copy_settings_from_device():
+    """Copy settings.json from the MicroPython device"""
+    print("Copying settings from device...")
+    try:
+        # Use mpremote to copy settings.json to local temp file
+        result = subprocess.run(['mpremote', 'cp', ':/settings.json', 'settings.json'], 
+                              capture_output=True, text=True)
+        if result.returncode == 0:
+            print("Settings copied successfully")
+            return True
+        else:
+            print(f"Failed to copy settings: {result.stderr}")
+            return False
+    except Exception as e:
+        print(f"Error copying settings: {e}")
+        return False
+
+def load_local_settings():
+    """Load settings from local file"""
+    try:
+        with open('settings.json', 'r') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        print("No local settings file found")
+        return {}
+    except Exception as e:
+        print(f"Error loading settings: {e}")
+        return {}
+
+def save_local_settings(settings):
+    """Save settings to local file"""
+    try:
+        with open('settings.json', 'w') as f:
+            json.dump(settings, f, indent=2)
+        print("Settings saved locally")
+        return True
+    except Exception as e:
+        print(f"Error saving settings: {e}")
+        return False
+
+def upload_settings_to_device():
+    """Upload settings.json to the MicroPython device"""
+    print("Uploading settings to device...")
+    try:
+        result = subprocess.run(['mpremote', 'cp', 'settings.json', ':/settings.json'], 
+                              capture_output=True, text=True)
+        if result.returncode == 0:
+            print("Settings uploaded successfully")
+            return True
+        else:
+            print(f"Failed to upload settings: {result.stderr}")
+            return False
+    except Exception as e:
+        print(f"Error uploading settings: {e}")
+        return False
+
+def edit_settings_interactive(settings):
+    """Interactive settings editor"""
+    print("\nLED Bar Settings Editor")
+    print("=======================")
+    
+    # Display current settings
+    current_pin = settings.get("led_pin", 10)
+    current_leds = settings.get("num_leds", 119)
+    current_name = settings.get("name", "104")
+    current_color_order = settings.get("color_order", "rgb")
+    
+    print(f"\nCurrent settings:")
+    print(f"  1. LED Pin: {current_pin}")
+    print(f"  2. Number of LEDs: {current_leds}")
+    print(f"  3. Device Name: {current_name}")
+    print(f"  4. Color Order: {current_color_order}")
+    
+    print(f"\nEnter new values (press Enter to keep current):")
+    
+    # LED Pin
+    new_pin = input(f"LED Pin [{current_pin}]: ").strip()
+    if new_pin:
+        try:
+            settings["led_pin"] = int(new_pin)
+        except ValueError:
+            print("Invalid pin number, keeping current value.")
+    
+    # Number of LEDs
+    new_leds = input(f"Number of LEDs [{current_leds}]: ").strip()
+    if new_leds:
+        try:
+            settings["num_leds"] = int(new_leds)
+        except ValueError:
+            print("Invalid LED count, keeping current value.")
+    
+    # Device Name
+    new_name = input(f"Device Name [{current_name}]: ").strip()
+    if new_name:
+        settings["name"] = new_name
+    
+    # Color Order
+    print(f"Color Order options: rgb, rbg")
+    new_color_order = input(f"Color Order [{current_color_order}]: ").strip().lower()
+    if new_color_order in ['rgb', 'rbg']:
+        settings["color_order"] = new_color_order
+    elif new_color_order:
+        print("Invalid color order, keeping current value.")
+    
+    return settings
+
+def main():
+    print("LED Bar Settings Editor")
+    print("=======================")
+    
+    # Step 1: Copy settings from device
+    if not copy_settings_from_device():
+        print("Creating default settings...")
+        default_settings = {
+            "led_pin": 10,
+            "num_leds": 119,
+            "color_order": "rgb",
+            "name": "104"
+        }
+        save_local_settings(default_settings)
+    
+    # Step 2: Load and edit settings
+    settings = load_local_settings()
+    if not settings:
+        print("No settings to edit")
+        return
+    
+    # Step 3: Interactive editing
+    edited_settings = edit_settings_interactive(settings.copy())
+    
+    # Step 4: Save locally
+    if edited_settings != settings:
+        save_local_settings(edited_settings)
+        
+        # Step 5: Upload to device
+        upload_choice = input("\nUpload settings to device? (y/n): ").strip().lower()
+        if upload_choice in ['y', 'yes']:
+            if upload_settings_to_device():
+                print("\nSettings updated successfully!")
+                print("Restart the device to apply changes.")
+            else:
+                print("\nFailed to upload settings.")
+        else:
+            print("\nSettings saved locally but not uploaded.")
+    else:
+        print("\nNo changes made.")
+
+if __name__ == "__main__":
+    main()
+
+
+
+
+

patterns.py

@@ -0,0 +1,431 @@
+
+import utime
+import random
+from patterns_base import PatternBase # Import PatternBase
+
+class Patterns(PatternBase): # Inherit from PatternBase
+    def __init__(self, pin, num_leds, color1=(0,0,0), color2=(0,0,0), brightness=127, selected="rainbow_cycle", delay=100):
+        super().__init__(pin, num_leds, color1, color2, brightness, selected, delay) # Call parent constructor
+        
+        # Pattern-specific initializations
+        self.on_width = 1 # Default on width
+        self.off_width = 2 # Default off width (so total segment is 3, matching original behavior)
+        self.n1 = 0 # Default start of fill range
+        self.n2 = self.num_leds - 1 # Default end of fill range
+        self.oneshot = False # New: One-shot flag for patterns like fill_range
+        self.patterns = {
+            "off": self.off,
+            "on" : self.on,
+            "color_wipe": self.color_wipe,
+            "rainbow_cycle": self.rainbow_cycle,
+            "theater_chase": self.theater_chase,
+            "blink": self.blink,
+            "color_transition": self.color_transition, # Added new pattern
+            "flicker": self.flicker,
+            "scanner": self.scanner, # New: Single direction scanner
+            "bidirectional_scanner": self.bidirectional_scanner, # New: Bidirectional scanner
+            "fill_range": self.fill_range, # New: Fill from n1 to n2
+            "n_chase": self.n_chase, # New: N1 on, N2 off repeating chase
+            "alternating": self.alternating, # New: N1 on/off, N2 off/on alternating chase
+            "external": None,
+            "pulse": self.pulse
+        }
+        # Beat-related functionality removed
+        # self.selected is already initialized in PatternBase, but we need to ensure it uses our patterns dict
+        # self.selected = selected # Handled by PatternBase
+
+        # Ensure colors list always starts with at least two for robust transition handling
+        # self.colors handled by PatternBase
+
+        # Transition attributes handled by PatternBase
+
+        # Scanner attributes handled by PatternBase
+        # self.run handled by PatternBase
+
+    def set_on_width(self, on_width):
+        self.on_width = on_width
+
+    def set_off_width(self, off_width):
+        self.off_width = off_width
+        
+    def set_on_off_width(self, on_width, off_width):
+        self.on_width = on_width
+        self.off_width = off_width
+        self.sync()
+
+    def set_fill_range(self, n1, n2):
+        self.n1 = n1
+        self.n2 = n2
+        self.sync()
+
+    def set_oneshot(self, oneshot_value):
+        self.oneshot = oneshot_value
+        if self.oneshot: # Reset pattern step if enabling one-shot
+            self.pattern_step = 0
+        self.sync()
+
+    def select(self, pattern):
+        if pattern in self.patterns:
+            super().select(pattern) # Use parent select to set self.selected and self.transition_step
+            self.run = True # Set run flag
+            if pattern == "color_transition":
+                if len(self.colors) < 2:
+                    print("Warning: 'color_transition' requires at least two colors. Switching to 'on'.")
+                    self.selected = "on" # Fallback if not enough colors
+                    self.sync() # Re-sync for the new pattern
+                else:
+                    self.transition_step = 0
+                    self.current_color_idx = 0 # Start from the first color in the list
+                    self.current_color = self.colors[self.current_color_idx]
+                    self.hold_start_time = utime.ticks_ms() # Reset hold timer
+                    self.transition_duration = self.delay * 50 # Initialize transition duration
+                    self.hold_duration = self.delay * 10 # Initialize hold duration
+            return True
+        return False
+    
+    def off(self):
+        self.fill((0, 0, 0))
+        return self.delay
+
+    def on(self):
+        self.fill(self.apply_brightness(self.colors[0]))
+        return self.delay
+
+    def color_wipe(self):
+        color = self.apply_brightness(self.colors[0])
+        current_time = utime.ticks_ms()
+        if self.pattern_step < self.num_leds:
+            for i in range(self.num_leds):
+                self.n[i] = (0, 0, 0)
+            self.n[self.pattern_step] = self.apply_brightness(color)
+            self.n.write()
+            self.pattern_step += 1
+        else:
+            self.pattern_step = 0
+        self.last_update = current_time
+        return self.delay
+
+    def rainbow_cycle(self):
+        current_time = utime.ticks_ms()
+        def wheel(pos):
+            if pos < 85:
+                return (pos * 3, 255 - pos * 3, 0)
+            elif pos < 170:
+                pos -= 85
+                return (255 - pos * 3, 0, pos * 3)
+            else:
+                pos -= 170
+                return (0, pos * 3, 255 - pos * 3)
+
+        # Rainbow travels along the length - each LED position gets a different color
+        for i in range(self.num_leds):
+            # Map LED position along strip to rainbow color
+            # Full 256 color range distributed along the strip length
+            rc_index = ((i * 256 // self.num_leds) + self.pattern_step) % 256
+            self.n[i] = self.apply_brightness(wheel(rc_index & 255))
+        self.n.write()
+        self.pattern_step = (self.pattern_step + 1) % 256
+        self.last_update = current_time
+        return max(1, int(self.delay // 5))
+
+    def theater_chase(self):
+        current_time = utime.ticks_ms()
+        segment_length = self.on_width + self.off_width
+        for i in range(self.num_leds):
+            if (i + self.pattern_step) % segment_length < self.on_width:
+                self.n[i] = self.apply_brightness(self.colors[0])
+            else:
+                self.n[i] = (0, 0, 0)
+        self.n.write()
+        self.pattern_step = (self.pattern_step + 1) % segment_length
+        self.last_update = current_time
+        return self.delay
+
+    def blink(self):
+        current_time = utime.ticks_ms()
+        if self.pattern_step % 2 == 0:
+            self.fill(self.apply_brightness(self.colors[0]))
+        else:
+            self.fill((0, 0, 0))
+        self.pattern_step = (self.pattern_step + 1) % 2
+        self.last_update = current_time
+        return self.delay
+
+    def color_transition(self):
+        current_time = utime.ticks_ms()
+
+        # Check for hold duration first
+        if utime.ticks_diff(current_time, self.hold_start_time) < self.hold_duration:
+            # Still in hold phase, just display the current solid color
+            self.fill(self.apply_brightness(self.current_color))
+            self.last_update = current_time # Keep updating last_update to avoid skipping frames
+            return self.delay
+
+        # If hold duration is over, proceed with transition
+        if utime.ticks_diff(current_time, self.last_update) >= self.delay:
+            num_colors = len(self.colors)
+            if num_colors < 2:
+                # Should not happen if select handles it, but as a safeguard
+                self.select("on")
+                return self.delay
+
+            from_color = self.colors[self.current_color_idx]
+            to_color_idx = (self.current_color_idx + 1) % num_colors
+            to_color = self.colors[to_color_idx]
+
+            # Calculate interpolation factor (0.0 to 1.0)
+            # transition_step goes from 0 to transition_duration - 1
+            if self.transition_duration > 0:
+                interp_factor = self.transition_step / self.transition_duration
+            else:
+                interp_factor = 1.0 # Immediately transition if duration is zero
+
+            # Interpolate each color component
+            r = int(from_color[0] + (to_color[0] - from_color[0]) * interp_factor)
+            g = int(from_color[1] + (to_color[1] - from_color[1]) * interp_factor)
+            b = int(from_color[2] + (to_color[2] - from_color[2]) * interp_factor)
+
+            self.current_color = (r, g, b)
+            self.fill(self.apply_brightness(self.current_color))
+
+            self.transition_step += self.delay # Advance the transition step by the delay
+
+            if self.transition_step >= self.transition_duration:
+                # Transition complete, move to the next color and reset for hold phase
+                self.current_color_idx = to_color_idx
+                self.current_color = self.colors[self.current_color_idx] # Ensure current_color is the exact target color
+                self.transition_step = 0 # Reset transition progress
+                self.hold_start_time = current_time # Start hold phase for the new color
+
+            self.last_update = current_time
+        return self.delay
+
+    def flicker(self):
+        current_time = utime.ticks_ms()
+        base_color = self.colors[0]
+        # Increase the range for flicker_brightness_offset
+        # Changed from self.brightness // 4 to self.brightness // 2 (or even self.brightness for max intensity)
+        flicker_brightness_offset = random.randint(-int(self.brightness // 1.5), int(self.brightness // 1.5))
+        flicker_brightness = max(0, min(255, self.brightness + flicker_brightness_offset))
+
+        flicker_color = self.apply_brightness(base_color, brightness_override=flicker_brightness)
+        self.fill(flicker_color)
+        self.last_update = current_time
+        return max(1, int(self.delay // 5))
+
+    def scanner(self):
+        """
+        Mimics a 'Knight Rider' style scanner, moving in one direction.
+        """
+        current_time = utime.ticks_ms()
+        self.fill((0, 0, 0)) # Clear all LEDs
+
+        # Calculate the head and tail position
+        head_pos = self.pattern_step
+        color = self.apply_brightness(self.colors[0])
+
+        # Draw the head
+        if 0 <= head_pos < self.num_leds:
+            self.n[head_pos] = color
+
+        # Draw the trailing pixels with decreasing brightness
+        for i in range(1, self.scanner_tail_length + 1):
+            tail_pos = head_pos - i
+            if 0 <= tail_pos < self.num_leds:
+                # Calculate fading color for tail
+                # Example: linear fade from full brightness to off
+                fade_factor = 1.0 - (i / (self.scanner_tail_length + 1))
+                faded_color = tuple(int(c * fade_factor) for c in color)
+                self.n[tail_pos] = faded_color
+
+        self.n.write()
+
+        self.pattern_step += 1
+        if self.pattern_step >= self.num_leds + self.scanner_tail_length:
+            self.pattern_step = 0 # Reset to start
+
+        self.last_update = current_time
+        return self.delay
+
+    def bidirectional_scanner(self):
+        """
+        Mimics a 'Knight Rider' style scanner, moving back and forth.
+        """
+        current_time = utime.ticks_ms()
+        self.fill((0, 0, 0)) # Clear all LEDs
+
+        color = self.apply_brightness(self.colors[0])
+
+        # Calculate the head position based on direction
+        head_pos = self.pattern_step
+
+        # Draw the head
+        if 0 <= head_pos < self.num_leds:
+            self.n[head_pos] = color
+
+        # Draw the trailing pixels with decreasing brightness
+        for i in range(1, self.scanner_tail_length + 1):
+            tail_pos = head_pos - (i * self.scanner_direction)
+            if 0 <= tail_pos < self.num_leds:
+                fade_factor = 1.0 - (i / (self.scanner_tail_length + 1))
+                faded_color = tuple(int(c * fade_factor) for c in color)
+                self.n[tail_pos] = faded_color
+
+        self.n.write()
+
+        self.pattern_step += self.scanner_direction
+
+        # Change direction if boundaries are reached
+        if self.scanner_direction == 1 and self.pattern_step >= self.num_leds:
+            self.scanner_direction = -1
+            self.pattern_step = self.num_leds - 1 # Start moving back from the last LED
+        elif self.scanner_direction == -1 and self.pattern_step < 0:
+            self.scanner_direction = 1
+            self.pattern_step = 0 # Start moving forward from the first LED
+
+        self.last_update = current_time
+        return self.delay
+
+    def fill_range(self):
+        """
+        Fills a range of LEDs from n1 to n2 with a solid color.
+        If self.oneshot is True, it fills once and then turns off the LEDs.
+        """
+        current_time = utime.ticks_ms()
+        if self.oneshot and self.pattern_step >= 1:
+            self.fill((0, 0, 0)) # Turn off LEDs if one-shot already happened
+        else:
+            color = self.apply_brightness(self.colors[0])
+            for i in range(self.n1, self.n2 + 1):
+                self.n[i] = color
+            self.n.write()
+            self.last_update = current_time
+            return self.delay
+        self.last_update = current_time
+        return self.delay
+
+    def n_chase(self):
+        """
+        A theater chase pattern using n1 for on-width and n2 for off-width.
+        """
+        current_time = utime.ticks_ms()
+        segment_length = self.n1 + self.n2
+        if segment_length == 0: # Avoid division by zero
+            self.fill((0,0,0))
+            self.n.write()
+            self.last_update = current_time
+            return self.delay
+        
+        for i in range(self.num_leds):
+            if (i + self.pattern_step) % segment_length < self.n1:
+                self.n[i] = self.apply_brightness(self.colors[0])
+            else:
+                self.n[i] = (0, 0, 0)
+        self.n.write()
+        self.pattern_step = (self.pattern_step + 1) % segment_length
+        self.last_update = current_time
+        return self.delay
+
+    def alternating(self):
+        """
+        An alternating pattern where n1 LEDs are ON/OFF and n2 LEDs are OFF/ON globally, without moving.
+        """
+        current_time = utime.ticks_ms()
+        total_segment_length = self.n1 + self.n2
+        if total_segment_length == 0:
+            self.fill((0,0,0))
+            self.n.write()
+            self.last_update = current_time
+            return self.delay
+ 
+        # current_phase will alternate between 0 and 1
+        current_phase = self.pattern_step % 2
+ 
+        for i in range(self.num_leds):
+            # Position within a single repeating segment (n1 + n2)
+            pos_in_segment = i % total_segment_length
+ 
+            if current_phase == 0: # State 0: n1 ON, n2 OFF
+                if pos_in_segment < self.n1:
+                    self.n[i] = self.apply_brightness(self.colors[0]) # n1 is ON
+                else:
+                    self.n[i] = (0, 0, 0) # n2 is OFF
+            else: # State 1: n1 OFF, n2 ON
+                if pos_in_segment < self.n1:
+                    self.n[i] = (0, 0, 0) # n1 is OFF
+                else:
+                    self.n[i] = self.apply_brightness(self.colors[0]) # n2 is ON
+        
+        self.n.write()
+        self.pattern_step = (self.pattern_step + 1) % 2 # Toggle between 0 and 1
+        self.last_update = current_time
+        return self.delay * 2
+
+    def pulse(self):
+        if self.pattern_step == 0:
+            self.fill(self.apply_brightness(self.colors[0]))
+            self.pattern_step = 1
+
+            self.last_update = utime.ticks_ms()
+        if utime.ticks_diff(utime.ticks_ms(), self.last_update) > self.delay:
+            self.fill((0, 0, 0))
+            print(utime.ticks_diff(utime.ticks_ms(), self.last_update))
+            self.run = False
+        return self.delay
+
+
+if __name__ == "__main__":
+    import time 
+    from machine import WDT
+    wdt = WDT(timeout=2000)  # Enable watchdog with a 2 second timeout
+    p = Patterns(pin=4, num_leds=60, color1=(255,0,0), color2=(0,0,255), brightness=127, selected="off", delay=100)
+
+    print(p.colors, p.brightness)
+
+    tests = [
+        ("off", {"duration_ms": 500}),
+        ("on", {"duration_ms": 500}),
+        ("color_wipe", {"delay": 200, "duration_ms": 1000}),
+        ("rainbow_cycle", {"delay": 100, "duration_ms": 2500}),
+        ("theater_chase", {"on_width": 3, "off_width": 3, "delay": 1000, "duration_ms": 2500}),
+        ("blink", {"delay": 500, "duration_ms": 2000}),
+        ("color_transition", {"delay": 150, "colors": [(255,0,0),(0,255,0),(0,0,255)], "duration_ms": 5000}),
+        ("flicker", {"delay": 100, "duration_ms": 2000}),
+        ("scanner", {"delay": 150, "duration_ms": 2500}),
+        ("bidirectional_scanner", {"delay": 50, "duration_ms": 2500}),
+        ("fill_range", {"n1": 10, "n2": 20, "delay": 500, "duration_ms": 2000}),
+        ("n_chase", {"n1": 5, "n2": 5, "delay": 2000, "duration_ms": 2500}),
+        ("alternating", {"n1": 5, "n2": 5, "delay": 500, "duration_ms": 2500}),
+        ("pulse", {"delay": 100, "duration_ms": 700}),
+    ]
+
+
+    print("\n--- Running pattern self-test ---")
+    for name, cfg in tests:
+        print(f"\nPattern: {name}")
+        # apply simple config helpers
+        if "delay" in cfg:
+            p.set_delay(cfg["delay"])
+        if "on_width" in cfg:
+            p.set_on_width(cfg["on_width"]) 
+        if "off_width" in cfg:
+            p.set_off_width(cfg["off_width"]) 
+        if "n1" in cfg and "n2" in cfg:
+            p.set_fill_range(cfg["n1"], cfg["n2"]) 
+        if "colors" in cfg:
+            p.set_colors(cfg["colors"]) 
+
+        p.select(name)
+
+        # run per configured duration using absolute-scheduled tick(next_due_ms)
+        start = utime.ticks_ms()
+        duration_ms = cfg["duration_ms"]
+        delay = cfg.get("delay", 0)
+        next_due = utime.ticks_ms() - 1  # force immediate first call
+        while utime.ticks_diff(utime.ticks_ms(), start) < duration_ms:
+            delay = p.tick(delay)
+            wdt.feed()
+
+    print("\n--- Test routine finished ---")
+
+

src/boot.py

@@ -1,19 +1,9 @@
+import settings
 import wifi
-import time
 from settings import Settings
 
-print(wifi.ap('qwerty'))
+s = Settings()
 
-
-settings = Settings()
-ssid = settings.get('wifi', {}).get('ssid', None)
-password = settings.get('wifi', {}).get('password', None)
-ip = settings.get('wifi', {}).get('ip', None)
-gateway = settings.get('wifi', {}).get('gateway', None)
-
-for i in range(10):
-    config = wifi.connect(ssid, password, ip, gateway)
-    if config:
-        print(config)
-        break
-    time.sleep(0.1)
+name = s.get('name', 'led')
+password = s.get("ap_password", "")
+# wifi.ap(name, password)

src/main.py

@@ -1,54 +1,85 @@
-import asyncio
+
+import patterns
 from settings import Settings
 from web import web
 from patterns import Patterns
 import gc
 import utime
 import machine
-import ntptime
 import time
 import wifi
+import json
+from p2p import p2p
+import espnow
+import network
 
-
-async def main():
-
-    
-
+def main():
     settings = Settings()
-
-    patterns = Patterns(4, settings["num_leds"], selected=settings["selected_pattern"])
-    patterns.set_color1(tuple(int(settings["color1"][i:i+2], 16) for i in (1, 5, 3)))
-    patterns.set_color2(tuple(int(settings["color2"][i:i+2], 16) for i in (1, 5, 3)))
-    patterns.set_brightness(int(settings["brightness"]))
-    patterns.set_delay(int(settings["delay"]))
-
-    w = web(settings, patterns)
     print(settings)
-    # start the server in a bacakground task
-    print("Starting")
-    server = asyncio.create_task(w.start_server(host="0.0.0.0", port=80))
+
+    patterns = Patterns(settings["led_pin"], settings["num_leds"], selected="off")
+
+    sta_if = network.WLAN(network.STA_IF)
+    sta_if.active(True)
+
+    e = espnow.ESPNow()
+    e.config(rxbuf=1024)
+    e.active(True)
+    # Increase buffer size for 8-bar payloads (default 526 bytes might be too small)  # Set to 1KB to handle larger multi-bar payloads
+
     wdt = machine.WDT(timeout=10000)
-
-    async def tick():
-        while True:
-            patterns.tick()
-            await asyncio.sleep_ms(1)
-
-    asyncio.create_task(tick())
-
-    first = True
-
+    wdt.feed()
     while True:
-        #print(time.localtime())
-            
-        # gc.collect()
-        for i in range(60):
-            wdt.feed()      
-            await asyncio.sleep_ms(500)
+        # advance pattern based on its own returned schedule
+        # due = patterns.tick(due)
+        wdt.feed()
 
-    # cleanup before ending the application
-    await server
-
-asyncio.run(main())
+        # Drain all pending packets and only process the latest
+        last_msg = None
+        while True:
+            host, msg = e.recv(0)
+            if not msg:
+                break
+            last_msg = msg
 
+        if last_msg:
+            try:
+                data = json.loads(last_msg)
+                print(data)
+                defaults = data.get("d", {})
+                bar = data.get(settings.get("name"), {})
+                
+                # Check message type
+                message_type = defaults.get("t", "b")  # Default to beat if not specified
+                
+                # Always update parameters from message
+                param_mapping = {
+                    "br": "brightness",
+                    "dl": "delay", 
+                    "cl": "colors",
+                    "n1": "n1",
+                    "n2": "n2",
+                    "n3": "n3",
+                    "n4": "n4",
+                    "s": "step"
+                }
+                
+                # Iterate through values in bar and update parameters
+                print("Bar values:")
+                for key, value in bar.items():
+                    print(f"  {key}: {value}")
+                    
+                    # Update parameter if it exists in param_mapping
+                    if key in param_mapping:
+                        attr_name = param_mapping[key]
+                        current_value = getattr(patterns, attr_name)
+                        new_value = bar.get(key, defaults.get(key, current_value))
+                        setattr(patterns, attr_name, new_value)
+                
+                # Print received parameters
+            except Exception as ex:
+                print(f"Failed to load espnow data {last_msg}: {ex}")
+                continue
+        
 
+main()

src/patterns_base.py

@@ -0,0 +1,70 @@
+from machine import Pin
+from neopixel import NeoPixel
+import utime
+
+
+class PatternBase:
+    def __init__(self, pin, num_leds, color1=(0,0,0), color2=(0,0,0), brightness=127, selected="rainbow_cycle", delay=100):
+        self.n = NeoPixel(Pin(pin, Pin.OUT), num_leds)
+        self.num_leds = num_leds
+        self.pattern_step = 0
+        self.last_update = utime.ticks_ms()
+        self.delay = delay
+        self.brightness = brightness
+        self.patterns = {}
+        self.selected = selected
+        self.run = True
+        # Ensure colors list always starts with at least two for robust transition handling
+        self.colors = [color1, color2] if color1 != color2 else [color1, (255, 255, 255)] # Fallback if initial colors are same
+        if not self.colors: # Ensure at least one color exists
+            self.colors = [(0, 0, 0)]
+
+        self.transition_duration = delay * 50 # Default transition duration
+        self.hold_duration = delay * 10 # Default hold duration at each color
+        self.transition_step = 0 # Current step in the transition
+        self.current_color_idx = 0 # Index of the color currently being held/transitioned from
+        self.current_color = self.colors[self.current_color_idx] # The actual blended color
+
+        self.hold_start_time = utime.ticks_ms() # Time when the current color hold started
+
+        # New attributes for scanner patterns (moved from Patterns to PatternBase as they are generic enough)
+        self.scanner_direction = 1 # 1 for forward, -1 for backward
+        self.scanner_tail_length = 3 # Number of trailing pixels
+
+        # Store last pattern-returned delay to use for subsequent gating
+        self._last_returned_delay = None
+    def update_num_leds(self, pin, num_leds):
+        self.n = NeoPixel(Pin(pin, Pin.OUT), num_leds)
+        self.num_leds = num_leds
+
+    def set_color(self, num, color):
+        if 0 <= num < len(self.colors):
+           self.colors[num] = color
+        elif num == len(self.colors): # Allow setting a new color at the end
+            self.colors.append(color)
+            return True
+        return False
+
+    def del_color(self, num):
+        if 0 <= num < len(self.colors):
+           del self.colors[num]
+           return True
+        return False
+
+    def apply_brightness(self, color, brightness_override=None):
+        effective_brightness = brightness_override if brightness_override is not None else self.brightness
+        return tuple(int(c * effective_brightness / 255) for c in color)
+
+    def write(self):
+        self.n.write()
+
+    def fill(self, color=None):
+        fill_color = color if color is not None else self.colors[0]
+        self.n.fill(fill_color)
+        self.n.write()
+
+    def off(self):
+        self.fill((0, 0, 0))
+
+    def on(self):
+        self.fill(self.apply_brightness(self.colors[0]))

src/settings.py

@@ -1,4 +1,7 @@
 import json
+import wifi
+import ubinascii
+import machine
 
 class Settings(dict):
     SETTINGS_FILE = "/settings.json"
@@ -6,15 +9,14 @@ class Settings(dict):
     def __init__(self):
         super().__init__()
         self.load()  # Load settings from file during initialization
+        if self.get("color_order", "rgb") == "rbg": self.color_order = (1, 5, 3)
+        else: self.color_order = (1, 3, 5)
 
     def set_defaults(self):
-        self["num_leds"] = 50
-        self["selected_pattern"] = "blink"
-        self["color1"] = "#000f00"
-        self["color2"] = "#0f0000"
-        self["delay"] = 100
-        self["brightness"] = 100
-        self["wifi"] = {"ssid": "", "password": ""}
+        self["led_pin"] = 10
+        self["num_leds"] = 119
+        self["color_order"] = "rgb"
+        self["name"] = f"104"
 
     def save(self):
         try:
@@ -34,6 +36,73 @@ class Settings(dict):
         except Exception as e:
             print(f"Error loading settings")
             self.set_defaults()
+            self.save()
+
+    def set_settings(self, data, patterns, save):
+        try:
+            for key, value in data.items():
+                print(key, value)
+                if key == "colors":
+                    buff = []
+                    for color in value:
+                        buff.append(tuple(int(color[i:i+2], 16) for i in self.color_order))
+                    patterns.set_colors(buff)
+                elif key == "color1":
+                    patterns.set_color1(tuple(int(value[i:i+2], 16) for i in self.color_order))  # Convert hex to RGB
+                elif key == "color2":
+                    patterns.set_color2(tuple(int(value[i:i+2], 16) for i in self.color_order))  # Convert hex to RGB
+                elif key == "num_leds":
+                    patterns.update_num_leds(self["led_pin"], value)
+                elif key ==  "pattern":
+                    if not patterns.select(value):
+                        return "Pattern doesn't exist", 400
+                elif key == "delay":
+                    delay = int(data["delay"])
+                    patterns.set_delay(delay)
+                elif key == "brightness":
+                    brightness = int(data["brightness"])
+                    patterns.set_brightness(brightness)
+                elif key == "on_width":
+                    on_width = int(data["on_width"])
+                    patterns.set_on_width(on_width)
+                elif key == "off_width":
+                    off_width = int(data["off_width"])
+                    on_width = int(data.get("on_width", self["on_width"]))
+                    patterns.set_on_off_width(on_width, off_width)
+                elif key == "n1":
+                    n1 = int(data["n1"])
+                    n2 = int(data.get("n2", patterns.n2))
+                    patterns.set_fill_range(n1, n2)
+                elif key == "n2":
+                    n2 = int(data["n2"])
+                    n1 = int(data.get("n1", patterns.n1))
+                    patterns.set_fill_range(n1, n2)
+                elif key == "oneshot":
+                    oneshot_value = bool(data["oneshot"])
+                    patterns.set_oneshot(oneshot_value)
+                elif key == "name":
+                    self[key] = value
+                    self.save()
+                    machine.reset()
+                elif key == "color_order":
+                    if value == "rbg": self.color_order = (1, 5, 3)
+                    else: self.color_order = (1, 3, 5)
+                    pass
+                elif key == "id":
+                    pass
+                elif key == "led_pin":
+                    patterns.update_num_leds(value, self["num_leds"])
+                else:
+                    return "Invalid key", 400
+                self[key] = value
+            #print(self)
+            patterns.sync()
+            if save:
+                self.save()
+            return "OK", 200
+        except Exception as e:
+            print(f"An unexpected error occurred in set_settings: {e}")
+            return "Bad request", 400
 
 # Example usage
 def main():
@@ -42,12 +111,14 @@ def main():
     settings['num_leds'] = 100
     print(f"Updated number of LEDs: {settings['num_leds']}")
     settings.save()
-    
+
     # Create a new Settings object to test loading
     new_settings = Settings()
     print(f"Loaded number of LEDs: {new_settings['num_leds']}")
     print(settings)
 
+
+
 # Run the example
 if __name__ == "__main__":
-    main()
+    main()

src/static/main.css

@@ -1,75 +1,109 @@
 body {
-            font-family: Arial, sans-serif;
-            max-width: 600px;
-            margin: 0 auto;
-            padding: 20px;
-            line-height: 1.6;
-        }
-        h1 {
-            text-align: center;
-        }
-        
-        form {
-            margin-bottom: 20px;
-        }
-        label {
-            display: block;
-            margin-bottom: 5px;
-        }
-        input[type="text"], input[type="submit"], input[type="range"], input[type="color"] {
-            width: 100%;
-            
-            margin-bottom: 10px;
-            box-sizing: border-box;
-        }
-        input[type="range"] {
-            -webkit-appearance: none;
-            appearance: none;
-            height: 25px;
-            background: #d3d3d3;
-            outline: none;
-            opacity: 0.7;
-            transition: opacity .2s;
-        }
-        input[type="range"]:hover {
-            opacity: 1;
-        }
-        input[type="range"]::-webkit-slider-thumb {
-            -webkit-appearance: none;
-            appearance: none;
-            width: 25px;
-            height: 25px;
-            background: #4CAF50;
-            cursor: pointer;
-            border-radius: 50%;
-        }
-        input[type="range"]::-moz-range-thumb {
-            width: 25px;
-            height: 25px;
-            background: #4CAF50;
-            cursor: pointer;
-            border-radius: 50%;
-        }
-        #pattern_buttons {
-            display: flex;
-            flex-wrap: wrap;
-            gap: 10px;
-            margin-bottom: 20px;
-        }
-        #pattern_buttons button {
-            flex: 1 0 calc(33.333% - 10px);
-            padding: 10px;
-            background-color: #4CAF50;
-            color: white;
-            border: none;
-            cursor: pointer;
-            transition: background-color 0.3s;
-        }
-        #pattern_buttons button:hover {
-            background-color: #45a049;
-        }
-        @media (max-width: 480px) {
-            #pattern_buttons button {
-                flex: 1 0 calc(50% - 10px);
-            }
-        }
+    font-family: Arial, sans-serif;
+    max-width: 600px;
+    margin: 0 auto;
+    padding: 20px;
+    line-height: 1.6;
+}
+h1 {
+    text-align: center;
+}
+
+form {
+    margin-bottom: 20px;
+}
+label {
+    display: block;
+    margin-bottom: 5px;
+}
+input[type="text"],
+input[type="submit"],
+input[type="range"],
+input[type="color"] {
+    width: 100%;
+
+    margin-bottom: 10px;
+    box-sizing: border-box;
+}
+input[type="range"] {
+    -webkit-appearance: none;
+    appearance: none;
+    height: 25px;
+    background: #d3d3d3;
+    outline: none;
+    opacity: 0.7;
+    transition: opacity 0.2s;
+}
+input[type="range"]:hover {
+    opacity: 1;
+}
+input[type="range"]::-webkit-slider-thumb {
+    -webkit-appearance: none;
+    appearance: none;
+    width: 25px;
+    height: 25px;
+    background: #4caf50;
+    cursor: pointer;
+    border-radius: 50%;
+}
+input[type="range"]::-moz-range-thumb {
+    width: 25px;
+    height: 25px;
+    background: #4caf50;
+    cursor: pointer;
+    border-radius: 50%;
+}
+#pattern_buttons {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 10px;
+    margin-bottom: 20px;
+}
+#pattern_buttons button {
+    flex: 1 0 calc(33.333% - 10px);
+    padding: 10px;
+    background-color: #4caf50;
+    color: white;
+    border: none;
+    cursor: pointer;
+    transition: background-color 0.3s;
+}
+#pattern_buttons button:hover {
+    background-color: #45a049;
+}
+@media (max-width: 480px) {
+    #pattern_buttons button {
+        flex: 1 0 calc(50% - 10px);
+    }
+}
+#connection-status {
+    width: 15px;
+    height: 15px;
+    border-radius: 50%;
+    display: inline-block; /* Or block, depending on where you put it */
+    margin-left: 10px; /* Adjust spacing as needed */
+    vertical-align: middle; /* Align with nearby text */
+    background-color: grey; /* Default: Unknown */
+}
+
+#connection-status.connecting {
+    background-color: yellow;
+}
+
+#connection-status.open {
+    background-color: green;
+}
+
+#connection-status.closing,
+#connection-status.closed {
+    background-color: red;
+}
+
+#color_order_form label,
+#color_order_form input[type="radio"] {
+    /* Ensures they behave as inline elements */
+    display: inline-block;
+    /* Adds some space between them for readability */
+    margin-right: 10px;
+    vertical-align: middle; /* Aligns them nicely if heights vary */
+}

src/static/main.js

@@ -2,146 +2,243 @@ let delayTimeout;
 let brightnessTimeout;
 let colorTimeout;
 let color2Timeout;
+let ws; // Variable to hold the WebSocket connection
+let connectionStatusElement; // Variable to hold the connection status element
 
-async function post(path, data) {
-    console.log(`POST to ${path}`, data);
-    try {
-        const response = await fetch(path, {
-            method: "POST",
-            headers: {
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify(data) // Convert data to JSON string
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP error! Status: ${response.status}`);
-        }
-    } catch (error) {
-        console.error('Error during POST request:', error);
+// Function to update the connection status indicator
+function updateConnectionStatus(status) {
+  if (!connectionStatusElement) {
+    connectionStatusElement = document.getElementById("connection-status");
+  }
+  if (connectionStatusElement) {
+    connectionStatusElement.className = ""; // Clear existing classes
+    connectionStatusElement.classList.add(status);
+    // Optionally, you could also update text content based on status
+    // connectionStatusElement.textContent = status.charAt(0).toUpperCase() + status.slice(1);
+  }
+}
+
+// Function to establish WebSocket connection
+function connectWebSocket() {
+  // Determine the WebSocket URL based on the current location
+  const wsUrl = `ws://${window.location.host}/ws`;
+  ws = new WebSocket(wsUrl);
+
+  updateConnectionStatus("connecting"); // Indicate connecting state
+
+  ws.onopen = function (event) {
+    console.log("WebSocket connection opened:", event);
+    updateConnectionStatus("open"); // Indicate open state
+    // Optionally, you could send an initial message here
+  };
+
+  ws.onmessage = function (event) {
+    console.log("WebSocket message received:", event.data);
+  };
+
+  ws.onerror = function (event) {
+    console.error("WebSocket error:", event);
+    updateConnectionStatus("closed"); // Indicate error state (treat as closed)
+  };
+
+  ws.onclose = function (event) {
+    if (event.wasClean) {
+      console.log(
+        `WebSocket connection closed cleanly, code=${event.code}, reason=${event.reason}`,
+      );
+      updateConnectionStatus("closed"); // Indicate closed state
+    } else {
+      console.error("WebSocket connection died");
+      updateConnectionStatus("closed"); // Indicate closed state
     }
+    // Attempt to reconnect after a delay
+    setTimeout(connectWebSocket, 1000);
+  };
+}
+
+// Function to send data over WebSocket
+function sendWebSocketData(data) {
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    console.log("Sending data over WebSocket:", data);
+    ws.send(JSON.stringify(data));
+  } else {
+    console.error("WebSocket is not connected. Cannot send data:", data);
+    // You might want to queue messages or handle this in a different way
+  }
+}
+
+// Keep the post and get functions for now, they might still be useful
+async function post(path, data) {
+  console.log(`POST to ${path}`, data);
+  try {
+    const response = await fetch(path, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(data),
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error! Status: ${response.status}`);
+    }
+  } catch (error) {
+    console.error("Error during POST request:", error);
+  }
 }
 
 async function get(path) {
-    try {
-        const response = await fetch(path);
-        if (!response.ok) {
-            throw new Error(`HTTP error! Status: ${response.status}`);
-        }
-        return await response.json(); // Assuming you are expecting JSON response
-    } catch (error) {
-        console.error('Error during GET request:', error);
+  try {
+    const response = await fetch(path);
+    if (!response.ok) {
+      throw new Error(`HTTP error! Status: ${response.status}`);
     }
+    return await response.json();
+  } catch (error) {
+    console.error("Error during GET request:", error);
+  }
 }
 
 async function updateColor(event) {
-    event.preventDefault();
-    clearTimeout(colorTimeout);
-    colorTimeout = setTimeout(async function() {
-        const color = document.getElementById('color').value;
-        await post("/color", { color }); // Send as JSON
-    }, 500);
+  event.preventDefault();
+  clearTimeout(colorTimeout);
+  colorTimeout = setTimeout(function () {
+    const color = document.getElementById("color").value;
+    sendWebSocketData({ color1: color });
+  }, 500);
 }
 
 async function updateColor2(event) {
-    event.preventDefault();
-    clearTimeout(color2Timeout);
-    color2Timeout = setTimeout(async function() {
-        const color = document.getElementById('color2').value;
-        await post("/color2", { color }); // Send as JSON
-    }, 500);
+  event.preventDefault();
+  clearTimeout(color2Timeout);
+  color2Timeout = setTimeout(function () {
+    const color = document.getElementById("color2").value;
+    sendWebSocketData({ color2: color });
+  }, 500);
 }
 
 async function updatePattern(pattern) {
-    event.preventDefault();
-    await post("/pattern", { pattern }); // Send as JSON
+  sendWebSocketData({ pattern: pattern });
 }
 
 async function updateBrightness(event) {
-    event.preventDefault();
-    clearTimeout(brightnessTimeout);
-    brightnessTimeout = setTimeout(async function() {
-        const brightness = document.getElementById('brightness').value;
-        await post('/brightness', { brightness }); // Send as JSON
-    }, 500);
+  event.preventDefault();
+  clearTimeout(brightnessTimeout);
+  brightnessTimeout = setTimeout(function () {
+    const brightness = document.getElementById("brightness").value;
+    sendWebSocketData({ brightness: brightness });
+  }, 500);
 }
 
 async function updateDelay(event) {
-    event.preventDefault();
-    clearTimeout(delayTimeout);
-    delayTimeout = setTimeout(async function() {
-        const delay = document.getElementById('delay').value;
-        await post('/delay', { delay }); // Send as JSON
-    }, 500);
+  event.preventDefault();
+  clearTimeout(delayTimeout);
+  delayTimeout = setTimeout(function () {
+    const delay = document.getElementById("delay").value;
+    sendWebSocketData({ delay: delay });
+  }, 500);
 }
 
 async function updateNumLeds(event) {
-    event.preventDefault();
-    const numLeds = document.getElementById('num_leds').value;
-    await post('/num_leds', { num_leds: numLeds }); // Send as JSON
+  event.preventDefault();
+  const numLeds = document.getElementById("num_leds").value;
+  sendWebSocketData({ num_leds: parseInt(numLeds) });
 }
 
-async function updateWifi(event) {
-    event.preventDefault();
-    const ssid = document.getElementById('ssid').value;
-    const password = document.getElementById('password').value;
-    const ip = document.getElementById('ip').value;
-    const gateway = document.getElementById('gateway').value;
+async function updateName(event) {
+  event.preventDefault();
+  const name = document.getElementById("name").value;
+  sendWebSocketData({ name: name });
+}
 
-    const wifiSettings = { ssid, password, ip, gateway }; // Create JSON object
-    console.log(wifiSettings);
-    const response = await post('/wifi_settings', wifiSettings); // Send as JSON
-    if (response === 500) {
-        alert("Failed to connect to Wi-Fi");
-    }
+async function updateID(event) {
+  event.preventDefault();
+  const id = document.getElementById("id").value;
+  sendWebSocketData({ id: parseInt(id) });
+}
+
+async function updateLedPin(event) {
+  event.preventDefault();
+  const ledpin = document.getElementById("led_pin").value;
+  sendWebSocketData({ led_pin: parseInt(ledpin) });
+}
+
+function handleRadioChange(event) {
+  event.preventDefault();
+  console.log("Selected color order:", event.target.value);
+  // Add your specific logic here
+  if (event.target.value === "rgb") {
+    console.log("RGB order selected!");
+  } else if (event.target.value === "rbg") {
+    console.log("RBG order selected!");
+  }
+  sendWebSocketData({ color_order: event.target.value });
 }
 
 function createPatternButtons(patterns) {
-    const container = document.getElementById('pattern_buttons');
-    container.innerHTML = ''; // Clear previous buttons
+  const container = document.getElementById("pattern_buttons");
+  container.innerHTML = ""; // Clear previous buttons
 
-    patterns.forEach(pattern => {
-        const button = document.createElement('button');
-        button.type = 'button'; // Use 'button' instead of 'submit'
-        button.textContent = pattern;
-        button.value = pattern;
-        button.addEventListener('click', async function(event) {
-            event.preventDefault();
-            await updatePattern(pattern);
-        });
-        container.appendChild(button);
+  patterns.forEach((pattern) => {
+    const button = document.createElement("button");
+    button.type = "button";
+    button.textContent = pattern;
+    button.value = pattern;
+    button.addEventListener("click", async function (event) {
+      event.preventDefault();
+      await updatePattern(pattern);
     });
+    container.appendChild(button);
+  });
 }
 
-document.addEventListener('DOMContentLoaded', async function() {
-    document.getElementById('color').addEventListener('input', updateColor);
-    document.getElementById('color2').addEventListener('input', updateColor2);
-    document.getElementById('delay').addEventListener('input', updateDelay);
-    document.getElementById('brightness').addEventListener('input', updateBrightness);
-    document.getElementById('num_leds_form').addEventListener('submit', updateNumLeds);
-    document.getElementById('wifi_form').addEventListener('submit', updateWifi);
-    document.getElementById('delay').addEventListener('touchend', updateDelay);
-    document.getElementById('brightness').addEventListener('touchend', updateBrightness);
+document.addEventListener("DOMContentLoaded", async function () {
+  // Get the connection status element once the DOM is ready
+  connectionStatusElement = document.getElementById("connection-status");
 
-    document.querySelectorAll(".pattern_button").forEach(button => {
-        console.log(button.value);
-        button.addEventListener('click', async event => {
-            event.preventDefault();
-            await updatePattern(button.value);
-        });
-    });  
+  // Establish WebSocket connection on page load
+  connectWebSocket();
+
+  document.getElementById("color").addEventListener("input", updateColor);
+  document.getElementById("color2").addEventListener("input", updateColor2);
+  document.getElementById("delay").addEventListener("input", updateDelay);
+  document
+    .getElementById("brightness")
+    .addEventListener("input", updateBrightness);
+  document
+    .getElementById("num_leds_form")
+    .addEventListener("submit", updateNumLeds);
+  document.getElementById("name_form").addEventListener("submit", updateName);
+  document.getElementById("id_form").addEventListener("submit", updateID);
+  document
+    .getElementById("led_pin_form")
+    .addEventListener("submit", updateLedPin);
+  document.getElementById("delay").addEventListener("touchend", updateDelay);
+  document
+    .getElementById("brightness")
+    .addEventListener("touchend", updateBrightness);
+
+  document.getElementById("rgb").addEventListener("change", handleRadioChange);
+  document.getElementById("rbg").addEventListener("change", handleRadioChange);
+  document.querySelectorAll(".pattern_button").forEach((button) => {
+    console.log(button.value);
+    button.addEventListener("click", async (event) => {
+      event.preventDefault();
+      await updatePattern(button.value);
+    });
+  });
 });
 
 // Function to toggle the display of the settings menu
 function selectSettings() {
-    const settingsMenu = document.getElementById('settings_menu');
-    controls = document.getElementById('controls');
-    settingsMenu.style.display = 'block';
-    controls.style.display = 'none';
+  const settingsMenu = document.getElementById("settings_menu");
+  controls = document.getElementById("controls");
+  settingsMenu.style.display = "block";
+  controls.style.display = "none";
 }
 
 function selectControls() {
-    const settingsMenu = document.getElementById('settings_menu');
-    controls = document.getElementById('controls');
-    settingsMenu.style.display = 'none';
-    controls.style.display = 'block';
+  const settingsMenu = document.getElementById("settings_menu");
+  controls = document.getElementById("controls");
+  settingsMenu.style.display = "none";
+  controls.style.display = "block";
 }

src/templates/index.html

@@ -1,71 +1,124 @@
-{% args settings, patterns %}
-<!DOCTYPE html>
+{% args settings, patterns, mac %}
+<!doctype html>
 <html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>LED Control</title>
-    <script src="static/main.js"></script>
-    <link rel="stylesheet" href="static/main.css">
-</head>
-<body>
-    <h1>Control LEDs</h1>
-    <button onclick="selectControls()">Controls</button>
-    <button onclick="selectSettings()">Settings</button>
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>{{settings['name']}}</title>
+        <script src="static/main.js"></script>
+        <link rel="stylesheet" href="static/main.css" />
+    </head>
+    <body>
+        <h1>{{settings['name']}}</h1>
+        <button onclick="selectControls()">Controls</button>
+        <button onclick="selectSettings()">Settings</button>
 
-    <!-- Main LED Controls -->
-    <div id="controls">
-        <div id="pattern_buttons">
-            {% for p in patterns %}
-            <button class="pattern_button" value="{{p}}">{{p}}</button>
-            {% endfor %}
-           
-            <!-- Pattern buttons will be inserted here -->
+        <!-- Main LED Controls -->
+        <div id="controls">
+            <div id="pattern_buttons">
+                {% for p in patterns %}
+                <button class="pattern_button" value="{{p}}">{{p}}</button>
+                {% endfor %}
+
+                <!-- Pattern buttons will be inserted here -->
+            </div>
+            <form id="delay_form" method="post" action="/delay">
+                <label for="delay">Delay:</label>
+                <input
+                    type="range"
+                    id="delay"
+                    name="delay"
+                    min="1"
+                    max="1000"
+                    value="{{settings['delay']}}"
+                    step="10"
+                />
+            </form>
+            <form id="brightness_form" method="post" action="/brightness">
+                <label for="brightness">Brightness:</label>
+                <input
+                    type="range"
+                    id="brightness"
+                    name="brightness"
+                    min="0"
+                    max="100"
+                    value="{{settings['brightness']}}"
+                    step="1"
+                />
+            </form>
+            <form id="color_form" method="post" action="/color">
+                <input
+                    type="color"
+                    id="color"
+                    name="color"
+                    value="{{settings['color1']}}"
+                />
+            </form>
+            <form id="color2_form" method="post" action="/color2">
+                <input
+                    type="color"
+                    id="color2"
+                    name="color2"
+                    value="{{settings['color2']}}"
+                />
+            </form>
         </div>
-        <form id="delay_form" method="post" action="/delay">
-            <label for="delay">Delay:</label>
-            <input type="range" id="delay" name="delay" min="1" max="1000" value="{{settings['delay']}}" step="10">
-        </form>
-        <form id="brightness_form" method="post" action="/brightness">
-            <label for="brightness">Brightness:</label>
-            <input type="range" id="brightness" name="brightness" min="0" max="100" value="{{settings['brightness']}}" step="1">
-        </form>
-        <form id="color_form" method="post" action="/color">
-            <input type="color" id="color" name="color" value="{{settings['color1']}}">
-        </form>
-        <form id="color2_form" method="post" action="/color2">
-            <input type="color" id="color2" name="color2" value="{{settings['color2']}}">
-        </form>
-    </div>
 
-    <!-- Settings Menu for num_leds, Wi-Fi SSID, and Password -->
-    
-    <div id="settings_menu" style="display: none;">
-        <h2>Settings</h2>
-        
-        <!-- Separate form for submitting num_leds -->
-        <form id="num_leds_form" method="post" action="/num_leds">
-            <label for="num_leds">Number of LEDs:</label>
-            <input type="text" id="num_leds" name="num_leds" value="{{settings['num_leds']}}">
-            <input type="submit" value="Update Number of LEDs">
-        </form>
+        <!-- Settings Menu for num_leds, Wi-Fi SSID, and Password -->
 
-        <!-- Form for Wi-Fi SSID and password -->
-        <form id="wifi_form" method="post" action="/wifi_settings">
-            <label for="ssid">Wi-Fi SSID:</label>
-            <input type="text" id="ssid" name="ssid" value="{{settings['wifi']['ssid']}}">
-            <br>
-            <label for="password">Wi-Fi Password:</label>
-            <input type="password" id="password" name="password">
-            <br>
-            <label for="ip">Wi-Fi IP:</label>
-            <input type="ip" id="ip" name="ip" value="{{settings.get('wifi', {}).get('ip', '')}}">
-            <br>
-            <label for="gateway">Wi-Fi Gateway:</label>
-            <input type="gateway" id="gateway" name="gateway" value="{{settings.get('wifi', {}).get('gateway', '')}}">
-            <br>
-            <input type="submit" value="Save Wi-Fi Settings">
-        </form>
-    </div>
-</body>
+        <div id="settings_menu" style="display: none">
+            <h2>Settings</h2>
+
+            <form id="name_form" method="post" action="/name">
+                <label for="name">Name:</label>
+                <input
+                    type="text"
+                    id="name"
+                    name="num_leds"
+                    value="{{settings['name']}}"
+                />
+                <input type="submit" value="Update Name" />
+            </form>
+            <form id="id_form" method="post" action="/id">
+                <label for="id">ID:</label>
+                <input
+                    type="text"
+                    id="id"
+                    name="id"
+                    value="{{settings['id']}}"
+                />
+                <input type="submit" value="Update ID" />
+            </form>
+            <!-- Separate form for submitting num_leds -->
+            <form id="num_leds_form" method="post" action="/num_leds">
+                <label for="num_leds">Number of LEDs:</label>
+                <input
+                    type="text"
+                    id="num_leds"
+                    name="num_leds"
+                    value="{{settings['num_leds']}}"
+                />
+                <input type="submit" value="Update Number of LEDs" />
+            </form>
+            <form id="led_pin_form" method="post" action="/led_pin">
+                <label for="num_leds">Led pin:</label>
+                <input
+                    type="text"
+                    id="led_pin"
+                    name="led_pin"
+                    value="{{settings['led_pin']}}"
+                />
+                <input type="submit" value="Update Led Pin" />
+            </form>
+            <form id="color_order_form">
+                <label for="rgb">RGB:</label>
+                <input type="radio" id="rgb" name="color_order" value="rgb" {{'checked' if settings["color_order"]=="rgb" else ''}} />
+                <label for="rbg">RBG</label>
+                <input type="radio" id="rbg" name="color_order" value="rbg" {{'checked' if settings["color_order"]=="rbg" else ''}}/>
+            </form>
+
+            <p>Mac address: {{mac}}</p>
+        </div>
+        <div id="connection-status"></div>
+    </body>
 </html>

src/templates/index_html.py

@@ -1,94 +0,0 @@
-# Autogenerated file
-def render(settings, patterns):
-    yield """<!DOCTYPE html>
-<html lang=\"en\">
-<head>
-    <meta charset=\"UTF-8\">
-    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">
-    <title>LED Control</title>
-    <script src=\"static/main.js\"></script>
-    <link rel=\"stylesheet\" href=\"static/main.css\">
-</head>
-<body>
-    <h1>Control LEDs</h1>
-    <button onclick=\"selectControls()\">Controls</button>
-    <button onclick=\"selectSettings()\">Settings</button>
-
-    <!-- Main LED Controls -->
-    <div id=\"controls\">
-        <div id=\"pattern_buttons\">
-            """
-    for p in patterns:
-        yield """            <button class=\"pattern_button\" value=\""""
-        yield str(p)
-        yield """\">"""
-        yield str(p)
-        yield """</button>
-            """
-    yield """           
-            <!-- Pattern buttons will be inserted here -->
-        </div>
-        <form id=\"delay_form\" method=\"post\" action=\"/delay\">
-            <label for=\"delay\">Delay:</label>
-            <input type=\"range\" id=\"delay\" name=\"delay\" min=\"1\" max=\"1000\" value=\""""
-    yield str(settings['delay'])
-    yield """\" step=\"10\">
-        </form>
-        <form id=\"brightness_form\" method=\"post\" action=\"/brightness\">
-            <label for=\"brightness\">Brightness:</label>
-            <input type=\"range\" id=\"brightness\" name=\"brightness\" min=\"0\" max=\"100\" value=\""""
-    yield str(settings['brightness'])
-    yield """\" step=\"1\">
-        </form>
-        <form id=\"color_form\" method=\"post\" action=\"/color\">
-            <input type=\"color\" id=\"color\" name=\"color\" value=\""""
-    yield str(settings['color1'])
-    yield """\">
-        </form>
-        <form id=\"color2_form\" method=\"post\" action=\"/color2\">
-            <input type=\"color\" id=\"color2\" name=\"color2\" value=\""""
-    yield str(settings['color2'])
-    yield """\">
-        </form>
-    </div>
-
-    <!-- Settings Menu for num_leds, Wi-Fi SSID, and Password -->
-    
-    <div id=\"settings_menu\" style=\"display: none;\">
-        <h2>Settings</h2>
-        
-        <!-- Separate form for submitting num_leds -->
-        <form id=\"num_leds_form\" method=\"post\" action=\"/num_leds\">
-            <label for=\"num_leds\">Number of LEDs:</label>
-            <input type=\"text\" id=\"num_leds\" name=\"num_leds\" value=\""""
-    yield str(settings['num_leds'])
-    yield """\">
-            <input type=\"submit\" value=\"Update Number of LEDs\">
-        </form>
-
-        <!-- Form for Wi-Fi SSID and password -->
-        <form id=\"wifi_form\" method=\"post\" action=\"/wifi_settings\">
-            <label for=\"ssid\">Wi-Fi SSID:</label>
-            <input type=\"text\" id=\"ssid\" name=\"ssid\" value=\""""
-    yield str(settings['wifi']['ssid'])
-    yield """\">
-            <br>
-            <label for=\"password\">Wi-Fi Password:</label>
-            <input type=\"password\" id=\"password\" name=\"password\">
-            <br>
-            <label for=\"ip\">Wi-Fi IP:</label>
-            <input type=\"ip\" id=\"ip\" name=\"ip\" value=\""""
-    yield str(settings.get('wifi', {}).get('ip', ''))
-    yield """\">
-            <br>
-            <label for=\"gateway\">Wi-Fi Gateway:</label>
-            <input type=\"gateway\" id=\"gateway\" name=\"gateway\" value=\""""
-    yield str(settings.get('wifi', {}).get('gateway', ''))
-    yield """\">
-            <br>
-            <input type=\"submit\" value=\"Save Wi-Fi Settings\">
-        </form>
-    </div>
-</body>
-</html>
-"""

src/web.py

@@ -1,135 +1,43 @@
 from microdot import Microdot, send_file, Response
 from microdot.utemplate import Template
 from microdot.websocket import with_websocket
-
-import json
+import machine
 import wifi
+import json
 
 def web(settings, patterns):
     app = Microdot()
     Response.default_content_type = 'text/html'
 
     @app.route('/')
-    async def index(request):
-        return Template('/index.html').render(settings=settings, patterns=patterns.patterns.keys())
+    async def index_hnadler(request):
+        mac = wifi.get_mac().hex()
+        return Template('/index.html').render(settings=settings, patterns=patterns.patterns.keys(), mac=mac)
 
     @app.route("/static/<path:path>")
-    def static(request, path):
+    def static_handler(request, path):
         if '..' in path:
             # Directory traversal is not allowed
             return 'Not found', 404
         return send_file('static/' + path)
 
-    @app.post("/num_leds")
-    def num_leds(request):
-        try:
-            data = json.loads(request.body.decode('utf-8'))
-            num_leds = int(data["num_leds"])
-            patterns.update_num_leds(4, num_leds)
-            settings["num_leds"] = num_leds
-            settings.save()
-            return "OK", 200
-        except (ValueError, KeyError, json.JSONDecodeError):
-            return "Bad request", 400
+    @app.post("/settings")
+    def settings_handler(request):
+        # Keep the POST handler for compatibility or alternative usage if needed
+        # For WebSocket updates, the /ws handler is now primary
+        return settings.set_settings(request.body.decode('utf-8'), patterns)
 
-    @app.post("/pattern")
-    def pattern(request):
-        try:
-            data = json.loads(request.body.decode('utf-8'))
-            pattern = data["pattern"]
-            if patterns.select(pattern):
-                settings["selected_pattern"] = pattern
-                settings.save()
-                return "OK", 200
-            else:
-                return "Bad request", 400
-        except (KeyError, json.JSONDecodeError):
-            return "Bad request", 400
-
-    @app.post("/delay")
-    def delay(request):
-        try:
-            data = json.loads(request.body.decode('utf-8'))
-            delay = int(data["delay"])
-            patterns.set_delay(delay)
-            settings["delay"] = delay
-            settings.save()
-            return "OK", 200
-        except (ValueError, KeyError, json.JSONDecodeError):
-            return "Bad request", 400
-
-    @app.post("/brightness")
-    def brightness(request):
-        try:
-            data = json.loads(request.body.decode('utf-8'))
-            brightness = int(data["brightness"])
-            patterns.set_brightness(brightness)
-            settings["brightness"] = brightness
-            settings.save()
-            return "OK", 200
-        except (ValueError, KeyError, json.JSONDecodeError):
-            return "Bad request", 400
-
-    @app.post("/color")          
-    def color(request):
-        try:
-            data = json.loads(request.body.decode('utf-8'))
-            color = data["color"]
-            patterns.set_color1(tuple(int(color[i:i+2], 16) for i in (1, 3, 5)))  # Convert hex to RGB
-            settings["color1"] = color
-            settings.save()
-            return "OK", 200
-        except (KeyError, json.JSONDecodeError, ValueError):
-            return "Bad request", 400
-
-    @app.post("/color2")          
-    def color2(request):
-        try:
-            data = json.loads(request.body.decode('utf-8'))
-            color = data["color2"]
-            patterns.set_color2(tuple(int(color[i:i+2], 16) for i in (1, 3, 5)))  # Convert hex to RGB
-            settings["color2"] = color
-            settings.save()
-            return "OK", 200
-        except (KeyError, json.JSONDecodeError, ValueError):
-            return "Bad request", 400
-
-
-    @app.post("/wifi_settings")          
-    def wifi_settings(request):
-        try:
-            data = json.loads(request.body.decode('utf-8'))
-            print(data)
-            ssid = settings['wifi']['ssid'] = data['ssid']
-            password = settings['wifi']['password'] = data.get('password', settings['wifi']['password'])
-            ip = settings['wifi']['ip'] = data.get('ip', None)
-            gateway = settings['wifi']['gateway'] = data.get('gateway', None)
-            print(settings)
-            
-            if config := wifi.connect(ssid, password, ip, gateway):
-                print(config)
-                settings.save()
-
-            return "OK", 200
-        except Exception as e:
-            print(f"Wifi {e}")
-            return "Bad request", 400
-
-
-    @app.post("/sync")
-    def sync(request):
-        patterns.sync()
-        return "OK", 200
-
-    @app.route("/external")
+    @app.route("/ws")
     @with_websocket
     async def ws(request, ws):
-        patterns.select("external")
         while True:
             data = await ws.receive()
-            print(data)
-            for i in range(min(patterns.num_leds, int(len(data)/3))):
-                patterns.set(i, (data[i*3], data[i*3+1], data[i*3+2]))
-            patterns.write()
+            if data:
+
+                # Process the received data
+                _, status_code = settings.set_settings(json.loads(data), patterns, True)
+                #await ws.send(status_code)
+            else:
+                break
 
     return app

src/wifi.py

@@ -1,18 +1,16 @@
 import network
-from machine import Pin
 from time import sleep
-import ubinascii
-from settings import Settings
 
 def connect(ssid, password, ip, gateway):
-    if ssid is None or password is None:
-        print("Missing ssid or password")
-        return None
+
     try:
         sta_if = network.WLAN(network.STA_IF)
-        if ip is not None and gateway is not None:
-            sta_if.ifconfig((ip, '255.255.255.0', gateway, '1.1.1.1'))
         if not sta_if.isconnected():
+            if ssid == "" or password == "":
+                print("Missing ssid or password")
+                return None
+            if ip != "" and gateway != "":
+                sta_if.ifconfig((ip, '255.255.255.0', gateway, '1.1.1.1'))
             print('connecting to network...')
             sta_if.active(True)
             sta_if.connect(ssid, password)
@@ -26,21 +24,16 @@ def connect(ssid, password, ip, gateway):
         return None
 
 
-def ap(password):
+def ap(ssid, password):
     ap_if = network.WLAN(network.AP_IF)
     ap_mac = ap_if.config('mac')
-    ssid = f"led-{ubinascii.hexlify(ap_mac).decode()}"
     print(ssid)
     ap_if.active(True)
-    ap_if.config(essid=ssid, password="qwerty1234")
+    ap_if.config(essid=ssid, password=password)
     ap_if.active(False)
     ap_if.active(True)
     print(ap_if.ifconfig())
 
-
-
-
-
-
-
-
+def get_mac():
+    ap_if = network.WLAN(network.AP_IF)
+    return ap_if.config('mac')

test/blink.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+Test script for blink pattern
+Run with: mpremote run test/blink.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+def test_blink():
+    print("Testing blink pattern...")
+    
+    # Initialize watchdog timer
+    wdt = WDT(timeout=10000)  # 10 second timeout
+    wdt.feed()
+    
+    # Load settings
+    settings = Settings()
+    
+    # Initialize patterns using settings
+    p = patterns.Patterns(
+        pin=settings["led_pin"], 
+        num_leds=settings["num_leds"],  # Set to 200 LEDs for test
+        brightness=255,  # Full brightness
+        delay=500
+    )
+    
+    # Set a bright red color
+    p.colors = [(255, 0, 0)]  # Red
+    
+    print(f"LED Pin: {settings['led_pin']}")
+    print(f"LEDs: {p.num_leds} (test override: 200)")
+    print(f"Brightness: {p.brightness}")
+    print(f"Delay: {p.delay}ms")
+    print(f"Color: {p.colors[0]}")
+    
+    # Test blink pattern
+    print("Starting blink pattern for 5 seconds...")
+    p.select("bl")
+    
+    # Let it run for 5 seconds with WDT feeding
+    start_time = utime.ticks_ms()
+    while utime.ticks_diff(utime.ticks_ms(), start_time) < 5000:
+        wdt.feed()
+        utime.sleep_ms(100)
+    
+    # Stop the pattern
+    p.run = False
+    print("Blink test completed")
+    
+    # Turn off LEDs
+    p.off()
+    print("LEDs turned off")
+
+if __name__ == "__main__":
+    test_blink()

test/circle/1.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+Circle loading test 1: n1=50, n2=100, n3=200, n4=0 (Red)
+Runs forever
+Run with: mpremote run test/circle/1.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Circle Loading Test 1: n1=50, n2=100, n3=200, n4=0 (Red)")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=2000
+)
+
+# Configure test parameters
+p.n1 = 50   # Head moves 50 LEDs/second
+p.n2 = 100  # Max length 100 LEDs
+p.n3 = 200  # Tail moves 200 LEDs/second
+p.n4 = 0    # Min length 0 LEDs
+p.colors = [(255, 0, 0)]  # Red
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Parameters: n1={p.n1}, n2={p.n2}, n3={p.n3}, n4={p.n4}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("cl")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/circle/2.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+Circle loading test 2: n1=10, n2=30, n3=20, n4=5 (Green)
+Runs forever
+Run with: mpremote run test/circle/2.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Circle Loading Test 2: n1=10, n2=30, n3=20, n4=5 (Green)")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=2000
+)
+
+# Configure test parameters
+p.n1 = 10   # Head moves 10 LEDs/second
+p.n2 = 30   # Max length 30 LEDs
+p.n3 = 20   # Tail moves 20 LEDs/second
+p.n4 = 5    # Min length 5 LEDs
+p.colors = [(0, 255, 0)]  # Green
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Parameters: n1={p.n1}, n2={p.n2}, n3={p.n3}, n4={p.n4}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("cl")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/circle/3.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+Circle loading test 3: n1=15, n2=25, n3=15, n4=3 (Blue)
+Runs forever
+Run with: mpremote run test/circle/3.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Circle Loading Test 3: n1=15, n2=25, n3=15, n4=3 (Blue)")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=2000
+)
+
+# Configure test parameters
+p.n1 = 15   # Head moves 15 LEDs/second
+p.n2 = 25   # Max length 25 LEDs
+p.n3 = 15   # Tail moves 15 LEDs/second
+p.n4 = 3    # Min length 3 LEDs
+p.colors = [(0, 0, 255)]  # Blue
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Parameters: n1={p.n1}, n2={p.n2}, n3={p.n3}, n4={p.n4}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("cl")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/circle/4.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+Circle loading test 4: n1=30, n2=40, n3=5, n4=8 (Yellow)
+Runs forever
+Run with: mpremote run test/circle/4.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Circle Loading Test 4: n1=30, n2=40, n3=5, n4=8 (Yellow)")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=2000
+)
+
+# Configure test parameters
+p.n1 = 30   # Head moves 30 LEDs/second
+p.n2 = 40   # Max length 40 LEDs
+p.n3 = 5    # Tail moves 5 LEDs/second
+p.n4 = 8    # Min length 8 LEDs
+p.colors = [(255, 255, 0)]  # Yellow
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Parameters: n1={p.n1}, n2={p.n2}, n3={p.n3}, n4={p.n4}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("cl")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/circle/5.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+Circle loading test 5: n1=25, n2=60, n3=30, n4=2 (Magenta)
+Runs forever
+Run with: mpremote run test/circle/5.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Circle Loading Test 5: n1=25, n2=60, n3=30, n4=2 (Magenta)")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=2000
+)
+
+# Configure test parameters
+p.n1 = 25   # Head moves 25 LEDs/second
+p.n2 = 60   # Max length 60 LEDs
+p.n3 = 30   # Tail moves 30 LEDs/second
+p.n4 = 2    # Min length 2 LEDs
+p.colors = [(255, 0, 255)]  # Magenta
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Parameters: n1={p.n1}, n2={p.n2}, n3={p.n3}, n4={p.n4}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("cl")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/circle/6.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+Circle loading test 6: n1=5, n2=20, n3=40, n4=1 (Cyan)
+Runs forever
+Run with: mpremote run test/circle/6.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Circle Loading Test 6: n1=5, n2=20, n3=40, n4=1 (Cyan)")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=2000
+)
+
+# Configure test parameters
+p.n1 = 5    # Head moves 5 LEDs/second
+p.n2 = 20   # Max length 20 LEDs
+p.n3 = 40   # Tail moves 40 LEDs/second
+p.n4 = 1    # Min length 1 LED
+p.colors = [(0, 255, 255)]  # Cyan
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Parameters: n1={p.n1}, n2={p.n2}, n3={p.n3}, n4={p.n4}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("cl")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/circle/7.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+Circle loading test 7: n1=12, n2=15, n3=18, n4=4 (Orange)
+Runs forever
+Run with: mpremote run test/circle/7.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Circle Loading Test 7: n1=12, n2=15, n3=18, n4=4 (Orange)")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=2000
+)
+
+# Configure test parameters
+p.n1 = 12   # Head moves 12 LEDs/second
+p.n2 = 15   # Max length 15 LEDs
+p.n3 = 18   # Tail moves 18 LEDs/second
+p.n4 = 4    # Min length 4 LEDs
+p.colors = [(255, 128, 0)]  # Orange
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Parameters: n1={p.n1}, n2={p.n2}, n3={p.n3}, n4={p.n4}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("cl")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/circle/8.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+Circle loading test 8: n1=100, n2=50, n3=150, n4=10 (Purple)
+Runs forever
+Run with: mpremote run test/circle/8.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Circle Loading Test 8: n1=100, n2=50, n3=150, n4=10 (Purple)")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=2000
+)
+
+# Configure test parameters
+p.n1 = 100  # Head moves 100 LEDs/second
+p.n2 = 50   # Max length 50 LEDs
+p.n3 = 150  # Tail moves 150 LEDs/second
+p.n4 = 10   # Min length 10 LEDs
+p.colors = [(128, 0, 255)]  # Purple
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Parameters: n1={p.n1}, n2={p.n2}, n3={p.n3}, n4={p.n4}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("cl")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/circle_loading.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""
+Test script for circle loading pattern with multiple test cases
+Run with: mpremote run test/circle_loading.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+def run_test_case(p, test_name, duration_ms=5000):
+    """Run a test case for specified duration"""
+    print(f"\n--- {test_name} ---")
+    print(f"Parameters: n1={p.n1} head/sec, n2={p.n2} max length, n3={p.n3} tail/sec, n4={p.n4} min length")
+    print(f"Color: {p.colors[0]}")
+    print(f"Running for {duration_ms//1000} seconds...")
+    
+    # Initialize watchdog timer
+    wdt = WDT(timeout=10000)
+    wdt.feed()
+    
+    # Start pattern
+    p.select("cl")
+    
+    # Run for specified duration
+    start_time = utime.ticks_ms()
+    while utime.ticks_diff(utime.ticks_ms(), start_time) < duration_ms:
+        wdt.feed()
+        utime.sleep_ms(100)
+    
+    # Stop pattern
+    p.run = False
+    print(f"{test_name} completed")
+    
+    # Brief pause between tests
+    utime.sleep_ms(500)
+
+def test_circle_loading():
+    print("Testing circle loading pattern with multiple configurations...")
+    
+    # Load settings
+    settings = Settings()
+    
+    # Initialize patterns using settings
+    p = patterns.Patterns(
+        pin=settings["led_pin"], 
+        num_leds=settings["num_leds"], 
+        brightness=255,
+        delay=2000  # Base cycle time
+    )
+    
+    print(f"LED Pin: {settings['led_pin']}")
+    print(f"LEDs: {settings['num_leds']}")
+    print(f"Brightness: {p.brightness}")
+    
+    # Test Case 1: Your specified parameters
+    p.n1 = 50 
+    p.n2 = 100
+    p.n3 = 200
+    p.n4 = 0  
+    p.colors = [(255, 0, 0)]  # Red
+    run_test_case(p, "Test 1: n1=50, n2=100, n3=200, n4=0", 15000)
+    
+    # Test Case 2: Slow head, fast tail
+    p.n1 = 10  # Head moves 10 LEDs/second
+    p.n2 = 30  # Max length 30 LEDs
+    p.n3 = 20  # Tail moves 20 LEDs/second
+    p.n4 = 5   # Min length 5 LEDs
+    p.colors = [(0, 255, 0)]  # Green
+    run_test_case(p, "Test 2: n1=10, n2=30, n3=20, n4=5", 10000)
+    
+    # Test Case 3: Equal head and tail speed
+    p.n1 = 15  # Head moves 15 LEDs/second
+    p.n2 = 25  # Max length 25 LEDs
+    p.n3 = 15  # Tail moves 15 LEDs/second
+    p.n4 = 3   # Min length 3 LEDs
+    p.colors = [(0, 0, 255)]  # Blue
+    run_test_case(p, "Test 3: n1=15, n2=25, n3=15, n4=3", 8000)
+    
+    # Test Case 4: Very fast head, slow tail
+    p.n1 = 30  # Head moves 30 LEDs/second
+    p.n2 = 40  # Max length 40 LEDs
+    p.n3 = 5   # Tail moves 5 LEDs/second
+    p.n4 = 8   # Min length 8 LEDs
+    p.colors = [(255, 255, 0)]  # Yellow
+    run_test_case(p, "Test 4: n1=30, n2=40, n3=5, n4=8", 12000)
+    
+    # Test Case 5: Long segment, fast cycle
+    p.n1 = 25  # Head moves 25 LEDs/second
+    p.n2 = 60  # Max length 60 LEDs
+    p.n3 = 30  # Tail moves 30 LEDs/second
+    p.n4 = 2   # Min length 2 LEDs
+    p.colors = [(255, 0, 255)]  # Magenta
+    run_test_case(p, "Test 5: n1=25, n2=60, n3=30, n4=2", 10000)
+    
+    # Test Case 6: Very slow head, very fast tail
+    p.n1 = 5   # Head moves 5 LEDs/second
+    p.n2 = 20  # Max length 20 LEDs
+    p.n3 = 40  # Tail moves 40 LEDs/second
+    p.n4 = 1   # Min length 1 LED
+    p.colors = [(0, 255, 255)]  # Cyan
+    run_test_case(p, "Test 6: n1=5, n2=20, n3=40, n4=1", 8000)
+    
+    # Test Case 7: Medium speeds, short segment
+    p.n1 = 12  # Head moves 12 LEDs/second
+    p.n2 = 15  # Max length 15 LEDs
+    p.n3 = 18  # Tail moves 18 LEDs/second
+    p.n4 = 4   # Min length 4 LEDs
+    p.colors = [(255, 128, 0)]  # Orange
+    run_test_case(p, "Test 7: n1=12, n2=15, n3=18, n4=4", 6000)
+    
+    # Test Case 8: Ultra fast everything
+    p.n1 = 100 # Head moves 100 LEDs/second
+    p.n2 = 50  # Max length 50 LEDs
+    p.n3 = 150 # Tail moves 150 LEDs/second
+    p.n4 = 10  # Min length 10 LEDs
+    p.colors = [(128, 0, 255)]  # Purple
+    run_test_case(p, "Test 8: n1=100, n2=50, n3=150, n4=10", 5000)
+    
+    print("\n=== All tests completed ===")
+    
+    # Turn off LEDs
+    p.off()
+    print("LEDs turned off")
+
+if __name__ == "__main__":
+    test_circle_loading()

test/flicker/1.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Flicker test 1: Red, delay=50ms, min brightness=50
+Runs forever
+Run with: mpremote run test/flicker/1.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Flicker Test 1: Red, delay=50ms, min brightness=50")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=50
+)
+
+# Configure test parameters
+p.n1 = 50   # Min brightness 50
+p.colors = [(255, 0, 0)]  # Red
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Min brightness: {p.n1}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("fl")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/flicker/2.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Flicker test 2: Green, delay=100ms, min brightness=100
+Runs forever
+Run with: mpremote run test/flicker/2.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Flicker Test 2: Green, delay=100ms, min brightness=100")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=100
+)
+
+# Configure test parameters
+p.n1 = 100  # Min brightness 100
+p.colors = [(0, 255, 0)]  # Green
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Min brightness: {p.n1}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("fl")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/flicker/3.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Flicker test 3: Blue, delay=200ms, min brightness=20
+Runs forever
+Run with: mpremote run test/flicker/3.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Flicker Test 3: Blue, delay=200ms, min brightness=20")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=200
+)
+
+# Configure test parameters
+p.n1 = 20   # Min brightness 20
+p.colors = [(0, 0, 255)]  # Blue
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Min brightness: {p.n1}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("fl")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/flicker/4.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Flicker test 4: White, delay=80ms, min brightness=150
+Runs forever
+Run with: mpremote run test/flicker/4.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Flicker Test 4: White, delay=80ms, min brightness=150")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=80
+)
+
+# Configure test parameters
+p.n1 = 150  # Min brightness 150
+p.colors = [(255, 255, 255)]  # White
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Min brightness: {p.n1}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("fl")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/flicker/5.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Flicker test 5: Yellow, delay=150ms, min brightness=30
+Runs forever
+Run with: mpremote run test/flicker/5.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Flicker Test 5: Yellow, delay=150ms, min brightness=30")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=150
+)
+
+# Configure test parameters
+p.n1 = 30   # Min brightness 30
+p.colors = [(255, 255, 0)]  # Yellow
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Min brightness: {p.n1}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("fl")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/flicker/6.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Flicker test 6: Magenta, delay=60ms, min brightness=80
+Runs forever
+Run with: mpremote run test/flicker/6.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Flicker Test 6: Magenta, delay=60ms, min brightness=80")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=60
+)
+
+# Configure test parameters
+p.n1 = 80   # Min brightness 80
+p.colors = [(255, 0, 255)]  # Magenta
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Min brightness: {p.n1}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("fl")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/flicker/7.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Flicker test 7: Cyan, delay=120ms, min brightness=5
+Runs forever
+Run with: mpremote run test/flicker/7.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Flicker Test 7: Cyan, delay=120ms, min brightness=5")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=120
+)
+
+# Configure test parameters
+p.n1 = 5    # Min brightness 5
+p.colors = [(0, 255, 255)]  # Cyan
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Min brightness: {p.n1}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("fl")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/flicker/8.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Flicker test 8: Orange, delay=40ms, min brightness=180
+Runs forever
+Run with: mpremote run test/flicker/8.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Flicker Test 8: Orange, delay=40ms, min brightness=180")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=40
+)
+
+# Configure test parameters
+p.n1 = 180  # Min brightness 180
+p.colors = [(255, 128, 0)]  # Orange
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Min brightness: {p.n1}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("fl")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/main.py

@@ -0,0 +1,158 @@
+import asyncio
+import json
+import argparse
+import signal
+
+try:
+    import websockets  # type: ignore
+except Exception as e:
+    print("Please install websockets: pip install websockets")
+    raise
+
+WS_URI = "ws://192.168.4.1/ws"
+
+# Default pattern suite aligned with current firmware patterns
+PATTERN_SUITE = [
+    {"pattern": "flicker", "delay": 80, "iterations": 30, "repeat_delay": 80, "colors": ["#ffaa00"]},
+    {"pattern": "fill_range", "n1": 10, "n2": 20, "delay": 400, "iterations": 1, "repeat_delay": 500, "colors": ["#888888"]},
+    {"pattern": "n_chase", "n1": 5, "n2": 5, "delay": 250, "iterations": 40, "repeat_delay": 120, "colors": ["#00ff88"]},
+    {"pattern": "alternating", "n1": 6, "n2": 6, "delay": 300, "iterations": 20, "repeat_delay": 300, "colors": ["#ff8800"]},
+    {"pattern": "pulse", "delay": 200, "iterations": 6, "repeat_delay": 300, "colors": ["#ffffff"]},
+]
+
+
+def build_message(
+    pattern: str,
+    n: int | None = None,
+    delay: int | None = None,
+    colors: list[str] | None = None,
+    brightness: int | None = None,
+    num_leds: int | None = None,
+    n1: int | None = None,
+    n2: int | None = None,
+    name: str = "0",
+    pattern_step: int | None = None,
+):
+    settings: dict[str, object] = {
+        "pattern": pattern,
+    }
+    if n is not None:
+        settings["n"] = n
+    if delay is not None:
+        settings["delay"] = delay
+    if colors is not None:
+        settings["colors"] = colors
+    if brightness is not None:
+        settings["brightness"] = brightness
+    if num_leds is not None:
+        settings["num_leds"] = num_leds
+    if n1 is not None:
+        settings["n1"] = n1
+    if n2 is not None:
+        settings["n2"] = n2
+    if pattern_step is not None:
+        settings["pattern_step"] = pattern_step
+    # ESP-NOW-style nested payload keyed by name (e.g., "0")
+    return {name: settings}
+
+
+async def send_once(uri: str, payload: dict, hold_ms: int | None = None):
+    async with websockets.connect(uri) as ws:
+        await ws.send(json.dumps(payload))
+        if hold_ms and hold_ms > 0:
+            await asyncio.sleep(hold_ms / 1000)
+
+
+async def run_suite(uri: str):
+    async with websockets.connect(uri) as ws:
+        for cfg in PATTERN_SUITE:
+            iterations = int(cfg.get("iterations", 10))
+            interval_ms = int(cfg.get("interval_ms", cfg.get("delay", 100) or 100))
+            repeat_ms = int(cfg.get("repeat_delay", interval_ms))
+            for i in range(iterations):
+                msg = build_message(
+                    cfg.get("pattern", "off"),
+                    i,
+                    delay=cfg.get("delay"),
+                    colors=cfg.get("colors"),
+                    brightness=cfg.get("brightness", 255),
+                    num_leds=cfg.get("num_leds"),
+                    n1=cfg.get("n1"),
+                    n2=cfg.get("n2"),
+                    name=cfg.get("name", "0"),
+                    pattern_step=cfg.get("pattern_step"),
+                )
+                print(msg)
+                await ws.send(json.dumps(msg))
+                await asyncio.sleep(repeat_ms / 1000)
+
+
+def _parse_args():
+    p = argparse.ArgumentParser(description="WebSocket LED pattern tester")
+    p.add_argument("--uri", default=WS_URI, help="WebSocket URI, default ws://192.168.4.1/ws")
+    p.add_argument("--pattern", help="Single pattern to send (overrides suite)")
+    p.add_argument("--delay", type=int, help="Delay ms")
+    p.add_argument("--brightness", type=int, help="Brightness 0-255")
+    p.add_argument("--num-leds", type=int, help="Number of LEDs")
+    p.add_argument("--colors", nargs="*", help="Hex colors like #ff0000 #00ff00")
+    p.add_argument("--on-width", type=int)
+    p.add_argument("--off-width", type=int)
+    p.add_argument("--n1", type=int)
+    p.add_argument("--n2", type=int)
+    p.add_argument("--name", default="0", help="Target name key for nested payload (default: 0)")
+    p.add_argument("--iterations", type=int, help="How many cycles/messages to send")
+    p.add_argument("--interval", type=int, help="Interval between messages in ms (default: delay or 100)")
+    p.add_argument("--repeat-delay", dest="repeat_delay", type=int, help="Delay between repeats in ms (overrides --interval if set)")
+    p.add_argument("--hold", type=int, default=1500, help="Hold ms for single send")
+    return p.parse_args()
+
+def _setup_sigint(loop: asyncio.AbstractEventLoop):
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        try:
+            loop.add_signal_handler(sig, loop.stop)
+        except NotImplementedError:
+            pass
+
+
+async def main_async():
+    args = _parse_args()
+    if args.pattern:
+        iterations = int(args.iterations or 1)
+        interval_ms = int(args.interval or (args.delay if args.delay is not None else 100))
+        repeat_ms = int(args.repeat_delay or interval_ms)
+        async with websockets.connect(args.uri) as ws:
+            for i in range(iterations):
+                msg = build_message(
+                    pattern=args.pattern,
+                    n=i,
+                    delay=args.delay,
+                    colors=args.colors,
+                    brightness=args.brightness,
+                    num_leds=args.num_leds,
+                    n1=args.n1,
+                    n2=args.n2,
+                    name=args.name,
+                )
+                print(msg)
+                await ws.send(json.dumps(msg))
+                await asyncio.sleep(repeat_ms / 1000)
+    else:
+        await run_suite(args.uri)
+
+
+def main():
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    _setup_sigint(loop)
+    try:
+        loop.run_until_complete(main_async())
+    finally:
+        try:
+            loop.run_until_complete(asyncio.sleep(0))
+        except Exception:
+            pass
+        loop.close()
+
+
+if __name__ == "__main__":
+    main()

test/n_chase/1.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+N-chase test 1: Red, on=5, off=5, delay=100ms
+Runs forever
+Run with: mpremote run test/n_chase/1.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting N-Chase Test 1: Red, on=5, off=5, delay=100ms")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=100
+)
+
+# Configure test parameters
+p.n1 = 5    # On width 5
+p.n2 = 5    # Off width 5
+p.colors = [(255, 0, 0)]  # Red
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"On width: {p.n1}")
+print(f"Off width: {p.n2}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("nc")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/n_chase/2.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+N-chase test 2: Green, on=10, off=5, delay=150ms
+Runs forever
+Run with: mpremote run test/n_chase/2.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting N-Chase Test 2: Green, on=10, off=5, delay=150ms")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=150
+)
+
+# Configure test parameters
+p.n1 = 10   # On width 10
+p.n2 = 5    # Off width 5
+p.colors = [(0, 255, 0)]  # Green
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"On width: {p.n1}")
+print(f"Off width: {p.n2}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("nc")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/n_chase/3.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+N-chase test 3: Blue, on=3, off=10, delay=80ms
+Runs forever
+Run with: mpremote run test/n_chase/3.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting N-Chase Test 3: Blue, on=3, off=10, delay=80ms")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=80
+)
+
+# Configure test parameters
+p.n1 = 3    # On width 3
+p.n2 = 10   # Off width 10
+p.colors = [(0, 0, 255)]  # Blue
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"On width: {p.n1}")
+print(f"Off width: {p.n2}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("nc")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/n_chase/4.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+N-chase test 4: Yellow, on=7, off=7, delay=120ms
+Runs forever
+Run with: mpremote run test/n_chase/4.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting N-Chase Test 4: Yellow, on=7, off=7, delay=120ms")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=120
+)
+
+# Configure test parameters
+p.n1 = 7    # On width 7
+p.n2 = 7    # Off width 7
+p.colors = [(255, 255, 0)]  # Yellow
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"On width: {p.n1}")
+print(f"Off width: {p.n2}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("nc")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/n_chase/5.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+N-chase test 5: White, on=2, off=8, delay=200ms
+Runs forever
+Run with: mpremote run test/n_chase/5.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting N-Chase Test 5: White, on=2, off=8, delay=200ms")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=200
+)
+
+# Configure test parameters
+p.n1 = 2    # On width 2
+p.n2 = 8    # Off width 8
+p.colors = [(255, 255, 255)]  # White
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"On width: {p.n1}")
+print(f"Off width: {p.n2}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("nc")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/n_chase/6.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+N-chase test 6: Magenta, on=15, off=3, delay=60ms
+Runs forever
+Run with: mpremote run test/n_chase/6.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting N-Chase Test 6: Magenta, on=15, off=3, delay=60ms")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=60
+)
+
+# Configure test parameters
+p.n1 = 15   # On width 15
+p.n2 = 3    # Off width 3
+p.colors = [(255, 0, 255)]  # Magenta
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"On width: {p.n1}")
+print(f"Off width: {p.n2}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("nc")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/n_chase/7.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+N-chase test 7: Cyan, on=4, off=12, delay=180ms
+Runs forever
+Run with: mpremote run test/n_chase/7.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting N-Chase Test 7: Cyan, on=4, off=12, delay=180ms")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=180
+)
+
+# Configure test parameters
+p.n1 = 4    # On width 4
+p.n2 = 12   # Off width 12
+p.colors = [(0, 255, 255)]  # Cyan
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"On width: {p.n1}")
+print(f"Off width: {p.n2}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("nc")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/n_chase/8.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+N-chase test 8: Orange, on=1, off=20, delay=250ms
+Runs forever
+Run with: mpremote run test/n_chase/8.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting N-Chase Test 8: Orange, on=1, off=20, delay=250ms")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=250
+)
+
+# Configure test parameters
+p.n1 = 1    # On width 1
+p.n2 = 20   # Off width 20
+p.colors = [(255, 128, 0)]  # Orange
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"On width: {p.n1}")
+print(f"Off width: {p.n2}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("nc")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/n_chase/9.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""
+N-chase test 9: Cyan, on=20, off=20, delay=200ms
+Runs forever
+Run with: mpremote run test/n_chase/9.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting N-Chase Test 9: Cyan, on=20, off=20, delay=200ms")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=200
+)
+
+# Configure test parameters
+p.n1 = 20   # On width 20
+p.n2 = 20   # Off width 20
+p.n3 = 20   # Reserved for future use
+p.n4 = -5   # Reserved for future use
+p.colors = [(0, 255, 255)]  # Cyan
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"On width: {p.n1}")
+print(f"Off width: {p.n2}")
+print(f"n3: {p.n3}")
+print(f"n4: {p.n4}")
+print(f"Color: {p.colors[0]}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("nc")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/rainbow/1.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Rainbow test 1: Single node (full spectrum), 3 second cycle, full brightness
+Runs forever
+Run with: mpremote run test/rainbow/1.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Rainbow Test 1: Single node (full spectrum), 3 second cycle")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=3000  # 3 second cycle
+)
+
+# Configure test parameters
+p.n1 = 1            # 1 node (full spectrum)
+p.delay = 3000      # 3 second cycle
+p.brightness = 255  # Full brightness
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Nodes: {p.n1}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("rb")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/rainbow/2.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Rainbow test 2: Two nodes, 2 second cycle, full brightness
+Runs forever
+Run with: mpremote run test/rainbow/2.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Rainbow Test 2: Two nodes, 2 second cycle")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=2000  # 2 second cycle
+)
+
+# Configure test parameters
+p.n1 = 2            # 2 nodes
+p.delay = 2000      # 2 second cycle
+p.brightness = 255  # Full brightness
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Nodes: {p.n1}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("rb")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/rainbow/3.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Rainbow test 3: Three nodes (RGB), 1.5 second cycle, full brightness
+Runs forever
+Run with: mpremote run test/rainbow/3.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Rainbow Test 3: Three nodes (RGB), 1.5 second cycle")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=1500  # 1.5 second cycle
+)
+
+# Configure test parameters
+p.n1 = 3            # 3 nodes
+p.delay = 1500      # 1.5 second cycle
+p.brightness = 255  # Full brightness
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Nodes: {p.n1}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("rb")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/rainbow/4.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Rainbow test 4: Four nodes (RYGB), 1 second cycle, full brightness
+Runs forever
+Run with: mpremote run test/rainbow/4.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Rainbow Test 4: Four nodes (RYGB), 1 second cycle")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=1000  # 1 second cycle
+)
+
+# Configure test parameters
+p.n1 = 4            # 4 nodes
+p.delay = 1000      # 1 second cycle
+p.brightness = 255  # Full brightness
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Nodes: {p.n1}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("rb")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/rainbow/5.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Rainbow test 5: Six nodes (ROYGBP), 0.8 second cycle, full brightness
+Runs forever
+Run with: mpremote run test/rainbow/5.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Rainbow Test 5: Six nodes (ROYGBP), 0.8 second cycle")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=800  # 0.8 second cycle
+)
+
+# Configure test parameters
+p.n1 = 6            # 6 nodes
+p.delay = 800       # 0.8 second cycle
+p.brightness = 255  # Full brightness
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Nodes: {p.n1}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("rb")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/rainbow/6.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Rainbow test 6: Eight nodes, 0.6 second cycle, full brightness
+Runs forever
+Run with: mpremote run test/rainbow/6.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Rainbow Test 6: Eight nodes, 0.6 second cycle")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=600  # 0.6 second cycle
+)
+
+# Configure test parameters
+p.n1 = 8            # 8 nodes
+p.delay = 600       # 0.6 second cycle
+p.brightness = 255  # Full brightness
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Nodes: {p.n1}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("rb")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/rainbow/7.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Rainbow test 7: Twelve nodes (fine gradation), 0.4 second cycle, full brightness
+Runs forever
+Run with: mpremote run test/rainbow/7.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Rainbow Test 7: Twelve nodes (fine gradation), 0.4 second cycle")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=400  # 0.4 second cycle
+)
+
+# Configure test parameters
+p.n1 = 12           # 12 nodes
+p.delay = 400       # 0.4 second cycle
+p.brightness = 255  # Full brightness
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Nodes: {p.n1}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("rb")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/rainbow/8.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Rainbow test 8: Many nodes (20), slow cycle (2 seconds), full brightness
+Runs forever
+Run with: mpremote run test/rainbow/8.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Rainbow Test 8: Many nodes (20), slow cycle (2 seconds)")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=2000  # 2 second cycle
+)
+
+# Configure test parameters
+p.n1 = 20           # 20 nodes
+p.delay = 2000      # 2 second cycle
+p.brightness = 255  # Full brightness
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Nodes: {p.n1}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("rb")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/rainbow/9.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Rainbow test 9: Five nodes, 1 second cycle, full brightness
+Runs forever
+Run with: mpremote run test/rainbow/9.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+print("Starting Rainbow Test 9: Five nodes, 1 second cycle")
+print("Press Ctrl+C to stop")
+
+# Load settings
+settings = Settings()
+
+# Initialize patterns using settings
+p = patterns.Patterns(
+    pin=settings["led_pin"], 
+    num_leds=settings["num_leds"], 
+    brightness=255,
+    delay=1000  # 1 second cycle
+)
+
+# Configure test parameters
+p.n1 = 5            # 5 nodes
+p.delay = 1000      # 1 second cycle
+p.brightness = 255  # Full brightness
+
+print(f"LED Pin: {settings['led_pin']}")
+print(f"LEDs: {settings['num_leds']}")
+print(f"Brightness: {p.brightness}")
+print(f"Delay: {p.delay}ms")
+print(f"Nodes: {p.n1}")
+
+# Initialize watchdog timer
+wdt = WDT(timeout=10000)
+wdt.feed()
+
+# Start pattern
+p.select("rb")
+print("Pattern started. Running forever...")
+
+# Run forever
+try:
+    while True:
+        wdt.feed()
+        utime.sleep_ms(100)
+except KeyboardInterrupt:
+    print("\nStopping...")
+    p.run = False
+    p.off()
+    print("LEDs turned off")
+

test/rainbow/main.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""
+Rainbow test suite - runs all tests in sequence forever
+Run with: mpremote run test/rainbow/main.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+def run_test_case(p, test_name, n1, delay, brightness, duration_ms=6000):
+    """Run a test case for specified duration"""
+    print(f"\n--- {test_name} ---")
+    print(f"Parameters: n1={n1} nodes, delay={delay}ms cycle time, brightness={brightness}")
+    
+    # Configure parameters
+    p.n1 = n1
+    p.delay = delay
+    p.brightness = brightness
+    
+    # Restart the pattern with new parameters
+    p.run = False
+    while p.running:
+        utime.sleep_ms(1)
+    
+    p.select("rb")
+    
+    # Run for specified duration
+    start_time = utime.ticks_ms()
+    while utime.ticks_diff(utime.ticks_ms(), start_time) < duration_ms:
+        wdt.feed()
+        utime.sleep_ms(100)
+    
+    # Stop pattern
+    p.run = False
+    print(f"{test_name} completed")
+    
+    # Brief pause between tests
+    utime.sleep_ms(500)
+
+def test_rainbow_suite():
+    """Run all rainbow tests continuously"""
+    print("Starting rainbow test suite...")
+    print("Runs all tests in sequence, then repeats")
+    print("Press Ctrl+C to stop")
+    
+    # Load settings
+    settings = Settings()
+    
+    # Initialize patterns using settings
+    p = patterns.Patterns(
+        pin=settings["led_pin"], 
+        num_leds=settings["num_leds"], 
+        brightness=255,
+        delay=1000
+    )
+    
+    print(f"LED Pin: {settings['led_pin']}")
+    print(f"LEDs: {settings['num_leds']}")
+    print(f"Base Brightness: {p.brightness}")
+    
+    # Initialize watchdog timer
+    global wdt
+    wdt = WDT(timeout=10000)
+    wdt.feed()
+    
+    # Test configurations
+    tests = [
+        ("Test 1: Single node (full spectrum)", 1, 3000, 255, 12000),
+        ("Test 2: Two nodes", 2, 2000, 255, 10000),
+        ("Test 3: Three nodes (RGB)", 3, 1500, 255, 9000),
+        ("Test 4: Four nodes (RYGB)", 4, 1000, 255, 8000),
+        ("Test 5: Six nodes (ROYGBP)", 6, 800, 255, 8000),
+        ("Test 6: Eight nodes", 8, 600, 255, 6000),
+        ("Test 7: Twelve nodes (fine gradation)", 12, 400, 255, 6000),
+        ("Test 8: Many nodes (20), slow cycle", 20, 2000, 255, 10000),
+        ("Test 9: Five nodes", 5, 1000, 255, 6000),
+    ]
+    
+    cycle = 0
+    try:
+        while True:
+            cycle += 1
+            print(f"\n\n========== Starting Cycle {cycle} ==========")
+            
+            for test_name, n1, delay, brightness, duration in tests:
+                run_test_case(p, test_name, n1, delay, brightness, duration)
+            
+            print("\n========== Cycle completed ==========\n")
+    
+    except KeyboardInterrupt:
+        print("\n\nStopping test suite...")
+        p.run = False
+        p.off()
+        print("LEDs turned off")
+
+if __name__ == "__main__":
+    test_rainbow_suite()
+

test/random_test.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""
+Random test - randomly selects and runs test patterns for 2-10 minutes each
+Run with: mpremote run test/random_test.py
+"""
+
+import patterns
+import utime
+import random
+import math
+from settings import Settings
+from machine import WDT
+
+def run_pattern(p, pattern_name, config, duration_ms):
+    """Run a pattern for specified duration"""
+    print(f"\n{'='*60}")
+    print(f"Starting: {pattern_name}")
+    print(f"Duration: {duration_ms//1000} seconds")
+    
+    # Configure parameters
+    if pattern_name == "blink":
+        p.delay = config.get("delay", 500)
+    elif pattern_name == "circle_loading":
+        p.n1 = config.get("n1", 50)
+        p.n2 = config.get("n2", 100)
+        p.n3 = config.get("n3", 200)
+        p.n4 = config.get("n4", 0)
+        p.delay = config.get("delay", 2000)
+    elif pattern_name == "sine_brightness":
+        p.n1 = config.get("n1", 50)
+        p.brightness = config.get("brightness", 255)
+        p.delay = config.get("delay", 1000)
+    elif pattern_name == "rainbow":
+        p.n1 = config.get("n1", 1)
+        p.delay = config.get("delay", 1000)
+    elif pattern_name == "flicker":
+        p.n1 = config.get("n1", 50)
+        p.delay = config.get("delay", 50)
+    elif pattern_name == "n_chase":
+        p.n1 = config.get("n1", 5)
+        p.n2 = config.get("n2", 5)
+        p.n3 = config.get("n3", 1)
+        p.n4 = config.get("n4", 1)
+        p.delay = config.get("delay", 100)
+    
+    # Set color if provided
+    if "color" in config:
+        p.colors = [config["color"]]
+    
+    # Start pattern
+    p.select(config.get("short_name", "o"))
+    
+    # Run for duration
+    start_time = utime.ticks_ms()
+    while utime.ticks_diff(utime.ticks_ms(), start_time) < duration_ms:
+        wdt.feed()
+        utime.sleep_ms(100)
+    
+    # Stop pattern
+    p.run = False
+    while p.running:
+        utime.sleep_ms(1)
+    
+    p.off()
+    print(f"Completed: {pattern_name}")
+    utime.sleep_ms(500)
+
+def random_test():
+    """Run random test patterns continuously"""
+    print("Starting Random Test Suite")
+    print("Patterns will change every 1-5 minutes")
+    print("Press Ctrl+C to stop")
+    
+    # Load settings
+    settings = Settings()
+    
+    # Initialize patterns
+    p = patterns.Patterns(
+        pin=settings["led_pin"], 
+        num_leds=settings["num_leds"], 
+        brightness=255
+    )
+    
+    print(f"LED Pin: {settings['led_pin']}")
+    print(f"LEDs: {settings['num_leds']}")
+    
+    # Initialize watchdog
+    global wdt
+    wdt = WDT(timeout=10000)
+    wdt.feed()
+    
+    # Define all test configurations
+    test_configs = [
+        # Circle loading patterns
+        {"pattern": "circle_loading", "short_name": "cl", "n1": 50, "n2": 100, "n3": 200, "n4": 0, "delay": 2000, "color": (255, 0, 0)},
+        {"pattern": "circle_loading", "short_name": "cl", "n1": 30, "n2": 60, "n3": 100, "n4": 0, "delay": 1500, "color": (0, 255, 0)},
+        {"pattern": "circle_loading", "short_name": "cl", "n1": 75, "n2": 150, "n3": 300, "n4": 10, "delay": 3000, "color": (0, 0, 255)},
+        
+        # Sine brightness patterns
+        {"pattern": "sine_brightness", "short_name": "sb", "n1": 50, "brightness": 255, "delay": 1000, "color": (255, 0, 0)},
+        {"pattern": "sine_brightness", "short_name": "sb", "n1": 100, "brightness": 255, "delay": 800, "color": (0, 255, 0)},
+        {"pattern": "sine_brightness", "short_name": "sb", "n1": 0, "brightness": 255, "delay": 1500, "color": (0, 0, 255)},
+        
+        # Rainbow patterns
+        {"pattern": "rainbow", "short_name": "rb", "n1": 1, "delay": 3000, "color": None},
+        {"pattern": "rainbow", "short_name": "rb", "n1": 2, "delay": 2000, "color": None},
+        {"pattern": "rainbow", "short_name": "rb", "n1": 3, "delay": 1500, "color": None},
+        {"pattern": "rainbow", "short_name": "rb", "n1": 6, "delay": 1000, "color": None},
+        {"pattern": "rainbow", "short_name": "rb", "n1": 12, "delay": 800, "color": None},
+        
+        # Flicker patterns
+        {"pattern": "flicker", "short_name": "fl", "n1": 50, "delay": 50, "color": (255, 0, 0)},
+        {"pattern": "flicker", "short_name": "fl", "n1": 30, "delay": 100, "color": (0, 255, 0)},
+        {"pattern": "flicker", "short_name": "fl", "n1": 100, "delay": 30, "color": (0, 0, 255)},
+        
+        # N-chase patterns (mix of forward-only and bidirectional)
+        # Forward-only patterns
+        {"pattern": "n_chase", "short_name": "nc", "n1": 5, "n2": 5, "n3": 5, "n4": 5, "delay": 100, "color": (255, 0, 0)},
+        {"pattern": "n_chase", "short_name": "nc", "n1": 10, "n2": 5, "n3": 10, "n4": 10, "delay": 150, "color": (0, 255, 0)},
+        {"pattern": "n_chase", "short_name": "nc", "n1": 20, "n2": 20, "n3": 20, "n4": 20, "delay": 200, "color": (0, 255, 255)},
+        # Bidirectional patterns
+        {"pattern": "n_chase", "short_name": "nc", "n1": 15, "n2": 10, "n3": 10, "n4": 5, "delay": 180, "color": (255, 255, 0)},
+        {"pattern": "n_chase", "short_name": "nc", "n1": 20, "n2": 20, "n3": 20, "n4": 5, "delay": 200, "color": (255, 0, 255)},
+        {"pattern": "n_chase", "short_name": "nc", "n1": 12, "n2": 8, "n3": 15, "n4": 8, "delay": 160, "color": (255, 128, 128)},
+        
+        # N-chase patterns (forward only, large segments)
+        {"pattern": "n_chase", "short_name": "nc", "n1": 30, "n2": 10, "n3": 5, "n4": 5, "delay": 150, "color": (255, 128, 0)},
+        {"pattern": "n_chase", "short_name": "nc", "n1": 40, "n2": 20, "n3": 10, "n4": 10, "delay": 180, "color": (128, 255, 0)},
+        {"pattern": "n_chase", "short_name": "nc", "n1": 50, "n2": 25, "n3": 20, "n4": 20, "delay": 200, "color": (0, 128, 255)},
+        {"pattern": "n_chase", "short_name": "nc", "n1": 60, "n2": 30, "n3": 30, "n4": 30, "delay": 220, "color": (255, 0, 128)},
+        {"pattern": "n_chase", "short_name": "nc", "n1": 80, "n2": 40, "n3": 50, "n4": 50, "delay": 250, "color": (128, 0, 255)},
+        {"pattern": "n_chase", "short_name": "nc", "n1": 100, "n2": 50, "n3": 100, "n4": 100, "delay": 300, "color": (255, 255, 255)},
+    ]
+    
+    try:
+        cycle = 0
+        while True:
+            cycle += 1
+            print(f"\n\n{'='*60}")
+            print(f"Random Test Cycle {cycle}")
+            print(f"{'='*60}")
+            
+            # Randomly select a test configuration
+            config = random.choice(test_configs)
+            
+            # Random duration between 1-5 minutes (60,000 - 300,000 ms)
+            duration_ms = random.randint(60000, 300000)
+            
+            # Run the selected pattern
+            run_pattern(p, config["pattern"], config, duration_ms)
+    
+    except KeyboardInterrupt:
+        print("\n\nStopping random test suite...")
+        p.run = False
+        p.off()
+        print("LEDs turned off")
+
+if __name__ == "__main__":
+    random_test()
+

test/sine_brightness.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+Test script for sine brightness pattern
+Run with: mpremote run test/sine_brightness.py
+"""
+
+import patterns
+import utime
+from settings import Settings
+from machine import WDT
+
+def run_test_case(p, test_name, duration_ms=5000):
+    """Run a test case for specified duration"""
+    print(f"\n--- {test_name} ---")
+    print(f"Parameters: n1={p.n1} min brightness, brightness={p.brightness} max brightness, delay={p.delay}ms wavelength")
+    print(f"Color: {p.colors[0]}")
+    print(f"Running for {duration_ms//1000} seconds...")
+    
+    # Initialize watchdog timer
+    wdt = WDT(timeout=10000)
+    wdt.feed()
+    
+    # Start pattern
+    p.select("sb")
+    
+    # Run for specified duration
+    start_time = utime.ticks_ms()
+    while utime.ticks_diff(utime.ticks_ms(), start_time) < duration_ms:
+        wdt.feed()
+        utime.sleep_ms(100)
+    
+    # Stop pattern
+    p.run = False
+    print(f"{test_name} completed")
+    
+    # Brief pause between tests
+    utime.sleep_ms(500)
+
+def test_sine_brightness():
+    print("Testing sine brightness pattern with multiple configurations...")
+    
+    # Load settings
+    settings = Settings()
+    
+    # Initialize patterns using settings
+    p = patterns.Patterns(
+        pin=settings["led_pin"], 
+        num_leds=settings["num_leds"], 
+        brightness=255,  # Full brightness
+        delay=1000  # Base wavelength
+    )
+    
+    print(f"LED Pin: {settings['led_pin']}")
+    print(f"LEDs: {settings['num_leds']}")
+    print(f"Base Brightness: {p.brightness}")
+    
+    # Test Case 1: Slow breathing
+    p.n1 = 50           # Min brightness 50
+    p.brightness = 255  # Max brightness 255
+    p.delay = 3000      # 3 second cycle
+    p.colors = [(255, 0, 0)]  # Red
+    run_test_case(p, "Test 1: Slow breathing (50-255 brightness)", 12000)
+    
+    # Test Case 2: Fast pulsing
+    p.n1 = 100          # Min brightness 100
+    p.brightness = 255  # Max brightness 255
+    p.delay = 500       # 0.5 second cycle
+    p.colors = [(0, 255, 0)]  # Green
+    run_test_case(p, "Test 2: Fast pulsing (100-255 brightness)", 8000)
+    
+    # Test Case 3: Medium breathing
+    p.n1 = 80           # Min brightness 80
+    p.brightness = 255  # Max brightness 255
+    p.delay = 1500      # 1.5 second cycle
+    p.colors = [(0, 0, 255)]  # Blue
+    run_test_case(p, "Test 3: Medium breathing (80-255 brightness)", 10000)
+    
+    # Test Case 4: Very slow breathing
+    p.n1 = 150          # Min brightness 150
+    p.brightness = 255  # Max brightness 255
+    p.delay = 5000      # 5 second cycle
+    p.colors = [(255, 255, 0)]  # Yellow
+    run_test_case(p, "Test 4: Very slow breathing (150-255 brightness)", 15000)
+    
+    # Test Case 5: Very fast pulsing
+    p.n1 = 50           # Min brightness 50
+    p.brightness = 255  # Max brightness 255
+    p.delay = 200       # 0.2 second cycle
+    p.colors = [(255, 0, 255)]  # Magenta
+    run_test_case(p, "Test 5: Very fast pulsing (50-255 brightness)", 6000)
+    
+    # Test Case 6: Low range, slow cycle
+    p.n1 = 200          # Min brightness 200
+    p.brightness = 255  # Max brightness 255
+    p.delay = 4000      # 4 second cycle
+    p.colors = [(0, 255, 255)]  # Cyan
+    run_test_case(p, "Test 6: Low range, slow cycle (200-255 brightness)", 12000)
+    
+    # Test Case 7: High range, medium cycle
+    p.n1 = 100          # Min brightness 100
+    p.brightness = 255  # Max brightness 255
+    p.delay = 1000      # 1 second cycle
+    p.colors = [(255, 128, 0)]  # Orange
+    run_test_case(p, "Test 7: High range, medium cycle (100-255 brightness)", 8000)
+    
+    # Test Case 8: Ultra fast strobe
+    p.n1 = 100          # Min brightness 100
+    p.brightness = 255  # Max brightness 255
+    p.delay = 100       # 0.1 second cycle
+    p.colors = [(128, 0, 255)]  # Purple
+    run_test_case(p, "Test 8: Ultra fast strobe (100-255 brightness)", 4000)
+    
+    print("\n=== All tests completed ===")
+    
+    # Turn off LEDs
+    p.off()
+    print("LEDs turned off")
+
+if __name__ == "__main__":
+    test_sine_brightness()