diff --git a/dev.py b/dev.py deleted file mode 100755 index 7c0bb71..0000000 --- a/dev.py +++ /dev/null @@ -1,75 +0,0 @@ -#!/usr/bin/env python3 - -import shutil -import subprocess -import serial -import sys -from pathlib import Path - - -def mpremote_base(): - """mpremote on PATH, or same interpreter as this script (e.g. pipenv venv).""" - exe = shutil.which("mpremote") - if exe: - return [exe] - return [sys.executable, "-m", "mpremote"] - - -print(sys.argv) - -# Extract port (first arg if it's not a command) -commands = ["src", "lib", "ls", "reset", "follow", "db", "test"] -port = None -if len(sys.argv) > 1 and sys.argv[1] not in commands: - port = sys.argv[1] - - -for cmd in sys.argv[1:]: - print(cmd) - match cmd: - case "src": - if port: - subprocess.call( - [*mpremote_base(), "connect", port, "fs", "cp", "-r", ".", ":"], - cwd="src", - ) - else: - print("Error: Port required for 'src' command") - case "lib": - if port: - subprocess.call([*mpremote_base(), "connect", port, "fs", "cp", "-r", "lib", ":"]) - else: - print("Error: Port required for 'lib' command") - case "ls": - if port: - subprocess.call([*mpremote_base(), "connect", port, "fs", "ls", ":"]) - else: - print("Error: Port required for 'ls' command") - case "reset": - if port: - with serial.Serial(port, baudrate=115200) as ser: - ser.write(b'\x03\x03\x04') - else: - print("Error: Port required for 'reset' command") - case "follow": - if port: - with serial.Serial(port, baudrate=115200) as ser: - while True: - if ser.in_waiting > 0: # Check if there is data in the buffer - data = ser.readline().decode('utf-8').strip() # Read and decode the data - print(data) - else: - print("Error: Port required for 'follow' command") - case "db": - if port: - subprocess.call([*mpremote_base(), "connect", port, "fs", "cp", "-r", "db", ":"]) - else: - print("Error: Port required for 'db' command") - case "test": - if port: - # Single self-contained suite (tests/all.py); requires ``src`` on device first. - subprocess.call( - [*mpremote_base(), "connect", port, "run", "tests/all.py"] - ) - else: - print("Error: Port required for 'test' command") diff --git a/lib/microdot/__init__.py b/lib/microdot/__init__.py deleted file mode 100644 index 68cb381..0000000 --- a/lib/microdot/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from microdot.microdot import Microdot, Request, Response, abort, redirect, \ - send_file # noqa: F401 \ No newline at end of file diff --git a/lib/microdot/helpers.py b/lib/microdot/helpers.py deleted file mode 100644 index 664e58c..0000000 --- a/lib/microdot/helpers.py +++ /dev/null @@ -1,8 +0,0 @@ -try: - from functools import wraps -except ImportError: # pragma: no cover - # MicroPython does not currently implement functools.wraps - def wraps(wrapped): - def _(wrapper): - return wrapper - return _ diff --git a/lib/microdot/microdot.py b/lib/microdot/microdot.py deleted file mode 100644 index 0513f21..0000000 --- a/lib/microdot/microdot.py +++ /dev/null @@ -1,1450 +0,0 @@ -""" -microdot --------- - -The ``microdot`` module defines a few classes that help implement HTTP-based -servers for MicroPython and standard Python. -""" -import asyncio -import io -import json -import time - -try: - from inspect import iscoroutinefunction, iscoroutine - from functools import partial - - async def invoke_handler(handler, *args, **kwargs): - """Invoke a handler and return the result. - - This method runs sync handlers in a thread pool executor. - """ - if iscoroutinefunction(handler): - ret = await handler(*args, **kwargs) - else: - ret = await asyncio.get_running_loop().run_in_executor( - None, partial(handler, *args, **kwargs)) - return ret -except ImportError: # pragma: no cover - def iscoroutine(coro): - return hasattr(coro, 'send') and hasattr(coro, 'throw') - - async def invoke_handler(handler, *args, **kwargs): - """Invoke a handler and return the result. - - This method runs sync handlers in the asyncio thread, which can - potentially cause blocking and performance issues. - """ - ret = handler(*args, **kwargs) - if iscoroutine(ret): - ret = await ret - return ret - -try: - from sys import print_exception -except ImportError: # pragma: no cover - import traceback - - def print_exception(exc): - traceback.print_exc() - -MUTED_SOCKET_ERRORS = [ - 32, # Broken pipe - 54, # Connection reset by peer - 104, # Connection reset by peer - 128, # Operation on closed socket -] - - -def urldecode_str(s): - s = s.replace('+', ' ') - parts = s.split('%') - if len(parts) == 1: - return s - result = [parts[0]] - for item in parts[1:]: - if item == '': - result.append('%') - else: - code = item[:2] - result.append(chr(int(code, 16))) - result.append(item[2:]) - return ''.join(result) - - -def urldecode_bytes(s): - s = s.replace(b'+', b' ') - parts = s.split(b'%') - if len(parts) == 1: - return s.decode() - result = [parts[0]] - for item in parts[1:]: - if item == b'': - result.append(b'%') - else: - code = item[:2] - result.append(bytes([int(code, 16)])) - result.append(item[2:]) - return b''.join(result).decode() - - -def urlencode(s): - return s.replace('+', '%2B').replace(' ', '+').replace( - '%', '%25').replace('?', '%3F').replace('#', '%23').replace( - '&', '%26').replace('=', '%3D') - - -class NoCaseDict(dict): - """A subclass of dictionary that holds case-insensitive keys. - - :param initial_dict: an initial dictionary of key/value pairs to - initialize this object with. - - Example:: - - >>> d = NoCaseDict() - >>> d['Content-Type'] = 'text/html' - >>> print(d['Content-Type']) - text/html - >>> print(d['content-type']) - text/html - >>> print(d['CONTENT-TYPE']) - text/html - >>> del d['cOnTeNt-TyPe'] - >>> print(d) - {} - """ - def __init__(self, initial_dict=None): - super().__init__(initial_dict or {}) - self.keymap = {k.lower(): k for k in self.keys() if k.lower() != k} - - def __setitem__(self, key, value): - kl = key.lower() - key = self.keymap.get(kl, key) - if kl != key: - self.keymap[kl] = key - super().__setitem__(key, value) - - def __getitem__(self, key): - kl = key.lower() - return super().__getitem__(self.keymap.get(kl, kl)) - - def __delitem__(self, key): - kl = key.lower() - super().__delitem__(self.keymap.get(kl, kl)) - - def __contains__(self, key): - kl = key.lower() - return self.keymap.get(kl, kl) in self.keys() - - def get(self, key, default=None): - kl = key.lower() - return super().get(self.keymap.get(kl, kl), default) - - def update(self, other_dict): - for key, value in other_dict.items(): - self[key] = value - - -def mro(cls): # pragma: no cover - """Return the method resolution order of a class. - - This is a helper function that returns the method resolution order of a - class. It is used by Microdot to find the best error handler to invoke for - the raised exception. - - In CPython, this function returns the ``__mro__`` attribute of the class. - In MicroPython, this function implements a recursive depth-first scanning - of the class hierarchy. - """ - if hasattr(cls, 'mro'): - return cls.__mro__ - - def _mro(cls): - m = [cls] - for base in cls.__bases__: - m += _mro(base) - return m - - mro_list = _mro(cls) - - # If a class appears multiple times (due to multiple inheritance) remove - # all but the last occurence. This matches the method resolution order - # of MicroPython, but not CPython. - mro_pruned = [] - for i in range(len(mro_list)): - base = mro_list.pop(0) - if base not in mro_list: - mro_pruned.append(base) - return mro_pruned - - -class MultiDict(dict): - """A subclass of dictionary that can hold multiple values for the same - key. It is used to hold key/value pairs decoded from query strings and - form submissions. - - :param initial_dict: an initial dictionary of key/value pairs to - initialize this object with. - - Example:: - - >>> d = MultiDict() - >>> d['sort'] = 'name' - >>> d['sort'] = 'email' - >>> print(d['sort']) - 'name' - >>> print(d.getlist('sort')) - ['name', 'email'] - """ - def __init__(self, initial_dict=None): - super().__init__() - if initial_dict: - for key, value in initial_dict.items(): - self[key] = value - - def __setitem__(self, key, value): - if key not in self: - super().__setitem__(key, []) - super().__getitem__(key).append(value) - - def __getitem__(self, key): - return super().__getitem__(key)[0] - - def get(self, key, default=None, type=None): - """Return the value for a given key. - - :param key: The key to retrieve. - :param default: A default value to use if the key does not exist. - :param type: A type conversion callable to apply to the value. - - If the multidict contains more than one value for the requested key, - this method returns the first value only. - - Example:: - - >>> d = MultiDict() - >>> d['age'] = '42' - >>> d.get('age') - '42' - >>> d.get('age', type=int) - 42 - >>> d.get('name', default='noname') - 'noname' - """ - if key not in self: - return default - value = self[key] - if type is not None: - value = type(value) - return value - - def getlist(self, key, type=None): - """Return all the values for a given key. - - :param key: The key to retrieve. - :param type: A type conversion callable to apply to the values. - - If the requested key does not exist in the dictionary, this method - returns an empty list. - - Example:: - - >>> d = MultiDict() - >>> d.getlist('items') - [] - >>> d['items'] = '3' - >>> d.getlist('items') - ['3'] - >>> d['items'] = '56' - >>> d.getlist('items') - ['3', '56'] - >>> d.getlist('items', type=int) - [3, 56] - """ - if key not in self: - return [] - values = super().__getitem__(key) - if type is not None: - values = [type(value) for value in values] - return values - - -class AsyncBytesIO: - """An async wrapper for BytesIO.""" - def __init__(self, data): - self.stream = io.BytesIO(data) - - async def read(self, n=-1): - return self.stream.read(n) - - async def readline(self): # pragma: no cover - return self.stream.readline() - - async def readexactly(self, n): # pragma: no cover - return self.stream.read(n) - - async def readuntil(self, separator=b'\n'): # pragma: no cover - return self.stream.readuntil(separator=separator) - - async def awrite(self, data): # pragma: no cover - return self.stream.write(data) - - async def aclose(self): # pragma: no cover - pass - - -class Request: - """An HTTP request.""" - #: Specify the maximum payload size that is accepted. Requests with larger - #: payloads will be rejected with a 413 status code. Applications can - #: change this maximum as necessary. - #: - #: Example:: - #: - #: Request.max_content_length = 1 * 1024 * 1024 # 1MB requests allowed - max_content_length = 16 * 1024 - - #: Specify the maximum payload size that can be stored in ``body``. - #: Requests with payloads that are larger than this size and up to - #: ``max_content_length`` bytes will be accepted, but the application will - #: only be able to access the body of the request by reading from - #: ``stream``. Set to 0 if you always access the body as a stream. - #: - #: Example:: - #: - #: Request.max_body_length = 4 * 1024 # up to 4KB bodies read - max_body_length = 16 * 1024 - - #: Specify the maximum length allowed for a line in the request. Requests - #: with longer lines will not be correctly interpreted. Applications can - #: change this maximum as necessary. - #: - #: Example:: - #: - #: Request.max_readline = 16 * 1024 # 16KB lines allowed - max_readline = 2 * 1024 - - class G: - pass - - def __init__(self, app, client_addr, method, url, http_version, headers, - body=None, stream=None, sock=None): - #: The application instance to which this request belongs. - self.app = app - #: The address of the client, as a tuple (host, port). - self.client_addr = client_addr - #: The HTTP method of the request. - self.method = method - #: The request URL, including the path and query string. - self.url = url - #: The path portion of the URL. - self.path = url - #: The query string portion of the URL. - self.query_string = None - #: The parsed query string, as a - #: :class:`MultiDict ` object. - self.args = {} - #: A dictionary with the headers included in the request. - self.headers = headers - #: A dictionary with the cookies included in the request. - self.cookies = {} - #: The parsed ``Content-Length`` header. - self.content_length = 0 - #: The parsed ``Content-Type`` header. - self.content_type = None - #: A general purpose container for applications to store data during - #: the life of the request. - self.g = Request.G() - - self.http_version = http_version - if '?' in self.path: - self.path, self.query_string = self.path.split('?', 1) - self.args = self._parse_urlencoded(self.query_string) - - if 'Content-Length' in self.headers: - self.content_length = int(self.headers['Content-Length']) - if 'Content-Type' in self.headers: - self.content_type = self.headers['Content-Type'] - if 'Cookie' in self.headers: - for cookie in self.headers['Cookie'].split(';'): - name, value = cookie.strip().split('=', 1) - self.cookies[name] = value - - self._body = body - self.body_used = False - self._stream = stream - self.sock = sock - self._json = None - self._form = None - self.after_request_handlers = [] - - @staticmethod - async def create(app, client_reader, client_writer, client_addr): - """Create a request object. - - :param app: The Microdot application instance. - :param client_reader: An input stream from where the request data can - be read. - :param client_writer: An output stream where the response data can be - written. - :param client_addr: The address of the client, as a tuple. - - This method is a coroutine. It returns a newly created ``Request`` - object. - """ - # request line - line = (await Request._safe_readline(client_reader)).strip().decode() - if not line: # pragma: no cover - return None - method, url, http_version = line.split() - http_version = http_version.split('/', 1)[1] - - # headers - headers = NoCaseDict() - content_length = 0 - while True: - line = (await Request._safe_readline( - client_reader)).strip().decode() - if line == '': - break - header, value = line.split(':', 1) - value = value.strip() - headers[header] = value - if header.lower() == 'content-length': - content_length = int(value) - - # body - body = b'' - if content_length and content_length <= Request.max_body_length: - body = await client_reader.readexactly(content_length) - stream = None - else: - body = b'' - stream = client_reader - - return Request(app, client_addr, method, url, http_version, headers, - body=body, stream=stream, - sock=(client_reader, client_writer)) - - def _parse_urlencoded(self, urlencoded): - data = MultiDict() - if len(urlencoded) > 0: # pragma: no branch - if isinstance(urlencoded, str): - for kv in [pair.split('=', 1) - for pair in urlencoded.split('&') if pair]: - data[urldecode_str(kv[0])] = urldecode_str(kv[1]) \ - if len(kv) > 1 else '' - elif isinstance(urlencoded, bytes): # pragma: no branch - for kv in [pair.split(b'=', 1) - for pair in urlencoded.split(b'&') if pair]: - data[urldecode_bytes(kv[0])] = urldecode_bytes(kv[1]) \ - if len(kv) > 1 else b'' - return data - - @property - def body(self): - """The body of the request, as bytes.""" - return self._body - - @property - def stream(self): - """The body of the request, as a bytes stream.""" - if self._stream is None: - self._stream = AsyncBytesIO(self._body) - return self._stream - - @property - def json(self): - """The parsed JSON body, or ``None`` if the request does not have a - JSON body.""" - if self._json is None: - if self.content_type is None: - return None - mime_type = self.content_type.split(';')[0] - if mime_type != 'application/json': - return None - self._json = json.loads(self.body.decode()) - return self._json - - @property - def form(self): - """The parsed form submission body, as a - :class:`MultiDict ` object, or ``None`` if the - request does not have a form submission.""" - if self._form is None: - if self.content_type is None: - return None - mime_type = self.content_type.split(';')[0] - if mime_type != 'application/x-www-form-urlencoded': - return None - self._form = self._parse_urlencoded(self.body) - return self._form - - def after_request(self, f): - """Register a request-specific function to run after the request is - handled. Request-specific after request handlers run at the very end, - after the application's own after request handlers. The function must - take two arguments, the request and response objects. The return value - of the function must be the updated response object. - - Example:: - - @app.route('/') - def index(request): - # register a request-specific after request handler - @req.after_request - def func(request, response): - # ... - return response - - return 'Hello, World!' - - Note that the function is not called if the request handler raises an - exception and an error response is returned instead. - """ - self.after_request_handlers.append(f) - return f - - @staticmethod - async def _safe_readline(stream): - line = (await stream.readline()) - if len(line) > Request.max_readline: - raise ValueError('line too long') - return line - - -class Response: - """An HTTP response class. - - :param body: The body of the response. If a dictionary or list is given, - a JSON formatter is used to generate the body. If a file-like - object or an async generator is given, a streaming response is - used. If a string is given, it is encoded from UTF-8. Else, - the body should be a byte sequence. - :param status_code: The numeric HTTP status code of the response. The - default is 200. - :param headers: A dictionary of headers to include in the response. - :param reason: A custom reason phrase to add after the status code. The - default is "OK" for responses with a 200 status code and - "N/A" for any other status codes. - """ - types_map = { - 'css': 'text/css', - 'gif': 'image/gif', - 'html': 'text/html', - 'jpg': 'image/jpeg', - 'js': 'application/javascript', - 'json': 'application/json', - 'png': 'image/png', - 'txt': 'text/plain', - } - - send_file_buffer_size = 1024 - - #: The content type to use for responses that do not explicitly define a - #: ``Content-Type`` header. - default_content_type = 'text/plain' - - #: The default cache control max age used by :meth:`send_file`. A value - #: of ``None`` means that no ``Cache-Control`` header is added. - default_send_file_max_age = None - - #: Special response used to signal that a response does not need to be - #: written to the client. Used to exit WebSocket connections cleanly. - already_handled = None - - def __init__(self, body='', status_code=200, headers=None, reason=None): - if body is None and status_code == 200: - body = '' - status_code = 204 - self.status_code = status_code - self.headers = NoCaseDict(headers or {}) - self.reason = reason - if isinstance(body, (dict, list)): - self.body = json.dumps(body).encode() - self.headers['Content-Type'] = 'application/json; charset=UTF-8' - elif isinstance(body, str): - self.body = body.encode() - else: - # this applies to bytes, file-like objects or generators - self.body = body - self.is_head = False - - def set_cookie(self, cookie, value, path=None, domain=None, expires=None, - max_age=None, secure=False, http_only=False, - partitioned=False): - """Add a cookie to the response. - - :param cookie: The cookie's name. - :param value: The cookie's value. - :param path: The cookie's path. - :param domain: The cookie's domain. - :param expires: The cookie expiration time, as a ``datetime`` object - or a correctly formatted string. - :param max_age: The cookie's ``Max-Age`` value. - :param secure: The cookie's ``secure`` flag. - :param http_only: The cookie's ``HttpOnly`` flag. - :param partitioned: Whether the cookie is partitioned. - """ - http_cookie = '{cookie}={value}'.format(cookie=cookie, value=value) - if path: - http_cookie += '; Path=' + path - if domain: - http_cookie += '; Domain=' + domain - if expires: - if isinstance(expires, str): - http_cookie += '; Expires=' + expires - else: # pragma: no cover - http_cookie += '; Expires=' + time.strftime( - '%a, %d %b %Y %H:%M:%S GMT', expires.timetuple()) - if max_age is not None: - http_cookie += '; Max-Age=' + str(max_age) - if secure: - http_cookie += '; Secure' - if http_only: - http_cookie += '; HttpOnly' - if partitioned: - http_cookie += '; Partitioned' - if 'Set-Cookie' in self.headers: - self.headers['Set-Cookie'].append(http_cookie) - else: - self.headers['Set-Cookie'] = [http_cookie] - - def delete_cookie(self, cookie, **kwargs): - """Delete a cookie. - - :param cookie: The cookie's name. - :param kwargs: Any cookie opens and flags supported by - ``set_cookie()`` except ``expires`` and ``max_age``. - """ - self.set_cookie(cookie, '', expires='Thu, 01 Jan 1970 00:00:01 GMT', - max_age=0, **kwargs) - - def complete(self): - if isinstance(self.body, bytes) and \ - 'Content-Length' not in self.headers: - self.headers['Content-Length'] = str(len(self.body)) - if 'Content-Type' not in self.headers: - self.headers['Content-Type'] = self.default_content_type - if 'charset=' not in self.headers['Content-Type']: - self.headers['Content-Type'] += '; charset=UTF-8' - - async def write(self, stream): - self.complete() - - try: - # status code - reason = self.reason if self.reason is not None else \ - ('OK' if self.status_code == 200 else 'N/A') - await stream.awrite('HTTP/1.0 {status_code} {reason}\r\n'.format( - status_code=self.status_code, reason=reason).encode()) - - # headers - for header, value in self.headers.items(): - values = value if isinstance(value, list) else [value] - for value in values: - await stream.awrite('{header}: {value}\r\n'.format( - header=header, value=value).encode()) - await stream.awrite(b'\r\n') - - # body - if not self.is_head: - iter = self.body_iter() - async for body in iter: - if isinstance(body, str): # pragma: no cover - body = body.encode() - try: - await stream.awrite(body) - except OSError as exc: # pragma: no cover - if exc.errno in MUTED_SOCKET_ERRORS or \ - exc.args[0] == 'Connection lost': - if hasattr(iter, 'aclose'): - await iter.aclose() - raise - if hasattr(iter, 'aclose'): # pragma: no branch - await iter.aclose() - - except OSError as exc: # pragma: no cover - if exc.errno in MUTED_SOCKET_ERRORS or \ - exc.args[0] == 'Connection lost': - pass - else: - raise - - def body_iter(self): - if hasattr(self.body, '__anext__'): - # response body is an async generator - return self.body - - response = self - - class iter: - ITER_UNKNOWN = 0 - ITER_SYNC_GEN = 1 - ITER_FILE_OBJ = 2 - ITER_NO_BODY = -1 - - def __aiter__(self): - if response.body: - self.i = self.ITER_UNKNOWN # need to determine type - else: - self.i = self.ITER_NO_BODY - return self - - async def __anext__(self): - if self.i == self.ITER_NO_BODY: - await self.aclose() - raise StopAsyncIteration - if self.i == self.ITER_UNKNOWN: - if hasattr(response.body, 'read'): - self.i = self.ITER_FILE_OBJ - elif hasattr(response.body, '__next__'): - self.i = self.ITER_SYNC_GEN - return next(response.body) - else: - self.i = self.ITER_NO_BODY - return response.body - elif self.i == self.ITER_SYNC_GEN: - try: - return next(response.body) - except StopIteration: - await self.aclose() - raise StopAsyncIteration - buf = response.body.read(response.send_file_buffer_size) - if iscoroutine(buf): # pragma: no cover - buf = await buf - if len(buf) < response.send_file_buffer_size: - self.i = self.ITER_NO_BODY - return buf - - async def aclose(self): - if hasattr(response.body, 'close'): - result = response.body.close() - if iscoroutine(result): # pragma: no cover - await result - - return iter() - - @classmethod - def redirect(cls, location, status_code=302): - """Return a redirect response. - - :param location: The URL to redirect to. - :param status_code: The 3xx status code to use for the redirect. The - default is 302. - """ - if '\x0d' in location or '\x0a' in location: - raise ValueError('invalid redirect URL') - return cls(status_code=status_code, headers={'Location': location}) - - @classmethod - def send_file(cls, filename, status_code=200, content_type=None, - stream=None, max_age=None, compressed=False, - file_extension=''): - """Send file contents in a response. - - :param filename: The filename of the file. - :param status_code: The 3xx status code to use for the redirect. The - default is 302. - :param content_type: The ``Content-Type`` header to use in the - response. If omitted, it is generated - automatically from the file extension of the - ``filename`` parameter. - :param stream: A file-like object to read the file contents from. If - a stream is given, the ``filename`` parameter is only - used when generating the ``Content-Type`` header. - :param max_age: The ``Cache-Control`` header's ``max-age`` value in - seconds. If omitted, the value of the - :attr:`Response.default_send_file_max_age` attribute is - used. - :param compressed: Whether the file is compressed. If ``True``, the - ``Content-Encoding`` header is set to ``gzip``. A - string with the header value can also be passed. - Note that when using this option the file must have - been compressed beforehand. This option only sets - the header. - :param file_extension: A file extension to append to the ``filename`` - parameter when opening the file, including the - dot. The extension given here is not considered - when generating the ``Content-Type`` header. - - Security note: The filename is assumed to be trusted. Never pass - filenames provided by the user without validating and sanitizing them - first. - """ - if content_type is None: - if compressed and filename.endswith('.gz'): - ext = filename[:-3].split('.')[-1] - else: - ext = filename.split('.')[-1] - if ext in Response.types_map: - content_type = Response.types_map[ext] - else: - content_type = 'application/octet-stream' - headers = {'Content-Type': content_type} - - if max_age is None: - max_age = cls.default_send_file_max_age - if max_age is not None: - headers['Cache-Control'] = 'max-age={}'.format(max_age) - - if compressed: - headers['Content-Encoding'] = compressed \ - if isinstance(compressed, str) else 'gzip' - - f = stream or open(filename + file_extension, 'rb') - return cls(body=f, status_code=status_code, headers=headers) - - -class URLPattern(): - def __init__(self, url_pattern): - self.url_pattern = url_pattern - self.segments = [] - self.regex = None - pattern = '' - use_regex = False - for segment in url_pattern.lstrip('/').split('/'): - if segment and segment[0] == '<': - if segment[-1] != '>': - raise ValueError('invalid URL pattern') - segment = segment[1:-1] - if ':' in segment: - type_, name = segment.rsplit(':', 1) - else: - type_ = 'string' - name = segment - parser = None - if type_ == 'string': - parser = self._string_segment - pattern += '/([^/]+)' - elif type_ == 'int': - parser = self._int_segment - pattern += '/(-?\\d+)' - elif type_ == 'path': - use_regex = True - pattern += '/(.+)' - elif type_.startswith('re:'): - use_regex = True - pattern += '/({pattern})'.format(pattern=type_[3:]) - else: - raise ValueError('invalid URL segment type') - self.segments.append({'parser': parser, 'name': name, - 'type': type_}) - else: - pattern += '/' + segment - self.segments.append({'parser': self._static_segment(segment)}) - if use_regex: - import re - self.regex = re.compile('^' + pattern + '$') - - def match(self, path): - args = {} - if self.regex: - g = self.regex.match(path) - if not g: - return - i = 1 - for segment in self.segments: - if 'name' not in segment: - continue - value = g.group(i) - if segment['type'] == 'int': - value = int(value) - args[segment['name']] = value - i += 1 - else: - if len(path) == 0 or path[0] != '/': - return - path = path[1:] - args = {} - for segment in self.segments: - if path is None: - return - arg, path = segment['parser'](path) - if arg is None: - return - if 'name' in segment: - args[segment['name']] = arg - if path is not None: - return - return args - - def _static_segment(self, segment): - def _static(value): - s = value.split('/', 1) - if s[0] == segment: - return '', s[1] if len(s) > 1 else None - return None, None - return _static - - def _string_segment(self, value): - s = value.split('/', 1) - if len(s[0]) == 0: - return None, None - return s[0], s[1] if len(s) > 1 else None - - def _int_segment(self, value): - s = value.split('/', 1) - try: - return int(s[0]), s[1] if len(s) > 1 else None - except ValueError: - return None, None - - -class HTTPException(Exception): - def __init__(self, status_code, reason=None): - self.status_code = status_code - self.reason = reason or str(status_code) + ' error' - - def __repr__(self): # pragma: no cover - return 'HTTPException: {}'.format(self.status_code) - - -class Microdot: - """An HTTP application class. - - This class implements an HTTP application instance and is heavily - influenced by the ``Flask`` class of the Flask framework. It is typically - declared near the start of the main application script. - - Example:: - - from microdot import Microdot - - app = Microdot() - """ - - def __init__(self): - self.url_map = [] - self.before_request_handlers = [] - self.after_request_handlers = [] - self.after_error_request_handlers = [] - self.error_handlers = {} - self.shutdown_requested = False - self.options_handler = self.default_options_handler - self.debug = False - self.server = None - - def route(self, url_pattern, methods=None): - """Decorator that is used to register a function as a request handler - for a given URL. - - :param url_pattern: The URL pattern that will be compared against - incoming requests. - :param methods: The list of HTTP methods to be handled by the - decorated function. If omitted, only ``GET`` requests - are handled. - - The URL pattern can be a static path (for example, ``/users`` or - ``/api/invoices/search``) or a path with dynamic components enclosed - in ``<`` and ``>`` (for example, ``/users/`` or - ``/invoices//products``). Dynamic path components can also - include a type prefix, separated from the name with a colon (for - example, ``/users/``). The type can be ``string`` (the - default), ``int``, ``path`` or ``re:[regular-expression]``. - - The first argument of the decorated function must be - the request object. Any path arguments that are specified in the URL - pattern are passed as keyword arguments. The return value of the - function must be a :class:`Response` instance, or the arguments to - be passed to this class. - - Example:: - - @app.route('/') - def index(request): - return 'Hello, world!' - """ - def decorated(f): - self.url_map.append( - ([m.upper() for m in (methods or ['GET'])], - URLPattern(url_pattern), f)) - return f - return decorated - - def get(self, url_pattern): - """Decorator that is used to register a function as a ``GET`` request - handler for a given URL. - - :param url_pattern: The URL pattern that will be compared against - incoming requests. - - This decorator can be used as an alias to the ``route`` decorator with - ``methods=['GET']``. - - Example:: - - @app.get('/users/') - def get_user(request, id): - # ... - """ - return self.route(url_pattern, methods=['GET']) - - def post(self, url_pattern): - """Decorator that is used to register a function as a ``POST`` request - handler for a given URL. - - :param url_pattern: The URL pattern that will be compared against - incoming requests. - - This decorator can be used as an alias to the``route`` decorator with - ``methods=['POST']``. - - Example:: - - @app.post('/users') - def create_user(request): - # ... - """ - return self.route(url_pattern, methods=['POST']) - - def put(self, url_pattern): - """Decorator that is used to register a function as a ``PUT`` request - handler for a given URL. - - :param url_pattern: The URL pattern that will be compared against - incoming requests. - - This decorator can be used as an alias to the ``route`` decorator with - ``methods=['PUT']``. - - Example:: - - @app.put('/users/') - def edit_user(request, id): - # ... - """ - return self.route(url_pattern, methods=['PUT']) - - def patch(self, url_pattern): - """Decorator that is used to register a function as a ``PATCH`` request - handler for a given URL. - - :param url_pattern: The URL pattern that will be compared against - incoming requests. - - This decorator can be used as an alias to the ``route`` decorator with - ``methods=['PATCH']``. - - Example:: - - @app.patch('/users/') - def edit_user(request, id): - # ... - """ - return self.route(url_pattern, methods=['PATCH']) - - def delete(self, url_pattern): - """Decorator that is used to register a function as a ``DELETE`` - request handler for a given URL. - - :param url_pattern: The URL pattern that will be compared against - incoming requests. - - This decorator can be used as an alias to the ``route`` decorator with - ``methods=['DELETE']``. - - Example:: - - @app.delete('/users/') - def delete_user(request, id): - # ... - """ - return self.route(url_pattern, methods=['DELETE']) - - def before_request(self, f): - """Decorator to register a function to run before each request is - handled. The decorated function must take a single argument, the - request object. - - Example:: - - @app.before_request - def func(request): - # ... - """ - self.before_request_handlers.append(f) - return f - - def after_request(self, f): - """Decorator to register a function to run after each request is - handled. The decorated function must take two arguments, the request - and response objects. The return value of the function must be an - updated response object. - - Example:: - - @app.after_request - def func(request, response): - # ... - return response - """ - self.after_request_handlers.append(f) - return f - - def after_error_request(self, f): - """Decorator to register a function to run after an error response is - generated. The decorated function must take two arguments, the request - and response objects. The return value of the function must be an - updated response object. The handler is invoked for error responses - generated by Microdot, as well as those returned by application-defined - error handlers. - - Example:: - - @app.after_error_request - def func(request, response): - # ... - return response - """ - self.after_error_request_handlers.append(f) - return f - - def errorhandler(self, status_code_or_exception_class): - """Decorator to register a function as an error handler. Error handler - functions for numeric HTTP status codes must accept a single argument, - the request object. Error handler functions for Python exceptions - must accept two arguments, the request object and the exception - object. - - :param status_code_or_exception_class: The numeric HTTP status code or - Python exception class to - handle. - - Examples:: - - @app.errorhandler(404) - def not_found(request): - return 'Not found' - - @app.errorhandler(RuntimeError) - def runtime_error(request, exception): - return 'Runtime error' - """ - def decorated(f): - self.error_handlers[status_code_or_exception_class] = f - return f - return decorated - - def mount(self, subapp, url_prefix=''): - """Mount a sub-application, optionally under the given URL prefix. - - :param subapp: The sub-application to mount. - :param url_prefix: The URL prefix to mount the application under. - """ - for methods, pattern, handler in subapp.url_map: - self.url_map.append( - (methods, URLPattern(url_prefix + pattern.url_pattern), - handler)) - for handler in subapp.before_request_handlers: - self.before_request_handlers.append(handler) - for handler in subapp.after_request_handlers: - self.after_request_handlers.append(handler) - for handler in subapp.after_error_request_handlers: - self.after_error_request_handlers.append(handler) - for status_code, handler in subapp.error_handlers.items(): - self.error_handlers[status_code] = handler - - @staticmethod - def abort(status_code, reason=None): - """Abort the current request and return an error response with the - given status code. - - :param status_code: The numeric status code of the response. - :param reason: The reason for the response, which is included in the - response body. - - Example:: - - from microdot import abort - - @app.route('/users/') - def get_user(id): - user = get_user_by_id(id) - if user is None: - abort(404) - return user.to_dict() - """ - raise HTTPException(status_code, reason) - - async def start_server(self, host='0.0.0.0', port=5000, debug=False, - ssl=None): - """Start the Microdot web server as a coroutine. This coroutine does - not normally return, as the server enters an endless listening loop. - The :func:`shutdown` function provides a method for terminating the - server gracefully. - - :param host: The hostname or IP address of the network interface that - will be listening for requests. A value of ``'0.0.0.0'`` - (the default) indicates that the server should listen for - requests on all the available interfaces, and a value of - ``127.0.0.1`` indicates that the server should listen - for requests only on the internal networking interface of - the host. - :param port: The port number to listen for requests. The default is - port 5000. - :param debug: If ``True``, the server logs debugging information. The - default is ``False``. - :param ssl: An ``SSLContext`` instance or ``None`` if the server should - not use TLS. The default is ``None``. - - This method is a coroutine. - - Example:: - - import asyncio - from microdot import Microdot - - app = Microdot() - - @app.route('/') - async def index(request): - return 'Hello, world!' - - async def main(): - await app.start_server(debug=True) - - asyncio.run(main()) - """ - self.debug = debug - - async def serve(reader, writer): - if not hasattr(writer, 'awrite'): # pragma: no cover - # CPython provides the awrite and aclose methods in 3.8+ - async def awrite(self, data): - self.write(data) - await self.drain() - - async def aclose(self): - self.close() - await self.wait_closed() - - from types import MethodType - writer.awrite = MethodType(awrite, writer) - writer.aclose = MethodType(aclose, writer) - - await self.handle_request(reader, writer) - - if self.debug: # pragma: no cover - print('Starting async server on {host}:{port}...'.format( - host=host, port=port)) - - try: - self.server = await asyncio.start_server(serve, host, port, - ssl=ssl) - except TypeError: # pragma: no cover - self.server = await asyncio.start_server(serve, host, port) - - while True: - try: - if hasattr(self.server, 'serve_forever'): # pragma: no cover - try: - await self.server.serve_forever() - except asyncio.CancelledError: - pass - await self.server.wait_closed() - break - except AttributeError: # pragma: no cover - # the task hasn't been initialized in the server object yet - # wait a bit and try again - await asyncio.sleep(0.1) - - def run(self, host='0.0.0.0', port=5000, debug=False, ssl=None): - """Start the web server. This function does not normally return, as - the server enters an endless listening loop. The :func:`shutdown` - function provides a method for terminating the server gracefully. - - :param host: The hostname or IP address of the network interface that - will be listening for requests. A value of ``'0.0.0.0'`` - (the default) indicates that the server should listen for - requests on all the available interfaces, and a value of - ``127.0.0.1`` indicates that the server should listen - for requests only on the internal networking interface of - the host. - :param port: The port number to listen for requests. The default is - port 5000. - :param debug: If ``True``, the server logs debugging information. The - default is ``False``. - :param ssl: An ``SSLContext`` instance or ``None`` if the server should - not use TLS. The default is ``None``. - - Example:: - - from microdot import Microdot - - app = Microdot() - - @app.route('/') - async def index(request): - return 'Hello, world!' - - app.run(debug=True) - """ - asyncio.run(self.start_server(host=host, port=port, debug=debug, - ssl=ssl)) # pragma: no cover - - def shutdown(self): - """Request a server shutdown. The server will then exit its request - listening loop and the :func:`run` function will return. This function - can be safely called from a route handler, as it only schedules the - server to terminate as soon as the request completes. - - Example:: - - @app.route('/shutdown') - def shutdown(request): - request.app.shutdown() - return 'The server is shutting down...' - """ - self.server.close() - - def find_route(self, req): - method = req.method.upper() - if method == 'OPTIONS' and self.options_handler: - return self.options_handler(req) - if method == 'HEAD': - method = 'GET' - f = 404 - for route_methods, route_pattern, route_handler in self.url_map: - req.url_args = route_pattern.match(req.path) - if req.url_args is not None: - if method in route_methods: - f = route_handler - break - else: - f = 405 - return f - - def default_options_handler(self, req): - allow = [] - for route_methods, route_pattern, route_handler in self.url_map: - if route_pattern.match(req.path) is not None: - allow.extend(route_methods) - if 'GET' in allow: - allow.append('HEAD') - allow.append('OPTIONS') - return {'Allow': ', '.join(allow)} - - async def handle_request(self, reader, writer): - req = None - try: - req = await Request.create(self, reader, writer, - writer.get_extra_info('peername')) - except Exception as exc: # pragma: no cover - print_exception(exc) - - res = await self.dispatch_request(req) - if res != Response.already_handled: # pragma: no branch - await res.write(writer) - try: - await writer.aclose() - except OSError as exc: # pragma: no cover - if exc.errno in MUTED_SOCKET_ERRORS: - pass - else: - raise - if self.debug and req: # pragma: no cover - print('{method} {path} {status_code}'.format( - method=req.method, path=req.path, - status_code=res.status_code)) - - async def dispatch_request(self, req): - after_request_handled = False - if req: - if req.content_length > req.max_content_length: - if 413 in self.error_handlers: - res = await invoke_handler(self.error_handlers[413], req) - else: - res = 'Payload too large', 413 - else: - f = self.find_route(req) - try: - res = None - if callable(f): - for handler in self.before_request_handlers: - res = await invoke_handler(handler, req) - if res: - break - if res is None: - res = await invoke_handler( - f, req, **req.url_args) - if isinstance(res, int): - res = '', res - if isinstance(res, tuple): - if isinstance(res[0], int): - res = ('', res[0], - res[1] if len(res) > 1 else {}) - body = res[0] - if isinstance(res[1], int): - status_code = res[1] - headers = res[2] if len(res) > 2 else {} - else: - status_code = 200 - headers = res[1] - res = Response(body, status_code, headers) - elif not isinstance(res, Response): - res = Response(res) - for handler in self.after_request_handlers: - res = await invoke_handler( - handler, req, res) or res - for handler in req.after_request_handlers: - res = await invoke_handler( - handler, req, res) or res - after_request_handled = True - elif isinstance(f, dict): - res = Response(headers=f) - elif f in self.error_handlers: - res = await invoke_handler(self.error_handlers[f], req) - else: - res = 'Not found', f - except HTTPException as exc: - if exc.status_code in self.error_handlers: - res = self.error_handlers[exc.status_code](req) - else: - res = exc.reason, exc.status_code - except Exception as exc: - print_exception(exc) - exc_class = None - res = None - if exc.__class__ in self.error_handlers: - exc_class = exc.__class__ - else: - for c in mro(exc.__class__)[1:]: - if c in self.error_handlers: - exc_class = c - break - if exc_class: - try: - res = await invoke_handler( - self.error_handlers[exc_class], req, exc) - except Exception as exc2: # pragma: no cover - print_exception(exc2) - if res is None: - if 500 in self.error_handlers: - res = await invoke_handler( - self.error_handlers[500], req) - else: - res = 'Internal server error', 500 - else: - if 400 in self.error_handlers: - res = await invoke_handler(self.error_handlers[400], req) - else: - res = 'Bad request', 400 - if isinstance(res, tuple): - res = Response(*res) - elif not isinstance(res, Response): - res = Response(res) - if not after_request_handled: - for handler in self.after_error_request_handlers: - res = await invoke_handler( - handler, req, res) or res - res.is_head = (req and req.method == 'HEAD') - return res - - -Response.already_handled = Response() - -abort = Microdot.abort -redirect = Response.redirect -send_file = Response.send_file \ No newline at end of file diff --git a/lib/microdot/session.py b/lib/microdot/session.py deleted file mode 100644 index 78ce2e6..0000000 --- a/lib/microdot/session.py +++ /dev/null @@ -1,225 +0,0 @@ -try: - import jwt - HAS_JWT = True -except ImportError: - HAS_JWT = False - try: - import ubinascii - except ImportError: - import binascii as ubinascii - try: - import uhashlib as hashlib - except ImportError: - import hashlib - try: - import uhmac as hmac - except ImportError: - try: - import hmac - except ImportError: - hmac = None - import json - -from microdot.microdot import invoke_handler -from microdot.helpers import wraps - - -class SessionDict(dict): - """A session dictionary. - - The session dictionary is a standard Python dictionary that has been - extended with convenience ``save()`` and ``delete()`` methods. - """ - def __init__(self, request, session_dict): - super().__init__(session_dict) - self.request = request - - def save(self): - """Update the session cookie.""" - self.request.app._session.update(self.request, self) - - def delete(self): - """Delete the session cookie.""" - self.request.app._session.delete(self.request) - - -class Session: - """Session handling - - :param app: The application instance. - :param secret_key: The secret key, as a string or bytes object. - :param cookie_options: A dictionary with cookie options to pass as - arguments to :meth:`Response.set_cookie() - `. - """ - secret_key = None - - def __init__(self, app=None, secret_key=None, cookie_options=None): - self.secret_key = secret_key - self.cookie_options = cookie_options or {} - if app is not None: - self.initialize(app) - - def initialize(self, app, secret_key=None, cookie_options=None): - if secret_key is not None: - self.secret_key = secret_key - if cookie_options is not None: - self.cookie_options = cookie_options - if 'path' not in self.cookie_options: - self.cookie_options['path'] = '/' - if 'http_only' not in self.cookie_options: - self.cookie_options['http_only'] = True - app._session = self - - def get(self, request): - """Retrieve the user session. - - :param request: The client request. - - The return value is a session dictionary with the data stored in the - user's session, or ``{}`` if the session data is not available or - invalid. - """ - if not self.secret_key: - raise ValueError('The session secret key is not configured') - if hasattr(request.g, '_session'): - return request.g._session - session = request.cookies.get('session') - if session is None: - request.g._session = SessionDict(request, {}) - return request.g._session - request.g._session = SessionDict(request, self.decode(session)) - return request.g._session - - def update(self, request, session): - """Update the user session. - - :param request: The client request. - :param session: A dictionary with the update session data for the user. - - Applications would normally not call this method directly, instead they - would use the :meth:`SessionDict.save` method on the session - dictionary, which calls this method. For example:: - - @app.route('/') - @with_session - def index(request, session): - session['foo'] = 'bar' - session.save() - return 'Hello, World!' - - Calling this method adds a cookie with the updated session to the - request currently being processed. - """ - if not self.secret_key: - raise ValueError('The session secret key is not configured') - - encoded_session = self.encode(session) - - @request.after_request - def _update_session(request, response): - response.set_cookie('session', encoded_session, - **self.cookie_options) - return response - - def delete(self, request): - """Remove the user session. - - :param request: The client request. - - Applications would normally not call this method directly, instead they - would use the :meth:`SessionDict.delete` method on the session - dictionary, which calls this method. For example:: - - @app.route('/') - @with_session - def index(request, session): - session.delete() - return 'Hello, World!' - - Calling this method adds a cookie removal header to the request - currently being processed. - """ - @request.after_request - def _delete_session(request, response): - response.delete_cookie('session', **self.cookie_options) - return response - - def encode(self, payload, secret_key=None): - """Encode session data using JWT if available, otherwise use simple HMAC.""" - if HAS_JWT: - return jwt.encode(payload, secret_key or self.secret_key, - algorithm='HS256') - else: - # Simple encoding for MicroPython: base64(json) + HMAC signature - key = (secret_key or self.secret_key).encode() if isinstance(secret_key or self.secret_key, str) else (secret_key or self.secret_key) - payload_json = json.dumps(payload) - payload_b64 = ubinascii.b2a_base64(payload_json.encode()).decode().strip() - - # Create HMAC signature - if hmac: - # Use hmac module if available - h = hmac.new(key, payload_json.encode(), hashlib.sha256) - else: - # Fallback: simple SHA256(key + message) - h = hashlib.sha256(key + payload_json.encode()) - signature = ubinascii.b2a_base64(h.digest()).decode().strip() - - return f"{payload_b64}.{signature}" - - def decode(self, session, secret_key=None): - """Decode session data using JWT if available, otherwise use simple HMAC.""" - if HAS_JWT: - try: - payload = jwt.decode(session, secret_key or self.secret_key, - algorithms=['HS256']) - except jwt.exceptions.PyJWTError: # pragma: no cover - return {} - return payload - else: - try: - # Simple decoding for MicroPython - if '.' not in session: - return {} - - payload_b64, signature = session.rsplit('.', 1) - payload_json = ubinascii.a2b_base64(payload_b64).decode() - - # Verify HMAC signature - key = (secret_key or self.secret_key).encode() if isinstance(secret_key or self.secret_key, str) else (secret_key or self.secret_key) - if hmac: - # Use hmac module if available - h = hmac.new(key, payload_json.encode(), hashlib.sha256) - else: - # Fallback: simple SHA256(key + message) - h = hashlib.sha256(key + payload_json.encode()) - expected_signature = ubinascii.b2a_base64(h.digest()).decode().strip() - - if signature != expected_signature: - return {} - - return json.loads(payload_json) - except Exception: - return {} - - -def with_session(f): - """Decorator that passes the user session to the route handler. - - The session dictionary is passed to the decorated function as an argument - after the request object. Example:: - - @app.route('/') - @with_session - def index(request, session): - return 'Hello, World!' - - Note that the decorator does not save the session. To update the session, - call the :func:`session.save() ` method. - """ - @wraps(f) - async def wrapper(request, *args, **kwargs): - return await invoke_handler( - f, request, request.app._session.get(request), *args, **kwargs) - - return wrapper diff --git a/lib/microdot/utemplate.py b/lib/microdot/utemplate.py deleted file mode 100644 index 16d0398..0000000 --- a/lib/microdot/utemplate.py +++ /dev/null @@ -1,70 +0,0 @@ -from utemplate import recompile - -_loader = None - - -class Template: - """A template object. - - :param template: The filename of the template to render, relative to the - configured template directory. - """ - @classmethod - def initialize(cls, template_dir='templates', - loader_class=recompile.Loader): - """Initialize the templating subsystem. - - :param template_dir: the directory where templates are stored. This - argument is optional. The default is to load - templates from a *templates* subdirectory. - :param loader_class: the ``utemplate.Loader`` class to use when loading - templates. This argument is optional. The default - is the ``recompile.Loader`` class, which - automatically recompiles templates when they - change. - """ - global _loader - _loader = loader_class(None, template_dir) - - def __init__(self, template): - if _loader is None: # pragma: no cover - self.initialize() - #: The name of the template - self.name = template - self.template = _loader.load(template) - - def generate(self, *args, **kwargs): - """Return a generator that renders the template in chunks, with the - given arguments.""" - return self.template(*args, **kwargs) - - def render(self, *args, **kwargs): - """Render the template with the given arguments and return it as a - string.""" - return ''.join(self.generate(*args, **kwargs)) - - def generate_async(self, *args, **kwargs): - """Return an asynchronous generator that renders the template in - chunks, using the given arguments.""" - class sync_to_async_iter(): - def __init__(self, iter): - self.iter = iter - - def __aiter__(self): - return self - - async def __anext__(self): - try: - return next(self.iter) - except StopIteration: - raise StopAsyncIteration - - return sync_to_async_iter(self.generate(*args, **kwargs)) - - async def render_async(self, *args, **kwargs): - """Render the template with the given arguments asynchronously and - return it as a string.""" - response = '' - async for chunk in self.generate_async(*args, **kwargs): - response += chunk - return response diff --git a/lib/microdot/websocket.py b/lib/microdot/websocket.py deleted file mode 100644 index 0fb6f7c..0000000 --- a/lib/microdot/websocket.py +++ /dev/null @@ -1,231 +0,0 @@ -import binascii -import hashlib -from microdot import Request, Response -from microdot.microdot import MUTED_SOCKET_ERRORS, print_exception -from microdot.helpers import wraps - - -class WebSocketError(Exception): - """Exception raised when an error occurs in a WebSocket connection.""" - pass - - -class WebSocket: - """A WebSocket connection object. - - An instance of this class is sent to handler functions to manage the - WebSocket connection. - """ - CONT = 0 - TEXT = 1 - BINARY = 2 - CLOSE = 8 - PING = 9 - PONG = 10 - - #: Specify the maximum message size that can be received when calling the - #: ``receive()`` method. Messages with payloads that are larger than this - #: size will be rejected and the connection closed. Set to 0 to disable - #: the size check (be aware of potential security issues if you do this), - #: or to -1 to use the value set in - #: ``Request.max_body_length``. The default is -1. - #: - #: Example:: - #: - #: WebSocket.max_message_length = 4 * 1024 # up to 4KB messages - max_message_length = -1 - - def __init__(self, request): - self.request = request - self.closed = False - - async def handshake(self): - response = self._handshake_response() - await self.request.sock[1].awrite( - b'HTTP/1.1 101 Switching Protocols\r\n') - await self.request.sock[1].awrite(b'Upgrade: websocket\r\n') - await self.request.sock[1].awrite(b'Connection: Upgrade\r\n') - await self.request.sock[1].awrite( - b'Sec-WebSocket-Accept: ' + response + b'\r\n\r\n') - - async def receive(self): - """Receive a message from the client.""" - while True: - opcode, payload = await self._read_frame() - send_opcode, data = self._process_websocket_frame(opcode, payload) - if send_opcode: # pragma: no cover - await self.send(data, send_opcode) - elif data: # pragma: no branch - return data - - async def send(self, data, opcode=None): - """Send a message to the client. - - :param data: the data to send, given as a string or bytes. - :param opcode: a custom frame opcode to use. If not given, the opcode - is ``TEXT`` or ``BINARY`` depending on the type of the - data. - """ - frame = self._encode_websocket_frame( - opcode or (self.TEXT if isinstance(data, str) else self.BINARY), - data) - await self.request.sock[1].awrite(frame) - - async def close(self): - """Close the websocket connection.""" - if not self.closed: # pragma: no cover - self.closed = True - await self.send(b'', self.CLOSE) - - def _handshake_response(self): - connection = False - upgrade = False - websocket_key = None - for header, value in self.request.headers.items(): - h = header.lower() - if h == 'connection': - connection = True - if 'upgrade' not in value.lower(): - return self.request.app.abort(400) - elif h == 'upgrade': - upgrade = True - if not value.lower() == 'websocket': - return self.request.app.abort(400) - elif h == 'sec-websocket-key': - websocket_key = value - if not connection or not upgrade or not websocket_key: - return self.request.app.abort(400) - d = hashlib.sha1(websocket_key.encode()) - d.update(b'258EAFA5-E914-47DA-95CA-C5AB0DC85B11') - return binascii.b2a_base64(d.digest())[:-1] - - @classmethod - def _parse_frame_header(cls, header): - fin = header[0] & 0x80 - opcode = header[0] & 0x0f - if fin == 0 or opcode == cls.CONT: # pragma: no cover - raise WebSocketError('Continuation frames not supported') - has_mask = header[1] & 0x80 - length = header[1] & 0x7f - if length == 126: - length = -2 - elif length == 127: - length = -8 - return fin, opcode, has_mask, length - - def _process_websocket_frame(self, opcode, payload): - if opcode == self.TEXT: - payload = payload.decode() - elif opcode == self.BINARY: - pass - elif opcode == self.CLOSE: - raise WebSocketError('Websocket connection closed') - elif opcode == self.PING: - return self.PONG, payload - elif opcode == self.PONG: # pragma: no branch - return None, None - return None, payload - - @classmethod - def _encode_websocket_frame(cls, opcode, payload): - frame = bytearray() - frame.append(0x80 | opcode) - if opcode == cls.TEXT: - payload = payload.encode() - if len(payload) < 126: - frame.append(len(payload)) - elif len(payload) < (1 << 16): - frame.append(126) - frame.extend(len(payload).to_bytes(2, 'big')) - else: - frame.append(127) - frame.extend(len(payload).to_bytes(8, 'big')) - frame.extend(payload) - return frame - - async def _read_frame(self): - header = await self.request.sock[0].read(2) - if len(header) != 2: # pragma: no cover - raise WebSocketError('Websocket connection closed') - fin, opcode, has_mask, length = self._parse_frame_header(header) - if length == -2: - length = await self.request.sock[0].read(2) - length = int.from_bytes(length, 'big') - elif length == -8: - length = await self.request.sock[0].read(8) - length = int.from_bytes(length, 'big') - max_allowed_length = Request.max_body_length \ - if self.max_message_length == -1 else self.max_message_length - if length > max_allowed_length: - raise WebSocketError('Message too large') - if has_mask: # pragma: no cover - mask = await self.request.sock[0].read(4) - payload = await self.request.sock[0].read(length) - if has_mask: # pragma: no cover - payload = bytes(x ^ mask[i % 4] for i, x in enumerate(payload)) - return opcode, payload - - -async def websocket_upgrade(request): - """Upgrade a request handler to a websocket connection. - - This function can be called directly inside a route function to process a - WebSocket upgrade handshake, for example after the user's credentials are - verified. The function returns the websocket object:: - - @app.route('/echo') - async def echo(request): - if not authenticate_user(request): - abort(401) - ws = await websocket_upgrade(request) - while True: - message = await ws.receive() - await ws.send(message) - """ - ws = WebSocket(request) - await ws.handshake() - - @request.after_request - async def after_request(request, response): - return Response.already_handled - - return ws - - -def websocket_wrapper(f, upgrade_function): - @wraps(f) - async def wrapper(request, *args, **kwargs): - ws = await upgrade_function(request) - try: - await f(request, ws, *args, **kwargs) - except OSError as exc: - if exc.errno not in MUTED_SOCKET_ERRORS: # pragma: no cover - raise - except WebSocketError: - pass - except Exception as exc: - print_exception(exc) - finally: # pragma: no cover - try: - await ws.close() - except Exception: - pass - return Response.already_handled - return wrapper - - -def with_websocket(f): - """Decorator to make a route a WebSocket endpoint. - - This decorator is used to define a route that accepts websocket - connections. The route then receives a websocket object as a second - argument that it can use to send and receive messages:: - - @app.route('/echo') - @with_websocket - async def echo(request, ws): - while True: - message = await ws.receive() - await ws.send(message) - """ - return websocket_wrapper(f, websocket_upgrade) diff --git a/lib/utemplate/__init__.py b/lib/utemplate/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/lib/utemplate/compiled.py b/lib/utemplate/compiled.py deleted file mode 100644 index 006e6f5..0000000 --- a/lib/utemplate/compiled.py +++ /dev/null @@ -1,14 +0,0 @@ -class Loader: - - def __init__(self, pkg, dir): - if dir == ".": - dir = "" - else: - dir = dir.replace("/", ".") + "." - if pkg and pkg != "__main__": - dir = pkg + "." + dir - self.p = dir - - def load(self, name): - name = name.replace(".", "_") - return __import__(self.p + name, None, None, (name,)).render \ No newline at end of file diff --git a/lib/utemplate/recompile.py b/lib/utemplate/recompile.py deleted file mode 100644 index b9bae4e..0000000 --- a/lib/utemplate/recompile.py +++ /dev/null @@ -1,21 +0,0 @@ -# (c) 2014-2020 Paul Sokolovsky. MIT license. -try: - from uos import stat, remove -except: - from os import stat, remove -from . import source - - -class Loader(source.Loader): - - def load(self, name): - o_path = self.pkg_path + self.compiled_path(name) - i_path = self.pkg_path + self.dir + "/" + name - try: - o_stat = stat(o_path) - i_stat = stat(i_path) - if i_stat[8] > o_stat[8]: - # input file is newer, remove output to force recompile - remove(o_path) - finally: - return super().load(name) \ No newline at end of file diff --git a/lib/utemplate/source.py b/lib/utemplate/source.py deleted file mode 100644 index 0ff4651..0000000 --- a/lib/utemplate/source.py +++ /dev/null @@ -1,188 +0,0 @@ -# (c) 2014-2019 Paul Sokolovsky. MIT license. -from . import compiled - - -class Compiler: - - START_CHAR = "{" - STMNT = "%" - STMNT_END = "%}" - EXPR = "{" - EXPR_END = "}}" - - def __init__(self, file_in, file_out, indent=0, seq=0, loader=None): - self.file_in = file_in - self.file_out = file_out - self.loader = loader - self.seq = seq - self._indent = indent - self.stack = [] - self.in_literal = False - self.flushed_header = False - self.args = "*a, **d" - - def indent(self, adjust=0): - if not self.flushed_header: - self.flushed_header = True - self.indent() - self.file_out.write("def render%s(%s):\n" % (str(self.seq) if self.seq else "", self.args)) - self.stack.append("def") - self.file_out.write(" " * (len(self.stack) + self._indent + adjust)) - - def literal(self, s): - if not s: - return - if not self.in_literal: - self.indent() - self.file_out.write('yield """') - self.in_literal = True - self.file_out.write(s.replace('"', '\\"')) - - def close_literal(self): - if self.in_literal: - self.file_out.write('"""\n') - self.in_literal = False - - def render_expr(self, e): - self.indent() - self.file_out.write('yield str(' + e + ')\n') - - def parse_statement(self, stmt): - tokens = stmt.split(None, 1) - if tokens[0] == "args": - if len(tokens) > 1: - self.args = tokens[1] - else: - self.args = "" - elif tokens[0] == "set": - self.indent() - self.file_out.write(stmt[3:].strip() + "\n") - elif tokens[0] == "include": - if not self.flushed_header: - # If there was no other output, we still need a header now - self.indent() - tokens = tokens[1].split(None, 1) - args = "" - if len(tokens) > 1: - args = tokens[1] - if tokens[0][0] == "{": - self.indent() - # "1" as fromlist param is uPy hack - self.file_out.write('_ = __import__(%s.replace(".", "_"), None, None, 1)\n' % tokens[0][2:-2]) - self.indent() - self.file_out.write("yield from _.render(%s)\n" % args) - return - - with self.loader.input_open(tokens[0][1:-1]) as inc: - self.seq += 1 - c = Compiler(inc, self.file_out, len(self.stack) + self._indent, self.seq) - inc_id = self.seq - self.seq = c.compile() - self.indent() - self.file_out.write("yield from render%d(%s)\n" % (inc_id, args)) - elif len(tokens) > 1: - if tokens[0] == "elif": - assert self.stack[-1] == "if" - self.indent(-1) - self.file_out.write(stmt + ":\n") - else: - self.indent() - self.file_out.write(stmt + ":\n") - self.stack.append(tokens[0]) - else: - if stmt.startswith("end"): - assert self.stack[-1] == stmt[3:] - self.stack.pop(-1) - elif stmt == "else": - assert self.stack[-1] == "if" - self.indent(-1) - self.file_out.write("else:\n") - else: - assert False - - def parse_line(self, l): - while l: - start = l.find(self.START_CHAR) - if start == -1: - self.literal(l) - return - self.literal(l[:start]) - self.close_literal() - sel = l[start + 1] - #print("*%s=%s=" % (sel, EXPR)) - if sel == self.STMNT: - end = l.find(self.STMNT_END) - assert end > 0 - stmt = l[start + len(self.START_CHAR + self.STMNT):end].strip() - self.parse_statement(stmt) - end += len(self.STMNT_END) - l = l[end:] - if not self.in_literal and l == "\n": - break - elif sel == self.EXPR: - # print("EXPR") - end = l.find(self.EXPR_END) - assert end > 0 - expr = l[start + len(self.START_CHAR + self.EXPR):end].strip() - self.render_expr(expr) - end += len(self.EXPR_END) - l = l[end:] - else: - self.literal(l[start]) - l = l[start + 1:] - - def header(self): - self.file_out.write("# Autogenerated file\n") - - def compile(self): - self.header() - for l in self.file_in: - self.parse_line(l) - self.close_literal() - return self.seq - - -class Loader(compiled.Loader): - - def __init__(self, pkg, dir): - super().__init__(pkg, dir) - self.dir = dir - if pkg == "__main__": - # if pkg isn't really a package, don't bother to use it - # it means we're running from "filesystem directory", not - # from a package. - pkg = None - - self.pkg_path = "" - if pkg: - p = __import__(pkg) - if isinstance(p.__path__, str): - # uPy - self.pkg_path = p.__path__ - else: - # CPy - self.pkg_path = p.__path__[0] - self.pkg_path += "/" - - def input_open(self, template): - path = self.pkg_path + self.dir + "/" + template - return open(path) - - def compiled_path(self, template): - return self.dir + "/" + template.replace(".", "_") + ".py" - - def load(self, name): - try: - return super().load(name) - except (OSError, ImportError): - pass - - compiled_path = self.pkg_path + self.compiled_path(name) - - f_in = self.input_open(name) - f_out = open(compiled_path, "w") - c = Compiler(f_in, f_out, loader=self) - c.compile() - f_in.close() - f_out.close() - return super().load(name) \ No newline at end of file diff --git a/src/background_tasks.py b/src/background_tasks.py deleted file mode 100644 index a816139..0000000 --- a/src/background_tasks.py +++ /dev/null @@ -1,17 +0,0 @@ -import asyncio -import utime - -from mem_stats import print_mem - - -async def presets_loop(presets, wdt): - last_mem_log = utime.ticks_ms() - while True: - presets.tick() - wdt.feed() - if bool(getattr(presets, "debug", False)): - now = utime.ticks_ms() - if utime.ticks_diff(now, last_mem_log) >= 5000: - print_mem("runtime") - last_mem_log = now - await asyncio.sleep(0) diff --git a/src/beat_sync.py b/src/beat_sync.py deleted file mode 100644 index 2a81575..0000000 --- a/src/beat_sync.py +++ /dev/null @@ -1,92 +0,0 @@ -import struct - -WIRE_MAGIC = 0x4C -MSG_BEAT = 0x25 -FRAME_LEN = 8 # [4C][25][flags][idx u16][period u16][fire_in] -MIN_GUARD_MS = 30 -FREERUN_MISS_MAX = 4 -RESTART_BEATS = 3 # consecutive beats that all look old mean the controller restarted its counter - - -def _diff(a, b): - return (a - b) & 0xFFFF - - -class BeatSync: - """Turns beat frames from the controller into step triggers. - - The controller sends every beat twice with the same index; only the first - copy that arrives is acted on. Between frames the driver free-runs on the - last period so a lost beat is not noticed. - """ - - def __init__(self): - self.last_idx = None - self.period = 0 - self.last_fire = 0 - self.fire_at = None - self.downbeat = False - self.bar = 0 - self.missed = 0 - self.stale_idx = None # newest index seen while every frame looked old - self.stale_n = 0 - self.freerun_fire = False # True when the last fire was invented, not triggered by a frame - # fires: beats acted on; dups: second copies dropped; late: too-soon or old frames; - # freerun: beats the driver made up because no frame arrived - self.stats = {"fires": 0, "dups": 0, "late": 0, "freerun": 0} - - def on_frame(self, data, now): - """Handle one received frame. Call from the ESP-NOW irq: no allocation beyond unpack.""" - if len(data) != FRAME_LEN or data[0] != WIRE_MAGIC or data[1] != MSG_BEAT: - return False - flags, idx, period, fire_in = struct.unpack_from("= 0x8000: - # Behind us. A late copy is one or two frames; a controller that rebooted and - # restarted its counter sends a run of consecutive indices, so follow it. - if idx == self.stale_idx: - self.stats["late"] += 1 - return False - self.stale_n = self.stale_n + 1 if self.stale_idx is not None and _diff(idx, self.stale_idx) == 1 else 1 - self.stale_idx = idx - if self.stale_n < RESTART_BEATS: - self.stats["late"] += 1 - return False - elif ( - self.fire_at is None and now - self.last_fire < guard and self.period - ): - self.stats["late"] += 1 - return False # late copy of an older beat, or too soon after the last one - self.stale_idx = None - self.stale_n = 0 - self.last_idx = idx - self.period = period - self.downbeat = bool(flags & 1) - self.bar = (flags >> 1) & 7 - self.fire_at = now + fire_in - self.missed = 0 - return True - - def poll(self, now): - """True when a beat should step the pattern now. Call every tick.""" - if self.fire_at is not None: - if now - self.fire_at >= 0: - self.fire_at = None - self.last_fire = now - self.freerun_fire = False - self.stats["fires"] += 1 - return True - return False - if self.period and self.last_idx is not None and self.missed < FREERUN_MISS_MAX: - if now - (self.last_fire + self.period + self.period // 4) >= 0: - self.last_fire += self.period - self.missed += 1 - self.freerun_fire = True - self.stats["fires"] += 1 - self.stats["freerun"] += 1 - return True - return False diff --git a/src/binary_envelope.py b/src/binary_envelope.py deleted file mode 100644 index 555be9b..0000000 --- a/src/binary_envelope.py +++ /dev/null @@ -1,209 +0,0 @@ -"""Decode compact binary controller envelopes — v2 native binary, v1 legacy JSON blobs.""" - -import json -import struct - -BINARY_ENVELOPE_VERSION_1 = 1 -BINARY_ENVELOPE_VERSION_2 = 2 -HEADER_LEN = 5 - - -def _brightness_0_255_from_wire(wire): - w = max(0, min(127, int(wire))) - return min(255, (w * 255) // 127) - - -def _decode_preset_record(buf, off): - nl = buf[off] - off += 1 - name = buf[off : off + nl].decode("utf-8") - off += nl - pl = buf[off] - off += 1 - pattern = buf[off : off + pl].decode("utf-8") - off += pl - nc = buf[off] - off += 1 - colors = [] - for _ in range(nc): - r, g, b = buf[off], buf[off + 1], buf[off + 2] - off += 3 - colors.append("#%02x%02x%02x" % (r, g, b)) - if off + 16 > len(buf): - raise ValueError("truncated") - delay, br, auto, n1, n2, n3, n4, n5, n6 = struct.unpack_from( - " None: - """Serial log when led-controller sends a message into ``process_data``.""" - try: - if isinstance(payload, (bytes, bytearray)): - n = len(payload) - if n == 0: - print("rx 0 B") - return - cap = 160 - chunk = payload if n <= cap else payload[:cap] - try: - txt = bytes(chunk).decode("utf-8") - except Exception: - txt = str(chunk) - if n > cap: - txt = txt + "..." - print("rx", n, "B", txt) - else: - s = str(payload) - cap = 200 - if len(s) <= cap: - print("rx", len(s), "C", s) - else: - print("rx", len(s), "C", s[:cap] + "...") - except Exception: - print("rx (logging failed)") - - -def process_data(payload, settings, presets, controller_ip=None, save=False): - """Read one controller message; binary v2 envelope or JSON v1, then apply fields.""" - _log_rx(payload) - data = None - if isinstance(payload, (bytes, bytearray)): - data = parse_binary_envelope(payload) - if data is None: - try: - data = json.loads(payload) - except (ValueError, TypeError): - return - else: - try: - data = json.loads(payload) - except (ValueError, TypeError): - return - if data.get("v", "") != "1": - return - data = expand_v1(data) - if save: - data["save"] = True - set_groups = bool(data.get("set_groups")) - groups = data.get("groups") - if set_groups and isinstance(groups, list): - dg.groups_replace(groups, settings) - print("groups set", dg.list_groups()) - elif isinstance(groups, list) and groups: - if not any(dg.in_group(str(g)) for g in groups): - print("ignored: not in groups", groups) - return - if "device_config" in data: - apply_device_config(data, settings, presets) - if "b" in data: - apply_brightness(data, settings, presets) - if "presets" in data: - apply_presets(data, settings, presets) - if "clear_presets" in data: - apply_clear_presets(data, presets) - if ("select" in data or "s" in data) and "presets" not in data: - apply_select(data, settings, presets) - if "default" in data: - apply_default(data, settings, presets) - if "manifest" in data: - apply_patterns_ota(data, presets, controller_ip=controller_ip) - if "save" in data and ("presets" in data or "default" in data): - presets.save() - if "save" in data and "clear_presets" in data: - presets.save() - if "save" in data and "b" in data: - settings.save() - if "save" in data and "device_config" in data: - settings.save() - _flush_pending_select(settings, presets) - - -_VALID_DEVICE_COLOR_ORDERS = frozenset({"rgb", "rbg", "grb", "gbr", "brg", "bgr"}) -_STARTUP_MODES = frozenset({"default", "last", "off"}) -_MAX_DEVICE_LEDS = 2048 - - -def apply_startup_pattern(settings, presets): - """Apply power-on behaviour from ``startup_mode`` (default / last / off).""" - mode = str(settings.get("startup_mode", "default")).lower().strip() - if mode not in _STARTUP_MODES: - mode = "default" - if mode == "off": - if presets.select("off"): - return - presets.fill((0, 0, 0)) - return - if mode == "last": - lp = settings.get("last_preset") or "" - if isinstance(lp, str) and lp.strip() and lp.strip() in presets.presets: - if presets.select(lp.strip()): - return - dp = settings.get("default", "") - if dp and dp in presets.presets: - if not presets.select(dp): - print("Startup preset failed (invalid pattern?):", dp) - - -def _config_flag(value): - """Parse a device_config boolean. None if the value is not a flag.""" - if isinstance(value, bool): - return value - if isinstance(value, int) and not isinstance(value, bool): - return value != 0 - if isinstance(value, str): - s = value.strip().lower() - if s in ("1", "true", "yes", "on"): - return True - if s in ("0", "false", "no", "off"): - return False - return None - - -def apply_device_config(data, settings, presets): - """Apply fields from v1 ``device_config``; reload presets when strip length or colour order changes.""" - dc = data.get("device_config") - if not isinstance(dc, dict): - return - strip_changed = False - meta_changed = False - if "name" in dc: - n = dc["name"] - if isinstance(n, str) and n.strip(): - settings["name"] = n.strip() - meta_changed = True - if "num_leds" in dc: - try: - n = int(dc["num_leds"]) - if 1 <= n <= _MAX_DEVICE_LEDS: - settings["num_leds"] = n - presets.update_num_leds(settings["led_pin"], n) - strip_changed = True - except (TypeError, ValueError): - pass - if "color_order" in dc: - co = str(dc["color_order"]).lower().strip() - if co in _VALID_DEVICE_COLOR_ORDERS: - settings["color_order"] = co - settings.color_order = settings.get_color_order(co) - strip_changed = True - if "startup_mode" in dc: - sm = str(dc["startup_mode"]).lower().strip() - if sm in _STARTUP_MODES: - settings["startup_mode"] = sm - meta_changed = True - if "reversed" in dc: - flag = _config_flag(dc["reversed"]) - if flag is not None: - settings["reversed"] = flag - presets.reversed = flag - meta_changed = True - max_changed = False - if "max_brightness" in dc: - try: - mb = max(0, min(255, int(dc["max_brightness"]))) - max_changed = presets.max_b != mb - settings["max_brightness"] = mb - presets.max_b = mb - meta_changed = True - except (TypeError, ValueError): - pass - if not strip_changed and not meta_changed: - return - if max_changed and not strip_changed and presets.selected in presets.presets: - presets.select(presets.selected) # redraw static patterns under the new ceiling - if strip_changed: - prev = presets.selected - try: - presets.load(settings) - except Exception as e: - print("device_config: presets.load failed:", e) - if prev and prev in presets.presets: - presets.select(prev) - elif settings.get("default") and settings["default"] in presets.presets: - presets.select(settings["default"]) - - -def record_last_preset(settings, preset_name): - """Persist the last selected preset id (single entry in flash).""" - if not isinstance(preset_name, str) or not preset_name: - return - settings["last_preset"] = preset_name.strip() - settings.save() - - -def apply_brightness(data, settings, presets): - try: - new_b = max(0, min(255, int(data["b"]))) - except (TypeError, ValueError): - return - changed = int(presets.b) != new_b - presets.b = new_b - settings["brightness"] = new_b - # A finished manual chase frame keeps the colours scaled at the last beat. - # Skip when this message also selects: that select redraws after ``b`` is set. - if not changed or presets.generator is not None: - return - if "select" in data or "s" in data: - return - name = presets.selected - preset = presets.presets.get(name) if name else None - if preset is None or getattr(preset, "p", None) != "chase": - return - presets.redraw = True - try: - presets.select(name) - finally: - presets.redraw = False - - -_pending_select = None - - -def _run_select(presets, settings, preset_name, step=None): - if presets.select(preset_name, step=step): - record_last_preset(settings, preset_name) - return True - return False - - -def _flush_pending_select(settings, presets): - global _pending_select - if _pending_select is None: - return - preset_name, step = _pending_select - if preset_name not in presets.presets and preset_name not in ("on", "off"): - return - _pending_select = None - if not _run_select(presets, settings, preset_name, step): - print("select failed (pending):", preset_name) - - -def apply_presets(data, settings, presets): - global _pending_select - presets_map = data["presets"] - for id, preset_data in presets_map.items(): - if not preset_data: - continue - color_key = "c" if "c" in preset_data else ("colors" if "colors" in preset_data else None) - if color_key is not None: - try: - preset_data[color_key] = convert_and_reorder_colors( - preset_data[color_key], settings - ) - except (TypeError, ValueError, KeyError) as err: - print("preset color convert failed:", id, err) - if "bg" in preset_data: - try: - bg_color = convert_and_reorder_colors([preset_data["bg"]], settings) - if bg_color: - preset_data["bg"] = bg_color[0] - except (TypeError, ValueError, KeyError): - pass - presets.edit(id, preset_data) - # Same message often carries select; apply now while presets are loaded. - if "select" in data or "s" in data: - apply_select(data, settings, presets) - else: - _flush_pending_select(settings, presets) - - -def _select_list_for_this_device(select_val, settings): - """Resolve select to ``[preset_id, step?]`` (wire list or legacy name map).""" - if isinstance(select_val, list) and select_val: - return select_val - if isinstance(select_val, str) and str(select_val).strip(): - return [str(select_val).strip()] - if not isinstance(select_val, dict) or not select_val: - return None - if "preset" in select_val: - preset_name = select_val.get("preset") - if preset_name is None: - return None - out = [str(preset_name)] - if "step" in select_val: - out.append(select_val["step"]) - return out - device_name = str(settings.get("name") or "").strip() - select_list = select_val.get(device_name) - if select_list: - return select_list - try: - sta = network.WLAN(network.STA_IF) - mac_hex = ubinascii.hexlify(sta.config("mac")).decode().lower() - except Exception: - mac_hex = "" - if mac_hex: - for key in select_val: - k = str(key).lower().replace(":", "").replace("-", "") - if mac_hex in k: - return select_val[key] - if len(select_val) == 1: - return next(iter(select_val.values())) - return None - - -def apply_select(data, settings, presets): - global _pending_select - select_val = data.get("select") - if select_val is None: - select_val = data.get("s") - select_list = _select_list_for_this_device(select_val, settings) - if not select_list: - print("select ignored:", repr(select_val)) - return - preset_name = str(select_list[0]).strip() - if not preset_name: - return - step = select_list[1] if len(select_list) > 1 else None - if preset_name not in presets.presets and preset_name not in ("on", "off"): - try: - presets.load(settings) - except Exception: - pass - if preset_name not in presets.presets and preset_name not in ("on", "off"): - _pending_select = (preset_name, step) - print("select deferred (preset not loaded yet):", preset_name) - return - if _run_select(presets, settings, preset_name, step): - _pending_select = None - else: - print("select failed:", preset_name) - - -def apply_clear_presets(data, presets): - clear_value = data.get("clear_presets") - if isinstance(clear_value, bool): - should_clear = clear_value - elif isinstance(clear_value, int): - should_clear = bool(clear_value) - elif isinstance(clear_value, str): - should_clear = clear_value.lower() in ("true", "1", "yes", "on") - else: - should_clear = False - if not should_clear: - return - presets.delete_all() - - -def apply_default(data, settings, presets): - targets = data.get("targets") or [] - default_name = data["default"] - if ( - settings["name"] in targets - and isinstance(default_name, str) - and default_name in presets.presets - ): - settings["default"] = default_name - settings.save() - - -def _parse_http_url(url): - """Parse http://host[:port]/path into (host, port, path).""" - if not isinstance(url, str): - raise ValueError("url must be a string") - if not url.startswith("http://"): - raise ValueError("only http:// URLs are supported") - remainder = url[7:] - slash_idx = remainder.find("/") - if slash_idx == -1: - host_port = remainder - path = "/" - else: - host_port = remainder[:slash_idx] - path = remainder[slash_idx:] - if ":" in host_port: - host, port_s = host_port.rsplit(":", 1) - port = int(port_s) - else: - host = host_port - port = 80 - if not host: - raise ValueError("missing host") - return host, port, path - - -def _http_get_raw(url, timeout_s=10.0): - host, port, path = _parse_http_url(url) - req = ( - "GET %s HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n\r\n" % (path, host) - ).encode("utf-8") - sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - try: - sock.settimeout(timeout_s) - sock.connect((host, int(port))) - sock.send(req) - data = b"" - while True: - chunk = sock.recv(1024) - if not chunk: - break - data += chunk - finally: - try: - sock.close() - except Exception: - pass - sep = b"\r\n\r\n" - if sep not in data: - raise OSError("invalid HTTP response") - head, body = data.split(sep, 1) - status_line = head.split(b"\r\n", 1)[0] - if b" 200 " not in status_line: - raise OSError("HTTP status not OK: %s" % status_line.decode("utf-8")) - return body - - -def _http_get_json(url, timeout_s=10.0): - body = _http_get_raw(url, timeout_s=timeout_s) - return json.loads(body.decode("utf-8")) - - -def _http_get_text(url, timeout_s=10.0, controller_ip=None): - # Support relative URLs from controller messages. - if isinstance(url, str) and url.startswith("/"): - if not controller_ip: - raise OSError("controller IP unavailable for relative URL") - url = "http://%s%s" % (controller_ip, url) - try: - body = _http_get_raw(url, timeout_s=timeout_s) - return body.decode("utf-8") - except Exception: - # Fallback for mDNS/unresolvable host: retry against current controller IP. - if not controller_ip or not isinstance(url, str) or not url.startswith("http://"): - raise - _host, _port, path = _parse_http_url(url) - fallback = "http://%s:%d%s" % (controller_ip, _port, path) - body = _http_get_raw(fallback, timeout_s=timeout_s) - return body.decode("utf-8") - - -def _safe_pattern_filename(name): - if not isinstance(name, str): - return False - if not name.endswith(".py"): - return False - if "/" in name or "\\" in name or ".." in name: - return False - return True - - -def apply_patterns_ota(data, presets, controller_ip=None): - manifest_payload = data.get("manifest") - if not manifest_payload: - return - try: - if isinstance(manifest_payload, dict): - manifest = manifest_payload - elif isinstance(manifest_payload, str): - manifest = _http_get_json(manifest_payload, timeout_s=20.0) - else: - print("patterns_ota: invalid manifest payload type") - return - files = manifest.get("files", []) - if not isinstance(files, list) or not files: - print("patterns_ota: no files in manifest") - return - try: - os.mkdir("patterns") - except OSError: - pass - updated = 0 - for item in files: - if not isinstance(item, dict): - continue - name = item.get("name") - url = item.get("url") - inline_code = item.get("code") - if not _safe_pattern_filename(name): - continue - if isinstance(inline_code, str): - code = inline_code - elif isinstance(url, str): - code = _http_get_text(url, timeout_s=20.0, controller_ip=controller_ip) - else: - continue - with open("patterns/" + name, "w") as f: - f.write(code) - updated += 1 - if updated > 0: - presets.reload_patterns() - except Exception as e: - print("patterns_ota failed:", e) diff --git a/src/device_groups.py b/src/device_groups.py deleted file mode 100644 index 0bc4b78..0000000 --- a/src/device_groups.py +++ /dev/null @@ -1,28 +0,0 @@ -"""Group membership for GROUP_CMD filtering; persisted in settings.json.""" - -_groups = [] - - -def load_from_settings(settings): - global _groups - g = settings.get("groups") if settings is not None else None - if isinstance(g, list): - _groups = [str(x) for x in g if str(x).strip()] - else: - _groups = [] - - -def groups_replace(group_ids, settings=None, *, persist=True): - global _groups - _groups = [str(g) for g in group_ids] - if persist and settings is not None: - settings["groups"] = list(_groups) - settings.save() - - -def in_group(group_id): - return str(group_id) in _groups - - -def list_groups(): - return list(_groups) diff --git a/src/espnow_ota.py b/src/espnow_ota.py deleted file mode 100644 index 591ef41..0000000 --- a/src/espnow_ota.py +++ /dev/null @@ -1,293 +0,0 @@ -"""App-file OTA over ESP-NOW (driver side). Imported on the first OTA packet only. - -Inner packets, carried in reliable-link DATA frames (unicast acked, or broadcast): - 0x07 BEGIN [4C][07][sess u16][size u32][sha256 32B][plen][path] - 0x08 DATA [4C][08][sess u16][chunk u16] + up to CHUNK bytes at chunk * CHUNK - 0x09 END [4C][09][sess u16] hash the staged file - 0x0A COMMIT [4C][0A][sess u16] move every staged file into place, then reset - 0x0B ABORT [4C][0B][sess u16] delete the staged files - 0x0C MISSING [4C][0C][sess u16] report which chunks of the current file are missing -Reply, sent straight back (not through the link): - 0x26 STATUS [4C][26][sess u16][op][code] + arg - arg: [cnt u16] + missing bitmap for MISSING, else received bytes u32 -Files are written to .new; a new session discards whatever an older one staged. -The committed session is kept in ota_last: the reset can beat a lost reply, and the -controller then asks again. -""" -import struct - -import file_hashes - -WIRE_MAGIC = 0x4C -OP_BEGIN = 0x07 -OP_DATA = 0x08 -OP_END = 0x09 -OP_COMMIT = 0x0A -OP_ABORT = 0x0B -OP_MISSING = 0x0C -MSG_STATUS = 0x26 - -OK = 0 -READY = 1 -SAME = 2 -BADHASH = 3 -INCOMPLETE = 4 -BADPATH = 5 -IOERR = 6 -NOSESS = 7 -TOOBIG = 8 - -CHUNK = 944 # 4 link fragments of 238 bytes minus this packet's 8-byte header -MAX_SIZE = 65536 -STAGED_SUFFIX = ".new" -LAST_FILE = "ota_last" # session last committed, so a repeated COMMIT after the reset still gets OK - -try: - import uos as os -except ImportError: - import os - - -def safe_path(path): - """Relative path to a root file, patterns/... or lib/..., never the hash manifest.""" - if not path or path.startswith("/") or "\\" in path or path == file_hashes.MANIFEST_FILENAME: - return False - parts = path.split("/") - if any(p in ("", ".", "..") for p in parts): - return False - return len(parts) == 1 or parts[0] in ("patterns", "lib") - - -def _makedirs(path): - parts = path.split("/")[:-1] - for i in range(1, len(parts) + 1): - try: - os.mkdir("/".join(parts[:i])) - except OSError: - pass - - -def _remove(path): - try: - os.remove(path) - except OSError: - pass - - -class Ota: - def __init__(self, send, reset=None): - self.send = send # send(mac, frame) - self.reset = reset # called after a commit; defaults to machine.reset - self.sess = 0 - self.staged = {} # path -> sha hex of a verified .new file - self.cur = None # [path, size, sha hex, file, have bitmap (bytearray), received bytes] - try: - with open(LAST_FILE) as f: - self.committed = int(f.read()) - except (OSError, ValueError): - self.committed = 0 - - def handle(self, mac, pkt): - if len(pkt) < 4: - return - op = pkt[1] - sess = pkt[2] | (pkt[3] << 8) - if sess == 0: - return - if op == OP_COMMIT and sess == self.committed: - self._reply(mac, sess, op, OK, struct.pack(" MAX_SIZE: - self._reply(mac, sess, OP_BEGIN, TOOBIG) - return - if self.cur is not None: - if self.cur[0] == path and self.cur[2] == sha: - self._reply(mac, sess, OP_BEGIN, READY) # our earlier reply was lost - return - self._close_cur(True) - if self.staged.get(path) == sha: - self._reply(mac, sess, OP_BEGIN, READY) - return - try: - if file_hashes._hash_file(path) == sha: - self._reply(mac, sess, OP_BEGIN, SAME) - return - except OSError: - pass # no such file yet - try: - _makedirs(path) - f = open(path + STAGED_SUFFIX, "w+b") - except OSError: - self._reply(mac, sess, OP_BEGIN, IOERR) - return - cnt = (size + CHUNK - 1) // CHUNK - self.staged.pop(path, None) - self.cur = [path, size, sha, f, bytearray((cnt + 7) // 8), 0] - self._reply(mac, sess, OP_BEGIN, READY) - - def _data(self, pkt): - cur = self.cur - if cur is None or len(pkt) < 6: - return - idx = pkt[4] | (pkt[5] << 8) - body = pkt[6:] - off = idx * CHUNK - have = cur[4] - if off >= cur[1] or have[idx >> 3] & (1 << (idx & 7)): - return # past the end, or a copy we already wrote - if len(body) != min(CHUNK, cur[1] - off): - return - f = cur[3] - try: - end = f.seek(0, 2) - if end < off: - f.write(bytes(off - end)) # a chunk before this one is still missing - f.seek(off) - f.write(body) - except OSError: - self._close_cur(True) - return - have[idx >> 3] |= 1 << (idx & 7) - cur[5] += len(body) - - def _missing_bitmap(self): - cur = self.cur - cnt = (cur[1] + CHUNK - 1) // CHUNK - miss = bytearray(len(cur[4])) - for i in range(cnt): - if not cur[4][i >> 3] & (1 << (i & 7)): - miss[i >> 3] |= 1 << (i & 7) - return cnt, miss - - def _missing(self, mac): - if self.cur is None: - self._reply(mac, self.sess, OP_MISSING, OK, struct.pack(" controller - 0x22 DIGEST [4C][22][ver u16] controller broadcast - 0x23 RESYNC [4C][23][ver u16] driver -> controller - 0x24 ECHO [4C][24][beat_idx u16] driver -> controller, bench only - 0x25 BEAT [4C][25][flags][idx u16][period u16][fire_in] handled by BeatSync - 0x26 OTA [4C][26][sess u16][op][code] + arg driver -> controller, see espnow_ota.py -Everything else (announce, groups, cmd, group cmd, plain JSON) goes straight to the handler. -""" -import struct - -WIRE_MAGIC = 0x4C -MSG_DATA = 0x20 -MSG_ACK = 0x21 -MSG_DIGEST = 0x22 -MSG_RESYNC = 0x23 -MSG_ECHO = 0x24 -MSG_BEAT = 0x25 -LINK_TYPES = (MSG_DATA, MSG_DIGEST) -F_ACK = 1 -F_COMMIT = 2 -HDR = 9 - -INBOX_MAX = 24 -DONE_MAX = 16 -ASM_TIMEOUT_MS = 3000 -RESYNC_MIN_GAP_MS = 3000 - - -def _due(now, t): - return (now - t) & 0x7FFFFFFF < 0x40000000 - - -class LinkRx: - def __init__(self, handler, beat, send=None, jitter_ms=0, rand=None): - self.handler = handler # handler(mac, packet_bytes) - self.beat = beat # BeatSync - self.send = send # send(mac, frame) - self.jitter_ms = jitter_ms # spreads resync requests across drivers - self.ver = 0 - self.master = None - self.inbox = [] - self.asm = {} - self.done = [] - self.resync_at = None - self.last_resync = None - self.loss_pct = 0 # lossy-link test: drop this percentage of received frames - self.loss_beats = True - self.rand = rand # rand() -> 0..99; defaults to the random module - self.stats = {"msgs": 0, "dups": 0, "acks": 0, "resyncs": 0, "dropped": 0, "sim_lost": 0} - - def on_packet(self, mac, data, now): - """Call for every received frame (irq or main loop). Beats are handled here; the rest is queued.""" - if not data: - return - is_beat = len(data) > 1 and data[0] == WIRE_MAGIC and data[1] == MSG_BEAT - if self.loss_pct and (self.loss_beats or not is_beat) and self._rand() < self.loss_pct: - self.stats["sim_lost"] += 1 - return - if is_beat: - self.beat.on_frame(data, now) - elif len(self.inbox) < INBOX_MAX: - self.inbox.append((bytes(mac), bytes(data))) - else: - self.stats["dropped"] += 1 - - def _rand(self): - if self.rand is None: - import random - - self.rand = lambda: random.getrandbits(16) % 100 - return self.rand() - - def echo(self, idx): - """Tell the controller we just fired beat idx (bench measurement only).""" - if self.send and self.master: - self.send(self.master, struct.pack(" 1 and data[0] == WIRE_MAGIC and data[1] == MSG_DATA: - self._data(mac, data, now) - elif len(data) > 1 and data[0] == WIRE_MAGIC and data[1] == MSG_DIGEST: - self._digest(mac, data, now) - else: - self.handler(mac, data) - if self.resync_at is not None and _due(now, self.resync_at): - self.resync_at = None - self._send_resync(now) - if self.asm: - for k in [k for k, e in self.asm.items() if now - e[3] > ASM_TIMEOUT_MS]: - del self.asm[k] - - def _ack(self, mac, seq, cnt, mask): - if self.send: - self.send(mac, struct.pack(" 32 or idx >= cnt: - return - self.master = mac - key = (mac, seq) - full = (1 << cnt) - 1 if cnt < 32 else 0xFFFFFFFF - if key in self.done: - self.stats["dups"] += 1 - if flags & F_ACK: - self._ack(mac, seq, cnt, full) # our earlier ack was lost - return - e = self.asm.get(key) - if e is None: - e = self.asm[key] = [cnt, 0, [None] * cnt, now, flags, ver] - e[1] |= 1 << idx - e[2][idx] = data[HDR:] - e[3] = now - if flags & F_ACK: - self._ack(mac, seq, cnt, e[1]) - if e[1] != full: - return - del self.asm[key] - self.done.append(key) - if len(self.done) > DONE_MAX: - self.done.pop(0) - msg = e[2][0] if cnt == 1 else b"".join(e[2]) - self.stats["msgs"] += 1 - self.handler(mac, msg) - if flags & F_COMMIT and ver: - self.ver = ver - self.resync_at = None - - def _digest(self, mac, data, now): - if len(data) < 4: - return - self.master = mac - ver = struct.unpack(" need and env[need] == 1 - body = env[:need] if save else env - if body: - process_data(body, settings, presets, save=save) - return - if mt == MSG_CMD: - env, save = cmd_envelope(pkt) - if env: - process_data(env, settings, presets, save=save) - return - if mt == MSG_PING_REQ: - ping_id = parse_ping_req(pkt) - if ping_id is not None and host and len(host) == 6: - _schedule_ping_rsp(host, settings, ping_id) - return - if mt == MSG_ANNOUNCE: - return - - -async def espnow_receive_loop(settings, presets, wdt=None): - global _groups_received - while True: - if _esp is None: - await asyncio.sleep(0.1) - continue - host, msg = _esp.recv(0) - if not host: - if not _groups_received: - await asyncio.sleep(5) - send_boot_announce(settings) - else: - await asyncio.sleep(0.02) - if wdt: - wdt.feed() - continue - try: - _handle_packet(host, msg, settings, presets) - except Exception as e: - print("espnow rx error:", e) - if wdt: - wdt.feed() diff --git a/src/espnow_wire.py b/src/espnow_wire.py deleted file mode 100644 index 8e36e79..0000000 --- a/src/espnow_wire.py +++ /dev/null @@ -1,137 +0,0 @@ -"""ESP-NOW wire format (MicroPython). See docs/espnow-binary-protocol.md in led-controller.""" - -import struct - -WIRE_MAGIC = 0x4C -MAX_ESPNOW_PAYLOAD = 250 - -MSG_ANNOUNCE = 0x01 -MSG_GROUPS = 0x02 -MSG_CMD = 0x03 -MSG_GROUP_CMD = 0x04 -MSG_PING_REQ = 0x05 -MSG_PING_RSP = 0x06 -MSG_OTA_FIRST = 0x07 # 0x07..0x0C app-file OTA, see espnow_ota.py -MSG_OTA_LAST = 0x0C - -BROADCAST_MAC = b"\xff\xff\xff\xff\xff\xff" - -COLOR_ORDER_TO_ENUM = { - "rgb": 0, - "rbg": 1, - "grb": 2, - "gbr": 3, - "brg": 4, - "bgr": 5, -} -STARTUP_MODE_TO_ENUM = {"default": 0, "last": 1, "off": 2} - - -def _pack_header(msg_type, body): - pkt = bytes([WIRE_MAGIC, msg_type]) + body - if len(pkt) > MAX_ESPNOW_PAYLOAD: - raise ValueError("packet too large") - return pkt - - -def pack_announce( - name, - num_leds, - color_order="rgb", - startup_mode="default", - brightness=32, - device_type=0, -): - name_b = name.encode("utf-8") - co = COLOR_ORDER_TO_ENUM.get(str(color_order).lower(), 0) - sm = STARTUP_MODE_TO_ENUM.get(str(startup_mode).lower(), 0) - body = ( - bytes([len(name_b)]) - + name_b - + struct.pack("= 2 and payload[0] == WIRE_MAGIC: - if payload[1] != MSG_GROUPS: - return None - body = payload[2:] - else: - body = payload - if not body: - return [] - off = 0 - count = body[off] - off += 1 - out = [] - for _ in range(count): - gl = body[off] - off += 1 - out.append(body[off : off + gl].decode("utf-8")) - off += gl - return out - - -def parse_group_cmd(payload): - if len(payload) < 2 or payload[0] != WIRE_MAGIC or payload[1] != MSG_GROUP_CMD: - return None - body = payload[2:] - gl = body[0] - gid = body[1 : 1 + gl].decode("utf-8") - env = body[1 + gl :] - return gid, env - - -HEADER_LEN = 5 - - -def _envelope_size(env): - if len(env) < HEADER_LEN: - return len(env) - lp, ls, ld = env[2], env[3], env[4] - return HEADER_LEN + lp + ls + ld - - -def cmd_envelope(payload): - if len(payload) < 2 or payload[0] != WIRE_MAGIC or payload[1] != MSG_CMD: - return None, False - env = payload[2:] - if not env: - return None, False - need = _envelope_size(env) - if need > len(env): - return None, False - save = len(env) > need and env[need] == 1 - return env[:need], save - - -def pack_ping_req(ping_id): - body = struct.pack("= 2 and payload[0] == WIRE_MAGIC: - if payload[1] != MSG_PING_REQ: - return None - body = payload[2:] - else: - body = payload - if len(body) < 4: - return None - return struct.unpack("= 2 and payload[0] == WIRE_MAGIC: - return payload[1] - return None diff --git a/src/file_hashes.py b/src/file_hashes.py deleted file mode 100644 index 4afe59b..0000000 --- a/src/file_hashes.py +++ /dev/null @@ -1,102 +0,0 @@ -""" -Deploy hash manifest at flash root (file_hashes.json). - -Updated by led-cli after directory uploads; used to skip unchanged files on -the next deploy. Format: {"version": 1, "algorithm": "sha256", "files": {...}} -""" - -import json -import os - -MANIFEST_VERSION = 1 -MANIFEST_FILENAME = "file_hashes.json" -HASH_ALGO = "sha256" - -_SKIP_NAMES = frozenset({MANIFEST_FILENAME, "__pycache__"}) -_SKIP_SUFFIXES = (".pyc", ".pyo") - - -def _normalize_path(path): - return path.replace("\\", "/").lstrip("/") - - -def load(): - """Return path -> sha256 hex map, or {} if missing or invalid.""" - try: - with open(MANIFEST_FILENAME, "r") as f: - doc = json.load(f) - except OSError: - return {} - if not isinstance(doc, dict): - return {} - files = doc.get("files") - return files if isinstance(files, dict) else {} - - -def save(files): - """Write manifest (path keys use forward slashes, no leading slash).""" - if not isinstance(files, dict): - files = {} - doc = { - "version": MANIFEST_VERSION, - "algorithm": HASH_ALGO, - "files": files, - } - with open(MANIFEST_FILENAME, "w") as f: - json.dump(doc, f) - - -def _hash_file(path): - import binascii - import hashlib - - h = hashlib.sha256() - with open(path, "rb") as f: - while True: - chunk = f.read(1024) - if not chunk: - break - h.update(chunk) - return binascii.hexlify(h.digest()).decode() # MicroPython's sha256 has no hexdigest() - - -def _walk_dir(base, prefix, out): - try: - names = os.listdir(base) - except OSError: - return - for name in names: - if name in _SKIP_NAMES or name.endswith(_SKIP_SUFFIXES): - continue - full = base + "/" + name if base else name - key = _normalize_path((prefix + "/" + name) if prefix else name) - try: - mode = os.stat(full)[0] - except OSError: - continue - if mode & 0x4000: - _walk_dir(full, key, out) - else: - out[key] = _hash_file(full) - - -def rebuild(): - """Rebuild manifest from root .py files plus patterns/ and lib/ trees.""" - files = {} - try: - for name in os.listdir("."): - if name in _SKIP_NAMES or name.endswith(_SKIP_SUFFIXES): - continue - try: - mode = os.stat(name)[0] - except OSError: - continue - if mode & 0x4000: - if name in ("patterns", "lib"): - _walk_dir(name, name, files) - else: - files[_normalize_path(name)] = _hash_file(name) - except OSError: - pass - save(files) - return files diff --git a/src/hello.py b/src/hello.py deleted file mode 100644 index 2673d11..0000000 --- a/src/hello.py +++ /dev/null @@ -1,174 +0,0 @@ -"""LED hello JSON line and UDP broadcast on port 8766. - -Used so led-controller can register the device (name, MAC, IP) when ``wait_reply`` is -false; the controller may then connect to the device's WebSocket. With -``wait_reply`` true, blocks for an echo and returns the controller IP (legacy discovery). - -Wi-Fi must already be connected; this module does not use Settings or call connect(). -""" - -import json -import socket -import ubinascii - -import network - -# Match led-controller/tests/udp_server.py -DISCOVERY_UDP_PORT = 8766 -DEFAULT_RECV_TIMEOUT_S = 3 - - -def pack_hello_dict(sta, device_name=""): - """Same fields as main HTTP/ESP-NOW hello.""" - mac = sta.config("mac") - return { - "v": "1", - "device_name": device_name, - "mac": ubinascii.hexlify(mac).decode().lower(), - "type": "led", - } - - -def pack_hello_bytes(sta, device_name=""): - return json.dumps(pack_hello_dict(sta, device_name)).encode("utf-8") - - -def pack_hello_line(sta, device_name=""): - """JSON hello + newline (HTTP/UDP discovery payloads).""" - return pack_hello_bytes(sta, device_name) + b"\n" - - -def ipv4_broadcast(ip, netmask): - """Directed broadcast (e.g. 192.168.1.0/24 -> 192.168.1.255).""" - ia = [int(x) for x in ip.split(".")] - im = [int(x) for x in netmask.split(".")] - if len(ia) != 4 or len(im) != 4: - return None - # STA often reports 255.255.255.255; "broadcast" would equal the host IP — useless for LAN. - if netmask == "255.255.255.255": - return None - bcast = ".".join(str(ia[i] | (255 - im[i])) for i in range(4)) - if bcast == ip: - return None - return bcast - - -def udp_discovery_targets(ip, mask): - """(directed_broadcast, port) then limited broadcast.""" - out = [("255.255.255.255", DISCOVERY_UDP_PORT)] - b = ipv4_broadcast(ip, mask) - if b: - out.insert(0, (b, DISCOVERY_UDP_PORT)) - return out - - -def _udp_discovery_targets_single(ip, mask): - """One destination: subnet broadcast if known, else limited broadcast.""" - b = ipv4_broadcast(ip, mask) - if b: - return [(b, DISCOVERY_UDP_PORT)] - return [("255.255.255.255", DISCOVERY_UDP_PORT)] - - -def broadcast_hello_udp( - sta, - device_name="", - *, - wait_reply=True, - recv_timeout_s=DEFAULT_RECV_TIMEOUT_S, - wdt=None, - dual_destinations=True, -): - """ - Send pack_hello_line on DISCOVERY_UDP_PORT. - STA must already be connected with a valid IPv4 (caller brings up Wi-Fi). - - If dual_destinations (default), send subnet broadcast then 255.255.255.255 so - discovery works on awkward APs — the controller may receive two packets. - If dual_destinations is False, send only one (subnet broadcast or limited), - e.g. after TCP connect so the Pi does not run duplicate resync handlers. - - If wait_reply, wait for first UDP echo. Returns controller IP string or None. - """ - ip, mask, _gw, _dns = sta.ifconfig() - msg = pack_hello_line(sta, device_name) - - sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) - try: - sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) - except (AttributeError, OSError) as e: - print("SO_BROADCAST not set:", e) - try: - sock.bind((ip, 0)) - except (AttributeError, OSError, TypeError) as e: - try: - sock.bind(("0.0.0.0", 0)) - except (AttributeError, OSError) as e2: - print("bind skipped:", e, e2) - if wait_reply: - try: - sock.settimeout(recv_timeout_s) - except (AttributeError, OSError): - pass - - discovered = None - targets = ( - udp_discovery_targets(ip, mask) - if dual_destinations - else _udp_discovery_targets_single(ip, mask) - ) - for dest_ip, dest_port in targets: - if wdt is not None: - wdt.feed() - target = (dest_ip, dest_port) - try: - sock.sendto(msg, target) - except OSError as e: - print("sendto failed:", e) - continue - if not wait_reply: - continue - if wdt is not None: - wdt.feed() - try: - _data, addr = sock.recvfrom(2048) - remote_ip = addr[0] - discovered = remote_ip - break - except OSError: - pass - - sock.close() - return discovered - - -def discover_controller_udp(device_name="", wdt=None): - """ - Broadcast hello; return controller IP from first UDP echo, or None. - STA must already be connected. - - device_name: logical name in the JSON (caller supplies, e.g. from Settings elsewhere). - wdt: optional WDT to feed during waits. - """ - sta = network.WLAN(network.STA_IF) - if not sta.isconnected(): - print("hello: STA not connected — connect Wi-Fi before discovery.") - raise SystemExit(1) - - ip, mask, _g, _d = sta.ifconfig() - if ip == "0.0.0.0": - print("hello: STA has no IP address.") - raise SystemExit(1) - - discovered = broadcast_hello_udp( - sta, - device_name, - wait_reply=True, - wdt=wdt, - ) - return discovered - - -if __name__ == "__main__": - if not discover_controller_udp(): - raise SystemExit(1) diff --git a/src/http_routes.py b/src/http_routes.py deleted file mode 100644 index 913b398..0000000 --- a/src/http_routes.py +++ /dev/null @@ -1,107 +0,0 @@ -import json - -from controller_messages import process_data -from microdot.websocket import WebSocketError, with_websocket - -try: - import uos as os -except ImportError: - import os - - -def _safe_pattern_filename(name): - if not isinstance(name, str): - return False - if not name.endswith(".py"): - return False - if "/" in name or "\\" in name or ".." in name: - return False - return True - - -def register_routes(app, settings, presets, runtime_state): - @app.route("/ws") - @with_websocket - async def ws_handler(request, ws): - runtime_state.ws_connected() - controller_ip = None - try: - client_addr = getattr(request, "client_addr", None) - if isinstance(client_addr, (tuple, list)) and client_addr: - controller_ip = client_addr[0] - elif isinstance(client_addr, str): - controller_ip = client_addr - except Exception: - controller_ip = None - try: - while True: - data = await ws.receive() - if not data: - break - process_data(data, settings, presets, controller_ip=controller_ip) - except WebSocketError as e: - print("WS client disconnected:", e) - except OSError as e: - print("WS client dropped (OSError):", e) - finally: - runtime_state.ws_disconnected() - - @app.post("/patterns/upload") - async def upload_pattern(request): - """Receive one pattern file body from led-controller and reload patterns.""" - raw_name = request.args.get("name") - reload_raw = request.args.get("reload", "1") - reload_patterns = str(reload_raw).strip().lower() not in ("0", "false", "no", "off") - - if not isinstance(raw_name, str) or not raw_name.strip(): - return json.dumps({"error": "name is required"}), 400, {"Content-Type": "application/json"} - body = request.body - if not isinstance(body, (bytes, bytearray)) or not body: - return json.dumps({"error": "code is required"}), 400, {"Content-Type": "application/json"} - try: - code = body.decode("utf-8") - except UnicodeError: - return json.dumps({"error": "body must be utf-8 text"}), 400, {"Content-Type": "application/json"} - if not code.strip(): - return json.dumps({"error": "code is required"}), 400, {"Content-Type": "application/json"} - - name = raw_name.strip() - if not name.endswith(".py"): - name += ".py" - if not _safe_pattern_filename(name) or name in ("__init__.py", "main.py"): - return json.dumps({"error": "invalid pattern filename"}), 400, {"Content-Type": "application/json"} - - try: - os.mkdir("patterns") - except OSError: - pass - - path = "patterns/" + name - try: - with open(path, "w") as f: - f.write(code) - if reload_patterns: - presets.reload_patterns() - except OSError as e: - print("patterns/upload failed:", e) - return json.dumps({"error": str(e)}), 500, {"Content-Type": "application/json"} - - return json.dumps( - { - "message": "pattern uploaded", - "name": name, - "reloaded": reload_patterns, - } - ), 201, {"Content-Type": "application/json"} - - @app.post("/presets/upload") - async def upload_presets(request): - """Receive v1 JSON with ``presets`` and apply/save on the driver.""" - body = request.body - if not isinstance(body, (bytes, bytearray)) or not body: - return json.dumps({"error": "body is required"}), 400, {"Content-Type": "application/json"} - try: - process_data(body, settings, presets) - except Exception as e: - return json.dumps({"error": str(e)}), 400, {"Content-Type": "application/json"} - return json.dumps({"message": "presets applied"}), 200, {"Content-Type": "application/json"} diff --git a/src/main.py b/src/main.py deleted file mode 100644 index b3c9a37..0000000 --- a/src/main.py +++ /dev/null @@ -1,128 +0,0 @@ -import print_timestamp # noqa: F401 -from settings import Settings -import machine -import asyncio -import gc -import json -import network -import espnow -import device_groups as dg -from board import apply_cpu_freq -from presets import Presets -from controller_messages import apply_startup_pattern, process_data -from espnow_transport import _handle_packet, init_espnow -from espnow_wire import BROADCAST_MAC, WIRE_MAGIC -import utime -from beat_sync import BeatSync -from espnow_rx import LinkRx, make_sender - -wdt = machine.WDT(timeout=10000) -wdt.feed() - -apply_cpu_freq() - -settings = Settings() -dg.load_from_settings(settings) -print(settings) -gc.collect() - -# Bring Wi-Fi up before the pattern library and the LED driver claim memory: on the ESP32-C3 the radio -# tasks otherwise fail to start on about every other cold boot (Wifi Unknown Error 0x0101) -esp = init_espnow(settings) - -presets = Presets(settings["led_pin"], settings["num_leds"]) -presets.load(settings) -presets.b = settings.get("brightness", 255) -presets.max_b = settings.get("max_brightness", 255) -presets.debug = bool(settings.get("debug", False)) -gc.collect() - -apply_startup_pattern(settings, presets) - -print(network.WLAN(network.STA_IF).config("channel")) - -hello = json.dumps({ - "v": "1", - "name": settings.get("name", "led"), - "type": "led", -}) -print(hello) - -esp.send(BROADCAST_MAC, hello) -print("espnow hello", len(hello), "B") - - -def _on_espnow_message(host, msg): - if not msg: - return - if msg[0] == WIRE_MAGIC: - _handle_packet(host, msg, settings, presets) - return - if msg[0:1] == b"{": - process_data(msg, settings, presets) - - -beat_sync = BeatSync() -link = LinkRx( - _on_espnow_message, - beat_sync, - make_sender(esp), - jitter_ms=int.from_bytes(network.WLAN(network.STA_IF).config("mac")[-2:], "big") % 1000, -) -link.loss_pct = int(settings.get("espnow_loss", 0)) -bench = bool(settings.get("bench", False)) # echo each fired beat to the controller, print stats -usb_log = bool(settings.get("usb_log", False)) # print "FIRE " per real beat for tools/usb_latency.py -fire_log = None -last_stat = utime.ticks_ms() -beat_pin = None -if settings.get("beat_pin") is not None: - beat_pin = machine.Pin(int(settings["beat_pin"]), machine.Pin.OUT) - -def _drain(e): - # Runs scheduled between bytecodes, so frames are taken while presets.tick() is still busy. - # irecv reuses its buffers: on_packet handles beats in place and copies everything else. - while True: - try: - host, msg = e.irecv(0) - except OSError: - return - if not host: - return - if msg: - try: - link.on_packet(host, msg, utime.ticks_ms()) - except Exception as ex: - print("espnow rx error:", ex) - - -try: - esp.irq(_drain) - use_irq = True -except AttributeError: # firmware built without ESP-NOW irq support: poll as before - use_irq = False - -while True: - wdt.feed() - if not use_irq: - _drain(esp) - now = utime.ticks_ms() - try: - link.poll(now) - except Exception as e: - print("espnow rx error:", e) - if beat_sync.poll(now): - fire_us = utime.ticks_us() - presets.beat() - if beat_pin is not None: - beat_pin.value(not beat_pin.value()) # edge for the latency measurement - if usb_log and not beat_sync.freerun_fire: - fire_log = (beat_sync.last_idx, fire_us) # printed after the LED update so it never delays it - if bench and not beat_sync.freerun_fire: - link.echo(beat_sync.last_idx) # only real triggers: an invented beat has no send time to compare - if bench and utime.ticks_diff(now, last_stat) >= 5000: - last_stat = now - print("beat", beat_sync.stats, "link", link.stats, "radio", esp.stats()) # radio: tx, tx_resp, tx_fail, rx, rx_dropped - presets.tick() - if fire_log is not None: - print("FIRE", fire_log[0], fire_log[1]) - fire_log = None diff --git a/src/mem_stats.py b/src/mem_stats.py deleted file mode 100644 index bc4f671..0000000 --- a/src/mem_stats.py +++ /dev/null @@ -1,34 +0,0 @@ -"""GC / heap snapshot helpers for debug logging.""" - -import gc - - -def snapshot(): - """Return a dict of memory stats after ``gc.collect()``.""" - gc.collect() - out = { - "free": gc.mem_free(), - "alloc": gc.mem_alloc(), - } - try: - import esp32 - - blocks = esp32.idf_heap_info(esp32.HEAP_DATA) - if blocks: - block = blocks[0] - if isinstance(block, dict): - if "total_free_bytes" in block: - out["idf_free"] = block["total_free_bytes"] - largest = block.get("largest_free_block") - if largest is None: - largest = block.get("largest_free_block_in_bytes") - if largest is not None: - out["idf_largest"] = largest - except Exception: - pass - return out - - -def print_mem(label): - """Print one timestamped memory line (via ``print_timestamp`` when installed).""" - print("mem %s:" % label, snapshot()) diff --git a/src/patterns/__init__.py b/src/patterns/__init__.py deleted file mode 100644 index 8eb36d8..0000000 --- a/src/patterns/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -"""Pattern modules are registered only via Presets._load_dynamic_patterns(). - -This file is ignored as a pattern (see presets.py). Keep it free of imports so -adding a pattern does not require editing this package. -""" diff --git a/src/patterns/aurora.py b/src/patterns/aurora.py deleted file mode 100644 index f9341d2..0000000 --- a/src/patterns/aurora.py +++ /dev/null @@ -1,95 +0,0 @@ -import math -import utime - -from patterns.pattern_modes import style_mode - -_LEGACY = {"northern_wave": 1} - - -class Aurora: - def __init__(self, driver): - self.driver = driver - - def _run_bands(self, preset, colors): - bands = max(1, int(preset.n1) if int(preset.n1) > 0 else 3) - shimmer = max(0, min(255, int(preset.n2) if int(preset.n2) > 0 else 40)) - phase = self.driver.step % 256 - last = utime.ticks_ms() - while True: - d = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) >= d: - for i in range(self.driver.num_leds): - idx = ( - (i * bands) // max(1, self.driver.num_leds) + (phase // 32) - ) % len(colors) - c = self.driver.apply_brightness(colors[idx], preset.b) - w = 255 - abs(128 - ((i * 8 + phase) & 255)) * 2 - w = max(0, min(255, w + shimmer)) - self.driver.n[self.driver.led_i(preset, i)] = ( - (c[0] * w) // 255, - (c[1] * w) // 255, - (c[2] * w) // 255, - ) - self.driver.n.write() - phase = (phase + self.driver.signed(preset, 1)) & 255 - self.driver.step = phase - last = utime.ticks_add(last, d) - if not preset.a: - yield - return - yield - - def _run_northern(self, preset, colors): - period = max(4, int(preset.n1) if int(preset.n1) > 0 else 20) - contrast = max(1, min(255, int(preset.n2) if int(preset.n2) > 0 else 200)) - drift = max(1, int(preset.n3) if int(preset.n3) > 0 else 2) - phase = 0 - last = utime.ticks_ms() - ncols = len(colors) - if ncols < 2: - colors = list(colors) + [(120, 180, 255)] - ncols = len(colors) - twopi = 6.2831853 - - def lerp3(a, b, f): - return ( - a[0] + ((b[0] - a[0]) * f) // 255, - a[1] + ((b[1] - a[1]) * f) // 255, - a[2] + ((b[2] - a[2]) * f) // 255, - ) - - while True: - d = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) >= d: - bg = self.driver.apply_brightness(preset.background_or(colors), preset.b) - for i in range(self.driver.num_leds): - t = (i * twopi / period) + (phase * twopi / 256.0) - w = (math.sin(t) + 1.0) * 0.5 - u = w * (ncols - 1) * 256.0 - fi = int(u) >> 8 - frac = int(u) & 255 - if fi >= ncols - 1: - fi = ncols - 2 - frac = 255 - peak = lerp3(colors[fi], colors[fi + 1], frac) - peak = self.driver.apply_brightness(peak, preset.b) - mixf = min(255, int(w * contrast * 2) >> 1) - self.driver.n[self.driver.led_i(preset, i)] = lerp3(bg, peak, mixf) - self.driver.n.write() - phase = (phase + self.driver.signed(preset, drift)) % 256 - last = utime.ticks_add(last, d) - if not preset.a: - yield - return - yield - - def run(self, preset): - """Aurora bands (n6=0) or sine northern wave (n6=1, legacy northern_wave).""" - colors = preset.c if preset.c else [(40, 200, 140), (80, 120, 255), (160, 80, 220)] - if style_mode(preset, 0, _LEGACY) == 1: - colors = preset.c if preset.c else [(20, 55, 120), (60, 140, 220), (180, 220, 255)] - yield from self._run_northern(preset, colors) - return - yield from self._run_bands(preset, colors) diff --git a/src/patterns/bar_graph.py b/src/patterns/bar_graph.py deleted file mode 100644 index ccdc895..0000000 --- a/src/patterns/bar_graph.py +++ /dev/null @@ -1,29 +0,0 @@ -import utime - - -class BarGraph: - def __init__(self, driver): - self.driver = driver - - def run(self, preset): - colors = preset.c if preset.c else [(0, 255, 0), (255, 80, 0)] - last_update = utime.ticks_ms() - while True: - delay_ms = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last_update) >= delay_ms: - level = max(0, min(100, int(preset.n1) if int(preset.n1) >= 0 else 50)) - target = (self.driver.num_leds * level) // 100 - lit = self.driver.apply_brightness(colors[0], preset.b) - unlit = self.driver.apply_brightness( - preset.background_or(colors), - preset.b, - ) - for i in range(self.driver.num_leds): - self.driver.n[i] = lit if i < target else unlit - self.driver.n.write() - last_update = utime.ticks_add(last_update, delay_ms) - if not preset.a: - yield - return - yield diff --git a/src/patterns/blink.py b/src/patterns/blink.py deleted file mode 100644 index 8572adf..0000000 --- a/src/patterns/blink.py +++ /dev/null @@ -1,34 +0,0 @@ -import utime - - -class Blink: - def __init__(self, driver): - self.driver = driver - - def run(self, preset): - """Blink pattern: toggles LEDs on/off using preset delay, cycling through colors.""" - # Use provided colors, or default to white if none - colors = preset.c if preset.c else [(255, 255, 255)] - bg_color = self.driver.apply_brightness(preset.background_or(colors), preset.b) - color_index = 0 - state = True # True = on, False = off - last_update = utime.ticks_ms() - - while True: - current_time = utime.ticks_ms() - # Re-read delay each loop so live updates to preset.d take effect - delay_ms = max(1, int(preset.d)) - if utime.ticks_diff(current_time, last_update) >= delay_ms: - if state: - base_color = colors[color_index % len(colors)] - color = self.driver.apply_brightness(base_color, preset.b) - self.driver.fill(color) - # Advance to next color for the next "on" phase - color_index += 1 - else: - # Inactive phase uses the preset background color. - self.driver.fill(bg_color) - state = not state - last_update = utime.ticks_add(last_update, delay_ms) - # Yield once per tick so other logic can run - yield diff --git a/src/patterns/blizzard.py b/src/patterns/blizzard.py deleted file mode 100644 index e3c2ab3..0000000 --- a/src/patterns/blizzard.py +++ /dev/null @@ -1,67 +0,0 @@ -import random -import utime - - -class Blizzard: - """Dense falling flakes with sideways drift (compare `snowfall` for gentler flakes).""" - - def __init__(self, driver): - self.driver = driver - - def run(self, preset): - colors = preset.c if preset.c else [(255, 255, 255), (200, 230, 255), (180, 210, 255)] - # Higher n1 → more spawns (0–255 threshold vs random) - density = max(1, int(preset.n1) if int(preset.n1) > 0 else 90) - speed = max(1, int(preset.n2) if int(preset.n2) > 0 else 2) - # n3: 128 = no bias; <128 drift one way, >128 the other (scaled to small steps) - wraw = int(preset.n3) - if wraw <= 0: - wind = 0 - else: - wind = max(-4, min(4, (wraw - 128) // 20)) - - flakes = [] - last = utime.ticks_ms() - - while True: - d_ms = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) >= d_ms: - nled = self.driver.num_leds - bg = self.driver.apply_brightness(preset.background_or(colors), preset.b) - - for i in range(nled): - self.driver.n[i] = bg - - if random.randint(0, 255) < density: - flakes.append( - [ - nled - 1, - random.randint(0, len(colors) - 1), - 0 if wind == 0 else random.randint(-1, 1), - ] - ) - - nf = [] - for pos, ci, wj in flakes: - p = pos - lateral = wind + (wj if wj else 0) - p -= self.driver.signed(preset, speed) - p += self.driver.signed(preset, lateral) - if p < -2 or p >= nled + 2: - continue - pi = max(0, min(nled - 1, int(p))) - self.driver.n[self.driver.led_i(preset, pi)] = self.driver.apply_brightness( - colors[ci], preset.b - ) - nf.append([p, ci, wj]) - flakes = nf - - self.driver.n.write() - last = utime.ticks_add(last, d_ms) - - if not preset.a: - yield - return - - yield diff --git a/src/patterns/candle_glow.py b/src/patterns/candle_glow.py deleted file mode 100644 index 876dceb..0000000 --- a/src/patterns/candle_glow.py +++ /dev/null @@ -1,56 +0,0 @@ -import random -import utime - - -class CandleGlow: - def __init__(self, driver): - self.driver = driver - - def run(self, preset): - colors = preset.c if preset.c else [(255, 140, 40), (255, 200, 120), (255, 90, 20)] - n_candles = max(1, min(self.driver.num_leds, int(preset.n1) if int(preset.n1) > 0 else 4)) - width = max(1, int(preset.n2) if int(preset.n2) > 0 else 3) - flicker = max(1, min(255, int(preset.n3) if int(preset.n3) > 0 else 90)) - n_led = self.driver.num_leds - centers = tuple(random.randint(0, max(0, n_led - 1)) for _ in range(n_candles)) - last = utime.ticks_ms() - - while True: - d = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) >= d: - bg = self.driver.apply_brightness(preset.background_or(colors), preset.b) - for i in range(n_led): - self.driver.n[i] = bg - base_lo = 180 - flicker // 2 - if base_lo < 40: - base_lo = 40 - for ci, c in enumerate(centers): - warmth = colors[ci % len(colors)] - pulse = base_lo + random.randint(0, flicker) - if pulse > 255: - pulse = 255 - for off in range(-width, width + 1): - idx = c + off - if 0 <= idx < n_led: - dist = abs(off) - fall = ((width - dist + 1) * 256) // (width + 1) - fac = (fall * pulse) // 256 - px = ( - (warmth[0] * fac) // 255, - (warmth[1] * fac) // 255, - (warmth[2] * fac) // 255, - ) - lit = self.driver.apply_brightness(px, preset.b) - o = self.driver.n[idx] - self.driver.n[idx] = ( - max(o[0], lit[0]), - max(o[1], lit[1]), - max(o[2], lit[2]), - ) - self.driver.n.write() - last = utime.ticks_add(last, d) - if not preset.a: - yield - return - yield diff --git a/src/patterns/chase.py b/src/patterns/chase.py deleted file mode 100644 index 19697d6..0000000 --- a/src/patterns/chase.py +++ /dev/null @@ -1,164 +0,0 @@ -import utime - -from patterns.pattern_modes import style_mode - -_LEGACY = {"marquee": 1} - - -class Chase: - def __init__(self, driver): - self.driver = driver - - def _run_marquee(self, preset, colors): - on_len = max(1, int(preset.n1) if int(preset.n1) > 0 else 3) - off_len = max(1, int(preset.n2) if int(preset.n2) > 0 else 2) - step = max(1, abs(self.driver.signed(preset, int(preset.n3) if int(preset.n3) > 0 else 1))) - phase = self.driver.step % (on_len + off_len) - last = utime.ticks_ms() - while True: - d = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) >= d: - c = self.driver.apply_brightness(colors[0], preset.b) - bg_color = self.driver.apply_brightness(preset.background_or(colors), preset.b) - for i in range(self.driver.num_leds): - m = (i + phase) % (on_len + off_len) - self.driver.n[self.driver.led_i(preset, i)] = c if m < on_len else bg_color - self.driver.n.write() - phase = (phase + self.driver.signed(preset, step)) % (on_len + off_len) - self.driver.step = phase - last = utime.ticks_add(last, d) - if not preset.a: - yield - return - yield - - def run(self, preset): - """Chase (n6=0) or marquee dashes (n6=1, legacy marquee). - - Chase: n1/n2 segment lengths, n3/n4 step on even/odd beats. - Marquee: n1 on length, n2 off length, n3 scroll step. - """ - if style_mode(preset, 0, _LEGACY) == 1: - colors = preset.c if preset.c else [(255, 255, 255)] - yield from self._run_marquee(preset, colors) - return - - colors = preset.c - if len(colors) < 1: - # Need at least 1 color - return - - # Access colors, delay, and n values from preset - if not colors: - return - # If only one color provided, use it for both colors - if len(colors) < 2: - color0 = colors[0] - color1 = colors[0] - else: - color0 = colors[0] - color1 = colors[1] - - color0 = self.driver.apply_brightness(color0, preset.b) - color1 = self.driver.apply_brightness(color1, preset.b) - bg_color = self.driver.apply_brightness(preset.background_or(colors), preset.b) - - n1 = max(1, int(preset.n1)) # LEDs of color 0 - n2 = max(1, int(preset.n2)) # LEDs of color 1 - n3 = self.driver.signed(preset, int(preset.n3)) # Step movement on even steps - n4 = self.driver.signed(preset, int(preset.n4)) # Step movement on odd steps - - segment_length = n1 + n2 - - # Calculate position from step_count - step_count = int(self.driver.step) % 2 - # Position alternates: step 0 adds n3, step 1 adds n4, step 2 adds n3, etc. - if step_count % 2 == 0: - # Even steps: (step_count//2) pairs of (n3+n4) plus one extra n3 - position = (step_count // 2) * (n3 + n4) + n3 - else: - # Odd steps: ((step_count+1)//2) pairs of (n3+n4) - position = ((step_count + 1) // 2) * (n3 + n4) - - # Wrap position to keep it reasonable - max_pos = self.driver.num_leds + segment_length - position = position % max_pos - if position < 0: - position += max_pos - - # If auto is False, run a single step and then stop - if not preset.a: - # Clear all LEDs - self.driver.n.fill(bg_color) - - # Draw repeating pattern starting at position - for i in range(self.driver.num_leds): - # Calculate position in the repeating segment - relative_pos = (i - position) % segment_length - if relative_pos < 0: - relative_pos = (relative_pos + segment_length) % segment_length - - # Determine which color based on position in segment - if relative_pos < n1: - self.driver.n[self.driver.led_i(preset, i)] = color0 - else: - self.driver.n[self.driver.led_i(preset, i)] = color1 - - self.driver.n.write() - print("[chase] step", step_count) - - # Increment step for next beat - self.driver.step = (step_count + 1) % 2 - - # Allow tick() to advance the generator once - yield - return - - # Auto mode: continuous loop - # Use transition_duration for timing and force the first update to happen immediately - transition_duration = max(10, int(preset.d)) - last_update = utime.ticks_ms() - transition_duration - - while True: - current_time = utime.ticks_ms() - if utime.ticks_diff(current_time, last_update) >= transition_duration: - # Calculate current position from step_count - if step_count % 2 == 0: - position = (step_count // 2) * (n3 + n4) + n3 - else: - position = ((step_count + 1) // 2) * (n3 + n4) - - # Wrap position - max_pos = self.driver.num_leds + segment_length - position = position % max_pos - if position < 0: - position += max_pos - - # Clear all LEDs - self.driver.n.fill(bg_color) - - # Draw repeating pattern starting at position - for i in range(self.driver.num_leds): - # Calculate position in the repeating segment - relative_pos = (i - position) % segment_length - if relative_pos < 0: - relative_pos = (relative_pos + segment_length) % segment_length - - # Determine which color based on position in segment - if relative_pos < n1: - self.driver.n[self.driver.led_i(preset, i)] = color0 - else: - self.driver.n[self.driver.led_i(preset, i)] = color1 - - self.driver.n.write() - print("[chase] step", step_count) - - # Increment step - step_count = (step_count + 1) % 2 - self.driver.step = step_count - last_update = utime.ticks_add(last_update, transition_duration) - transition_duration = max(10, int(preset.d)) - - # Yield once per tick so other logic can run - yield diff --git a/src/patterns/circle.py b/src/patterns/circle.py deleted file mode 100644 index be10827..0000000 --- a/src/patterns/circle.py +++ /dev/null @@ -1,100 +0,0 @@ -import utime - - -class Circle: - def __init__(self, driver): - self.driver = driver - - def run(self, preset): - """Circle loading pattern - grows to n2, then tail moves forward at n3 until min length n4""" - head = 0 - tail = 0 - - # Calculate timing from preset - head_rate = max(1, int(preset.n1)) # n1 = head moves per second - tail_rate = max(1, int(preset.n3)) # n3 = tail moves per second - max_length = max(1, int(preset.n2)) # n2 = max length - min_length = max(0, int(preset.n4)) # n4 = min length - - head_delay = 1000 // head_rate # ms between head movements - tail_delay = 1000 // tail_rate # ms between tail movements - - last_head_move = utime.ticks_ms() - last_tail_move = utime.ticks_ms() - - phase = "growing" # "growing", "shrinking", or "off" - - # Support up to two colors (like chase). If only one color is provided, - # use black for the second; if none, default to white. - colors = preset.c - if not colors: - base0 = base1 = (255, 255, 255) - elif len(colors) == 1: - base0 = colors[0] - base1 = preset.background_or(colors) - else: - base0 = colors[0] - base1 = preset.background_or(colors) - - color0 = self.driver.apply_brightness(base0, preset.b) - color1 = self.driver.apply_brightness(base1, preset.b) - - while True: - current_time = utime.ticks_ms() - - # Background: use second color during the "off" phase, otherwise clear to black - if phase == "off": - self.driver.n.fill(color1) - else: - self.driver.n.fill(color1) - - # Calculate segment length - segment_length = (head - tail) % self.driver.num_leds - if segment_length == 0 and head != tail: - segment_length = self.driver.num_leds - - # Draw segment from tail to head as a solid color (no per-LED alternation) - current_color = color0 - for i in range(segment_length + 1): - led_pos = (tail + i) % self.driver.num_leds - self.driver.n[led_pos] = current_color - - # Move head continuously at n1 LEDs per second - if utime.ticks_diff(current_time, last_head_move) >= head_delay: - head = (head + 1) % self.driver.num_leds - last_head_move = utime.ticks_add(last_head_move, head_delay) - head_rate = max(1, int(preset.n1)) - head_delay = 1000 // head_rate - - # Tail behavior based on phase - if phase == "growing": - # Growing phase: tail stays at 0 until max length reached - if segment_length >= max_length: - phase = "shrinking" - elif phase == "shrinking": - # Shrinking phase: move tail forward at n3 LEDs per second - if utime.ticks_diff(current_time, last_tail_move) >= tail_delay: - tail = (tail + 1) % self.driver.num_leds - last_tail_move = utime.ticks_add(last_tail_move, tail_delay) - tail_rate = max(1, int(preset.n3)) - tail_delay = 1000 // tail_rate - - # Check if we've reached min length - current_length = (head - tail) % self.driver.num_leds - if current_length == 0 and head != tail: - current_length = self.driver.num_leds - - # For min_length = 0, we need at least 1 LED (the head) - if min_length == 0 and current_length <= 1: - phase = "off" # All LEDs off for 1 step - elif min_length > 0 and current_length <= min_length: - phase = "growing" # Cycle repeats - else: # phase == "off" - # Off phase: second color fills the ring for 1 step, then restart - tail = head # Reset tail to head position to start fresh - phase = "growing" - - self.driver.n.write() - - # Yield once per tick so other logic can run - yield diff --git a/src/patterns/clock_sweep.py b/src/patterns/clock_sweep.py deleted file mode 100644 index 567c3fa..0000000 --- a/src/patterns/clock_sweep.py +++ /dev/null @@ -1,33 +0,0 @@ -import utime - - -class ClockSweep: - def __init__(self, driver): - self.driver = driver - - def run(self, preset): - colors = preset.c if preset.c else [(255, 255, 255), (60, 60, 60)] - width = max(1, int(preset.n1) if int(preset.n1) > 0 else 1) - marker = max(0, int(preset.n2) if int(preset.n2) > 0 else 0) - pos = self.driver.step % max(1, self.driver.num_leds) - last = utime.ticks_ms() - while True: - d = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) >= d: - bg = self.driver.apply_brightness(preset.background_or(colors), preset.b) - fg = self.driver.apply_brightness(colors[0], preset.b) - for i in range(self.driver.num_leds): - self.driver.n[i] = bg - if marker > 0 and i % marker == 0: - self.driver.n[i] = ((bg[0]*2)//3, (bg[1]*2)//3, (bg[2]*2)//3) - for w in range(width): - self.driver.n[(pos + w) % self.driver.num_leds] = fg - self.driver.n.write() - pos = (pos + 1) % max(1, self.driver.num_leds) - self.driver.step = pos - last = utime.ticks_add(last, d) - if not preset.a: - yield - return - yield diff --git a/src/patterns/colour_cycle.py b/src/patterns/colour_cycle.py deleted file mode 100644 index fb13859..0000000 --- a/src/patterns/colour_cycle.py +++ /dev/null @@ -1,100 +0,0 @@ -import utime - -from patterns.pattern_modes import style_mode - -_LEGACY = {"rainbow": 1, "gradient_scroll": 0} - - -class ColourCycle: - def __init__(self, driver): - self.driver = driver - - def _wheel(self, pos): - if pos < 85: - return (pos * 3, 255 - pos * 3, 0) - if pos < 170: - pos -= 85 - return (255 - pos * 3, 0, pos * 3) - pos -= 170 - return (0, pos * 3, 255 - pos * 3) - - def _render_gradient(self, preset, colors, phase, brightness): - num_leds = self.driver.num_leds - color_count = len(colors) - if num_leds <= 0 or color_count <= 0: - return - if color_count == 1: - self.driver.fill(self.driver.apply_brightness(colors[0], brightness)) - return - - full_span = color_count * 256 - phase_shift = (phase * full_span) // 256 - for i in range(num_leds): - pos = ((i * full_span) // num_leds + phase_shift) % full_span - idx = pos // 256 - frac = pos & 255 - c1 = colors[idx] - c2 = colors[(idx + 1) % color_count] - blended = ( - c1[0] + ((c2[0] - c1[0]) * frac) // 256, - c1[1] + ((c2[1] - c1[1]) * frac) // 256, - c1[2] + ((c2[2] - c1[2]) * frac) // 256, - ) - self.driver.n[self.driver.led_i(preset, i)] = self.driver.apply_brightness( - blended, brightness - ) - self.driver.n.write() - - def _render_rainbow(self, preset, phase, brightness): - num_leds = self.driver.num_leds - for i in range(num_leds): - rc_index = (i * 256 // max(1, num_leds)) + phase - self.driver.n[self.driver.led_i(preset, i)] = self.driver.apply_brightness( - self._wheel(rc_index & 255), brightness - ) - self.driver.n.write() - - def run(self, preset): - """Scroll gradient (n6=0) or fixed spectrum wheel (n6=1, legacy rainbow). - - n1: step rate - n6: 0 gradient scroll, 1 rainbow wheel - """ - mode = style_mode(preset, 0, _LEGACY) - step_amount = max(1, int(preset.n1) if int(preset.n1) > 0 else 1) - phase = self.driver.step % 256 - - if mode == 1: - if not preset.a: - self._render_rainbow(preset, phase, preset.b) - self.driver.step = (phase + self.driver.signed(preset, step_amount)) % 256 - yield - return - last_update = utime.ticks_ms() - while True: - delay_ms = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last_update) >= delay_ms: - self._render_rainbow(preset, phase, preset.b) - phase = (phase + self.driver.signed(preset, step_amount)) % 256 - self.driver.step = phase - last_update = utime.ticks_add(last_update, delay_ms) - yield - - colors = preset.c if preset.c else [(255, 0, 0), (0, 0, 255)] - if not preset.a: - self._render_gradient(preset, colors, phase, preset.b) - self.driver.step = (phase + self.driver.signed(preset, step_amount)) % 256 - yield - return - - last_update = utime.ticks_ms() - while True: - delay_ms = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last_update) >= delay_ms: - self._render_gradient(preset, colors, phase, preset.b) - phase = (phase + self.driver.signed(preset, step_amount)) % 256 - self.driver.step = phase - last_update = utime.ticks_add(last_update, delay_ms) - yield diff --git a/src/patterns/flame.py b/src/patterns/flame.py deleted file mode 100644 index e383de7..0000000 --- a/src/patterns/flame.py +++ /dev/null @@ -1,210 +0,0 @@ -import random -import utime - -# Default warm palette: ember → orange → yellow → pale hot (RGB) -_DEFAULT_PALETTE = ( - (90, 8, 8), - (200, 40, 12), - (255, 120, 30), - (255, 220, 140), -) - - -def _clamp(x, lo, hi): - if x < lo: - return lo - if x > hi: - return hi - return x - - -def _lerp_chan(a, b, t): - return a + ((b - a) * t >> 8) - - -def _lerp_rgb(c0, c1, t): - return ( - _lerp_chan(c0[0], c1[0], t), - _lerp_chan(c0[1], c1[1], t), - _lerp_chan(c0[2], c1[2], t), - ) - - -def _palette_sample(palette, pos256): - n = len(palette) - if n == 0: - return (255, 160, 60) - if n == 1: - return palette[0] - span = (n - 1) * pos256 - seg = span >> 8 - if seg >= n - 1: - return palette[n - 1] - frac = span & 0xFF - return _lerp_rgb(palette[seg], palette[seg + 1], frac) - - -def _triangle_255(elapsed_ms, period_ms): - period_ms = max(period_ms, 400) - p = elapsed_ms % period_ms - half = period_ms >> 1 - if half <= 0: - return 128 - if p < half: - return (p * 255) // half - return ((period_ms - p) * 255) // (period_ms - half) - - -class Flame: - def __init__(self, driver): - self.driver = driver - - def _build_palette(self, preset): - colors = preset.c - if not colors: - return list(_DEFAULT_PALETTE) - out = [] - for c in colors: - if isinstance(c, (list, tuple)) and len(c) == 3: - out.append( - ( - _clamp(int(c[0]), 0, 255), - _clamp(int(c[1]), 0, 255), - _clamp(int(c[2]), 0, 255), - ) - ) - return out if out else list(_DEFAULT_PALETTE) - - def _draw_frame(self, preset, palette, ticks_now, breath_el_ms, rise, cluster_jit, breath_ms, lo, hi, spark_state): - """spark_state: (active: bool, start_ticks, duration_ms). ticks_now for sparks; breath_el_ms for slow wave.""" - num = self.driver.num_leds - denom = num - 1 if num > 1 else 1 - - breathe = _triangle_255(breath_el_ms, breath_ms) - base_level = lo + (((hi - lo) * breathe) >> 8) - micro = 232 + random.randint(0, 35) - level = (base_level * micro) >> 8 - level = _clamp(level, lo, hi) - - spark_boost = 0 - spark_white = (0, 0, 0) - active, s0, dur = spark_state - if active and dur > 0: - el = utime.ticks_diff(ticks_now, s0) - if el < 0: - el = 0 - if el >= dur: - spark_boost = 0 - else: - env = 255 - ((el * 255) // dur) - spark_boost = (env * 90) >> 8 - spark_white = ((env * 55) >> 8, (env * 50) >> 8, (env * 40) >> 8) - - for i in range(num): - h = (i * 256) // denom - flow = (h + rise + ((i // max(1, num >> 3)) * 17)) & 255 - pos = (flow + cluster_jit[(i >> 2) & 7]) & 255 - rgb = _palette_sample(palette, pos) - if spark_boost: - rgb = ( - _clamp(rgb[0] + spark_white[0] + (spark_boost * 3 >> 2), 0, 255), - _clamp(rgb[1] + spark_white[1] + (spark_boost >> 1), 0, 255), - _clamp(rgb[2] + spark_white[2] + (spark_boost >> 2), 0, 255), - ) - self.driver.n[i] = self.driver.apply_brightness(rgb, level) - - self.driver.n.write() - - def run(self, preset): - """Salt-lamp / hearth-style flame: warm gradient, breathing, jitter, drift, rare sparks.""" - palette = self._build_palette(preset) - lo = max(0, min(255, int(preset.n1))) - hi = max(0, min(255, int(preset.b))) - if lo > hi: - lo, hi = hi, lo - - bp = int(preset.n2) - breath_ms = max(800, bp if bp > 0 else 2500) - - gap_lo = int(preset.n3) - gap_hi = int(preset.n4) - # n3 < 0 disables sparks; n3=n4=0 uses ~10–30 s gaps (hearth pops). - if gap_lo < 0: - sparks_on = False - else: - sparks_on = True - if gap_lo == 0 and gap_hi == 0: - gap_lo, gap_hi = 10000, 30000 - else: - gap_lo = max(gap_lo, 500) - if gap_hi < gap_lo: - gap_hi = gap_lo - - delay_ms = max(16, int(preset.d)) - rise = random.randint(0, 255) - cluster_jit = [random.randint(-18, 18) for _ in range(8)] - last_draw = utime.ticks_ms() - breath_origin = last_draw - last_cluster = last_draw - spark_active = False - spark_start = 0 - spark_dur = 0 - next_spark = utime.ticks_add(last_draw, random.randint(gap_lo, gap_hi)) if sparks_on else 0 - - if not preset.a: - now = utime.ticks_ms() - self._draw_frame( - preset, - palette, - now, - utime.ticks_diff(now, breath_origin), - rise, - cluster_jit, - breath_ms, - lo, - hi, - (False, 0, 0), - ) - yield - return - - while True: - now = utime.ticks_ms() - if utime.ticks_diff(now, last_draw) < delay_ms: - yield - continue - last_draw = utime.ticks_add(last_draw, delay_ms) - - rise = (rise + random.randint(-10, 12)) & 255 - - if utime.ticks_diff(now, last_cluster) >= (delay_ms * 4): - last_cluster = now - cluster_jit = [random.randint(-18, 18) for _ in range(8)] - - spark_state = (spark_active, spark_start, spark_dur) - if sparks_on: - if spark_active: - if utime.ticks_diff(now, spark_start) >= spark_dur: - spark_active = False - next_spark = utime.ticks_add( - now, - random.randint(gap_lo, gap_hi), - ) - elif utime.ticks_diff(now, next_spark) >= 0: - spark_active = True - spark_start = now - spark_dur = random.randint(180, 360) - - self._draw_frame( - preset, - palette, - now, - utime.ticks_diff(now, breath_origin), - rise, - cluster_jit, - breath_ms, - lo, - hi, - (spark_active, spark_start, spark_dur), - ) - yield diff --git a/src/patterns/flicker.py b/src/patterns/flicker.py deleted file mode 100644 index b17fd6d..0000000 --- a/src/patterns/flicker.py +++ /dev/null @@ -1,40 +0,0 @@ -import random -import utime - - -class Flicker: - def __init__(self, driver): - self.driver = driver - - def run(self, preset): - """Random brightness between n1 (min) and b (max); delay d ms between updates.""" - colors = preset.c if preset.c else [(255, 255, 255)] - color_index = 0 - last_update = utime.ticks_ms() - - def brightness_bounds(): - lo = max(0, min(255, int(preset.n1))) - hi = max(0, min(255, int(preset.b))) - if lo > hi: - lo, hi = hi, lo - return lo, hi - - if not preset.a: - lo, hi = brightness_bounds() - level = random.randint(lo, hi) - base = colors[color_index % len(colors)] - self.driver.fill(self.driver.apply_brightness(base, level)) - yield - return - - while True: - current_time = utime.ticks_ms() - delay_ms = max(1, int(preset.d)) - lo, hi = brightness_bounds() - if utime.ticks_diff(current_time, last_update) >= delay_ms: - level = random.randint(lo, hi) - base = colors[color_index % len(colors)] - self.driver.fill(self.driver.apply_brightness(base, level)) - color_index += 1 - last_update = utime.ticks_add(last_update, delay_ms) - yield diff --git a/src/patterns/icicles.py b/src/patterns/icicles.py deleted file mode 100644 index 8a64887..0000000 --- a/src/patterns/icicles.py +++ /dev/null @@ -1,62 +0,0 @@ -import utime - - -class Icicles: - """Icicles hanging from anchor points; tips brighten toward max length then shrink.""" - - def __init__(self, driver): - self.driver = driver - - def run(self, preset): - colors = preset.c if preset.c else [(240, 248, 255), (160, 210, 255), (255, 255, 255)] - spacing = max(1, int(preset.n1) if int(preset.n1) > 0 else 12) - nled = self.driver.num_leds - max_len = max( - 2, - min( - int(preset.n2) if int(preset.n2) > 0 else min(14, max(3, nled // 4)), - max(2, nled), - ), - ) - span = max_len * 2 - phase_step = max(1, int(preset.n3) if int(preset.n3) > 0 else 1) - phase = 0 - last = utime.ticks_ms() - - while True: - d_ms = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) >= d_ms: - bg_rgb = preset.background_or(colors) - bg = self.driver.apply_brightness(bg_rgb, preset.b) - - for i in range(nled): - self.driver.n[i] = bg - - aidx = 0 - for anchor in range(0, nled, spacing): - tri_i = (phase + aidx * 5) % span - ic_len = tri_i if tri_i <= max_len else span - tri_i - tip_c = colors[aidx % len(colors)] - tip = self.driver.apply_brightness(tip_c, preset.b) - for k in range(ic_len): - idx = anchor + k - if idx >= nled: - break - br = ((k + 1) * 255) // max(1, ic_len) - self.driver.n[self.driver.led_i(preset, idx)] = ( - (tip[0] * br + bg[0] * (255 - br)) // 255, - (tip[1] * br + bg[1] * (255 - br)) // 255, - (tip[2] * br + bg[2] * (255 - br)) // 255, - ) - aidx += 1 - - self.driver.n.write() - phase = (phase + self.driver.signed(preset, phase_step)) % span - last = utime.ticks_add(last, d_ms) - - if not preset.a: - yield - return - - yield diff --git a/src/patterns/meteor.py b/src/patterns/meteor.py deleted file mode 100644 index 3f160f3..0000000 --- a/src/patterns/meteor.py +++ /dev/null @@ -1,176 +0,0 @@ -import utime - -from patterns.pattern_modes import style_mode - -_LEGACY = {"comet_dual": 1, "scanner": 2} - - -class Meteor: - def __init__(self, driver): - self.driver = driver - - def _fade(self, color, fade_amount): - return ( - (color[0] * fade_amount) // 255, - (color[1] * fade_amount) // 255, - (color[2] * fade_amount) // 255, - ) - - def _run_meteor(self, preset, colors, color_index, head, direction, last_update): - tail_len = max(1, int(preset.n1) if int(preset.n1) > 0 else 8) - speed = max(1, int(preset.n2) if int(preset.n2) > 0 else 1) - fade_amount = int(preset.n3) if int(preset.n3) > 0 else 192 - fade_amount = max(1, min(255, fade_amount)) - delay_ms = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last_update) < delay_ms: - return color_index, head, direction, last_update, False - for i in range(self.driver.num_leds): - self.driver.n[i] = self._fade(self.driver.n[i], fade_amount) - base = colors[color_index % len(colors)] - lit = self.driver.apply_brightness(base, preset.b) - if 0 <= head < self.driver.num_leds: - self.driver.n[self.driver.led_i(preset, head)] = lit - self.driver.n.write() - head += self.driver.signed(preset, direction * speed) - if head >= self.driver.num_leds + tail_len: - head = self.driver.num_leds - 1 - direction = -1 - color_index += 1 - elif head < -tail_len: - head = 0 - direction = 1 - color_index += 1 - return color_index, head, direction, utime.ticks_add(last_update, delay_ms), True - - def _run_comet_dual(self, preset, colors, p1, p2, last): - tail = max(1, int(preset.n1) if int(preset.n1) > 0 else 6) - speed = max(1, int(preset.n2) if int(preset.n2) > 0 else 1) - gap = max(0, int(preset.n3)) - d = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) < d: - return p1, p2, last, False - bg_color = self.driver.apply_brightness(preset.background_or(colors), preset.b) - for i in range(self.driver.num_leds): - self.driver.n[i] = bg_color - c1 = self.driver.apply_brightness(colors[0 % len(colors)], preset.b) - c2 = self.driver.apply_brightness( - colors[1 % len(colors)] if len(colors) > 1 else colors[0], preset.b - ) - for t in range(tail): - i1 = p1 - t - if 0 <= i1 < self.driver.num_leds: - s = (255 * (tail - t)) // max(1, tail) - self.driver.n[self.driver.led_i(preset, i1)] = ( - (c1[0] * s) // 255, - (c1[1] * s) // 255, - (c1[2] * s) // 255, - ) - i2 = p2 + t - if 0 <= i2 < self.driver.num_leds: - s = (255 * (tail - t)) // max(1, tail) - self.driver.n[self.driver.led_i(preset, i2)] = ( - (c2[0] * s) // 255, - (c2[1] * s) // 255, - (c2[2] * s) // 255, - ) - self.driver.n.write() - p1 += self.driver.signed(preset, speed) - p2 -= self.driver.signed(preset, speed) - if p1 - tail > self.driver.num_leds and p2 + tail < 0: - p1 = 0 - p2 = self.driver.num_leds - 1 - gap - return p1, p2, utime.ticks_add(last, d), True - - def _run_scanner(self, preset, colors, color_index, center, direction, pause_frames, last_update): - width = max(1, int(preset.n1) if int(preset.n1) > 0 else 4) - end_pause = max(0, int(preset.n2)) - delay_ms = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last_update) < delay_ms: - return color_index, center, direction, pause_frames, last_update, False - base = self.driver.apply_brightness(colors[color_index % len(colors)], preset.b) - bg_color = self.driver.apply_brightness(preset.background_or(colors), preset.b) - for i in range(self.driver.num_leds): - dist = i - center - if dist < 0: - dist = -dist - if dist > width: - self.driver.n[self.driver.led_i(preset, i)] = bg_color - else: - scale = ((width - dist) * 255) // max(1, width) - self.driver.n[self.driver.led_i(preset, i)] = ( - (base[0] * scale) // 255, - (base[1] * scale) // 255, - (base[2] * scale) // 255, - ) - self.driver.n.write() - if pause_frames > 0: - pause_frames -= 1 - else: - center += self.driver.signed(preset, direction) - if center >= self.driver.num_leds - 1: - center = self.driver.num_leds - 1 - direction = -1 - pause_frames = end_pause - color_index += 1 - elif center <= 0: - center = 0 - direction = 1 - pause_frames = end_pause - color_index += 1 - return color_index, center, direction, pause_frames, utime.ticks_add(last_update, delay_ms), True - - def run(self, preset): - """Moving lights: n6 style 0 meteor, 1 dual comet, 2 scanner (legacy ids still work).""" - mode = style_mode(preset, 0, _LEGACY) - colors = preset.c if preset.c else [(255, 255, 255)] - - if mode == 1: - gap = max(0, int(preset.n3)) - nled = self.driver.num_leds - if self.driver.is_reversed(preset): - p1, p2 = nled - 1, gap - else: - p1, p2 = 0, nled - 1 - gap - last = utime.ticks_ms() - while True: - p1, p2, last, stepped = self._run_comet_dual(preset, colors, p1, p2, last) - if stepped and not preset.a: - yield - return - yield - - if mode == 2: - nled = self.driver.num_leds - if self.driver.is_reversed(preset): - color_index, center, direction, pause_frames = 0, max(0, nled - 1), -1, 0 - else: - color_index, center, direction, pause_frames = 0, 0, 1, 0 - last_update = utime.ticks_ms() - while True: - color_index, center, direction, pause_frames, last_update, stepped = ( - self._run_scanner( - preset, colors, color_index, center, direction, pause_frames, last_update - ) - ) - if stepped and not preset.a: - yield - return - yield - - nled = self.driver.num_leds - if self.driver.is_reversed(preset): - color_index, head, direction = 0, max(0, nled - 1), -1 - else: - color_index, head, direction = 0, 0, 1 - last_update = utime.ticks_ms() - while True: - color_index, head, direction, last_update, stepped = self._run_meteor( - preset, colors, color_index, head, direction, last_update - ) - if stepped and not preset.a: - yield - return - yield diff --git a/src/patterns/orbit.py b/src/patterns/orbit.py deleted file mode 100644 index 23a752e..0000000 --- a/src/patterns/orbit.py +++ /dev/null @@ -1,31 +0,0 @@ -import utime - - -class Orbit: - def __init__(self, driver): - self.driver = driver - - def run(self, preset): - colors = preset.c if preset.c else [(255, 255, 255), (0, 180, 255), (255, 0, 120)] - orbits = max(1, int(preset.n1) if int(preset.n1) > 0 else 3) - speed = max(1, int(preset.n2) if int(preset.n2) > 0 else 1) - phase = self.driver.step % 256 - last = utime.ticks_ms() - while True: - d = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) >= d: - bg_color = self.driver.apply_brightness(preset.background_or(colors), preset.b) - for i in range(self.driver.num_leds): - self.driver.n[i] = bg_color - for k in range(orbits): - idx = ((phase * (k + 1)) // 8 + (k * self.driver.num_leds // max(1, orbits))) % max(1, self.driver.num_leds) - self.driver.n[idx] = self.driver.apply_brightness(colors[k % len(colors)], preset.b) - self.driver.n.write() - phase = (phase + speed) & 255 - self.driver.step = phase - last = utime.ticks_add(last, d) - if not preset.a: - yield - return - yield diff --git a/src/patterns/palette_morph.py b/src/patterns/palette_morph.py deleted file mode 100644 index 27fb35f..0000000 --- a/src/patterns/palette_morph.py +++ /dev/null @@ -1,81 +0,0 @@ -import utime - - -class PaletteMorph: - def __init__(self, driver): - self.driver = driver - - def _blend(self, c1, c2, t): - return ( - c1[0] + ((c2[0] - c1[0]) * t) // 255, - c1[1] + ((c2[1] - c1[1]) * t) // 255, - c1[2] + ((c2[2] - c1[2]) * t) // 255, - ) - - def run(self, preset): - """Living color field (non-scrolling palette warp). - - Different from `colour_cycle`: this does not scroll a fixed gradient. - Instead, each LED breathes/warps through the palette with local phase - offsets so the strip looks alive. - - n1: morph duration (ms) - n2: warp rate - n3: spatial turbulence amount - """ - colors = preset.c if preset.c else [(255, 0, 0), (0, 255, 0), (0, 0, 255)] - if len(colors) < 2: - while True: - self.driver.fill(self.driver.apply_brightness(colors[0], preset.b)) - yield - morph = max(50, int(preset.n1) if int(preset.n1) > 0 else 1200) - warp_rate = max(1, int(preset.n2) if int(preset.n2) > 0 else 3) - turbulence = max(1, int(preset.n3) if int(preset.n3) > 0 else 24) - base_idx = 0 - start = utime.ticks_ms() - phase = self.driver.step % 256 - last_update = start - - while True: - now = utime.ticks_ms() - delay_ms = max(1, int(preset.d)) - if utime.ticks_diff(now, last_update) < delay_ms: - yield - continue - last_update = utime.ticks_add(last_update, delay_ms) - age = utime.ticks_diff(now, start) - if age < morph: - t = (age * 255) // morph - else: - t = 255 - - # Global morph anchor between neighboring palette colors. - a = colors[base_idx % len(colors)] - b = colors[(base_idx + 1) % len(colors)] - anchor = self._blend(a, b, t) - - for i in range(self.driver.num_leds): - # Non-linear local warp per LED to create "living" motion. - pos = (i * 256) // max(1, self.driver.num_leds) - wobble = ((pos * turbulence) // 32 + phase + (t // 2)) & 255 - breath = 255 - abs(128 - wobble) * 2 - local = (pos + (breath // 3) + (t // 4)) % 256 - idx = (base_idx + ((local * len(colors)) // 256)) % len(colors) - frac = (local * len(colors)) & 255 - c1 = colors[idx] - c2 = colors[(idx + 1) % len(colors)] - grad = self._blend(c1, c2, frac) - # Blend with anchor to keep coherent palette morphing. - out = self._blend(grad, anchor, 80) - self.driver.n[i] = self.driver.apply_brightness(out, preset.b) - self.driver.n.write() - - if age >= morph: - base_idx = (base_idx + 1) % len(colors) - start = now - if not preset.a: - yield - return - phase = (phase + warp_rate) & 255 - self.driver.step = phase - yield diff --git a/src/patterns/particles.py b/src/patterns/particles.py deleted file mode 100644 index dc4d23d..0000000 --- a/src/patterns/particles.py +++ /dev/null @@ -1,111 +0,0 @@ -import random -import utime - -from patterns.pattern_modes import style_mode - -_LEGACY = {"starfall": 1} - - -class Particles: - def __init__(self, driver): - self.driver = driver - - def _run_snowfall(self, preset, colors, flakes, last): - density = max(1, int(preset.n1) if int(preset.n1) > 0 else 20) - speed = max(1, abs(self.driver.signed(preset, int(preset.n2) if int(preset.n2) > 0 else 1))) - d = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) < d: - return flakes, last, False - bg_color = self.driver.apply_brightness(preset.background_or(colors), preset.b) - if random.randint(0, 255) < density: - flakes.append([self.driver.num_leds - 1, random.randint(0, len(colors) - 1)]) - for i in range(self.driver.num_leds): - self.driver.n[i] = bg_color - nf = [] - for pos, ci in flakes: - if 0 <= pos < self.driver.num_leds: - self.driver.n[self.driver.led_i(preset, pos)] = self.driver.apply_brightness( - colors[ci], preset.b - ) - pos -= self.driver.signed(preset, speed) - if pos >= -1: - nf.append([pos, ci]) - self.driver.n.write() - return nf, utime.ticks_add(last, d), True - - def _run_starfall(self, preset, colors, stars, last): - rate = max(1, min(255, int(preset.n1) if int(preset.n1) > 0 else 14)) - speed = max(1, abs(self.driver.signed(preset, int(preset.n2) if int(preset.n2) > 0 else 2))) - tail = max(2, int(preset.n3) if int(preset.n3) > 0 else 10) - max_stars = 4 - d = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) < d: - return stars, last, False - bg = self.driver.apply_brightness(preset.background_or(colors), preset.b) - for i in range(self.driver.num_leds): - self.driver.n[i] = bg - if len(stars) < max_stars and random.randint(0, 255) < rate: - top = self.driver.num_leds - 1 + random.randint( - 0, min(8, self.driver.num_leds // 2) - ) - stars.append({"h": float(top), "ci": random.randint(0, len(colors) - 1)}) - ns = [] - for s in stars: - h = s["h"] - ci = s["ci"] - ih = int(h) - for t in range(tail): - idx = ih + t - if 0 <= idx < self.driver.num_leds: - fade = 255 - (t * 255 // max(1, tail - 1)) - base = colors[ci] - lit = ( - (base[0] * fade) // 255, - (base[1] * fade) // 255, - (base[2] * fade) // 255, - ) - lit = self.driver.apply_brightness(lit, preset.b) - pix = self.driver.led_i(preset, idx) - o = self.driver.n[pix] - self.driver.n[pix] = ( - max(o[0], lit[0]), - max(o[1], lit[1]), - max(o[2], lit[2]), - ) - h -= self.driver.signed(preset, speed) - if h >= -tail: - s["h"] = h - ns.append(s) - stars = ns - self.driver.n.write() - return stars, utime.ticks_add(last, d), True - - def run(self, preset): - """Falling particles: n6 0 snowfall flakes, 1 starfall streaks.""" - mode = style_mode(preset, 0, _LEGACY) - colors = preset.c if preset.c else [(255, 255, 255), (180, 220, 255)] - last = utime.ticks_ms() - - if mode == 1: - colors = preset.c if preset.c else [ - (255, 255, 255), - (200, 230, 255), - (255, 248, 220), - ] - stars = [] - while True: - stars, last, stepped = self._run_starfall(preset, colors, stars, last) - if stepped and not preset.a: - yield - return - yield - - flakes = [] - while True: - flakes, last, stepped = self._run_snowfall(preset, colors, flakes, last) - if stepped and not preset.a: - yield - return - yield diff --git a/src/patterns/pattern_direction.py b/src/patterns/pattern_direction.py deleted file mode 100644 index c337a81..0000000 --- a/src/patterns/pattern_direction.py +++ /dev/null @@ -1,19 +0,0 @@ -"""Strip install direction: n5 bit 0 reverses along-strip motion (upside-down wiring).""" - - -def is_reversed(preset): - return bool(int(getattr(preset, "n5", 0) or 0) & 1) - - -def led_i(driver, preset, logical_index): - """Map a logical strip index (0 = pattern start) to a physical pixel index.""" - n = int(driver.num_leds) - i = int(logical_index) - if 0 <= i < n and is_reversed(preset): - return n - 1 - i - return i - - -def signed(preset, value): - v = int(value) - return -v if is_reversed(preset) else v diff --git a/src/patterns/pattern_modes.py b/src/patterns/pattern_modes.py deleted file mode 100644 index 2e4fef4..0000000 --- a/src/patterns/pattern_modes.py +++ /dev/null @@ -1,18 +0,0 @@ -"""Resolve pattern style from n6 or legacy preset pattern id (p).""" - - -def style_mode(preset, default=0, legacy=None): - legacy = legacy or {} - p = getattr(preset, "p", "") or "" - if p in legacy: - return legacy[p] - mode = getattr(preset, "mode", None) - if mode is None and isinstance(preset, dict): - mode = preset.get("mode") - if mode is not None: - try: - return int(mode) - except (TypeError, ValueError): - pass - n6 = int(getattr(preset, "n6", 0) or 0) - return n6 if n6 > 0 else default diff --git a/src/patterns/plasma.py b/src/patterns/plasma.py deleted file mode 100644 index 1137c13..0000000 --- a/src/patterns/plasma.py +++ /dev/null @@ -1,39 +0,0 @@ -import utime - - -class Plasma: - def __init__(self, driver): - self.driver = driver - - def _wheel(self, pos): - if pos < 85: - return (pos * 3, 255 - pos * 3, 0) - if pos < 170: - pos -= 85 - return (255 - pos * 3, 0, pos * 3) - pos -= 170 - return (0, pos * 3, 255 - pos * 3) - - def run(self, preset): - scale = max(1, int(preset.n1) if int(preset.n1) > 0 else 6) - speed = max(1, int(preset.n2) if int(preset.n2) > 0 else 2) - contrast = max(1, int(preset.n3) if int(preset.n3) > 0 else 2) - t = self.driver.step % 256 - last = utime.ticks_ms() - while True: - d = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) >= d: - for i in range(self.driver.num_leds): - v = ((i * scale + t) & 255) - v2 = (((i * scale // max(1, contrast)) - (t * 2)) & 255) - c = self._wheel((v + v2) & 255) - self.driver.n[i] = self.driver.apply_brightness(c, preset.b) - self.driver.n.write() - t = (t + speed) % 256 - self.driver.step = t - last = utime.ticks_add(last, d) - if not preset.a: - yield - return - yield diff --git a/src/patterns/pulse.py b/src/patterns/pulse.py deleted file mode 100644 index 1f05469..0000000 --- a/src/patterns/pulse.py +++ /dev/null @@ -1,68 +0,0 @@ -import utime - - -class Pulse: - def __init__(self, driver): - self.driver = driver - - def run(self, preset): - # Get colors from preset - colors = preset.c - if not colors: - colors = [(255, 255, 255)] - bg_base = preset.background_or(colors) - self.driver.fill(self.driver.apply_brightness(bg_base, preset.b)) - - manual = not preset.a - color_index = self.driver.step % max(1, len(colors)) - cycle_start = utime.ticks_ms() - - # State machine based pulse using a single generator loop - while True: - bg_color = self.driver.apply_brightness(bg_base, preset.b) - # Read current timing parameters from preset - attack_ms = max(0, int(preset.n1)) # Attack time in ms - hold_ms = max(0, int(preset.n2)) # Hold time in ms - decay_ms = max(0, int(preset.n3)) # Decay time in ms - delay_ms = 0 if manual else max(0, int(preset.d)) - - total_ms = attack_ms + hold_ms + decay_ms + delay_ms - if total_ms <= 0: - total_ms = 1 - - now = utime.ticks_ms() - elapsed = utime.ticks_diff(now, cycle_start) - - base_color = colors[color_index % len(colors)] - - if elapsed < attack_ms and attack_ms > 0: - # Attack: fade 0 -> 1 - factor = elapsed / attack_ms - color = tuple(int(c * factor) for c in base_color) - self.driver.fill(self.driver.apply_brightness(color, preset.b)) - elif elapsed < attack_ms + hold_ms: - # Hold: full brightness - self.driver.fill(self.driver.apply_brightness(base_color, preset.b)) - elif elapsed < attack_ms + hold_ms + decay_ms and decay_ms > 0: - # Decay: fade 1 -> 0 - dec_elapsed = elapsed - attack_ms - hold_ms - factor = max(0.0, 1.0 - (dec_elapsed / decay_ms)) - color = tuple(int(c * factor) for c in base_color) - self.driver.fill(self.driver.apply_brightness(color, preset.b)) - elif elapsed < total_ms: - # Delay phase: LEDs off between pulses - self.driver.fill(bg_color) - else: - # End of cycle: advance colour for the next run, then loop or stop. - nclr = max(1, len(colors)) - color_index = (color_index + 1) % nclr - self.driver.step = color_index - if manual: - self.driver.fill(bg_color) - break - cycle_start = now - yield - continue - - # Yield once per tick - yield diff --git a/src/patterns/radiate.py b/src/patterns/radiate.py deleted file mode 100644 index 1a2584a..0000000 --- a/src/patterns/radiate.py +++ /dev/null @@ -1,172 +0,0 @@ -import utime - -# When ``driver.debug`` is True (``settings["debug"]``), log at most this often (ms). -_RADIATE_DBG_INTERVAL_MS = 2500 - - -class Radiate: - def __init__(self, driver): - self.driver = driver - self._color_step = 0 - - def run(self, preset): - """Radiate from nodes every n1 LEDs, retriggering every delay (d). - - - n1: node spacing in LEDs - - n2: outbound travel time in ms - - n3: return travel time in ms - - d: retrigger interval in ms - """ - colors = preset.c if preset.c else [(255, 255, 255)] - base_off = preset.background_or(colors) - - spacing = max(1, int(preset.n1)) - outward_ms = max(1, int(preset.n2)) - return_ms = max(1, int(preset.n3)) - max_dist = spacing // 2 - - lit_color = self.driver.apply_brightness(colors[self._color_step % max(1, len(colors))], preset.b) - off_color = self.driver.apply_brightness(base_off, preset.b) - - now = utime.ticks_ms() - last_trigger = now - active_pulses = [now] - last_dbg = now - dbg_banner = False - - if not preset.a: - # Manual mode: one-shot pulse using the same ms-based timing as auto. - cycle_start = utime.ticks_ms() - last_dbg = cycle_start - while True: - dbg = bool(getattr(self.driver, "debug", False)) - spacing = max(1, int(preset.n1)) - outward_ms = max(1, int(preset.n2)) - return_ms = max(1, int(preset.n3)) - max_dist = spacing // 2 - on_color = colors[self._color_step % max(1, len(colors))] - lit_color = self.driver.apply_brightness(on_color, preset.b) - off_color = self.driver.apply_brightness(base_off, preset.b) - - pulse_lifetime = outward_ms + return_ms - now = utime.ticks_ms() - age = utime.ticks_diff(now, cycle_start) - if age < 1: - age = 1 - if age <= outward_ms: - front = (age * max_dist + outward_ms - 1) // outward_ms - elif age <= outward_ms + return_ms: - back_age = age - outward_ms - remaining = return_ms - back_age - front = (remaining * max_dist + return_ms - 1) // return_ms - else: - front = 0 - - lit_count = 0 - for i in range(self.driver.num_leds): - offset = (i + (spacing // 2)) % spacing - dist = min(offset, spacing - offset) - lit = dist <= front - self.driver.n[i] = lit_color if lit else off_color - if lit: - lit_count += 1 - self.driver.n.write() - - if dbg: - if not dbg_banner: - dbg_banner = True - print( - "[radiate] debug on n1=%s n2=%s n3=%s d=%s auto=%s num_leds=%d" - % (preset.n1, preset.n2, preset.n3, preset.d, preset.a, self.driver.num_leds) - ) - if utime.ticks_diff(now, last_dbg) >= _RADIATE_DBG_INTERVAL_MS: - print( - "[radiate] manual frame age=%d/%d front=%d lit=%d" - % (age, pulse_lifetime, front, lit_count) - ) - last_dbg = now - - yield - if age >= pulse_lifetime: - self._color_step += 1 - return - - while True: - now = utime.ticks_ms() - dbg = bool(getattr(self.driver, "debug", False)) - delay_ms = max(1, int(preset.d)) - spacing = max(1, int(preset.n1)) - outward_ms = max(1, int(preset.n2)) - return_ms = max(1, int(preset.n3)) - pulse_lifetime = outward_ms + return_ms - max_dist = spacing // 2 - on_color = colors[self._color_step % max(1, len(colors))] - lit_color = self.driver.apply_brightness(on_color, preset.b) - off_color = self.driver.apply_brightness(base_off, preset.b) - - if preset.a and utime.ticks_diff(now, last_trigger) >= delay_ms: - # Keep one pulse train at a time; replacing instead of appending - # prevents overlap from keeping color[0] continuously visible. - active_pulses = [now] - last_trigger = utime.ticks_add(last_trigger, delay_ms) - self._color_step += 1 - - # Drop pulses once their out-and-back lifetime ends. - kept = [] - for start in active_pulses: - age = utime.ticks_diff(now, start) - if age < pulse_lifetime: - kept.append(start) - active_pulses = kept - - lit_count = 0 - for i in range(self.driver.num_leds): - # Nearest node distance for a repeating node grid every `spacing` LEDs. - offset = (i + (spacing // 2)) % spacing - dist = min(offset, spacing - offset) - - lit = False - for start in active_pulses: - age = utime.ticks_diff(now, start) - # Auto: skip the exact trigger tick (age==0) so nodes are not stuck on. - if age <= 0: - continue - if age <= outward_ms: - # Integer-ceiling progression so peak can be reached even - # when tick timing skips the exact outward_ms boundary. - front = (age * max_dist + outward_ms - 1) // outward_ms - elif age <= outward_ms + return_ms: - back_age = age - outward_ms - remaining = return_ms - back_age - front = (remaining * max_dist + return_ms - 1) // return_ms - else: - continue - - if dist <= front: - lit = True - break - - self.driver.n[i] = lit_color if lit else off_color - if lit: - lit_count += 1 - - self.driver.n.write() - - if dbg: - if not dbg_banner: - dbg_banner = True - print( - "[radiate] debug on n1=%s n2=%s n3=%s d=%s auto=%s num_leds=%d" - % (preset.n1, preset.n2, preset.n3, preset.d, preset.a, self.driver.num_leds) - ) - pulse_age = -1 - if active_pulses: - pulse_age = utime.ticks_diff(now, active_pulses[0]) - if utime.ticks_diff(now, last_dbg) >= _RADIATE_DBG_INTERVAL_MS: - print( - "[radiate] pulses=%d first_age=%d lit=%d lifetime=%d" - % (len(active_pulses), pulse_age, lit_count, pulse_lifetime) - ) - last_dbg = now - - yield diff --git a/src/patterns/rain_drops.py b/src/patterns/rain_drops.py deleted file mode 100644 index 48af845..0000000 --- a/src/patterns/rain_drops.py +++ /dev/null @@ -1,41 +0,0 @@ -import random -import utime - - -class RainDrops: - def __init__(self, driver): - self.driver = driver - - def run(self, preset): - colors = preset.c if preset.c else [(120, 180, 255)] - rate = max(1, int(preset.n1) if int(preset.n1) > 0 else 32) - width = max(1, int(preset.n2) if int(preset.n2) > 0 else 3) - drops = [] - last = utime.ticks_ms() - while True: - d = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) >= d: - bg_color = self.driver.apply_brightness(preset.background_or(colors), preset.b) - for i in range(self.driver.num_leds): - self.driver.n[i] = bg_color - if random.randint(0, 255) < rate: - drops.append([random.randint(0, max(0, self.driver.num_leds - 1)), 0]) - nd = [] - for pos, age in drops: - for off in range(-width, width + 1): - idx = pos + off - if 0 <= idx < self.driver.num_leds: - s = 255 - min(255, abs(off) * 255 // max(1, width + 1) + age * 40) - base = self.driver.apply_brightness(colors[age % len(colors)], preset.b) - self.driver.n[idx] = ((base[0]*s)//255, (base[1]*s)//255, (base[2]*s)//255) - age += 1 - if age < 8: - nd.append([pos, age]) - drops = nd - self.driver.n.write() - last = utime.ticks_add(last, d) - if not preset.a: - yield - return - yield diff --git a/src/patterns/rime.py b/src/patterns/rime.py deleted file mode 100644 index b3741e0..0000000 --- a/src/patterns/rime.py +++ /dev/null @@ -1,72 +0,0 @@ -import random -import utime - - -class Rime: - """Slow frost build-up on a chilly background — gentle random brightening then decay.""" - - def __init__(self, driver): - self.driver = driver - - def run(self, preset): - colors = preset.c if preset.c else [(220, 235, 255), (255, 255, 255), (185, 220, 255)] - num = self.driver.num_leds - if num <= 0: - while True: - yield - return - - # n1: spawn tendency (like twinkle upper range) - chill = max(1, min(255, int(preset.n1) if int(preset.n1) > 0 else 36)) - # n2: decay per refresh (subtract from glow buffer) - melt = max(1, min(255, int(preset.n2) if int(preset.n2) > 0 else 12)) - # n3: how many LEDs can flash brighter per refresh (cap) - spark_cap = max(1, min(num, int(preset.n3) if int(preset.n3) > 0 else 3)) - - glow = [0] * num - last = utime.ticks_ms() - - while True: - d_ms = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) >= d_ms: - base_bg = preset.background_or(colors) - bg = self.driver.apply_brightness(base_bg, preset.b) - - for i in range(num): - if glow[i] > melt: - glow[i] -= melt - else: - glow[i] = 0 - - spawned = 0 - tries = spark_cap + num // 8 - for _ in range(tries): - if spawned >= spark_cap: - break - if random.randint(0, 255) >= chill: - continue - j = random.randint(0, num - 1) - glow[j] = min(255, glow[j] + random.randint(80, 200)) - spawned += 1 - - palette = colors - for i in range(num): - g = glow[i] - fg = palette[i % len(palette)] - hi = self.driver.apply_brightness(fg, preset.b) - mix = max(0, min(255, g)) - self.driver.n[i] = ( - (hi[0] * mix + bg[0] * (255 - mix)) // 255, - (hi[1] * mix + bg[1] * (255 - mix)) // 255, - (hi[2] * mix + bg[2] * (255 - mix)) // 255, - ) - - self.driver.n.write() - last = utime.ticks_add(last, d_ms) - - if not preset.a: - yield - return - - yield diff --git a/src/patterns/sparkle.py b/src/patterns/sparkle.py deleted file mode 100644 index 16083a7..0000000 --- a/src/patterns/sparkle.py +++ /dev/null @@ -1,147 +0,0 @@ -import random -import utime - -from patterns.pattern_modes import style_mode - -_LEGACY = {"sparkle_trail": 0, "ice_sparkle": 1, "fireflies": 2} - - -class Sparkle: - def __init__(self, driver): - self.driver = driver - - def _run_trail(self, preset, colors, last): - density = max(1, int(preset.n1) if int(preset.n1) > 0 else 24) - decay = max(1, min(255, int(preset.n2) if int(preset.n2) > 0 else 210)) - d = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) < d: - return last, False - for i in range(self.driver.num_leds): - r, g, b = self.driver.n[i] - self.driver.n[i] = ((r * decay) // 255, (g * decay) // 255, (b * decay) // 255) - sparks = max(1, self.driver.num_leds * density // 255) - for _ in range(sparks): - idx = random.randint(0, max(0, self.driver.num_leds - 1)) - c = self.driver.apply_brightness( - colors[random.randint(0, len(colors) - 1)], preset.b - ) - self.driver.n[idx] = c - self.driver.n.write() - return utime.ticks_add(last, d), True - - def _run_ice(self, preset, colors, sparks, last): - rate = max(1, min(255, int(preset.n1) if int(preset.n1) > 0 else 55)) - decay = max(1, min(255, int(preset.n2) if int(preset.n2) > 0 else 140)) - halo = max(0, min(3, int(preset.n3))) - cap = 28 - d = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) < d: - return sparks, last, False - bg = self.driver.apply_brightness(preset.background_or(colors), preset.b) - for i in range(self.driver.num_leds): - self.driver.n[i] = bg - ns = [] - for s in sparks: - lv = s["lv"] - decay - if lv > 0: - s["lv"] = lv - ns.append(s) - sparks = ns - if len(sparks) < cap and random.randint(0, 255) < rate: - sparks.append( - { - "p": random.randint(0, max(0, self.driver.num_leds - 1)), - "lv": 255, - "ci": random.randint(0, len(colors) - 1), - } - ) - for s in sparks: - p = s["p"] - lv = s["lv"] - ci = s["ci"] - base = colors[ci] - for off in range(-halo, halo + 1): - idx = p + off - if 0 <= idx < self.driver.num_leds: - dist = abs(off) - fac = lv if dist == 0 else (lv * (halo - dist + 1)) // (halo + 1) - lit = self.driver.apply_brightness( - ( - (base[0] * fac) // 255, - (base[1] * fac) // 255, - (base[2] * fac) // 255, - ), - preset.b, - ) - o = self.driver.n[idx] - self.driver.n[idx] = ( - min(255, o[0] + lit[0]), - min(255, o[1] + lit[1]), - min(255, o[2] + lit[2]), - ) - self.driver.n.write() - return sparks, utime.ticks_add(last, d), True - - def _run_fireflies(self, preset, colors, bugs, last): - count = max(1, int(preset.n1) if int(preset.n1) > 0 else 6) - speed = max(1, int(preset.n2) if int(preset.n2) > 0 else 8) - d = max(1, int(preset.d)) - now = utime.ticks_ms() - if utime.ticks_diff(now, last) < d: - return bugs, last, False - bg_color = self.driver.apply_brightness(preset.background_or(colors), preset.b) - for i in range(self.driver.num_leds): - self.driver.n[i] = bg_color - for b in bugs: - idx, ph = b - tri = 255 - abs(128 - ph) * 2 - c = self.driver.apply_brightness(colors[idx % len(colors)], preset.b) - self.driver.n[idx] = ((c[0] * tri) // 255, (c[1] * tri) // 255, (c[2] * tri) // 255) - b[1] = (ph + speed) & 255 - if random.randint(0, 31) == 0: - b[0] = random.randint(0, max(0, self.driver.num_leds - 1)) - self.driver.n.write() - return bugs, utime.ticks_add(last, d), True - - def run(self, preset): - """Sparkles: n6 0 trail decay, 1 ice burst+halo, 2 fireflies.""" - mode = style_mode(preset, 0, _LEGACY) - colors = preset.c if preset.c else [(120, 120, 255)] - last = utime.ticks_ms() - - if mode == 2: - colors = preset.c if preset.c else [(255, 210, 80), (120, 255, 120)] - count = max(1, int(preset.n1) if int(preset.n1) > 0 else 6) - bugs = [ - [random.randint(0, max(0, self.driver.num_leds - 1)), random.randint(0, 255)] - for _ in range(count) - ] - while True: - bugs, last, stepped = self._run_fireflies(preset, colors, bugs, last) - if stepped and not preset.a: - yield - return - yield - - if mode == 1: - colors = preset.c if preset.c else [ - (240, 248, 255), - (200, 235, 255), - (255, 255, 255), - ] - sparks = [] - while True: - sparks, last, stepped = self._run_ice(preset, colors, sparks, last) - if stepped and not preset.a: - yield - return - yield - - while True: - last, stepped = self._run_trail(preset, colors, last) - if stepped and not preset.a: - yield - return - yield diff --git a/src/patterns/strobe_burst.py b/src/patterns/strobe_burst.py deleted file mode 100644 index 36ae8b2..0000000 --- a/src/patterns/strobe_burst.py +++ /dev/null @@ -1,45 +0,0 @@ -import utime - - -class StrobeBurst: - def __init__(self, driver): - self.driver = driver - - def run(self, preset): - colors = preset.c if preset.c else [(255, 255, 255)] - state = "flash_on" - flash_idx = 0 - state_start = utime.ticks_ms() - while True: - count = max(1, int(preset.n1) if int(preset.n1) > 0 else 3) - gap = max(1, int(preset.n2) if int(preset.n2) > 0 else 60) - cooldown = max(1, int(preset.n3) if int(preset.n3) > 0 else 400) - on_ms = max(1, int(preset.d) // 2) - c = self.driver.apply_brightness(colors[0], preset.b) - bg_color = self.driver.apply_brightness(preset.background_or(colors), preset.b) - now = utime.ticks_ms() - - if state == "flash_on": - self.driver.fill(c) - if utime.ticks_diff(now, state_start) >= on_ms: - state = "flash_off" - state_start = utime.ticks_add(state_start, on_ms) - elif state == "flash_off": - self.driver.fill(bg_color) - if utime.ticks_diff(now, state_start) >= gap: - flash_idx += 1 - if flash_idx >= count: - if not preset.a: - return - state = "cooldown" - flash_idx = 0 - state_start = utime.ticks_add(state_start, gap) - else: - state = "flash_on" - state_start = utime.ticks_add(state_start, gap) - else: - self.driver.fill(bg_color) - if utime.ticks_diff(now, state_start) >= cooldown: - state = "flash_on" - state_start = utime.ticks_add(state_start, cooldown) - yield diff --git a/src/patterns/transition.py b/src/patterns/transition.py deleted file mode 100644 index b29545a..0000000 --- a/src/patterns/transition.py +++ /dev/null @@ -1,57 +0,0 @@ -import utime - - -class Transition: - def __init__(self, driver): - self.driver = driver - - def run(self, preset): - """Transition between colors, blending over `delay` ms.""" - colors = preset.c - if not colors: - self.driver.off() - yield - return - - # Only one color: just keep it on - if len(colors) == 1: - while True: - self.driver.fill(self.driver.apply_brightness(colors[0], preset.b)) - yield - return - - color_index = 0 - start_time = utime.ticks_ms() - - while True: - if not colors: - break - - # Get current and next color based on live list - c1 = colors[color_index % len(colors)] - c2 = colors[(color_index + 1) % len(colors)] - - duration = max(10, int(preset.d)) # At least 10ms - now = utime.ticks_ms() - elapsed = utime.ticks_diff(now, start_time) - - if elapsed >= duration: - # End of this transition step - if not preset.a: - # One-shot: transition from first to second color only - self.driver.fill(self.driver.apply_brightness(c2, preset.b)) - break - # Auto: move to next pair - color_index = (color_index + 1) % len(colors) - start_time = now - yield - continue - - # Interpolate between c1 and c2 - factor = elapsed / duration - interpolated = tuple( - int(c1[i] + (c2[i] - c1[i]) * factor) for i in range(3) - ) - self.driver.fill(self.driver.apply_brightness(interpolated, preset.b)) - - yield diff --git a/src/patterns/twinkle.py b/src/patterns/twinkle.py deleted file mode 100644 index bc56455..0000000 --- a/src/patterns/twinkle.py +++ /dev/null @@ -1,160 +0,0 @@ -import random -import utime - -# Default cool palette (icy blues, violet, mint) when preset has no colours. -_DEFAULT_COOL = ( - (120, 200, 255), - (80, 140, 255), - (180, 120, 255), - (100, 220, 240), - (160, 200, 255), - (90, 180, 220), -) - - -class Twinkle: - def __init__(self, driver): - self.driver = driver - - def _palette(self, preset): - colors = preset.c - if not colors: - return list(_DEFAULT_COOL) - out = [] - for c in colors: - if isinstance(c, (list, tuple)) and len(c) == 3: - out.append( - ( - max(0, min(255, int(c[0]))), - max(0, min(255, int(c[1]))), - max(0, min(255, int(c[2]))), - ) - ) - return out if out else list(_DEFAULT_COOL) - - def run(self, preset): - """Twinkle: n1 activity, n2 density; n3/n4 min/max length of adjacent on/off runs.""" - palette = self._palette(preset) - num = self.driver.num_leds - bg_color = self.driver.apply_brightness(preset.background_or(palette), preset.b) - if num <= 0: - while True: - yield - return - - def activity_rate(): - r = int(preset.n1) - if r <= 0: - r = 48 - return max(1, min(255, r)) - - def density255(): - """Higher → more LEDs lit on average when a twinkle step fires (0 = default mid).""" - d = int(preset.n2) - if d <= 0: - d = 128 - return max(0, min(255, d)) - - def cluster_len_bounds(): - """n3 = min adjacent LEDs per twinkle, n4 = max (both 0 → 1..4).""" - lo = int(preset.n3) - hi = int(preset.n4) - if lo <= 0 and hi <= 0: - lo, hi = 1, min(4, num) - else: - if lo <= 0: - lo = 1 - if hi <= 0: - hi = lo - if hi < lo: - lo, hi = hi, lo - lo = max(1, min(lo, num)) - hi = max(lo, min(hi, num)) - return lo, hi - - def random_cluster_len(): - lo, hi = cluster_len_bounds() - # When min and max match, every lit/dim run is exactly that many LEDs (still capped by strip length). - if lo == hi: - return lo - return random.randint(lo, hi) - - def cluster_base_index(start, k): - """Shift run left so a length-k segment fits; keeps full k when num >= k.""" - k = min(max(0, int(k)), num) - if k <= 0: - return 0 - return max(0, min(int(start), num - k)) - - dens = density255() - on = [random.randint(0, 255) < dens for _ in range(num)] - colour_i = [random.randint(0, len(palette) - 1) for _ in range(num)] - last_update = utime.ticks_ms() - - if not preset.a: - for i in range(num): - if on[i]: - base = palette[colour_i[i] % len(palette)] - self.driver.n[i] = self.driver.apply_brightness(base, preset.b) - else: - self.driver.n[i] = bg_color - self.driver.n.write() - yield - return - - while True: - now = utime.ticks_ms() - delay_ms = max(1, int(preset.d)) - if utime.ticks_diff(now, last_update) >= delay_ms: - rate = activity_rate() - dens = density255() - # Snapshot for decisions; apply all darks then all lights so - # overlaps in the same tick favour lit runs (lights win). - prev_on = on[:] - prev_ci = colour_i[:] - next_on = list(prev_on) - next_ci = list(prev_ci) - - light_i = [] - dark_i = [] - for i in range(num): - if random.randint(0, 255) < rate: - r = random.randint(0, 255) - if not prev_on[i]: - if r < dens: - light_i.append(i) - else: - if r < (255 - dens): - dark_i.append(i) - - def light_adjacent(start): - k = random_cluster_len() - b = cluster_base_index(start, k) - for dj in range(k): - idx = b + dj - next_on[idx] = True - next_ci[idx] = random.randint(0, len(palette) - 1) - - def dark_adjacent(start): - k = random_cluster_len() - b = cluster_base_index(start, k) - for dj in range(k): - idx = b + dj - next_on[idx] = False - - for i in dark_i: - dark_adjacent(i) - for i in light_i: - light_adjacent(i) - - for i in range(num): - if next_on[i]: - base = palette[next_ci[i] % len(palette)] - self.driver.n[i] = self.driver.apply_brightness(base, preset.b) - else: - self.driver.n[i] = bg_color - self.driver.n.write() - on = next_on - colour_i = next_ci - last_update = utime.ticks_add(last_update, delay_ms) - yield diff --git a/src/preset.py b/src/preset.py deleted file mode 100644 index b529465..0000000 --- a/src/preset.py +++ /dev/null @@ -1,156 +0,0 @@ -class Preset: - def __init__(self, data): - # Set default values for all preset attributes - self.p = "off" - self.d = 100 - self.b = 127 - self.c = [(255, 255, 255)] - self.a = True - self.n1 = 0 - self.n2 = 0 - self.n3 = 0 - self.n4 = 0 - self.n5 = 0 - self.n6 = 0 - self.bg = (0, 0, 0) - - # Override defaults with provided data - self.edit(data) - - def edit(self, data=None): - if not data: - return False - aliases = { - "pattern": "p", - "colors": "c", - "delay": "d", - "brightness": "b", - "auto": "a", - "background": "bg", - "mode": "n6", - } - int_fields = {"d", "b", "n1", "n2", "n3", "n4", "n5", "n6"} - allowed_fields = {"p", "c", "d", "b", "a", "bg", "n1", "n2", "n3", "n4", "n5", "n6"} - for key, value in data.items(): - if key == "reverse": - try: - if isinstance(value, bool): - self.n5 = 1 if value else 0 - elif isinstance(value, (int, float)): - self.n5 = 1 if int(value) else 0 - elif isinstance(value, str): - lowered = value.lower() - self.n5 = 1 if lowered in ("true", "1", "yes", "on") else 0 - except (TypeError, ValueError): - pass - continue - key = aliases.get(key, key) - if key not in allowed_fields: - continue - if key in int_fields: - try: - parsed = int(value) - if key == "b": - parsed = max(0, min(255, parsed)) - elif key in ("d", "n1", "n2", "n3", "n4", "n5", "n6"): - parsed = max(0, parsed) - setattr(self, key, parsed) - except (TypeError, ValueError): - continue - elif key == "a": - if isinstance(value, bool): - self.a = value - elif isinstance(value, int): - self.a = bool(value) - elif isinstance(value, str): - lowered = value.lower() - if lowered in ("true", "1", "yes", "on"): - self.a = True - elif lowered in ("false", "0", "no", "off"): - self.a = False - elif key == "c": - if isinstance(value, (list, tuple)): - self.c = value - elif key == "bg": - if isinstance(value, str) and value.startswith("#") and len(value) == 7: - try: - self.bg = ( - int(value[1:3], 16), - int(value[3:5], 16), - int(value[5:7], 16), - ) - except (TypeError, ValueError): - continue - elif isinstance(value, (list, tuple)) and len(value) == 3: - try: - self.bg = tuple(max(0, min(255, int(x))) for x in value) - except (TypeError, ValueError): - continue - else: - setattr(self, key, value) - return True - - @property - def pattern(self): - return self.p - - @pattern.setter - def pattern(self, value): - self.p = value - - @property - def delay(self): - return self.d - - @delay.setter - def delay(self, value): - self.d = value - - @property - def brightness(self): - return self.b - - @brightness.setter - def brightness(self, value): - self.b = value - - @property - def colors(self): - return self.c - - @colors.setter - def colors(self, value): - self.c = value - - @property - def auto(self): - return self.a - - @auto.setter - def auto(self, value): - self.a = value - - def background_or(self, colors=None, default=(0, 0, 0)): - bg = getattr(self, "bg", None) - if isinstance(bg, (list, tuple)) and len(bg) == 3: - try: - return tuple(max(0, min(255, int(x))) for x in bg) - except (TypeError, ValueError): - return default - return default - - def to_dict(self): - return { - "p": self.p, - "d": self.d, - "b": self.b, - "c": self.c, - "a": self.a, - "bg": self.bg, - "n1": self.n1, - "n2": self.n2, - "n3": self.n3, - "n4": self.n4, - "n5": self.n5, - "n6": self.n6, - } diff --git a/src/presets.py b/src/presets.py deleted file mode 100644 index 44d4881..0000000 --- a/src/presets.py +++ /dev/null @@ -1,324 +0,0 @@ -from machine import Pin -from neopixel import NeoPixel -from preset import Preset -from utils import convert_and_reorder_colors -import json -import sys -import utime -try: - import uos as os -except ImportError: - import os - -MAX_PRESETS = 32 - -# Tests set this so pattern import can feed the 10s watchdog. -load_wdt = None - - -class Presets: - def __init__(self, pin, num_leds): - self.n = NeoPixel(Pin(pin, Pin.OUT), num_leds) - self.num_leds = num_leds - self.step = 0 - # Global brightness (0–255), controlled via ESPNow {"b": } - self.b = 255 - # Ceiling for the effective brightness (0–255): neither the global nor a preset's brightness goes above it - self.max_b = 255 - self.reversed = False - - self.generator = None - self.presets = {} - self.selected = None - - self.reload_patterns() - - def reload_patterns(self): - # Register built-in methods first, then discovered pattern classes - self.patterns = { - "off": self.off, - "on": self.on, - "blink": self.blink, - } - self.patterns.update(self._load_dynamic_patterns()) - - def _load_dynamic_patterns(self): - loaded = {} - try: - files = os.listdir("patterns") - except OSError: - return loaded - - for filename in files: - if load_wdt is not None: - load_wdt.feed() - if not filename.endswith(".py") or filename in ("__init__.py", "main.py"): - continue - module_basename = filename[:-3] - module_name = "patterns." + module_basename - try: - if module_name in sys.modules: - del sys.modules[module_name] - module = __import__(module_name, None, None, ["*"]) - except Exception as e: - print("Pattern import failed:", module_name, e) - continue - - pattern_class = None - for attr_name in dir(module): - attr = getattr(module, attr_name) - # Pick the first class in the module that exposes run() - if isinstance(attr, type) and hasattr(attr, "run"): - pattern_class = attr - break - - if pattern_class is None: - continue - - try: - loaded[module_basename] = pattern_class(self).run - except Exception as e: - print("Pattern init failed:", module_name, e) - - self._apply_pattern_aliases(loaded) - return loaded - - def _apply_pattern_aliases(self, loaded): - """Legacy pattern ids -> merged implementations (same generator).""" - aliases = ( - ("rainbow", "colour_cycle"), - ("gradient_scroll", "colour_cycle"), - ("meteor_rain", "meteor"), - ("comet_dual", "meteor"), - ("scanner", "meteor"), - ("snowfall", "particles"), - ("starfall", "particles"), - ("sparkle_trail", "sparkle"), - ("ice_sparkle", "sparkle"), - ("fireflies", "sparkle"), - ("marquee", "chase"), - ("northern_wave", "aurora"), - ) - for old, new in aliases: - if new in loaded and old not in loaded: - loaded[old] = loaded[new] - - def save(self): - """Save the presets to a file.""" - with open("presets.json", "w") as f: - json.dump({name: preset.to_dict() for name, preset in self.presets.items()}, f) - return True - - def load(self, settings=None): - """Load presets from a file. - - `settings` is used to convert hex strings in `c` to RGB tuples and apply - the device's colour order (same as ESPNow receive). If omitted, RGB order - is assumed. - """ - try: - with open("presets.json", "r") as f: - data = json.load(f) - except OSError: - # Create an empty presets file if missing - self.presets = {} - self.save() - return True - - order = settings if settings is not None else "rgb" - self.presets = {} - for name, preset_data in data.items(): - if len(self.presets) >= MAX_PRESETS: - print("Preset limit reached on load:", MAX_PRESETS) - break - color_key = "c" if "c" in preset_data else ("colors" if "colors" in preset_data else None) - if color_key is not None: - preset_data[color_key] = convert_and_reorder_colors( - preset_data[color_key], order - ) - self.presets[name] = Preset(preset_data) - return True - - def edit(self, name, data): - """Create or update a preset with the given name.""" - if name in self.presets: - # Update existing preset - was_auto = self.presets[name].a - self.presets[name].edit(data) - # Editing the live preset: auto still re-selects (one tick) so the strip - # restarts without a separate select message (controller often sends both). - # Manual must NOT call select() here — presets-only pushes (e.g. zone sequence - # arming the first step) would otherwise run select's first tick and consume a - # beat/step. Manual advances only on explicit select from the controller. - if self.selected == name: - preset = self.presets[name] - if preset.a: - self.step = 0 - self.generator = None - self.fill((0, 0, 0)) - self.select(name) - elif was_auto: - self.step = 0 - self.generator = None - self.fill((0, 0, 0)) - else: - if len(self.presets) >= MAX_PRESETS and name not in ("on", "off"): - print("Preset limit reached:", MAX_PRESETS) - return False - # Create new preset - self.presets[name] = Preset(data) - return True - - def delete(self, name): - if name in self.presets: - del self.presets[name] - return True - return False - - def delete_all(self): - self.presets = {} - self.generator = None - self.selected = None - return True - - def tick(self): - if self.generator is None: - return - try: - next(self.generator) - except StopIteration: - self.generator = None - except Exception as e: - print(f"Error in tick: {e}") - self.generator = None - - def beat(self): - """Step the selected pattern once; same effect as re-selecting it, without the message.""" - name = self.selected - if name in self.presets: - preset = self.presets[name] - if preset.p in self.patterns: - self.generator = self.patterns[preset.p](preset) - - def select(self, preset_name, step=None): - # Auto-create simple built-in presets for common names on first use - if preset_name not in self.presets and preset_name in ("on", "off"): - if preset_name == "on": - self.presets[preset_name] = Preset({"p": "on"}) - else: - self.presets[preset_name] = Preset({"p": "off"}) - - if preset_name in self.presets: - preset = self.presets[preset_name] - if preset.p in self.patterns: - if preset.p == "off": - self.generator = None - self.step = 0 - self.fill((0, 0, 0)) - self.selected = preset_name - return True - # If re-selecting the same preset before the main loop has tick()'d the - # previous frame, run one pending tick so step stays in sync. - if ( - preset_name == self.selected - and self.generator is not None - ): - self.tick() - # Set step value if explicitly provided - if step is not None: - self.step = step - elif self.selected != preset_name: - self.step = 0 - self.generator = self.patterns[preset.p](preset) - self.selected = preset_name # Store the preset name, not the object - self.tick() - return True - print("select failed: pattern not found for preset", preset_name, "pattern=", preset.p) - return False - print("select failed: preset not found", preset_name) - # If preset doesn't exist or pattern not found, indicate failure - return False - - def update_num_leds(self, pin, num_leds): - self.n = NeoPixel(Pin(pin, Pin.OUT), num_leds) - self.num_leds = num_leds - - def is_reversed(self, preset): - from patterns.pattern_direction import is_reversed as _is_reversed - - return _is_reversed(preset, self) - - def led_i(self, preset, logical_index): - from patterns.pattern_direction import led_i as _led_i - - return _led_i(self, preset, logical_index) - - def set(self, preset, logical_index, color): - from patterns.pattern_direction import set_led - - set_led(self, preset, logical_index, color) - - def signed(self, preset, value): - from patterns.pattern_direction import signed as _signed - - return _signed(preset, value, self) - - def apply_brightness(self, color, brightness_override=None): - # Combine per-preset brightness (override) with global brightness self.b - local = brightness_override if brightness_override is not None else 255 - # Scale preset brightness by global brightness - effective_brightness = min(int(local * self.b / 255), self.max_b) - return tuple(int(c * effective_brightness / 255) for c in color) - - def fill(self, color=None): - fill_color = color if color is not None else (0, 0, 0) - for i in range(self.num_leds): - self.n[i] = fill_color - self.n.write() - - def off(self, preset=None): - self.fill((0, 0, 0)) - - def on(self, preset): - colors = preset.c - color = colors[0] if colors else (255, 255, 255) - while True: - self.fill(self.apply_brightness(color, preset.b)) - yield - - def blink(self, preset): - """Built-in blink (used by controller identify); no patterns/ deploy required.""" - colors = preset.c if preset.c else [(255, 255, 255)] - bg_color = self.apply_brightness(preset.background_or(colors), preset.b) - color_index = 0 - delay_ms = max(1, int(preset.d)) - period = delay_ms * 2 - now = utime.ticks_ms() - # Phase-lock to wall time so group identify (broadcast select) stays in sync even - # when devices process the packet on different main-loop iterations. - phase = now % period if period else 0 - state = phase < delay_ms - last_update = utime.ticks_add(now, -phase) - if state: - base = colors[color_index % len(colors)] - self.fill(self.apply_brightness(base, preset.b)) - color_index += 1 - else: - self.fill(bg_color) - while True: - now = utime.ticks_ms() - if utime.ticks_diff(now, last_update) >= delay_ms: - if state: - base = colors[color_index % len(colors)] - self.fill(self.apply_brightness(base, preset.b)) - color_index += 1 - else: - self.fill(bg_color) - state = not state - last_update = utime.ticks_add(last_update, delay_ms) - yield - - -def run_tick(presets): - """Advance one animation frame (standalone tests / mpremote demos).""" - presets.tick() diff --git a/src/print_timestamp.py b/src/print_timestamp.py deleted file mode 100644 index 9c516b4..0000000 --- a/src/print_timestamp.py +++ /dev/null @@ -1,17 +0,0 @@ -"""Install a builtins.print wrapper that prefixes each line with uptime (ms). - -Import this module before other led-driver imports that print (e.g. first in main). -""" - -import builtins -import utime - -_original_print = builtins.print - - -def _timestamped_print(*args, **kwargs): - ts = utime.ticks_ms() - return _original_print("[%d]" % ts, *args, **kwargs) - - -builtins.print = _timestamped_print diff --git a/src/runtime_state.py b/src/runtime_state.py deleted file mode 100644 index 6122ea7..0000000 --- a/src/runtime_state.py +++ /dev/null @@ -1,12 +0,0 @@ -class RuntimeState: - def __init__(self): - self.hello = True - self.ws_client_count = 0 - - def ws_connected(self): - self.ws_client_count += 1 - self.hello = False - - def ws_disconnected(self): - self.ws_client_count = max(0, self.ws_client_count - 1) - self.hello = self.ws_client_count == 0 diff --git a/src/settings.py b/src/settings.py deleted file mode 100644 index 3e8dd16..0000000 --- a/src/settings.py +++ /dev/null @@ -1,112 +0,0 @@ -import json -import ubinascii -import machine -import network - -WIFI_CHANNEL_DEFAULT = 5 - -class Settings(dict): - SETTINGS_FILE = "/settings.json" - - def __init__(self): - super().__init__() - self.load() # Load settings from file during initialization - self.color_order = self.get_color_order(self["color_order"]) - - def set_defaults(self): - - self["led_pin"] = 10 - self["num_leds"] = 200 - - self["color_order"] = "grb" - - sta = network.WLAN(network.STA_IF) - sta.active(True) - #use led-mac for name - mac = sta.config("mac") - mac = ubinascii.hexlify(mac).decode().lower() - self["name"] = "led-" + mac - - self["debug"] = False - self["default"] = "on" - self["last_preset"] = "" - # Power-on: "default" | "last" | "off" - self["startup_mode"] = "default" - self["brightness"] = 32 - - self["wifi_channel"] = WIFI_CHANNEL_DEFAULT - self["groups"] = [] - - - def save(self): - try: - j = json.dumps(self) - with open(self.SETTINGS_FILE, 'w') as file: - file.write(j) - except Exception as e: - print(f"Error saving settings: {e}") - - def load(self): - try: - with open(self.SETTINGS_FILE, 'r') as file: - loaded_settings = json.load(file) - self.update(loaded_settings) - old_recent = self.pop("recent_presets", None) - if isinstance(old_recent, list) and old_recent and not self.get("last_preset"): - for x in reversed(old_recent): - if isinstance(x, str) and x.strip(): - self["last_preset"] = x.strip() - break - if x is not None: - s = str(x).strip() - if s: - self["last_preset"] = s - break - except Exception as e: - print(f"Error loading settings") - self.set_defaults() - self.save() - - def get_color_order(self, color_order): - """Convert color order string to tuple of hex string indices.""" - color_orders = { - "rgb": (1, 3, 5), - "rbg": (1, 5, 3), - "grb": (3, 1, 5), - "gbr": (3, 5, 1), - "brg": (5, 1, 3), - "bgr": (5, 3, 1) - } - return color_orders.get(color_order.lower(), (1, 3, 5)) # Default to RGB - - def get_rgb_channel_order(self, color_order=None): - """Convert color order string to RGB channel indices for reordering tuples. - Returns tuple of channel indices: (r_channel, g_channel, b_channel) - Example: 'grb' -> (1, 0, 2) means (G, R, B)""" - if color_order is None: - color_order = self.get("color_order", "rgb") - color_order = color_order.lower() - # Map hex string positions to RGB channel indices - # Position 1 (R in hex) -> channel 0, Position 3 (G) -> channel 1, Position 5 (B) -> channel 2 - hex_to_channel = {1: 0, 3: 1, 5: 2} - hex_indices = self.get_color_order(color_order) - return tuple(hex_to_channel[pos] for pos in hex_indices) - -# Example usage -def main(): - settings = Settings() - print(f"Number of LEDs: {settings['num_leds']}") - 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() diff --git a/src/startup.py b/src/startup.py deleted file mode 100644 index 09f59ed..0000000 --- a/src/startup.py +++ /dev/null @@ -1,52 +0,0 @@ -import gc -import machine -import network -import utime - -from presets import Presets -from settings import Settings -from controller_messages import apply_startup_pattern - - -def initialize_runtime(): - machine.freq(160000000) - - settings = Settings() - - wdt = machine.WDT(timeout=10000) - wdt.feed() - - gc.collect() - - presets = Presets(settings["led_pin"], settings["num_leds"]) - presets.load(settings) - presets.b = settings.get("brightness", 255) - presets.max_b = settings.get("max_brightness", 255) - presets.debug = bool(settings.get("debug", False)) - gc.collect() - - apply_startup_pattern(settings, presets) - - # On ESP32-C3, soft reboots can leave Wi-Fi driver state allocated. - # Reset both interfaces and collect before bringing STA up. - ap_if = network.WLAN(network.AP_IF) - ap_if.active(False) - sta_if = network.WLAN(network.STA_IF) - if sta_if.active(): - sta_if.active(False) - utime.sleep_ms(100) - gc.collect() - sta_if.active(True) - sta_if.config(pm=network.WLAN.PM_NONE) - sta_if.connect(settings["ssid"], settings["password"]) - while not sta_if.isconnected(): - utime.sleep(1) - wdt.feed() - - try: - led_ip = sta_if.ifconfig()[0] - except Exception: - led_ip = "?" - print("led-driver IP:", led_ip, " led-controller IP:", "(not connected)") - - return settings, presets, wdt, sta_if diff --git a/src/utils.py b/src/utils.py deleted file mode 100644 index 8343b13..0000000 --- a/src/utils.py +++ /dev/null @@ -1,58 +0,0 @@ -def convert_and_reorder_colors(colors, settings_or_color_order): - """Convert hex color strings to RGB tuples and reorder based on device color order. - - Args: - colors: List of colors, either hex strings like "#FF0000" or RGB tuples like (255, 0, 0) - settings_or_color_order: Either a Settings object or a color_order string (e.g., "rgb", "grb") - - Returns: - List of RGB tuples reordered according to device color order - """ - # Get channel order from settings or color_order string - if hasattr(settings_or_color_order, 'get_rgb_channel_order'): - # It's a Settings object - channel_order = settings_or_color_order.get_rgb_channel_order() - elif isinstance(settings_or_color_order, str): - # It's a color_order string, convert to channel order - color_order = settings_or_color_order.lower() - color_orders = { - "rgb": (1, 3, 5), - "rbg": (1, 5, 3), - "grb": (3, 1, 5), - "gbr": (3, 5, 1), - "brg": (5, 1, 3), - "bgr": (5, 3, 1) - } - hex_indices = color_orders.get(color_order, (1, 3, 5)) - # Map hex string positions to RGB channel indices - hex_to_channel = {1: 0, 3: 1, 5: 2} - channel_order = tuple(hex_to_channel[pos] for pos in hex_indices) - else: - # Assume it's already a channel order tuple - channel_order = settings_or_color_order - - converted_colors = [] - for color in colors: - try: - # Convert "#RRGGBB" to (R, G, B) - if isinstance(color, str) and color.startswith("#") and len(color) == 7: - r = int(color[1:3], 16) - g = int(color[3:5], 16) - b = int(color[5:7], 16) - rgb = (r, g, b) - elif isinstance(color, (list, tuple)) and len(color) == 3: - # Already a tuple/list, just coerce and clamp. - rgb = tuple(max(0, min(255, int(x))) for x in color) - else: - # Unknown format: ignore safely. - continue - - # Reorder based on device color order - reordered = (rgb[channel_order[0]], rgb[channel_order[1]], rgb[channel_order[2]]) - converted_colors.append(reordered) - except (TypeError, ValueError, IndexError): - # Skip malformed color entries to avoid crashing pattern loops. - continue - if not converted_colors: - converted_colors.append((255, 255, 255)) - return converted_colors diff --git a/src/v1_wire.py b/src/v1_wire.py deleted file mode 100644 index 2a2aaf2..0000000 --- a/src/v1_wire.py +++ /dev/null @@ -1,36 +0,0 @@ -"""Expand short v1 wire keys to long names (MicroPython).""" - - -K_PRESETS = "p" -K_SELECT = "s" -K_GROUPS = "g" -K_SET_GROUPS = "sg" -K_SAVE = "sv" -K_DEFAULT = "df" -K_DEVICE_CONFIG = "dc" -K_CLEAR_PRESETS = "cp" -K_MANIFEST = "mf" - -_SHORT_TO_LONG = { - K_PRESETS: "presets", - K_SELECT: "select", - K_GROUPS: "groups", - K_SET_GROUPS: "set_groups", - K_SAVE: "save", - K_DEFAULT: "default", - K_DEVICE_CONFIG: "device_config", - K_CLEAR_PRESETS: "clear_presets", - K_MANIFEST: "manifest", -} - - -def expand_v1(data): - if not isinstance(data, dict): - return data - out = dict(data) - for short_key, long_key in _SHORT_TO_LONG.items(): - if short_key in data and long_key not in out: - out[long_key] = data[short_key] - if short_key in out: - del out[short_key] - return out diff --git a/src/wifi_sta.py b/src/wifi_sta.py deleted file mode 100644 index de0842f..0000000 --- a/src/wifi_sta.py +++ /dev/null @@ -1,129 +0,0 @@ -"""STA connect helpers aligned with tests/test_wifi.py (status polling, fatal codes).""" - -import gc -import machine -import utime -import network - -_CONNECT_TIMEOUT_S = 45 -_RETRY_DELAY_S = 2 - - -def _wifi_status_label(code): - names = { - getattr(network, "STAT_IDLE", 0): "idle", - getattr(network, "STAT_CONNECTING", 1): "connecting", - getattr(network, "STAT_WRONG_PASSWORD", -3): "wrong_password", - getattr(network, "STAT_NO_AP_FOUND", -2): "no_ap_found", - getattr(network, "STAT_CONNECT_FAIL", -1): "connect_fail", - getattr(network, "STAT_GOT_IP", 3): "got_ip", - } - return names.get(code, str(code)) - - -# Only abort the wait loop immediately on wrong password. NO_AP_FOUND / CONNECT_FAIL are often -# transient while the radio is still scanning (ESP32-C3 may report them before the AP appears). -_ABORT_WAIT_IMMEDIATE = ( - getattr(network, "STAT_WRONG_PASSWORD", -3), -) - - -def _one_association_campaign(sta_if, ssid, password, wdt): - """disconnect → connect → wait until connected, wrong password, or timeout. Returns True if connected.""" - try: - sta_if.disconnect() - except Exception: - pass - utime.sleep_ms(200) - try: - sta_if.connect(ssid, password) - except Exception as ex: - print("wifi_sta: connect raised:", ex) - return False - - start = utime.time() - last_status = None - while not sta_if.isconnected(): - status = sta_if.status() - if status != last_status: - print("wifi_sta: status", status, _wifi_status_label(status)) - last_status = status - if status in _ABORT_WAIT_IMMEDIATE: - return False - if utime.time() - start >= _CONNECT_TIMEOUT_S: - print("wifi_sta: association timeout") - return False - utime.sleep(1) - if wdt is not None: - wdt.feed() - return True - - -def boot_sta(settings, wdt): - """Tear down and bring up STA. Call before large heap users (NeoPixel, patterns). - - On ESP32-C3, soft reboots can leave the Wi-Fi driver allocated; init while the - heap is still free. If re-init fails after a soft reboot, hard-reset once. - """ - sta_if = network.WLAN(network.STA_IF) - try: - if sta_if.active(): - try: - sta_if.disconnect() - except Exception: - pass - sta_if.active(False) - except Exception: - pass - utime.sleep_ms(100) - gc.collect() - try: - sta_if.active(True) - except OSError as e: - err = str(e) - if "Out of Memory" in err or "WiFi" in err: - if machine.reset_cause() == machine.SOFT_RESET: - print("wifi_sta: init failed after soft reboot, hard reset:", err) - machine.reset() - raise - sta_if.config(pm=network.WLAN.PM_NONE) - ssid = settings.get("ssid") or "" - if ssid: - connect_until_up(sta_if, ssid, settings.get("password") or "", wdt) - return sta_if - - -def connect_until_up(sta_if, ssid, password, wdt): - """Boot: repeat campaigns until STA has a route (same strategy as tests/test_wifi.py).""" - if not ssid: - print("wifi_sta: no ssid in settings") - return False - attempt = 0 - while True: - attempt += 1 - print("wifi_sta: boot attempt", attempt, "ssid=", repr(ssid)) - if _one_association_campaign(sta_if, ssid, password, wdt): - try: - print("wifi_sta: connected", sta_if.ifconfig()[0]) - except Exception: - print("wifi_sta: connected") - return True - print("wifi_sta: retry in", _RETRY_DELAY_S, "s") - for _ in range(_RETRY_DELAY_S): - utime.sleep(1) - if wdt is not None: - wdt.feed() - - -def try_reconnect(sta_if, ssid, password, wdt): - """Runtime: single association campaign after link loss; non-looping.""" - if not ssid: - return False - print("wifi_sta: reconnect") - ok = _one_association_campaign(sta_if, ssid, password, wdt) - if ok: - try: - print("wifi_sta: connected", sta_if.ifconfig()[0]) - except Exception: - print("wifi_sta: connected") - return ok diff --git a/tests/all.py b/tests/all.py deleted file mode 100644 index 93222da..0000000 --- a/tests/all.py +++ /dev/null @@ -1,419 +0,0 @@ -#!/usr/bin/env python3 -"""Self-contained led-driver test runner for MicroPython/mpremote. - -Run on device (from led-driver repo root):: - - mpremote connect run tests/all.py - -Or via dev helper:: - - python dev.py test -""" - -import json -import sys -import utime -from machine import WDT - - -def _bootstrap_import_path(): - """Find ``settings`` / ``presets`` whether this file lives in ``tests/`` or ``:/``.""" - try: - import uos as os - except ImportError: - import os - - candidates = [] - try: - here = __file__.rsplit("/", 1)[0] - if here: - candidates.append(here) - parent = here.rsplit("/", 1)[0] - if parent: - candidates.append(parent) - except NameError: - pass - candidates.extend([".", "..", "/"]) - for p in candidates: - if p and p not in sys.path: - sys.path.insert(0, p) - - -_bootstrap_import_path() - -from settings import Settings # noqa: E402 -from presets import Presets, run_tick # noqa: E402 -from preset import Preset # noqa: E402 -from utils import convert_and_reorder_colors # noqa: E402 - - -class _TestContext: - def __init__(self): - self.settings = Settings() - self.settings["name"] = self.settings.get("name", "test_device") - self.presets = Presets(self.settings["led_pin"], self.settings["num_leds"]) - self.presets.b = self.settings.get("brightness", 255) - self.wdt = WDT(timeout=10000) - - def tick_for_ms(self, duration_ms, sleep_ms=5): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < duration_ms: - self.wdt.feed() - run_tick(self.presets) - utime.sleep_ms(sleep_ms) - - -def _pattern_loaded(ctx, pattern_id): - return pattern_id in ctx.presets.patterns - - -def _smoke_preset(ctx, name, data, ms=80): - pattern_id = data.get("p") or data.get("pattern") - if not _pattern_loaded(ctx, pattern_id): - raise AssertionError("pattern not loaded: %s" % pattern_id) - ctx.presets.edit(name, data) - if not ctx.presets.select(name): - raise AssertionError("select failed: %s" % name) - ctx.tick_for_ms(ms) - - -def _process_message(ctx, payload): - """Small test helper that mirrors the main message handling logic.""" - try: - if isinstance(payload, (bytes, bytearray)): - data = json.loads(payload) - elif isinstance(payload, str): - data = json.loads(payload) - else: - data = payload - except (TypeError, ValueError): - return "invalid_json" - - if not isinstance(data, dict): - return "invalid_shape" - if data.get("v") != "1": - return "wrong_version" - - if "b" in data: - try: - ctx.presets.b = max(0, min(255, int(data["b"]))) - except (TypeError, ValueError): - pass - - if isinstance(data.get("presets"), dict): - for name, preset_data in data["presets"].items(): - if not isinstance(preset_data, dict): - continue - color_key = "c" if "c" in preset_data else ("colors" if "colors" in preset_data else None) - if color_key is not None: - try: - preset_data[color_key] = convert_and_reorder_colors( - preset_data[color_key], ctx.settings - ) - except (TypeError, ValueError): - continue - ctx.presets.edit(name, preset_data) - - if isinstance(data.get("select"), dict) and ctx.settings.get("name") in data["select"]: - select_list = data["select"][ctx.settings.get("name")] - if isinstance(select_list, list) and select_list: - preset_name = select_list[0] - step = select_list[1] if len(select_list) > 1 else None - if isinstance(preset_name, str): - ctx.presets.select(preset_name, step=step) - - if "default" in data: - default_name = data["default"] - this_device_name = ctx.settings.get("name") - this_device_name_norm = ( - this_device_name.strip().lower() - if isinstance(this_device_name, str) - else None - ) - should_apply_default = True - if "targets" in data: - should_apply_default = False - targets = data.get("targets") - if isinstance(targets, list) and this_device_name_norm: - normalized_targets = [ - target.strip().lower() - for target in targets - if isinstance(target, str) and target.strip() - ] - should_apply_default = this_device_name_norm in normalized_targets - if ( - should_apply_default - and isinstance(default_name, str) - and default_name - and default_name in ctx.presets.presets - ): - ctx.settings["default"] = default_name - - if "save" in data: - ctx.presets.save() - - return "ok" - - -def test_invalid_messages_do_not_crash(): - ctx = _TestContext() - cases = [ - b"{not-json", - "[]", - json.dumps({"v": "2"}), - json.dumps({"v": "1", "presets": ["bad"]}), - json.dumps({"v": "1", "select": {"test_device": "not-list"}}), - json.dumps({"v": "1", "presets": {"x": {"c": ["#GG0000"]}}}), - ] - for payload in cases: - _process_message(ctx, payload) - ctx.wdt.feed() - - -def test_preset_edit_sanitization(): - ctx = _TestContext() - ctx.presets.edit( - "sanitize", - { - "pattern": "blink", - "delay": "120", - "brightness": "999", - "auto": "false", - "n1": "-5", - "n2": "7", - "unknown_field": "ignored", - }, - ) - p = ctx.presets.presets["sanitize"] - assert p.p == "blink" - assert p.d == 120 - assert p.b == 255 - assert p.a is False - assert p.n1 == 0 - assert p.n2 == 7 - assert not hasattr(p, "unknown_field") - - -def test_preset_mode_alias_maps_to_n6(): - ctx = _TestContext() - ctx.presets.edit( - "rainbow_mode", - {"pattern": "colour_cycle", "mode": 1, "d": 50, "n1": 2, "a": True}, - ) - p = ctx.presets.presets["rainbow_mode"] - assert p.p == "colour_cycle" - assert p.n6 == 1 - - -def test_style_mode_and_legacy_aliases(): - from patterns.pattern_modes import style_mode - - p = Preset({"p": "colour_cycle", "mode": 0, "d": 50, "c": [(255, 0, 0)]}) - assert style_mode(p, 0, {"rainbow": 1}) == 0 - - legacy = Preset({"p": "rainbow", "d": 50, "c": [(255, 0, 0)]}) - assert style_mode(legacy, 0, {"rainbow": 1}) == 1 - - ctx = _TestContext() - legacy_ids = ( - "rainbow", - "meteor_rain", - "snowfall", - "sparkle_trail", - "marquee", - "northern_wave", - ) - for lid in legacy_ids: - if not _pattern_loaded(ctx, lid): - raise AssertionError("legacy alias not registered: %s" % lid) - - -def test_colour_conversion_and_transition(): - ctx = _TestContext() - msg = { - "v": "1", - "presets": { - "fade": { - "p": "transition", - "c": ["#ff0000", "#00ff00"], - "d": 80, - "a": True, - } - }, - "select": {ctx.settings["name"]: ["fade"]}, - } - result = _process_message(ctx, msg) - assert result == "ok" - assert ctx.presets.selected == "fade" - ctx.tick_for_ms(250) - - -def test_pattern_smoke(): - ctx = _TestContext() - cases = { - "t_on": {"p": "on", "c": [(16, 8, 4)]}, - "t_off": {"p": "off"}, - "t_blink": {"p": "blink", "c": [(255, 0, 0)], "d": 20}, - "t_colour_cycle": {"p": "colour_cycle", "n6": 0, "d": 5, "n1": 2, "c": [(255, 0, 0), (0, 255, 0)]}, - "t_chase": {"p": "chase", "c": [(255, 0, 0), (0, 0, 255)], "n1": 3, "n2": 2, "n3": 1, "n4": 1, "d": 20}, - } - for name, data in cases.items(): - _smoke_preset(ctx, name, data, ms=100) - - -def test_merged_pattern_modes(): - """Smoke each style (``n6`` / ``mode``) for merged multi-mode patterns.""" - ctx = _TestContext() - colors = [(200, 220, 255), (255, 180, 80)] - cases = ( - ("mc_grad", "colour_cycle", {"p": "colour_cycle", "n6": 0, "n1": 2, "d": 8, "c": colors}), - ("mc_wheel", "colour_cycle", {"p": "colour_cycle", "mode": 1, "n1": 2, "d": 8}), - ("chase_std", "chase", {"p": "chase", "n6": 0, "n1": 2, "n2": 2, "n3": 1, "n4": 1, "d": 15, "c": colors}), - ("chase_marq", "chase", {"p": "chase", "n6": 1, "n1": 3, "n2": 2, "n3": 1, "d": 15, "c": colors}), - ("meteor_0", "meteor", {"p": "meteor", "n6": 0, "n1": 4, "n2": 2, "n3": 8, "d": 10, "c": colors}), - ("meteor_1", "meteor", {"p": "meteor", "n6": 1, "n1": 3, "n2": 2, "n3": 4, "d": 10, "c": colors}), - ("part_0", "particles", {"p": "particles", "n6": 0, "n1": 4, "n2": 1, "d": 10, "c": colors}), - ("part_1", "particles", {"p": "particles", "mode": 1, "n1": 3, "n2": 1, "n3": 4, "d": 10, "c": colors}), - ("spark_0", "sparkle", {"p": "sparkle", "n6": 0, "n1": 4, "n2": 6, "d": 10, "c": colors}), - ("spark_1", "sparkle", {"p": "sparkle", "n6": 1, "n1": 3, "n2": 4, "n3": 2, "d": 10, "c": colors}), - ("aurora_0", "aurora", {"p": "aurora", "n6": 0, "n1": 3, "n2": 2, "n3": 0, "d": 12, "c": colors}), - ("aurora_1", "aurora", {"p": "aurora", "mode": 1, "n1": 8, "n2": 2, "n3": 1, "d": 12, "c": colors}), - ) - for name, pattern_id, data in cases: - if not _pattern_loaded(ctx, pattern_id): - continue - _smoke_preset(ctx, name, data, ms=60) - - legacy_smoke = ( - ("leg_rainbow", "rainbow", {"p": "rainbow", "d": 8, "n1": 2}), - ("leg_ice", "ice_sparkle", {"p": "ice_sparkle", "n1": 3, "n2": 2, "n3": 2, "d": 10, "c": colors}), - ("leg_wave", "northern_wave", {"p": "northern_wave", "n1": 6, "n2": 2, "n3": 1, "d": 12, "c": colors}), - ("leg_star", "starfall", {"p": "starfall", "n1": 3, "n2": 1, "n3": 3, "d": 10, "c": colors}), - ) - for name, pattern_id, data in legacy_smoke: - if not _pattern_loaded(ctx, pattern_id): - continue - _smoke_preset(ctx, name, data, ms=60) - - -def test_patterns_do_not_use_blocking_sleep(): - try: - import uos as os - except ImportError: - import os - - pattern_dir = "patterns" - offenders = [] - try: - files = os.listdir(pattern_dir) - except OSError: - raise AssertionError("patterns directory is missing") - - skip = frozenset(("__init__.py", "main.py", "pattern_modes.py")) - for filename in files: - if not filename.endswith(".py") or filename in skip: - continue - path = pattern_dir + "/" + filename - try: - with open(path, "r") as f: - src = f.read() - except OSError: - offenders.append(filename + " (unreadable)") - continue - - if ( - "utime.sleep(" in src - or "utime.sleep_ms(" in src - or "time.sleep(" in src - or "time.sleep_ms(" in src - ): - offenders.append(filename) - - assert not offenders, "blocking sleep found in patterns: %s" % ", ".join(offenders) - - -def test_default_requires_existing_preset(): - ctx = _TestContext() - _process_message(ctx, {"v": "1", "default": "missing"}) - assert ctx.settings.get("default") != "missing" - - ctx.presets.edit("exists", {"p": "on"}) - _process_message(ctx, {"v": "1", "default": "exists"}) - assert ctx.settings.get("default") == "exists" - - -def test_default_targets_gate_by_device_name(): - ctx = _TestContext() - ctx.settings["name"] = "a" - ctx.presets.edit("targeted", {"p": "on"}) - ctx.settings["default"] = "baseline" - - _process_message( - ctx, - {"v": "1", "default": "targeted", "targets": ["11"]}, - ) - assert ctx.settings.get("default") == "baseline" - - _process_message( - ctx, - {"v": "1", "default": "targeted", "targets": [" A "]}, - ) - assert ctx.settings.get("default") == "targeted" - - -def test_save_and_load_roundtrip(): - try: - import uos as os - except ImportError: - import os - - ctx = _TestContext() - ctx.presets.edit( - "persist", - {"p": "blink", "c": [(1, 2, 3), (4, 5, 6)], "d": 77, "b": 123, "a": False}, - ) - assert ctx.presets.save() - - reloaded = Presets(ctx.settings["led_pin"], ctx.settings["num_leds"]) - assert reloaded.load(ctx.settings) - p = reloaded.presets.get("persist") - assert p is not None - assert p.p == "blink" - assert p.d == 77 - assert p.b == 123 - assert p.a is False - assert p.c == [(1, 2, 3), (4, 5, 6)] - - try: - os.remove("presets.json") - except OSError: - pass - - -def run_all(): - tests = [ - test_invalid_messages_do_not_crash, - test_preset_edit_sanitization, - test_preset_mode_alias_maps_to_n6, - test_style_mode_and_legacy_aliases, - test_colour_conversion_and_transition, - test_pattern_smoke, - test_merged_pattern_modes, - test_patterns_do_not_use_blocking_sleep, - test_default_requires_existing_preset, - test_default_targets_gate_by_device_name, - test_save_and_load_roundtrip, - ] - print("=" * 56) - print("led-driver self-contained tests") - print("=" * 56) - for test_func in tests: - print("Running %s ..." % test_func.__name__) - test_func() - print(" PASS") - print("-" * 56) - print("All tests passed") - - -if __name__ == "__main__": - run_all() diff --git a/tests/bridge_ws_blink.py b/tests/bridge_ws_blink.py deleted file mode 100644 index 9fe16ad..0000000 --- a/tests/bridge_ws_blink.py +++ /dev/null @@ -1,169 +0,0 @@ -#!/usr/bin/env python3 -"""Send blink preset + select to a driver via the ESP-NOW bridge WebSocket. - -Pairs with the on-device demo ``tests/patterns/blink.py``: same preset slot, -pattern, and colours; this script reaches the driver over ESP-NOW through -``espnow-sender`` (devices envelope, not legacy broadcast JSON). - -Run from the **led-controller** repo (needs ``websockets`` in Pipenv):: - - pipenv run python led-driver/tests/bridge_ws_blink.py - - pipenv run python led-driver/tests/bridge_ws_blink.py \\ - --url ws://192.168.4.1/ws --mac 18:8b:0e:15:60:a8 - -From **led-driver** (if Pipenv/env is the parent project):: - - pipenv run python tests/bridge_ws_blink.py --dry-run -""" - -from __future__ import annotations - -import argparse -import asyncio -import json -import re -import sys -from pathlib import Path -from typing import Any, Dict, Optional - -# led-driver/tests -> led-driver -> led-controller -LED_DRIVER_ROOT = Path(__file__).resolve().parents[1] -PROJECT_ROOT = LED_DRIVER_ROOT.parent - - -def _load_bridge_url(explicit: Optional[str]) -> str: - if explicit and explicit.strip(): - return explicit.strip() - for path in (PROJECT_ROOT / "settings.json", LED_DRIVER_ROOT / "settings.json"): - if not path.is_file(): - continue - try: - data = json.loads(path.read_text(encoding="utf-8")) - url = str(data.get("bridge_ws_url") or "").strip() - if url: - return url - except (OSError, json.JSONDecodeError, TypeError): - pass - return "ws://192.168.4.1/ws" - - -def _format_mac(mac: str) -> str: - s = re.sub(r"[^0-9a-fA-F]", "", str(mac or "").strip().lower()) - if len(s) != 12 or not re.fullmatch(r"[0-9a-f]{12}", s): - raise ValueError("MAC must be 12 hex digits (e.g. 188b0e1560a8)") - return ":".join(s[i : i + 2] for i in range(0, 12, 2)) - - -def build_blink_envelope( - mac: str, - *, - preset_id: str = "2", - delay_ms: int = 200, - brightness: int = 64, -) -> Dict[str, Any]: - """v1 devices envelope: preset body + list select (same shape as the Pi).""" - body = { - "p": { - preset_id: { - "p": "blink", - "b": max(0, min(255, int(brightness))), - "d": max(1, int(delay_ms)), - "c": ["#FF0000", "#0000FF"], - "a": True, - } - }, - "s": [str(preset_id)], - } - return {"v": "1", "dv": {_format_mac(mac): body}} - - -async def _send(url: str, envelope: Dict[str, Any], hold_s: float) -> None: - import websockets - - packet = json.dumps(envelope, separators=(",", ":")).encode("utf-8") - print(f"connecting to {url}") - async with websockets.connect(url, ping_interval=20, ping_timeout=20) as ws: - print(f"connected, sending {len(packet)} B") - print(packet.decode("utf-8")) - await ws.send(packet) - if hold_s > 0: - print(f"holding connection {hold_s}s …") - await asyncio.sleep(hold_s) - print("done") - - -def main() -> int: - parser = argparse.ArgumentParser( - description="Send blink preset+select to one driver via bridge WebSocket.", - ) - parser.add_argument( - "--url", - default=None, - help="Bridge WebSocket URL (default: settings.json bridge_ws_url or ws://192.168.4.1/ws)", - ) - parser.add_argument( - "--mac", - default="188b0e1560a8", - help="Driver MAC (12 hex, colons optional). Default: registry example id.", - ) - parser.add_argument( - "--preset-id", - default="2", - help="Wire preset slot id (default: 2, matches zone push)", - ) - parser.add_argument( - "--delay-ms", - type=int, - default=200, - help="Blink delay in ms (default: 200)", - ) - parser.add_argument( - "--brightness", - type=int, - default=64, - help="Preset brightness 0–255 (default: 64)", - ) - parser.add_argument( - "--hold", - type=float, - default=2.0, - help="Seconds to keep WebSocket open after send (default: 2)", - ) - parser.add_argument( - "--dry-run", - action="store_true", - help="Print envelope only; do not connect", - ) - args = parser.parse_args() - - url = _load_bridge_url(args.url) - try: - envelope = build_blink_envelope( - args.mac, - preset_id=args.preset_id, - delay_ms=args.delay_ms, - brightness=args.brightness, - ) - except ValueError as e: - print(f"error: {e}", file=sys.stderr) - return 1 - - print(f"url={url!r} mac={_format_mac(args.mac)!r}") - if args.dry_run: - print(json.dumps(envelope, indent=2)) - return 0 - - try: - asyncio.run(_send(url, envelope, args.hold)) - except KeyboardInterrupt: - print("interrupted") - return 130 - except Exception as e: - print(f"failed: {e!r}", file=sys.stderr) - return 1 - return 0 - - -if __name__ == "__main__": - raise SystemExit(main()) diff --git a/tests/device_test_radio_diag.py b/tests/device_test_radio_diag.py deleted file mode 100644 index 2a8f61f..0000000 --- a/tests/device_test_radio_diag.py +++ /dev/null @@ -1,116 +0,0 @@ -"""Device-side radio diagnostic test (MicroPython). - -Checks: -1) STA/AP bring-up on channel 5 -2) ESP-NOW init and broadcast peer add -3) Broadcast TX test packet send -4) RX wait window to see any incoming ESP-NOW frames -""" - -import espnow -import machine -import network -import time -import ubinascii - - -CHANNEL = 5 -RX_WINDOW_MS = 3000 -WDT_TIMEOUT_MS = 10000 -BROADCAST_MAC = b"\xff\xff\xff\xff\xff\xff" -TEST_PAYLOAD = b"\x4c\x05\x01\x00\x00\x00" - - -def _mac_hex(mac_bytes): - try: - return ubinascii.hexlify(mac_bytes).decode() - except Exception: - return "?" - - -def run_diag(channel=CHANNEL, rx_window_ms=RX_WINDOW_MS): - wdt = machine.WDT(timeout=WDT_TIMEOUT_MS) - wdt.feed() - - print("diag start") - print("cpu freq", machine.freq()) - - sta = network.WLAN(network.STA_IF) - ap = network.WLAN(network.AP_IF) - - # Clean start - try: - sta.active(False) - ap.active(False) - time.sleep_ms(100) - except Exception as e: - print("wifi reset failed", repr(e)) - - # STA setup - try: - sta.active(True) - sta.config(pm=network.WLAN.PM_NONE) - sta.config(channel=channel) - print("sta ok ch", sta.config("channel"), "mac", _mac_hex(sta.config("mac"))) - except Exception as e: - print("sta setup failed", repr(e)) - - # AP setup - try: - ap.active(True) - try: - ap.config(essid="diag-ap", channel=channel, hidden=True) - except TypeError: - ap.config(essid="diag-ap", channel=channel) - print("ap ok ch", ap.config("channel"), "mac", _mac_hex(ap.config("mac"))) - except Exception as e: - print("ap setup failed", repr(e)) - - wdt.feed() - - # ESP-NOW setup - try: - e = espnow.ESPNow() - e.active(True) - print("espnow active ok") - except Exception as e_err: - print("espnow init failed", repr(e_err)) - return - - # Add broadcast peer - try: - e.add_peer(BROADCAST_MAC, channel=channel) - print("add bcast peer ok") - except TypeError: - try: - e.add_peer(BROADCAST_MAC) - print("add bcast peer ok (no channel arg)") - except Exception as e_err: - print("add bcast peer failed", repr(e_err)) - except Exception as e_err: - print("add bcast peer failed", repr(e_err)) - - # TX test - try: - ok = e.send(BROADCAST_MAC, TEST_PAYLOAD, True) - print("tx bcast", ok, "len", len(TEST_PAYLOAD)) - except Exception as e_err: - print("tx bcast failed", repr(e_err)) - - # RX window - print("rx window ms", rx_window_ms) - t_end = time.ticks_add(time.ticks_ms(), rx_window_ms) - rx_count = 0 - while time.ticks_diff(t_end, time.ticks_ms()) > 0: - wdt.feed() - host, msg = e.recv(100) - if host: - rx_count += 1 - print("rx", rx_count, _mac_hex(host), "len", len(msg)) - time.sleep_ms(5) - - print("diag done rx_count", rx_count) - - -if __name__ == "__main__": - run_diag() diff --git a/tests/device_test_recv_ch5.py b/tests/device_test_recv_ch5.py deleted file mode 100644 index ebcef5e..0000000 --- a/tests/device_test_recv_ch5.py +++ /dev/null @@ -1,40 +0,0 @@ -"""Device test: receive ESP-NOW packets on channel 5 (MicroPython).""" - -import espnow -import machine -import network -import ubinascii -import time - - -CHANNEL = 5 -TIMEOUT_MS = 1000 -WDT_TIMEOUT_MS = 10000 - - -def _set_channel(channel): - sta = network.WLAN(network.STA_IF) - sta.active(True) - sta.config(pm=network.WLAN.PM_NONE) - sta.config(channel=channel) - - -def recv_loop(channel=CHANNEL, timeout_ms=TIMEOUT_MS): - wdt = machine.WDT(timeout=WDT_TIMEOUT_MS) - _set_channel(channel) - e = espnow.ESPNow() - e.active(True) - print("recv ready ch", channel) - while True: - wdt.feed() - host, msg = e.recv(timeout_ms) - if host: - mac_hex = ubinascii.hexlify(host).decode() - print("rx", mac_hex, "len", len(msg), "hex", ubinascii.hexlify(msg).decode()) - else: - print("rx timeout") - time.sleep_ms(10) - - -if __name__ == "__main__": - recv_loop() diff --git a/tests/device_test_send_ch5.py b/tests/device_test_send_ch5.py deleted file mode 100644 index 4bc6c52..0000000 --- a/tests/device_test_send_ch5.py +++ /dev/null @@ -1,47 +0,0 @@ -"""Device test: send one ESP-NOW packet on channel 5 (MicroPython).""" - -import espnow -import machine -import network -import ubinascii - - -CHANNEL = 5 -DEST_HEX = "ffffffffffff" -PAYLOAD_HEX = "4c0501000000" -WDT_TIMEOUT_MS = 10000 - - -def _set_channel(channel): - sta = network.WLAN(network.STA_IF) - sta.active(True) - sta.config(pm=network.WLAN.PM_NONE) - sta.config(channel=channel) - - -def _add_peer(esp, dest, channel): - try: - esp.add_peer(dest, channel=channel) - except TypeError: - esp.add_peer(dest) - except OSError: - pass - - -def send_once(dest_hex=DEST_HEX, payload_hex=PAYLOAD_HEX, channel=CHANNEL): - wdt = machine.WDT(timeout=WDT_TIMEOUT_MS) - wdt.feed() - dest = ubinascii.unhexlify(dest_hex) - pkt = ubinascii.unhexlify(payload_hex) - _set_channel(channel) - e = espnow.ESPNow() - e.active(True) - _add_peer(e, dest, channel) - wdt.feed() - ok = e.send(dest, pkt, True) - print("sent", ok, "ch", channel, "dest", dest_hex, "len", len(pkt)) - return ok - - -if __name__ == "__main__": - send_once() diff --git a/tests/patterns/aurora.py b/tests/patterns/aurora.py deleted file mode 100644 index 27be98f..0000000 --- a/tests/patterns/aurora.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_aurora", { - "p": "aurora", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_aurora") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/bar_graph.py b/tests/patterns/bar_graph.py deleted file mode 100644 index 1a4b390..0000000 --- a/tests/patterns/bar_graph.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_bar_graph", { - "p": "bar_graph", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_bar_graph") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/blink.py b/tests/patterns/blink.py deleted file mode 100644 index edfeba2..0000000 --- a/tests/patterns/blink.py +++ /dev/null @@ -1,74 +0,0 @@ -#!/usr/bin/env python3 -"""Standalone blink pattern demo (WDT-fed tick loop). - -Run on device:: - - mpremote connect run tests/patterns/blink.py -""" -import sys -import utime - - -def _bootstrap_import_path(): - """Find ``settings`` / ``presets`` on device or when run via mpremote.""" - try: - import uos as os - except ImportError: - import os - - candidates = [] - try: - here = __file__.rsplit("/", 1)[0] - if here: - candidates.append(here) - tests = here.rsplit("/", 1)[0] - if tests: - candidates.append(tests) - root = tests.rsplit("/", 1)[0] - if root: - candidates.append(root) - candidates.append(root + "/src") - except NameError: - pass - for p in (".", "..", "/", "src", "/src"): - candidates.append(p) - for p in candidates: - if p and p not in sys.path: - sys.path.insert(0, p) - - -_bootstrap_import_path() - -from machine import WDT # noqa: E402 -from settings import Settings # noqa: E402 -from presets import Presets # noqa: E402 - - -def _run_ms(presets, wdt, duration_ms, sleep_ms=10): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < duration_ms: - wdt.feed() - presets.tick() - utime.sleep_ms(sleep_ms) - - -def main(): - settings = Settings() - presets = Presets(settings.get("led_pin", 10), settings.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - presets.edit( - "test_blink", - { - "p": "blink", - "b": 64, - "d": 200, - "c": [(255, 0, 0), (0, 0, 255)], - }, - ) - presets.select("test_blink") - _run_ms(presets, wdt, 1500) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/breathing_dual.py b/tests/patterns/breathing_dual.py deleted file mode 100644 index 4cc35f3..0000000 --- a/tests/patterns/breathing_dual.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_breathing_dual", { - "p": "breathing_dual", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_breathing_dual") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/chase.py b/tests/patterns/chase.py deleted file mode 100644 index 2e79c49..0000000 --- a/tests/patterns/chase.py +++ /dev/null @@ -1,161 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - """Helper: run current pattern for given ms using tick().""" - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - pin = s.get("led_pin", 10) - num = s.get("num_leds", 30) - - p = Presets(pin=pin, num_leds=num) - wdt = WDT(timeout=10000) - - # Test 1: Basic chase (n1=5, n2=5, n3=1, n4=1) - print("Test 1: Basic chase (n1=5, n2=5, n3=1, n4=1)") - p.edit("chase1", { - "p": "chase", - "b": 255, - "d": 200, - "n1": 5, - "n2": 5, - "n3": 1, - "n4": 1, - "c": [(255, 0, 0), (0, 255, 0)], - }) - p.select("chase1") - run_for(p, wdt, 3000) - - # Test 2: Forward and backward (n3=2, n4=-1) - print("Test 2: Forward and backward (n3=2, n4=-1)") - p.edit("chase2", { - "p": "chase", - "n1": 3, - "n2": 3, - "n3": 2, - "n4": -1, - "d": 150, - "c": [(0, 0, 255), (255, 255, 0)], - }) - p.select("chase2") - run_for(p, wdt, 3000) - - # Test 3: Large segments (n1=10, n2=5) - print("Test 3: Large segments (n1=10, n2=5, n3=3, n4=3)") - p.edit("chase3", { - "p": "chase", - "n1": 10, - "n2": 5, - "n3": 3, - "n4": 3, - "d": 200, - "c": [(255, 128, 0), (128, 0, 255)], - }) - p.select("chase3") - run_for(p, wdt, 3000) - - # Test 4: Fast movement (n3=5, n4=5) - print("Test 4: Fast movement (n3=5, n4=5)") - p.edit("chase4", { - "p": "chase", - "n1": 4, - "n2": 4, - "n3": 5, - "n4": 5, - "d": 100, - "c": [(255, 0, 255), (0, 255, 255)], - }) - p.select("chase4") - run_for(p, wdt, 2000) - - # Test 5: Backward movement (n3=-2, n4=-2) - print("Test 5: Backward movement (n3=-2, n4=-2)") - p.edit("chase5", { - "p": "chase", - "n1": 6, - "n2": 4, - "n3": -2, - "n4": -2, - "d": 200, - "c": [(255, 255, 255), (0, 0, 0)], - }) - p.select("chase5") - run_for(p, wdt, 3000) - - # Test 6: Alternating forward/backward (n3=3, n4=-2) - print("Test 6: Alternating forward/backward (n3=3, n4=-2)") - p.edit("chase6", { - "p": "chase", - "n1": 5, - "n2": 5, - "n3": 3, - "n4": -2, - "d": 250, - "c": [(255, 0, 0), (0, 255, 0)], - }) - p.select("chase6") - run_for(p, wdt, 4000) - - # Test 7: Manual mode - advance one step per beat - print("Test 7: Manual mode chase (auto=False, n3=2, n4=1)") - p.edit("chase_manual", { - "p": "chase", - "n1": 4, - "n2": 4, - "n3": 2, - "n4": 1, - "d": 200, - "c": [(255, 255, 0), (0, 255, 255)], - "a": False, - }) - p.step = 0 # Reset step counter - print(" Advancing pattern with 10 beats (select + tick)...") - for i in range(10): - p.select("chase_manual") # Simulate beat - restarts generator - run_tick(p) # Advance one step - utime.sleep_ms(500) # Pause to see the pattern - wdt.feed() - print(f" Beat {i+1}: step={p.step}") - - # Test 8: Verify step increments correctly in manual mode - print("Test 8: Verify step increments (auto=False)") - p.edit("chase_manual2", { - "p": "chase", - "n1": 3, - "n2": 3, - "n3": 1, - "n4": 1, - "a": False, - }) - p.step = 0 - initial_step = p.step - p.select("chase_manual2") - run_tick(p) - final_step = p.step - print(f" Step updated from {initial_step} to {final_step} (expected: 1)") - if final_step == 1: - print(" ✓ Step increment working correctly") - else: - print(f" ✗ Step increment mismatch! Expected 1, got {final_step}") - - # Cleanup - print("Test complete, turning off") - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() - diff --git a/tests/patterns/circle.py b/tests/patterns/circle.py deleted file mode 100644 index d84456f..0000000 --- a/tests/patterns/circle.py +++ /dev/null @@ -1,113 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - """Helper: run current pattern for given ms using tick().""" - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - pin = s.get("led_pin", 10) - num = s.get("num_leds", 30) - - p = Presets(pin=pin, num_leds=num) - wdt = WDT(timeout=10000) - - # Test 1: Basic circle (n1=50, n2=100, n3=200, n4=0) - print("Test 1: Basic circle (n1=50, n2=100, n3=200, n4=0)") - p.edit("circle1", { - "p": "circle", - "b": 255, - "n1": 50, # Head moves 50 LEDs/second - "n2": 100, # Max length 100 LEDs - "n3": 200, # Tail moves 200 LEDs/second - "n4": 0, # Min length 0 LEDs - "c": [(255, 0, 0)], # Red - }) - p.select("circle1") - run_for(p, wdt, 5000) - - # Test 2: Slow growth, fast shrink (n1=20, n2=50, n3=100, n4=0) - print("Test 2: Slow growth, fast shrink (n1=20, n2=50, n3=100, n4=0)") - p.edit("circle2", { - "p": "circle", - "n1": 20, - "n2": 50, - "n3": 100, - "n4": 0, - "c": [(0, 255, 0)], # Green - }) - p.select("circle2") - run_for(p, wdt, 5000) - - # Test 3: Fast growth, slow shrink (n1=100, n2=30, n3=20, n4=0) - print("Test 3: Fast growth, slow shrink (n1=100, n2=30, n3=20, n4=0)") - p.edit("circle3", { - "p": "circle", - "n1": 100, - "n2": 30, - "n3": 20, - "n4": 0, - "c": [(0, 0, 255)], # Blue - }) - p.select("circle3") - run_for(p, wdt, 5000) - - # Test 4: With minimum length (n1=50, n2=40, n3=100, n4=10) - print("Test 4: With minimum length (n1=50, n2=40, n3=100, n4=10)") - p.edit("circle4", { - "p": "circle", - "n1": 50, - "n2": 40, - "n3": 100, - "n4": 10, - "c": [(255, 255, 0)], # Yellow - }) - p.select("circle4") - run_for(p, wdt, 5000) - - # Test 5: Very fast (n1=200, n2=20, n3=200, n4=0) - print("Test 5: Very fast (n1=200, n2=20, n3=200, n4=0)") - p.edit("circle5", { - "p": "circle", - "n1": 200, - "n2": 20, - "n3": 200, - "n4": 0, - "c": [(255, 0, 255)], # Magenta - }) - p.select("circle5") - run_for(p, wdt, 3000) - - # Test 6: Very slow (n1=10, n2=25, n3=10, n4=0) - print("Test 6: Very slow (n1=10, n2=25, n3=10, n4=0)") - p.edit("circle6", { - "p": "circle", - "n1": 10, - "n2": 25, - "n3": 10, - "n4": 0, - "c": [(0, 255, 255)], # Cyan - }) - p.select("circle6") - run_for(p, wdt, 5000) - - # Cleanup - print("Test complete, turning off") - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() - diff --git a/tests/patterns/clock_sweep.py b/tests/patterns/clock_sweep.py deleted file mode 100644 index 0fb1106..0000000 --- a/tests/patterns/clock_sweep.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_clock_sweep", { - "p": "clock_sweep", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_clock_sweep") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/comet_dual.py b/tests/patterns/comet_dual.py deleted file mode 100644 index bcb3e8e..0000000 --- a/tests/patterns/comet_dual.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_comet_dual", { - "p": "comet_dual", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_comet_dual") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/fireflies.py b/tests/patterns/fireflies.py deleted file mode 100644 index e6645f6..0000000 --- a/tests/patterns/fireflies.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_fireflies", { - "p": "fireflies", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_fireflies") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/gradient_scroll.py b/tests/patterns/gradient_scroll.py deleted file mode 100644 index e7ed744..0000000 --- a/tests/patterns/gradient_scroll.py +++ /dev/null @@ -1,39 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - print("Test gradient_scroll") - p.edit("gradient_test", { - "p": "gradient_scroll", - "b": 220, - "d": 60, - "c": [(255, 0, 0), (0, 255, 0), (0, 0, 255)], - "n1": 2, - "a": True, - }) - p.select("gradient_test") - run_for(p, wdt, 4000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/heartbeat.py b/tests/patterns/heartbeat.py deleted file mode 100644 index e5f6995..0000000 --- a/tests/patterns/heartbeat.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_heartbeat", { - "p": "heartbeat", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_heartbeat") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/marquee.py b/tests/patterns/marquee.py deleted file mode 100644 index ba30d36..0000000 --- a/tests/patterns/marquee.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_marquee", { - "p": "marquee", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_marquee") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/meteor_rain.py b/tests/patterns/meteor_rain.py deleted file mode 100644 index e71c4f2..0000000 --- a/tests/patterns/meteor_rain.py +++ /dev/null @@ -1,41 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - print("Test meteor_rain") - p.edit("meteor_test", { - "p": "meteor_rain", - "b": 200, - "d": 40, - "c": [(255, 80, 0), (0, 120, 255)], - "n1": 10, - "n2": 1, - "n3": 200, - "a": True, - }) - p.select("meteor_test") - run_for(p, wdt, 4000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/off.py b/tests/patterns/off.py deleted file mode 100644 index bf7574b..0000000 --- a/tests/patterns/off.py +++ /dev/null @@ -1,30 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def main(): - s = Settings() - pin = s.get("led_pin", 10) - num = s.get("num_leds", 30) - - p = Presets(pin=pin, num_leds=num) - wdt = WDT(timeout=10000) - - # Create an "off" preset (use short-key field `p` for pattern) - p.edit("test_off", {"p": "off"}) - p.select("test_off") - - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < 200: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -if __name__ == "__main__": - main() - - diff --git a/tests/patterns/on.py b/tests/patterns/on.py deleted file mode 100644 index 1a3aea1..0000000 --- a/tests/patterns/on.py +++ /dev/null @@ -1,47 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def main(): - s = Settings() - pin = s.get("led_pin", 10) - num = s.get("num_leds", 30) - - p = Presets(pin=pin, num_leds=num) - wdt = WDT(timeout=10000) - - # Create presets for on and off using the short-key fields that Presets expects - # Preset fields: - # p = pattern name, b = brightness, d = delay, c = list of (r,g,b) colors - p.edit("test_on", { - "p": "on", - "b": 64, - "d": 120, - "c": [(255, 0, 0), (0, 0, 255)], - }) - p.edit("test_off", {"p": "off"}) - - # ON phase - p.select("test_on") - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < 800: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - # OFF phase - p.select("test_off") - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < 100: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -if __name__ == "__main__": - main() - - diff --git a/tests/patterns/orbit.py b/tests/patterns/orbit.py deleted file mode 100644 index dada446..0000000 --- a/tests/patterns/orbit.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_orbit", { - "p": "orbit", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_orbit") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/palette_morph.py b/tests/patterns/palette_morph.py deleted file mode 100644 index 9079516..0000000 --- a/tests/patterns/palette_morph.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_palette_morph", { - "p": "palette_morph", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_palette_morph") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/plasma.py b/tests/patterns/plasma.py deleted file mode 100644 index aae72f7..0000000 --- a/tests/patterns/plasma.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_plasma", { - "p": "plasma", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_plasma") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/pulse.py b/tests/patterns/pulse.py deleted file mode 100644 index f1793dc..0000000 --- a/tests/patterns/pulse.py +++ /dev/null @@ -1,92 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - """Helper: run current pattern for given ms using tick().""" - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - pin = s.get("led_pin", 10) - num = s.get("num_leds", 30) - - p = Presets(pin=pin, num_leds=num) - wdt = WDT(timeout=10000) - - # Test 1: Simple single-color pulse - print("Test 1: Single-color pulse (attack=500, hold=500, decay=500, delay=500)") - p.edit("pulse1", { - "p": "pulse", - "b": 255, - "c": [(255, 0, 0)], - "n1": 500, # attack ms - "n2": 500, # hold ms - "n3": 500, # decay ms - "d": 500, # delay ms between pulses - "a": True, - }) - p.select("pulse1") - run_for(p, wdt, 5000) - - # Test 2: Faster pulse - print("Test 2: Fast pulse (attack=100, hold=100, decay=100, delay=100)") - p.edit("pulse2", { - "p": "pulse", - "n1": 100, - "n2": 100, - "n3": 100, - "d": 100, - "c": [(0, 255, 0)], - }) - p.select("pulse2") - run_for(p, wdt, 4000) - - # Test 3: Multi-color pulse cycle - print("Test 3: Multi-color pulse (red -> green -> blue)") - p.edit("pulse3", { - "p": "pulse", - "n1": 300, - "n2": 300, - "n3": 300, - "d": 200, - "c": [(255, 0, 0), (0, 255, 0), (0, 0, 255)], - "a": True, - }) - p.select("pulse3") - run_for(p, wdt, 6000) - - # Test 4: One-shot pulse (auto=False) - print("Test 4: Single pulse, auto=False") - p.edit("pulse4", { - "p": "pulse", - "n1": 400, - "n2": 0, - "n3": 400, - "d": 0, - "c": [(255, 255, 255)], - "a": False, - }) - p.select("pulse4") - # Run long enough to allow one full pulse cycle - run_for(p, wdt, 1500) - - # Cleanup - print("Test complete, turning off") - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 200) - - -if __name__ == "__main__": - main() - - diff --git a/tests/patterns/rain_drops.py b/tests/patterns/rain_drops.py deleted file mode 100644 index 50e36b8..0000000 --- a/tests/patterns/rain_drops.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_rain_drops", { - "p": "rain_drops", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_rain_drops") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/scanner.py b/tests/patterns/scanner.py deleted file mode 100644 index 03823fc..0000000 --- a/tests/patterns/scanner.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - print("Test scanner") - p.edit("scanner_test", { - "p": "scanner", - "b": 255, - "d": 30, - "c": [(255, 0, 0)], - "n1": 4, - "n2": 2, - "a": True, - }) - p.select("scanner_test") - run_for(p, wdt, 4000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/segment_chase.py b/tests/patterns/segment_chase.py deleted file mode 100644 index 59e810c..0000000 --- a/tests/patterns/segment_chase.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_segment_chase", { - "p": "segment_chase", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_segment_chase") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/snowfall.py b/tests/patterns/snowfall.py deleted file mode 100644 index ba35880..0000000 --- a/tests/patterns/snowfall.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_snowfall", { - "p": "snowfall", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_snowfall") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/sparkle_trail.py b/tests/patterns/sparkle_trail.py deleted file mode 100644 index bc98cfa..0000000 --- a/tests/patterns/sparkle_trail.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_sparkle_trail", { - "p": "sparkle_trail", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_sparkle_trail") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/strobe_burst.py b/tests/patterns/strobe_burst.py deleted file mode 100644 index 15a5e56..0000000 --- a/tests/patterns/strobe_burst.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_strobe_burst", { - "p": "strobe_burst", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_strobe_burst") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/transition.py b/tests/patterns/transition.py deleted file mode 100644 index 8ff981e..0000000 --- a/tests/patterns/transition.py +++ /dev/null @@ -1,81 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - """Helper: run current pattern for given ms using tick().""" - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - pin = s.get("led_pin", 10) - num = s.get("num_leds", 30) - - p = Presets(pin=pin, num_leds=num) - wdt = WDT(timeout=10000) - - # Test 1: Simple two-color transition - print("Test 1: Two-color transition (red <-> blue, delay=1000)") - p.edit("transition1", { - "p": "transition", - "b": 255, - "d": 1000, # transition duration - "c": [(255, 0, 0), (0, 0, 255)], - "a": True, - }) - p.select("transition1") - run_for(p, wdt, 6000) - - # Test 2: Multi-color transition - print("Test 2: Multi-color transition (red -> green -> blue -> white)") - p.edit("transition2", { - "p": "transition", - "d": 800, - "c": [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 255)], - "a": True, - }) - p.select("transition2") - run_for(p, wdt, 8000) - - # Test 3: One-shot transition (auto=False) - print("Test 3: One-shot transition (auto=False)") - p.edit("transition3", { - "p": "transition", - "d": 1000, - "c": [(255, 0, 0), (0, 255, 0)], - "a": False, - }) - p.select("transition3") - # Run long enough for a single transition step - run_for(p, wdt, 2000) - - # Test 4: Single-color behavior (should just stay on) - print("Test 4: Single-color transition (should hold color)") - p.edit("transition4", { - "p": "transition", - "c": [(0, 0, 255)], - "d": 500, - "a": True, - }) - p.select("transition4") - run_for(p, wdt, 3000) - - # Cleanup - print("Test complete, turning off") - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 200) - - -if __name__ == "__main__": - main() - - diff --git a/tests/patterns/twinkle.py b/tests/patterns/twinkle.py deleted file mode 100644 index 7c13983..0000000 --- a/tests/patterns/twinkle.py +++ /dev/null @@ -1,52 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets - - -def main(): - print("[test] twinkle: start") - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - p.debug = True - wdt = WDT(timeout=10000) - - print("[test] twinkle: auto phase begin") - p.edit("test_pattern", {"p": "twinkle", "b": 64, "a": True, "d": 3000, "c": [(255, 0, 0), (0, 0, 255)]}) - if not p.select("test_pattern"): - raise Exception("twinkle select failed in auto phase") - auto_start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), auto_start) < 2500: - wdt.feed() - p.run_step() - utime.sleep_ms(20) - remaining_ms = utime.ticks_diff(p.next_tick_ms, utime.ticks_ms()) - if p.next_tick_ms == 0 or remaining_ms <= 0: - raise Exception("twinkle delay scheduling invalid") - print("[test] twinkle: auto phase end") - - print("[test] twinkle: manual phase begin") - p.edit("test_pattern", {"p": "twinkle", "b": 64, "a": False, "d": 3000, "c": [(255, 0, 0), (0, 0, 255)]}) - if not p.select("test_pattern", step=0): - raise Exception("twinkle select failed in manual phase") - for _ in range(6): - current_step = int(p.step) - if not p.select("test_pattern", step=current_step): - raise Exception("twinkle external select failed") - p.run_step() - wdt.feed() - if int(p.step) == current_step: - raise Exception("twinkle external step did not advance") - if p.generator is not None: - raise Exception("twinkle manual mode rescheduled generator") - hold_start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), hold_start) < 700: - wdt.feed() - utime.sleep_ms(20) - print("[test] twinkle: manual phase end") - print("[test] twinkle: pass") - - -if __name__ == "__main__": - main() diff --git a/tests/patterns/wave.py b/tests/patterns/wave.py deleted file mode 100644 index 6a5d5bb..0000000 --- a/tests/patterns/wave.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python3 -import utime -from machine import WDT -from settings import Settings -from presets import Presets, run_tick - - -def run_for(p, wdt, ms): - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < ms: - wdt.feed() - run_tick(p) - utime.sleep_ms(10) - - -def main(): - s = Settings() - p = Presets(pin=s.get("led_pin", 10), num_leds=s.get("num_leds", 30)) - wdt = WDT(timeout=10000) - - p.edit("test_wave", { - "p": "wave", - "b": 200, - "d": 60, - "c": [(255, 0, 0), (0, 0, 255), (0, 255, 0)], - "n1": 4, - "n2": 2, - "n3": 120, - "a": True, - }) - p.select("test_wave") - run_for(p, wdt, 3000) - - p.edit("cleanup_off", {"p": "off"}) - p.select("cleanup_off") - run_for(p, wdt, 100) - - -if __name__ == "__main__": - main() diff --git a/tests/peers.py b/tests/peers.py deleted file mode 100644 index fcaf3ce..0000000 --- a/tests/peers.py +++ /dev/null @@ -1,25 +0,0 @@ -from espnow import ESPNow -import network - -sta = network.WLAN(network.STA_IF) -sta.active(True) - -espnow = ESPNow() -espnow.active(True) - -# add_peer() expects a 6-byte MAC (bytes/bytearray), not integers. -# Unicast placeholders (not broadcast/multicast) so get_peers() lists them. -# PEERS = aa:aa:aa:aa:aa:START … aa:aa:aa:aa:aa:END (inclusive last octet). -_PREFIX = b"\xaa\xaa\xaa\xaa\xaa" -_START_LAST_OCTET = 1 -_END_LAST_OCTET = 40 -PEERS = tuple(_PREFIX + bytes((i,)) for i in range(_START_LAST_OCTET, _END_LAST_OCTET + 1)) -for peer in PEERS: - espnow.add_peer(peer) - -print("peers:", PEERS) - -for peer in PEERS: - espnow.send(peer, b"Hello, world!") - -print(espnow.get_peers()) \ No newline at end of file diff --git a/tests/test_ap_pm0.py b/tests/test_ap_pm0.py deleted file mode 100644 index 9a01de1..0000000 --- a/tests/test_ap_pm0.py +++ /dev/null @@ -1,41 +0,0 @@ -#!/usr/bin/env python3 -"""MicroPython AP example with power management disabled (pm=0). - -Run on device: - mpremote connect /dev/ttyACM0 run tests/test_ap_pm0.py -""" - -import network -import time - -AP_SSID = "led-ap" -AP_PASSWORD = "ledpass123" -AP_CHANNEL = 6 - - -def main(): - ap = network.WLAN(network.AP_IF) - ap.active(True) - - # Explicitly disable Wi-Fi power save for AP mode. - try: - ap.config(pm=0) - except (AttributeError, ValueError, TypeError): - try: - ap.config(pm=network.WLAN.PM_NONE) - except (AttributeError, ValueError, TypeError): - pass - - ap.config(essid=AP_SSID, password=AP_PASSWORD, channel=AP_CHANNEL, authmode=3) - - print("[ap-pm0] AP active:", ap.active()) - print("[ap-pm0] SSID:", AP_SSID) - print("[ap-pm0] IFCONFIG:", ap.ifconfig()) - print("[ap-pm0] Waiting for clients. Ctrl+C to stop.") - - while True: - time.sleep(2) - - -if __name__ == "__main__": - main() diff --git a/tests/test_beat_sync.py b/tests/test_beat_sync.py deleted file mode 100644 index 86c083f..0000000 --- a/tests/test_beat_sync.py +++ /dev/null @@ -1,112 +0,0 @@ -#!/usr/bin/env python3 -"""BeatSync accepts exactly one of the two copies of each beat - runs on MicroPython.""" -import struct -from beat_sync import BeatSync - - -def frame(idx, period=500, fire_in=30, flags=0): - return struct.pack("> 3)] & (1 << (i & 7)): - r(chunk(11, body, i)) - assert r(cmd(o.OP_END, 11))[1] == o.OK - r(cmd(o.OP_COMMIT, 11)) - assert open("lib/x.py", "rb").read() == body - os.chdir(old) - - -@in_tmp -def test_commit_repeated_after_reset(): - r = Rig() - r.send_file(14, "a.py", BODY) - assert r(cmd(o.OP_COMMIT, 14))[1] == o.OK - fresh = Rig() # the driver reset before its reply arrived - op, code, arg = fresh(cmd(o.OP_COMMIT, 14)) - assert code == o.OK and fresh.resets == 0 - assert fresh(cmd(o.OP_COMMIT, 15))[1] == o.NOSESS - - -@in_tmp -def test_empty_file(): - r = Rig() - assert r.send_file(13, "lib/pkg/__init__.py", b"") == o.OK - r(cmd(o.OP_COMMIT, 13)) - assert open("lib/pkg/__init__.py", "rb").read() == b"" - - -@in_tmp -def test_too_big_rejected(): - r = Rig() - pkt = bytearray(begin(12, "a.py", b"x")) - struct.pack_into(" 0 - - def recv(self): - """Receive a message (removes it from queue).""" - if self.messages: - return self.messages.pop(0) - return None, None - - def send_message(self, host, msg_data): - """Send a message by adding it to the queue (testing helper).""" - if isinstance(msg_data, dict): - msg = json.dumps(msg_data) - else: - msg = msg_data - self.messages.append((host, msg)) - - def clear(self): - """Clear all messages (testing helper).""" - self.messages = [] - - -from machine import WDT - -def get_wdt(): - """Get a real WDT instance for tests.""" - return WDT(timeout=10000) # 10 second timeout for tests - - -def run_main_loop_iterations(espnow, patterns, settings, wdt, max_iterations=10): - """Run main loop iterations until no messages or max reached.""" - iterations = 0 - results = [] - - while iterations < max_iterations: - wdt.feed() - run_tick(patterns) - - if espnow.any(): - host, msg = espnow.recv() - data = json.loads(msg) - - if data.get("v") != "1": - results.append(("version_rejected", data)) - continue - - if "presets" in data: - for name, preset_data in data["presets"].items(): - # Convert hex color strings to RGB tuples and reorder based on device color order - if "colors" in preset_data: - preset_data["colors"] = convert_and_reorder_colors(preset_data["colors"], settings) - patterns.edit(name, preset_data) - results.append(("presets_processed", list(data["presets"].keys()))) - - if settings.get("name") in data.get("select", {}): - select_list = data["select"][settings.get("name")] - # Select value is always a list: ["preset_name"] or ["preset_name", step] - if select_list: - preset_name = select_list[0] - step = select_list[1] if len(select_list) > 1 else None - if patterns.select(preset_name, step=step): - results.append(("selected", preset_name)) - - iterations += 1 - - # Stop if no more messages - if not espnow.any(): - break - - return results - - -def test_version_check(): - """Test that messages with wrong version are rejected.""" - print("Test 1: Version check") - settings = Settings() - patterns = Presets(settings["led_pin"], settings["num_leds"]) - mock_espnow = MockESPNow() - wdt = get_wdt() - - # Send message with wrong version - mock_espnow.send_message(b"\xaa\xaa\xaa\xaa\xaa\xaa", {"v": "2", "presets": {"test": {"pattern": "on"}}}) - results = run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - - assert len([r for r in results if r[0] == "version_rejected"]) > 0, "Should reject wrong version" - assert "test" not in patterns.presets, "Preset should not be created" - print(" ✓ Version check passed") - - # Send message with correct version - mock_espnow.clear() - mock_espnow.send_message(b"\xaa\xaa\xaa\xaa\xaa\xaa", {"v": "1", "presets": {"test": {"pattern": "on"}}}) - results = run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - - assert len([r for r in results if r[0] == "presets_processed"]) > 0, "Should process correct version" - assert "test" in patterns.presets, "Preset should be created" - print(" ✓ Correct version accepted") - - -def test_preset_creation(): - """Test preset creation from ESPNow messages.""" - print("\nTest 2: Preset creation") - settings = Settings() - patterns = Presets(settings["led_pin"], settings["num_leds"]) - mock_espnow = MockESPNow() - wdt = get_wdt() - - msg = { - "v": "1", - "presets": { - "test_blink": { - "pattern": "blink", - "colors": ["#FF0000", "#00FF00"], - "delay": 200, - "brightness": 128 - }, - "test_rainbow": { - "pattern": "rainbow", - "delay": 100, - "n1": 2 - } - } - } - - mock_espnow.send_message(b"\xbb\xbb\xbb\xbb\xbb\xbb", msg) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - - assert "test_blink" in patterns.presets, "test_blink preset should exist" - assert "test_rainbow" in patterns.presets, "test_rainbow preset should exist" - - # Check preset values - blink_preset = patterns.presets["test_blink"] - assert blink_preset.pattern == "blink", "Pattern should be blink" - assert blink_preset.delay == 200, "Delay should be 200" - assert blink_preset.brightness == 128, "Brightness should be 128" - - rainbow_preset = patterns.presets["test_rainbow"] - assert rainbow_preset.pattern == "rainbow", "Pattern should be rainbow" - assert rainbow_preset.n1 == 2, "n1 should be 2" - - print(" ✓ Presets created correctly") - - -def test_color_conversion(): - """Test hex color string conversion and reordering.""" - print("\nTest 3: Color conversion") - settings = Settings() - settings["color_order"] = "rgb" # Default RGB order - patterns = Presets(settings["led_pin"], settings["num_leds"]) - mock_espnow = MockESPNow() - wdt = get_wdt() - - msg = { - "v": "1", - "presets": { - "test_colors": { - "pattern": "on", - "colors": ["#FF0000", "#00FF00", "#0000FF"] # Red, Green, Blue - } - } - } - - mock_espnow.send_message(b"\xcc\xcc\xcc\xcc\xcc\xcc", msg) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - - preset = patterns.presets["test_colors"] - assert len(preset.colors) == 3, "Should have 3 colors" - assert preset.colors[0] == (255, 0, 0), "First color should be red (255,0,0)" - assert preset.colors[1] == (0, 255, 0), "Second color should be green (0,255,0)" - assert preset.colors[2] == (0, 0, 255), "Third color should be blue (0,0,255)" - print(" ✓ Colors converted correctly (RGB order)") - - # Test GRB order - settings["color_order"] = "grb" - patterns2 = Presets(settings["led_pin"], settings["num_leds"]) - mock_espnow2 = MockESPNow() - msg2 = { - "v": "1", - "presets": { - "test_grb": { - "pattern": "on", - "colors": ["#FF0000"] # Red in RGB, should become (0, 255, 0) in GRB - } - } - } - mock_espnow2.send_message(b"\xdd\xdd\xdd\xdd\xdd\xdd", msg2) - wdt2 = get_wdt() - run_main_loop_iterations(mock_espnow2, patterns2, settings, wdt2) - preset2 = patterns2.presets["test_grb"] - assert preset2.colors[0] == (0, 255, 0), "GRB: Red should become green (0,255,0)" - print(" ✓ Colors reordered correctly (GRB order)") - - -def test_preset_update(): - """Test that editing an existing preset updates it.""" - print("\nTest 4: Preset update") - settings = Settings() - patterns = Presets(settings["led_pin"], settings["num_leds"]) - mock_espnow = MockESPNow() - wdt = get_wdt() - - # Create initial preset - msg1 = { - "v": "1", - "presets": { - "test_update": { - "pattern": "blink", - "delay": 100, - "brightness": 64 - } - } - } - mock_espnow.send_message(b"\xee\xee\xee\xee\xee\xee", msg1) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - assert patterns.presets["test_update"].delay == 100, "Initial delay should be 100" - - # Update preset - mock_espnow.clear() - msg2 = { - "v": "1", - "presets": { - "test_update": { - "pattern": "blink", - "delay": 200, - "brightness": 128 - } - } - } - mock_espnow.send_message(b"\xff\xff\xff\xff\xff\xff", msg2) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - assert patterns.presets["test_update"].delay == 200, "Updated delay should be 200" - assert patterns.presets["test_update"].brightness == 128, "Updated brightness should be 128" - print(" ✓ Preset updated correctly") - - -def test_select(): - """Test preset selection.""" - print("\nTest 5: Preset selection") - settings = Settings() - settings["name"] = "device1" - patterns = Presets(settings["led_pin"], settings["num_leds"]) - mock_espnow = MockESPNow() - wdt = get_wdt() - - # Create presets - msg1 = { - "v": "1", - "presets": { - "preset1": {"pattern": "on", "colors": [(255, 0, 0)]}, - "preset2": {"pattern": "rainbow", "delay": 50} - } - } - mock_espnow.send_message(b"\x11\x11\x11\x11\x11\x11", msg1) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - - # Select preset - mock_espnow.clear() - msg2 = { - "v": "1", - "select": { - "device1": ["preset1"], - "device2": ["preset2"] - } - } - mock_espnow.send_message(b"\x22\x22\x22\x22\x22\x22", msg2) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - assert patterns.selected == "preset1", "Should select preset1" - print(" ✓ Preset selected correctly") - - -def test_full_message(): - """Test a full message with presets and select.""" - print("\nTest 6: Full message (presets + select)") - settings = Settings() - settings["name"] = "test_device" - patterns = Presets(settings["led_pin"], settings["num_leds"]) - mock_espnow = MockESPNow() - wdt = get_wdt() - - msg = { - "v": "1", - "presets": { - "my_preset": { - "pattern": "pulse", - "colors": ["#FF0000", "#00FF00"], - "delay": 150, - "n1": 500, - "n2": 200, - "n3": 500 - } - }, - "select": { - "test_device": ["my_preset"], - "other_device": ["other_preset"] - } - } - - mock_espnow.send_message(b"\x44\x44\x44\x44\x44\x44", msg) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - - assert "my_preset" in patterns.presets, "Preset should be created" - assert patterns.selected == "my_preset", "Preset should be selected" - - preset = patterns.presets["my_preset"] - assert preset.pattern == "pulse", "Pattern should be pulse" - assert preset.delay == 150, "Delay should be 150" - assert preset.n1 == 500, "n1 should be 500" - print(" ✓ Full message processed correctly") - - -def test_switch_presets(): - """Test switching between different presets.""" - print("\nTest 7: Switch between presets") - settings = Settings() - settings["name"] = "switch_device" - patterns = Presets(settings["led_pin"], settings["num_leds"]) - mock_espnow = MockESPNow() - wdt = get_wdt() - - # Create multiple presets - msg1 = { - "v": "1", - "presets": { - "preset_blink": {"pattern": "blink", "delay": 200, "colors": [(255, 0, 0)]}, - "preset_rainbow": {"pattern": "rainbow", "delay": 100, "n1": 2}, - "preset_pulse": {"pattern": "pulse", "delay": 150, "n1": 500, "n2": 200, "n3": 500} - } - } - mock_espnow.send_message(b"\x55\x55\x55\x55\x55\x55", msg1) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - - # Select and run first preset for 2 seconds - mock_espnow.clear() - msg2 = { - "v": "1", - "select": { - "switch_device": ["preset_blink"] - } - } - mock_espnow.send_message(b"\x66\x66\x66\x66\x66\x66", msg2) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - assert patterns.selected == "preset_blink", "Should select preset_blink" - print(" ✓ Selected preset_blink, running for 2 seconds...") - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < 2000: - wdt.feed() - run_tick(patterns) - utime.sleep_ms(10) - - # Switch to second preset and run for 2 seconds - mock_espnow.clear() - msg3 = { - "v": "1", - "select": { - "switch_device": ["preset_rainbow"] - } - } - mock_espnow.send_message(b"\x77\x77\x77\x77\x77\x77", msg3) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - assert patterns.selected == "preset_rainbow", "Should switch to preset_rainbow" - print(" ✓ Switched to preset_rainbow, running for 2 seconds...") - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < 2000: - wdt.feed() - run_tick(patterns) - utime.sleep_ms(10) - - # Switch to third preset and run for 2 seconds - mock_espnow.clear() - msg4 = { - "v": "1", - "select": { - "switch_device": ["preset_pulse"] - } - } - mock_espnow.send_message(b"\x88\x88\x88\x88\x88\x88", msg4) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - assert patterns.selected == "preset_pulse", "Should switch to preset_pulse" - print(" ✓ Switched to preset_pulse, running for 2 seconds...") - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < 2000: - wdt.feed() - run_tick(patterns) - utime.sleep_ms(10) - - # Switch back to first preset and run for 2 seconds - mock_espnow.clear() - msg5 = { - "v": "1", - "select": { - "switch_device": ["preset_blink"] - } - } - mock_espnow.send_message(b"\x99\x99\x99\x99\x99\x99", msg5) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - assert patterns.selected == "preset_blink", "Should switch back to preset_blink" - print(" ✓ Switched back to preset_blink, running for 2 seconds...") - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < 2000: - wdt.feed() - run_tick(patterns) - utime.sleep_ms(10) - - print(" ✓ Preset switching works correctly") - - -def test_beat_functionality(): - """Test beat functionality - calling select() again with same preset restarts pattern.""" - print("\nTest 8: Beat functionality") - settings = Settings() - settings["name"] = "beat_device" - patterns = Presets(settings["led_pin"], settings["num_leds"]) - mock_espnow = MockESPNow() - wdt = get_wdt() - - # Create presets with manual mode - msg1 = { - "v": "1", - "presets": { - "beat_rainbow": {"pattern": "rainbow", "delay": 100, "n1": 1, "auto": False}, - "beat_chase": {"pattern": "chase", "delay": 200, "n1": 4, "n2": 4, "n3": 2, "n4": 1, "auto": False}, - "beat_pulse": {"pattern": "pulse", "delay": 150, "n1": 300, "n2": 100, "n3": 300, "auto": False} - } - } - mock_espnow.send_message(b"\xaa\xaa\xaa\xaa\xaa\xaa", msg1) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - - # Test 1: Beat with rainbow (manual mode) - should advance one step per beat - print(" Test 8.1: Beat with rainbow (manual mode)") - patterns.step = 0 - mock_espnow.clear() - msg2 = { - "v": "1", - "select": { - "beat_device": ["beat_rainbow"] - } - } - mock_espnow.send_message(b"\xbb\xbb\xbb\xbb\xbb\xbb", msg2) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - assert patterns.selected == "beat_rainbow", "Should select beat_rainbow" - initial_step = patterns.step - - # First beat - advance one step - mock_espnow.clear() - mock_espnow.send_message(b"\xcc\xcc\xcc\xcc\xcc\xcc", msg2) # Same select message = beat - run_main_loop_iterations(mock_espnow, patterns, settings, wdt, max_iterations=5) - # tick() is already called in run_main_loop_iterations, so step should be incremented - assert patterns.step == (initial_step + 1) % 256, f"Step should increment from {initial_step} to {(initial_step + 1) % 256}, got {patterns.step}" - - # Second beat - advance another step - mock_espnow.clear() - mock_espnow.send_message(b"\xdd\xdd\xdd\xdd\xdd\xdd", msg2) # Beat again - run_main_loop_iterations(mock_espnow, patterns, settings, wdt, max_iterations=5) - assert patterns.step == (initial_step + 2) % 256, f"Step should increment to {(initial_step + 2) % 256}, got {patterns.step}" - print(" ✓ Rainbow beat advances one step per beat") - - # Test 2: Beat with chase (manual mode) - should advance one step per beat - print(" Test 8.2: Beat with chase (manual mode)") - patterns.step = 0 - mock_espnow.clear() - msg3 = { - "v": "1", - "select": { - "beat_device": ["beat_chase"] - } - } - mock_espnow.send_message(b"\xee\xee\xee\xee\xee\xee", msg3) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - assert patterns.selected == "beat_chase", "Should select beat_chase" - initial_step = patterns.step - - # First beat - mock_espnow.clear() - mock_espnow.send_message(b"\xff\xff\xff\xff\xff\xff", msg3) # Beat - run_main_loop_iterations(mock_espnow, patterns, settings, wdt, max_iterations=5) - # tick() is already called in run_main_loop_iterations - assert patterns.step == initial_step + 1, f"Chase step should increment from {initial_step} to {initial_step + 1}, got {patterns.step}" - - # Second beat - mock_espnow.clear() - mock_espnow.send_message(b"\x11\x11\x11\x11\x11\x11", msg3) # Beat again - run_main_loop_iterations(mock_espnow, patterns, settings, wdt, max_iterations=5) - assert patterns.step == initial_step + 2, f"Chase step should increment to {initial_step + 2}, got {patterns.step}" - print(" ✓ Chase beat advances one step per beat") - - # Test 3: Beat with pulse (manual mode) - should restart full cycle - print(" Test 8.3: Beat with pulse (manual mode)") - mock_espnow.clear() - msg4 = { - "v": "1", - "select": { - "beat_device": ["beat_pulse"] - } - } - mock_espnow.send_message(b"\x22\x22\x22\x22\x22\x22", msg4) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - assert patterns.selected == "beat_pulse", "Should select beat_pulse" - assert patterns.generator is not None, "Generator should be active" - - # First beat - should restart generator - initial_generator = patterns.generator - mock_espnow.clear() - mock_espnow.send_message(b"\x33\x33\x33\x33\x33\x33", msg4) # Beat - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - assert patterns.generator is not None, "Generator should still be active after beat" - assert patterns.generator != initial_generator, "Generator should be restarted (new instance)" - print(" ✓ Pulse beat restarts generator for full cycle") - - # Test 4: Multiple beats in sequence - print(" Test 8.4: Multiple beats in sequence") - patterns.step = 0 - mock_espnow.clear() - mock_espnow.send_message(b"\x44\x44\x44\x44\x44\x44", msg2) # Select rainbow - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - - # Send 5 beats - for i in range(5): - mock_espnow.clear() - mock_espnow.send_message(b"\x55\x55\x55\x55\x55\x55", msg2) # Beat - run_main_loop_iterations(mock_espnow, patterns, settings, wdt, max_iterations=5) - # tick() is already called in run_main_loop_iterations - wdt.feed() - utime.sleep_ms(50) - - assert patterns.step == 5, f"After 5 beats, step should be 5, got {patterns.step}" - print(" ✓ Multiple beats work correctly") - - print(" ✓ Beat functionality works correctly") - - -def test_select_with_step(): - """Test selecting a preset with an explicit step value.""" - print("\nTest 9: Select with step value") - settings = Settings() - settings["name"] = "step_device" - patterns = Presets(settings["led_pin"], settings["num_leds"]) - mock_espnow = MockESPNow() - wdt = get_wdt() - - # Create preset - msg1 = { - "v": "1", - "presets": { - "step_preset": {"pattern": "rainbow", "delay": 100, "n1": 1, "auto": False} - } - } - mock_espnow.send_message(b"\xaa\xaa\xaa\xaa\xaa\xaa", msg1) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt) - - # Select with explicit step value - mock_espnow.clear() - msg2 = { - "v": "1", - "select": { - "step_device": ["step_preset", 10] - } - } - mock_espnow.send_message(b"\xbb\xbb\xbb\xbb\xbb\xbb", msg2) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt, max_iterations=2) - # Ensure tick() is called after select() to advance the step - run_tick(patterns) - - assert patterns.selected == "step_preset", "Should select step_preset" - # Step is set to 10, then tick() advances it, so it should be 11 - assert patterns.step == 11, f"Step should be set to 10 then advanced to 11 by tick(), got {patterns.step}" - print(" ✓ Step value set correctly") - - # Select without step (should use default behavior) - mock_espnow.clear() - msg3 = { - "v": "1", - "select": { - "step_device": ["step_preset"] - } - } - mock_espnow.send_message(b"\xcc\xcc\xcc\xcc\xcc\xcc", msg3) - initial_step = patterns.step # Should be 11 - run_main_loop_iterations(mock_espnow, patterns, settings, wdt, max_iterations=2) - # Ensure tick() is called after select() to advance the step - run_tick(patterns) - # Since it's the same preset, step should not be reset, but tick() will advance it - # So step should be initial_step + 1 (one tick call) - assert patterns.step == initial_step + 1, f"Step should advance from {initial_step} to {initial_step + 1} (not reset), got {patterns.step}" - print(" ✓ Step preserved when selecting same preset without step (tick advances it)") - - # Select different preset with step - patterns.edit("other_preset", {"p": "rainbow", "a": False}) - mock_espnow.clear() - msg4 = { - "v": "1", - "select": { - "step_device": ["other_preset", 5] - } - } - mock_espnow.send_message(b"\xdd\xdd\xdd\xdd\xdd\xdd", msg4) - run_main_loop_iterations(mock_espnow, patterns, settings, wdt, max_iterations=2) - # Ensure tick() is called after select() to advance the step - run_tick(patterns) - - assert patterns.selected == "other_preset", "Should select other_preset" - # Step is set to 5, then tick() advances it, so it should be 6 - assert patterns.step == 6, f"Step should be set to 5 then advanced to 6 by tick(), got {patterns.step}" - print(" ✓ Step set correctly when switching presets") - - -def test_preset_save_load(): - """Test saving and loading presets to/from JSON.""" - print("\nTest 10: Preset save/load") - settings = Settings() - patterns = Presets(settings["led_pin"], settings["num_leds"]) - - patterns.edit("saved_preset", { - "p": "blink", - "d": 150, - "b": 200, - "c": [(1, 2, 3), (4, 5, 6)], - "a": False, - "n1": 1, - "n2": 2, - "n3": 3, - "n4": 4, - "n5": 5, - "n6": 6, - }) - assert patterns.save(), "Save should return True" - - reloaded = Presets(settings["led_pin"], settings["num_leds"]) - assert reloaded.load(settings), "Load should return True" - - preset = reloaded.presets.get("saved_preset") - assert preset is not None, "Preset should be loaded" - assert preset.p == "blink", "Pattern should be blink" - assert preset.d == 150, "Delay should be 150" - assert preset.b == 200, "Brightness should be 200" - assert preset.c == [(1, 2, 3), (4, 5, 6)], "Colors should be restored as tuples" - assert preset.a is False, "Auto should be False" - assert (preset.n1, preset.n2, preset.n3, preset.n4, preset.n5, preset.n6) == (1, 2, 3, 4, 5, 6), "n1-n6 should match" - try: - os.remove("presets.json") - except OSError: - pass - print(" ✓ Preset save/load works correctly") - - -def main(): - """Run all tests.""" - print("=" * 60) - print("ESPNow Receive Functionality Tests") - print("=" * 60) - - try: - test_version_check() - test_preset_creation() - test_color_conversion() - test_preset_update() - test_select() - test_full_message() - test_switch_presets() - test_beat_functionality() - test_select_with_step() - test_preset_save_load() - - print("\n" + "=" * 60) - print("All tests passed! ✓") - print("=" * 60) - except AssertionError as e: - print("\n✗ Test failed:", e) - raise - except Exception as e: - print("\n✗ Unexpected error:", e) - raise - - -if __name__ == "__main__": - main() diff --git a/tests/test_espnow_rx.py b/tests/test_espnow_rx.py deleted file mode 100644 index e0c22d0..0000000 --- a/tests/test_espnow_rx.py +++ /dev/null @@ -1,156 +0,0 @@ -#!/usr/bin/env python3 -"""LinkRx: reassembly, dedupe, acks, commit and digest resync.""" -import struct -from espnow_rx import LinkRx, MSG_DATA, MSG_ACK, MSG_DIGEST, MSG_RESYNC, F_ACK, F_COMMIT, INBOX_MAX -from beat_sync import BeatSync - -M = b"\x01\x02\x03\x04\x05\x06" - - -def data(seq, payload, idx=0, cnt=1, flags=F_ACK, ver=0): - return struct.pack(".local -on builds where mDNS is enabled (see network.hostname() in MicroPython docs). - -By default the script stays connected until you stop it (reset or mpremote Ctrl+C) so you -can ping the mDNS name from another machine (e.g. name "a" -> leda.local; hyphens are omitted -in the hostname because ESP32 mDNS often breaks on '-'). - -After flashing, do a full hardware reset once so the first DHCP sees the new hostname. - -Deploy src to the device (including utils.py with mdns_hostname), then from the host: - - mpremote connect PORT run tests/test_mdns.py - -Copy ``utils.py`` from ``src/`` onto the device if imports fail. - -Or with cwd led-driver: - - mpremote connect /dev/ttyUSB0 run tests/test_mdns.py -""" - -import time -import network -import socket - -import utime -from machine import WDT - -from settings import Settings -from utils import mdns_hostname - -CONNECT_TIMEOUT_S = 45 -# ESP32 MicroPython WDT timeout is capped (typically 10000 ms). Longer blocking work -# (PHY calibration) runs with no WDT; WDT is only used in HOLD_S. -WDT_TIMEOUT_MS = 10000 -# socket.getaddrinfo(".local", …) often hangs a long time or indefinitely on ESP32; off by default. -SELF_LOCAL_GETADDRINFO = False -# After checks: 0 = exit immediately; >0 = stay up that many seconds; -1 = until reset/Ctrl+C (for remote ping). -HOLD_S = -1 -# Set False to silence [mdns-test] timing lines (phase labels + elapsed ms since test start). -DEBUG = True - - -def _dbg(t0, msg): - if not DEBUG: - return - ms = utime.ticks_diff(utime.ticks_ms(), t0) - print("[mdns-test +%dms] %s" % (ms, msg)) - - -def _set_hostname(h, sta): - """Apply hostname on this STA object before active(True) / connect (DHCP + mDNS).""" - try: - network.hostname(h) - how = "network.hostname" - except (AttributeError, ValueError, OSError) as e: - how = None - last = e - try: - sta.config(hostname=h) - how = how or "WLAN.config(hostname=)" - except (AttributeError, ValueError, OSError) as e: - if how is None: - last = e - if how: - return how - print("Warning: could not set hostname (%s); mDNS name may be default." % last) - return None - - -def _sta_ip(sta): - try: - pair = sta.ipconfig("addr4") - if isinstance(pair, tuple) and pair: - return pair[0].split("/")[0] if isinstance(pair[0], str) else str(pair[0]) - except (AttributeError, OSError, TypeError, ValueError): - pass - return sta.ifconfig()[0] - - -def _wait_wifi(sta, timeout_s, wdt, t0): - """Wait for connection. If wdt is set, feed each iteration (keep gap < WDT_TIMEOUT_MS).""" - deadline = utime.ticks_add(utime.ticks_ms(), int(timeout_s * 1000)) - n = 0 - while not sta.isconnected(): - if utime.ticks_diff(deadline, utime.ticks_ms()) <= 0: - _dbg(t0, "WiFi wait TIMEOUT after %d iterations, status=%s" % (n, sta.status())) - return False - st = sta.status() - n += 1 - if DEBUG: - _dbg(t0, "WiFi wait iter #%d status=%s" % (n, st)) - else: - print("WiFi status:", st, "(waiting)") - if wdt is not None: - wdt.feed() - time.sleep(1) - if wdt is not None: - wdt.feed() - _dbg(t0, "WiFi connected after %d wait iterations" % n) - return True - - -def _try_resolve_local(hostname, t0): - """Best-effort: resolve our own *.local via getaddrinfo (often blocks a very long time on ESP32).""" - fqdn = hostname + ".local" - _dbg(t0, "getaddrinfo(%r) starting (may block a long time)" % fqdn) - t_gai = utime.ticks_ms() - try: - ai = socket.getaddrinfo(fqdn, 80) - dt = utime.ticks_diff(utime.ticks_ms(), t_gai) - print("getaddrinfo(%r) -> %s" % (fqdn, ai)) - _dbg(t0, "getaddrinfo OK (call took %dms)" % dt) - return True - except OSError as e: - dt = utime.ticks_diff(utime.ticks_ms(), t_gai) - print("getaddrinfo(%r) failed: %s" % (fqdn, e)) - _dbg(t0, "getaddrinfo OSError after %dms" % dt) - return False - - -def main(): - t0 = utime.ticks_ms() - _dbg(t0, "start") - - settings = Settings() - _dbg(t0, "Settings() loaded") - ssid = settings.get("ssid") or "" - password = settings.get("password") or "" - if not ssid: - print("mDNS test skipped: ssid empty in settings.json (configure Wi-Fi to run this test).") - raise SystemExit(0) - - hostname = mdns_hostname(settings) - _dbg(t0, "mdns_hostname -> %r" % hostname) - sta = network.WLAN(network.STA_IF) - how = _set_hostname(hostname, sta) - if how: - print("Hostname set via %s: %r" % (how, hostname)) - _dbg(t0, "set_hostname done (%s)" % (how or "failed")) - - _dbg(t0, "before sta.active(True) (often slow: RF calibration)") - print("WiFi active(True) (can take a while for calibration)...") - sta.active(True) - _dbg(t0, "after sta.active(True)") - try: - sta.config(pm=network.WLAN.PM_NONE) - _dbg(t0, "sta.config(pm=PM_NONE) OK") - except (AttributeError, ValueError, TypeError) as e: - _dbg(t0, "sta.config(pm=PM_NONE) skipped: %s" % e) - - print("Connecting to SSID %r ..." % ssid) - _dbg(t0, "before sta.connect()") - sta.connect(ssid, password) - _dbg(t0, "after sta.connect() (returned; association may still be in progress)") - # No WDT during calibration/wait/getaddrinfo — they can block longer than WDT_TIMEOUT_MS. - if not _wait_wifi(sta, CONNECT_TIMEOUT_S, None, t0): - print("Timeout: not connected. status=", sta.status()) - raise SystemExit(1) - - ip = _sta_ip(sta) - print("WiFi OK, IP:", ip) - try: - stack_host = network.hostname() - except (AttributeError, ValueError, TypeError, OSError): - stack_host = None - if stack_host: - print( - "mDNS: use what the stack reports — ping %s.local (avahi-resolve -n %s.local)" - % (stack_host, stack_host) - ) - if str(stack_host) != str(hostname): - print( - "(We asked for %r but stack reports %r — ping the stack name; cold boot may help.)" - % (hostname, stack_host) - ) - else: - print("From another machine: ping %s.local" % hostname) - print("(or: avahi-resolve -n %s.local)" % hostname) - - if SELF_LOCAL_GETADDRINFO: - _try_resolve_local(hostname, t0) - else: - _dbg( - t0, - "skip getaddrinfo(%s.local): SELF_LOCAL_GETADDRINFO=False (on-device self-.local lookup often hangs)" - % hostname, - ) - print( - "Skipped on-device getaddrinfo(*.local); verify mDNS from a PC (ping above). " - "Set SELF_LOCAL_GETADDRINFO = True to attempt (may hang)." - ) - - if HOLD_S != 0: - forever = HOLD_S < 0 - _dbg( - t0, - "starting WDT(%dms) + hold %s" - % (WDT_TIMEOUT_MS, "forever" if forever else ("%ds" % HOLD_S)), - ) - wdt = WDT(timeout=WDT_TIMEOUT_MS) - wdt.feed() - if forever: - ping_target = stack_host or hostname - print( - "Staying online until you stop (reset device or mpremote Ctrl+C). " - "From another host: ping %s.local" % ping_target - ) - else: - print("Keeping connection up for %d s (Ctrl+C or reset to stop) ..." % HOLD_S) - end = None if forever else utime.ticks_add(utime.ticks_ms(), HOLD_S * 1000) - hold_i = 0 - while True: - wdt.feed() - time.sleep(2) - hold_i += 1 - if not sta.isconnected(): - print("lost WiFi connection") - break - if forever: - if DEBUG and hold_i % 15 == 0: - _dbg(t0, "hold alive #%d IP %s" % (hold_i, _sta_ip(sta))) - else: - _dbg(t0, "hold tick #%d" % hold_i) - print("still connected, IP", _sta_ip(sta)) - if utime.ticks_diff(end, utime.ticks_ms()) <= 0: - break - - _dbg(t0, "hold loop finished") - - _dbg(t0, "Done.") - print("Done.") - - -if __name__ == "__main__": - main() diff --git a/tests/test_wifi.py b/tests/test_wifi.py deleted file mode 100644 index 4e742f0..0000000 --- a/tests/test_wifi.py +++ /dev/null @@ -1,102 +0,0 @@ -#!/usr/bin/env python3 -"""Wi-Fi connection smoke test for MicroPython on ESP32. - -Runs on-device via mpremote and uses /settings.json credentials. - -Usage: - mpremote connect /dev/ttyACM0 run tests/test_wifi.py -""" - -import time -import utime -import network -from machine import WDT - -from settings import Settings - -CONNECT_TIMEOUT_S = 30 -RETRY_DELAY_S = 2 -WDT_TIMEOUT_MS = 10000 - - -def _wifi_status_label(code): - names = { - getattr(network, "STAT_IDLE", 0): "idle", - getattr(network, "STAT_CONNECTING", 1): "connecting", - getattr(network, "STAT_WRONG_PASSWORD", -3): "wrong_password", - getattr(network, "STAT_NO_AP_FOUND", -2): "no_ap_found", - getattr(network, "STAT_CONNECT_FAIL", -1): "connect_fail", - getattr(network, "STAT_GOT_IP", 3): "got_ip", - } - return names.get(code, str(code)) - - -def connect_wifi_with_wdt(sta, ssid, password, wdt): - attempt = 0 - while not sta.isconnected(): - attempt += 1 - print("[wifi-test] attempt", attempt, "ssid=", repr(ssid)) - try: - sta.disconnect() - except Exception: - pass - sta.connect(ssid, password) - - start = utime.time() - last_status = None - while not sta.isconnected(): - status = sta.status() - if status != last_status: - print("[wifi-test] status:", status, _wifi_status_label(status)) - last_status = status - if status in ( - getattr(network, "STAT_WRONG_PASSWORD", -3), - getattr(network, "STAT_NO_AP_FOUND", -2), - getattr(network, "STAT_CONNECT_FAIL", -1), - ): - break - if utime.time() - start >= CONNECT_TIMEOUT_S: - print("[wifi-test] timeout after", CONNECT_TIMEOUT_S, "seconds") - break - time.sleep(1) - wdt.feed() - - if sta.isconnected(): - return True - - print("[wifi-test] retry in", RETRY_DELAY_S, "seconds") - for _ in range(RETRY_DELAY_S): - time.sleep(1) - wdt.feed() - return True - - -def main(): - settings = Settings() - ssid = settings.get("ssid") or "" - password = settings.get("password") or "" - - if not ssid: - print("[wifi-test] skipped: settings.ssid is empty") - raise SystemExit(0) - - wdt = WDT(timeout=WDT_TIMEOUT_MS) - wdt.feed() - - sta = network.WLAN(network.STA_IF) - sta.active(True) - try: - sta.config(pm=network.WLAN.PM_NONE) - except (AttributeError, ValueError, TypeError): - pass - - ok = connect_wifi_with_wdt(sta, ssid, password, wdt) - if not ok or not sta.isconnected(): - print("[wifi-test] FAILED: not connected") - raise SystemExit(1) - - print("[wifi-test] OK:", sta.ifconfig()) - - -if __name__ == "__main__": - main() diff --git a/tests/udp_client.py b/tests/udp_client.py deleted file mode 100644 index 61a1052..0000000 --- a/tests/udp_client.py +++ /dev/null @@ -1,71 +0,0 @@ -#!/usr/bin/env python3 -"""UDP discovery test — runs on MicroPython (ESP32). - -Brings up Wi-Fi from settings (test harness only), then **`hello.discover_controller_udp(device_name, wdt)`**. -`hello` does not use Settings or connect Wi‑Fi. - -In firmware, **`main.py`** discovers the controller IP in RAM for HTTP; it is not written to settings. - -Deploy `src` (including `hello.py`), then from host with cwd `led-driver`: - - mpremote connect PORT run tests/udp_client.py -""" - -import time - -import network -import utime -from machine import WDT - -from hello import discover_controller_udp -from settings import Settings - -CONNECT_WAIT_S = 45 -WDT_MS = 10000 - - -def _wait_wifi(sta, timeout_s, wdt): - deadline = utime.ticks_add(utime.ticks_ms(), int(timeout_s * 1000)) - while not sta.isconnected(): - wdt.feed() - if utime.ticks_diff(deadline, utime.ticks_ms()) <= 0: - return False - print("WiFi status:", sta.status()) - wdt.feed() - time.sleep(1) - wdt.feed() - return True - - -def main(): - settings = Settings() - ssid = settings.get("ssid") or "" - password = settings.get("password") or "" - - if not ssid: - print("udp_client: set ssid/password in settings.json (test harness Wi-Fi).") - raise SystemExit(1) - - sta = network.WLAN(network.STA_IF) - sta.active(True) - try: - sta.config(pm=network.WLAN.PM_NONE) - except (AttributeError, ValueError, TypeError): - pass - - wdt = WDT(timeout=WDT_MS) - wdt.feed() - print("udp_client: connecting to", repr(ssid)) - sta.connect(ssid, password) - wdt.feed() - if not _wait_wifi(sta, CONNECT_WAIT_S, wdt): - print("WiFi timeout, status=", sta.status()) - raise SystemExit(1) - - ip = discover_controller_udp(settings.get("name", ""), wdt=wdt) - if not ip: - raise SystemExit(1) - - -if __name__ == "__main__": - main()