chore: remove MicroPython driver code (src, lib, tests, dev.py)
The cpp branch is the ESP-IDF firmware; the MicroPython drivers are removed. Uncommitted MicroPython work was saved outside the repo before removal. Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
9a04d28ecf
commit
4b623bb156
105 files changed
-11577
No files matched your search
@@ -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")
|
|
||||||
@@ -1,2 +0,0 @@
|
|||||||
from microdot.microdot import Microdot, Request, Response, abort, redirect, \
|
|
||||||
send_file # noqa: F401
|
|
||||||
@@ -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 _
|
|
||||||
File diff suppressed because it is too large.
Load diff
@@ -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()
|
|
||||||
<microdot.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() <microdot.session.SessionDict.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
|
|
||||||
@@ -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
|
|
||||||
@@ -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)
|
|
||||||
Whitespace-only changes.
@@ -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
|
|
||||||
@@ -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)
|
|
||||||
@@ -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)
|
|
||||||
@@ -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)
|
|
||||||
@@ -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("<BHHB", data, 2)
|
|
||||||
if self.last_idx is not None:
|
|
||||||
if idx == self.last_idx:
|
|
||||||
self.stats["dups"] += 1
|
|
||||||
return False # second copy of a beat we already took
|
|
||||||
guard = max(MIN_GUARD_MS, self.period // 2)
|
|
||||||
if _diff(idx, self.last_idx) >= 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
|
|
||||||
@@ -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(
|
|
||||||
"<HBBhhhhhh", buf, off
|
|
||||||
)
|
|
||||||
off += 16
|
|
||||||
preset = {
|
|
||||||
"p": pattern,
|
|
||||||
"c": colors,
|
|
||||||
"d": delay,
|
|
||||||
"b": br,
|
|
||||||
"a": bool(auto),
|
|
||||||
"n1": n1,
|
|
||||||
"n2": n2,
|
|
||||||
"n3": n3,
|
|
||||||
"n4": n4,
|
|
||||||
"n5": n5,
|
|
||||||
"n6": n6,
|
|
||||||
}
|
|
||||||
return name, preset, off
|
|
||||||
|
|
||||||
|
|
||||||
def _decode_presets_blob(chunk):
|
|
||||||
if not chunk:
|
|
||||||
return {}
|
|
||||||
off = 0
|
|
||||||
count = chunk[off]
|
|
||||||
off += 1
|
|
||||||
out = {}
|
|
||||||
for _ in range(count):
|
|
||||||
name, preset, off = _decode_preset_record(chunk, off)
|
|
||||||
out[name] = preset
|
|
||||||
if off != len(chunk):
|
|
||||||
raise ValueError("presets blob mismatch")
|
|
||||||
return out
|
|
||||||
|
|
||||||
|
|
||||||
def _decode_select_blob(chunk):
|
|
||||||
if not chunk:
|
|
||||||
return {}
|
|
||||||
off = 0
|
|
||||||
count = chunk[off]
|
|
||||||
off += 1
|
|
||||||
out = {}
|
|
||||||
for _ in range(count):
|
|
||||||
dl = chunk[off]
|
|
||||||
off += 1
|
|
||||||
device = chunk[off : off + dl].decode("utf-8")
|
|
||||||
off += dl
|
|
||||||
pl = chunk[off]
|
|
||||||
off += 1
|
|
||||||
pname = chunk[off : off + pl].decode("utf-8")
|
|
||||||
off += pl
|
|
||||||
has_step = chunk[off]
|
|
||||||
off += 1
|
|
||||||
if has_step:
|
|
||||||
step = struct.unpack_from("<H", chunk, off)[0]
|
|
||||||
off += 2
|
|
||||||
out[device] = [pname, step]
|
|
||||||
else:
|
|
||||||
out[device] = [pname]
|
|
||||||
if off != len(chunk):
|
|
||||||
raise ValueError("select blob mismatch")
|
|
||||||
return out
|
|
||||||
|
|
||||||
|
|
||||||
def _decode_default_blob(chunk):
|
|
||||||
if not chunk:
|
|
||||||
return "", []
|
|
||||||
off = 0
|
|
||||||
nl = chunk[off]
|
|
||||||
off += 1
|
|
||||||
default_name = chunk[off : off + nl].decode("utf-8") if nl else ""
|
|
||||||
off += nl
|
|
||||||
nt = chunk[off]
|
|
||||||
off += 1
|
|
||||||
targets = []
|
|
||||||
for _ in range(nt):
|
|
||||||
tl = chunk[off]
|
|
||||||
off += 1
|
|
||||||
targets.append(chunk[off : off + tl].decode("utf-8"))
|
|
||||||
off += tl
|
|
||||||
if off != len(chunk):
|
|
||||||
raise ValueError("default blob mismatch")
|
|
||||||
return default_name, targets
|
|
||||||
|
|
||||||
|
|
||||||
def parse_binary_envelope_v2(buf):
|
|
||||||
if not isinstance(buf, (bytes, bytearray)) or len(buf) < HEADER_LEN:
|
|
||||||
return None
|
|
||||||
if buf[0] != BINARY_ENVELOPE_VERSION_2:
|
|
||||||
return None
|
|
||||||
lp = buf[2]
|
|
||||||
ls = buf[3]
|
|
||||||
ld = buf[4]
|
|
||||||
need = HEADER_LEN + lp + ls + ld
|
|
||||||
if len(buf) != need:
|
|
||||||
return None
|
|
||||||
|
|
||||||
off = HEADER_LEN
|
|
||||||
presets_chunk = buf[off : off + lp]
|
|
||||||
off += lp
|
|
||||||
select_chunk = buf[off : off + ls]
|
|
||||||
off += ls
|
|
||||||
default_chunk = buf[off : off + ld]
|
|
||||||
|
|
||||||
data = {"v": "1"}
|
|
||||||
br = buf[1]
|
|
||||||
if br < 128:
|
|
||||||
data["b"] = _brightness_0_255_from_wire(br)
|
|
||||||
|
|
||||||
try:
|
|
||||||
if lp:
|
|
||||||
data["presets"] = _decode_presets_blob(presets_chunk)
|
|
||||||
if ls:
|
|
||||||
data["select"] = _decode_select_blob(select_chunk)
|
|
||||||
if ld:
|
|
||||||
dname, targets = _decode_default_blob(default_chunk)
|
|
||||||
data["default"] = dname
|
|
||||||
data["targets"] = targets
|
|
||||||
except (ValueError, UnicodeError, TypeError, struct.error):
|
|
||||||
return None
|
|
||||||
|
|
||||||
return data
|
|
||||||
|
|
||||||
|
|
||||||
def parse_binary_envelope_v1(buf):
|
|
||||||
if not isinstance(buf, (bytes, bytearray)) or len(buf) < HEADER_LEN:
|
|
||||||
return None
|
|
||||||
if buf[0] != BINARY_ENVELOPE_VERSION_1:
|
|
||||||
return None
|
|
||||||
lp = buf[2]
|
|
||||||
ls = buf[3]
|
|
||||||
ld = buf[4]
|
|
||||||
need = HEADER_LEN + lp + ls + ld
|
|
||||||
if len(buf) != need:
|
|
||||||
return None
|
|
||||||
|
|
||||||
off = HEADER_LEN
|
|
||||||
presets_chunk = buf[off : off + lp]
|
|
||||||
off += lp
|
|
||||||
select_chunk = buf[off : off + ls]
|
|
||||||
off += ls
|
|
||||||
default_chunk = buf[off : off + ld]
|
|
||||||
|
|
||||||
data = {"v": "1"}
|
|
||||||
|
|
||||||
br = buf[1]
|
|
||||||
if br < 128:
|
|
||||||
data["b"] = _brightness_0_255_from_wire(br)
|
|
||||||
|
|
||||||
if lp:
|
|
||||||
try:
|
|
||||||
data["presets"] = json.loads(presets_chunk.decode("utf-8"))
|
|
||||||
except (ValueError, UnicodeError):
|
|
||||||
return None
|
|
||||||
if ls:
|
|
||||||
try:
|
|
||||||
data["select"] = json.loads(select_chunk.decode("utf-8"))
|
|
||||||
except (ValueError, UnicodeError):
|
|
||||||
return None
|
|
||||||
if ld:
|
|
||||||
try:
|
|
||||||
extra = json.loads(default_chunk.decode("utf-8"))
|
|
||||||
except (ValueError, UnicodeError):
|
|
||||||
return None
|
|
||||||
if isinstance(extra, dict):
|
|
||||||
for k, v in extra.items():
|
|
||||||
data[k] = v
|
|
||||||
|
|
||||||
return data
|
|
||||||
|
|
||||||
|
|
||||||
def parse_binary_envelope(buf):
|
|
||||||
d = parse_binary_envelope_v2(buf)
|
|
||||||
if d is not None:
|
|
||||||
return d
|
|
||||||
return parse_binary_envelope_v1(buf)
|
|
||||||
@@ -1,41 +0,0 @@
|
|||||||
"""ESP32-C3 and ESP32-S3 differences for the LED driver.
|
|
||||||
|
|
||||||
Seeed XIAO silk-screen D10 is GPIO 10 on the C3 and GPIO 9 on the S3.
|
|
||||||
Fresh settings use that pad. A saved ``led_pin`` is left unchanged.
|
|
||||||
"""
|
|
||||||
|
|
||||||
try:
|
|
||||||
import uos as os
|
|
||||||
except ImportError:
|
|
||||||
import os
|
|
||||||
|
|
||||||
import machine
|
|
||||||
|
|
||||||
_LED_PIN_C3 = 10
|
|
||||||
_LED_PIN_S3 = 9
|
|
||||||
_CPU_HZ_C3 = 160000000
|
|
||||||
_CPU_HZ_S3 = 240000000
|
|
||||||
|
|
||||||
|
|
||||||
def mcu():
|
|
||||||
"""Return ``s3``, ``c3``, or ``""`` when the chip is neither."""
|
|
||||||
name = os.uname().machine.upper().replace("-", "")
|
|
||||||
if "ESP32S3" in name:
|
|
||||||
return "s3"
|
|
||||||
if "ESP32C3" in name:
|
|
||||||
return "c3"
|
|
||||||
return ""
|
|
||||||
|
|
||||||
|
|
||||||
def default_led_pin():
|
|
||||||
if mcu() == "s3":
|
|
||||||
return _LED_PIN_S3
|
|
||||||
return _LED_PIN_C3
|
|
||||||
|
|
||||||
|
|
||||||
def apply_cpu_freq():
|
|
||||||
"""C3 maximum is 160 MHz. S3 (XIAO firmware) runs at 240 MHz."""
|
|
||||||
if mcu() == "s3":
|
|
||||||
machine.freq(_CPU_HZ_S3)
|
|
||||||
else:
|
|
||||||
machine.freq(_CPU_HZ_C3)
|
|
||||||
@@ -1,512 +0,0 @@
|
|||||||
"""Parse controller JSON (v1) and apply brightness, presets, OTA patterns, etc."""
|
|
||||||
|
|
||||||
import json
|
|
||||||
import socket
|
|
||||||
import network
|
|
||||||
import ubinascii
|
|
||||||
|
|
||||||
import device_groups as dg
|
|
||||||
from v1_wire import expand_v1
|
|
||||||
from binary_envelope import parse_binary_envelope
|
|
||||||
from utils import convert_and_reorder_colors
|
|
||||||
|
|
||||||
try:
|
|
||||||
import uos as os
|
|
||||||
except ImportError:
|
|
||||||
import os
|
|
||||||
|
|
||||||
|
|
||||||
def _log_rx(payload) -> 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)
|
|
||||||
@@ -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)
|
|
||||||
@@ -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 <path>.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("<I", 0))
|
|
||||||
elif op == OP_BEGIN:
|
|
||||||
self._begin(mac, sess, pkt)
|
|
||||||
elif sess != self.sess:
|
|
||||||
if op != OP_DATA: # data for a session we never started: stay quiet, it may be broadcast
|
|
||||||
self._reply(mac, sess, op, NOSESS)
|
|
||||||
elif op == OP_DATA:
|
|
||||||
self._data(pkt)
|
|
||||||
elif op == OP_END:
|
|
||||||
self._end(mac)
|
|
||||||
elif op == OP_COMMIT:
|
|
||||||
self._commit(mac)
|
|
||||||
elif op == OP_ABORT:
|
|
||||||
self._abort()
|
|
||||||
self._reply(mac, sess, op, OK)
|
|
||||||
elif op == OP_MISSING:
|
|
||||||
self._missing(mac)
|
|
||||||
|
|
||||||
def _reply(self, mac, sess, op, code, arg=None):
|
|
||||||
if arg is None:
|
|
||||||
arg = struct.pack("<I", self.cur[5] if self.cur else 0)
|
|
||||||
self.send(mac, struct.pack("<BBHBB", WIRE_MAGIC, MSG_STATUS, sess, op, code) + arg)
|
|
||||||
|
|
||||||
def _close_cur(self, delete):
|
|
||||||
if self.cur is None:
|
|
||||||
return
|
|
||||||
try:
|
|
||||||
self.cur[3].close()
|
|
||||||
except OSError:
|
|
||||||
pass
|
|
||||||
if delete:
|
|
||||||
_remove(self.cur[0] + STAGED_SUFFIX)
|
|
||||||
self.cur = None
|
|
||||||
|
|
||||||
def _abort(self):
|
|
||||||
self._close_cur(True)
|
|
||||||
for path in self.staged:
|
|
||||||
_remove(path + STAGED_SUFFIX)
|
|
||||||
self.staged = {}
|
|
||||||
|
|
||||||
def _begin(self, mac, sess, pkt):
|
|
||||||
if len(pkt) < 43:
|
|
||||||
return
|
|
||||||
size = struct.unpack_from("<I", pkt, 4)[0]
|
|
||||||
sha = "".join("%02x" % b for b in pkt[8:40])
|
|
||||||
plen = pkt[40]
|
|
||||||
path = bytes(pkt[41 : 41 + plen]).decode()
|
|
||||||
if sess != self.sess:
|
|
||||||
self._abort()
|
|
||||||
self.sess = sess
|
|
||||||
if not safe_path(path):
|
|
||||||
self._reply(mac, sess, OP_BEGIN, BADPATH)
|
|
||||||
return
|
|
||||||
if size > 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("<H", 0))
|
|
||||||
return
|
|
||||||
cnt, miss = self._missing_bitmap()
|
|
||||||
self._reply(mac, self.sess, OP_MISSING, OK, struct.pack("<H", cnt) + miss)
|
|
||||||
|
|
||||||
def _end(self, mac):
|
|
||||||
cur = self.cur
|
|
||||||
if cur is None:
|
|
||||||
# already verified: our OK was lost and the controller asks again
|
|
||||||
self._reply(mac, self.sess, OP_END, OK if self.staged else NOSESS)
|
|
||||||
return
|
|
||||||
if cur[5] < cur[1]:
|
|
||||||
self._reply(mac, self.sess, OP_END, INCOMPLETE)
|
|
||||||
return
|
|
||||||
path, sha = cur[0], cur[2]
|
|
||||||
self._close_cur(False)
|
|
||||||
try:
|
|
||||||
ok = file_hashes._hash_file(path + STAGED_SUFFIX) == sha
|
|
||||||
except OSError:
|
|
||||||
ok = False
|
|
||||||
if not ok:
|
|
||||||
_remove(path + STAGED_SUFFIX)
|
|
||||||
self._reply(mac, self.sess, OP_END, BADHASH)
|
|
||||||
return
|
|
||||||
self.staged[path] = sha
|
|
||||||
self._reply(mac, self.sess, OP_END, OK)
|
|
||||||
|
|
||||||
def _commit(self, mac):
|
|
||||||
self._close_cur(True)
|
|
||||||
manifest = file_hashes.load()
|
|
||||||
failed = False
|
|
||||||
for path, sha in self.staged.items():
|
|
||||||
try:
|
|
||||||
try:
|
|
||||||
os.rename(path + STAGED_SUFFIX, path)
|
|
||||||
except OSError:
|
|
||||||
_remove(path)
|
|
||||||
os.rename(path + STAGED_SUFFIX, path)
|
|
||||||
manifest[path] = sha
|
|
||||||
except OSError:
|
|
||||||
failed = True
|
|
||||||
moved = len(self.staged)
|
|
||||||
self.staged = {}
|
|
||||||
try:
|
|
||||||
file_hashes.save(manifest)
|
|
||||||
with open(LAST_FILE, "w") as f:
|
|
||||||
f.write(str(self.sess))
|
|
||||||
except OSError:
|
|
||||||
failed = True
|
|
||||||
self.committed = self.sess
|
|
||||||
self._reply(mac, self.sess, OP_COMMIT, IOERR if failed else OK, struct.pack("<I", moved))
|
|
||||||
print("ota: committed", moved, "files" + (" with errors" if failed else ""))
|
|
||||||
if moved:
|
|
||||||
self._schedule_reset()
|
|
||||||
|
|
||||||
def _schedule_reset(self):
|
|
||||||
if self.reset is not None:
|
|
||||||
self.reset()
|
|
||||||
return
|
|
||||||
import machine
|
|
||||||
|
|
||||||
try:
|
|
||||||
t = machine.Timer(0)
|
|
||||||
t.init(mode=machine.Timer.ONE_SHOT, period=300, callback=lambda _: machine.reset())
|
|
||||||
except Exception:
|
|
||||||
import utime
|
|
||||||
|
|
||||||
utime.sleep_ms(300)
|
|
||||||
machine.reset()
|
|
||||||
|
|
||||||
|
|
||||||
_ota = None
|
|
||||||
|
|
||||||
|
|
||||||
def handle(mac, pkt, send):
|
|
||||||
global _ota
|
|
||||||
if _ota is None:
|
|
||||||
_ota = Ota(send)
|
|
||||||
_ota.handle(bytes(mac), pkt)
|
|
||||||
@@ -1,175 +0,0 @@
|
|||||||
"""Reliable-link extension of the 0x4C ESP-NOW protocol (driver side).
|
|
||||||
|
|
||||||
Extra message types, all inside the existing wire magic 0x4C:
|
|
||||||
0x20 DATA [4C][20][flags][seq u16][ver u16][idx][cnt] + fragment of an inner packet
|
|
||||||
flags: 1 = ack wanted, 2 = commit (record ver once complete)
|
|
||||||
The inner packet is any normal packet (4C 03 CMD, 4C 04 GROUP_CMD, 4C 02 GROUPS, or JSON).
|
|
||||||
0x21 ACK [4C][21][0][seq u16][cnt][mask u32] driver -> 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("<BBH", WIRE_MAGIC, MSG_ECHO, idx))
|
|
||||||
|
|
||||||
def poll(self, now):
|
|
||||||
"""Process queued frames. Call from the main loop."""
|
|
||||||
while self.inbox:
|
|
||||||
mac, data = self.inbox.pop(0)
|
|
||||||
if len(data) > 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("<BBBHBI", WIRE_MAGIC, MSG_ACK, 0, seq, cnt, mask))
|
|
||||||
self.stats["acks"] += 1
|
|
||||||
|
|
||||||
def _data(self, mac, data, now):
|
|
||||||
if len(data) <= HDR:
|
|
||||||
return
|
|
||||||
_, _, flags, seq, ver, idx, cnt = struct.unpack("<BBBHHBB", data[:HDR])
|
|
||||||
if cnt == 0 or cnt > 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("<H", data[2:4])[0]
|
|
||||||
if ver == 0 or ver == self.ver or self.resync_at is not None:
|
|
||||||
return
|
|
||||||
if self.last_resync is not None and now - self.last_resync < RESYNC_MIN_GAP_MS:
|
|
||||||
return
|
|
||||||
self.resync_at = now + self.jitter_ms
|
|
||||||
|
|
||||||
def _send_resync(self, now):
|
|
||||||
if self.send and self.master:
|
|
||||||
self.last_resync = now
|
|
||||||
self.stats["resyncs"] += 1
|
|
||||||
self.send(self.master, struct.pack("<BBH", WIRE_MAGIC, MSG_RESYNC, self.ver))
|
|
||||||
|
|
||||||
|
|
||||||
def make_sender(esp):
|
|
||||||
"""send(mac, frame) for an espnow.ESPNow instance, adding the peer on first use."""
|
|
||||||
peers = set()
|
|
||||||
|
|
||||||
def send(mac, frame):
|
|
||||||
if mac not in peers:
|
|
||||||
try:
|
|
||||||
esp.add_peer(mac)
|
|
||||||
except OSError:
|
|
||||||
pass
|
|
||||||
peers.add(mac)
|
|
||||||
try:
|
|
||||||
esp.send(mac, frame, False)
|
|
||||||
except OSError:
|
|
||||||
pass
|
|
||||||
|
|
||||||
return send
|
|
||||||
@@ -1,204 +0,0 @@
|
|||||||
"""ESP-NOW receive loop and boot announce."""
|
|
||||||
|
|
||||||
import asyncio
|
|
||||||
import urandom
|
|
||||||
import ubinascii
|
|
||||||
|
|
||||||
import espnow
|
|
||||||
import network
|
|
||||||
|
|
||||||
import device_groups as dg
|
|
||||||
from espnow_wire import (
|
|
||||||
BROADCAST_MAC,
|
|
||||||
MSG_ANNOUNCE,
|
|
||||||
MSG_CMD,
|
|
||||||
MSG_GROUP_CMD,
|
|
||||||
MSG_GROUPS,
|
|
||||||
MSG_OTA_FIRST,
|
|
||||||
MSG_OTA_LAST,
|
|
||||||
MSG_PING_REQ,
|
|
||||||
cmd_envelope,
|
|
||||||
pack_announce,
|
|
||||||
pack_ping_rsp,
|
|
||||||
parse_group_cmd,
|
|
||||||
parse_groups,
|
|
||||||
parse_ping_req,
|
|
||||||
wire_msg_type,
|
|
||||||
)
|
|
||||||
|
|
||||||
from controller_messages import process_data
|
|
||||||
from settings import WIFI_CHANNEL_DEFAULT
|
|
||||||
|
|
||||||
_PING_DELAY_MS_MIN = 50
|
|
||||||
_PING_DELAY_MS_MAX = 500
|
|
||||||
|
|
||||||
_esp = None
|
|
||||||
_ota_send = None
|
|
||||||
_groups_received = False
|
|
||||||
_debug = False
|
|
||||||
|
|
||||||
|
|
||||||
def _dlog(*parts):
|
|
||||||
if _debug:
|
|
||||||
print(*parts)
|
|
||||||
|
|
||||||
|
|
||||||
def init_espnow(settings):
|
|
||||||
global _esp, _debug
|
|
||||||
_debug = bool(settings.get("debug", False))
|
|
||||||
try:
|
|
||||||
ch = int(settings.get("wifi_channel", WIFI_CHANNEL_DEFAULT))
|
|
||||||
except (TypeError, ValueError):
|
|
||||||
ch = WIFI_CHANNEL_DEFAULT
|
|
||||||
ch = max(1, min(11, ch))
|
|
||||||
sta = network.WLAN(network.STA_IF)
|
|
||||||
sta.active(True)
|
|
||||||
sta.config(pm=network.WLAN.PM_NONE)
|
|
||||||
try:
|
|
||||||
sta.config(channel=ch)
|
|
||||||
except Exception as e:
|
|
||||||
print("espnow sta channel set failed:", e)
|
|
||||||
_esp = espnow.ESPNow()
|
|
||||||
try:
|
|
||||||
# The default 526 bytes holds two full frames; an OTA chunk is four
|
|
||||||
_esp.config(rxbuf=int(settings.get("espnow_rxbuf", 2048)))
|
|
||||||
except Exception as e:
|
|
||||||
print("espnow rxbuf set failed:", e)
|
|
||||||
_esp.active(True)
|
|
||||||
try:
|
|
||||||
_esp.add_peer(BROADCAST_MAC)
|
|
||||||
_dlog("espnow add bcast ok")
|
|
||||||
except Exception as e:
|
|
||||||
print("espnow add bcast failed:", e)
|
|
||||||
try:
|
|
||||||
actual_ch = sta.config("channel")
|
|
||||||
except Exception:
|
|
||||||
actual_ch = "?"
|
|
||||||
print("espnow init ch", ch, "sta_ch", actual_ch, "debug", _debug)
|
|
||||||
return _esp
|
|
||||||
|
|
||||||
|
|
||||||
def _send_ping_rsp(host, settings, ping_id, delay_ms):
|
|
||||||
import utime
|
|
||||||
|
|
||||||
utime.sleep_ms(delay_ms)
|
|
||||||
if _esp is None or not host or len(host) != 6:
|
|
||||||
return
|
|
||||||
pkt = pack_ping_rsp(ping_id, settings.get("name", "led"))
|
|
||||||
try:
|
|
||||||
try:
|
|
||||||
_esp.add_peer(host)
|
|
||||||
_dlog("espnow ping add_peer ok", ubinascii.hexlify(host).decode())
|
|
||||||
except Exception as e:
|
|
||||||
_dlog("espnow ping add_peer skip", repr(e))
|
|
||||||
_esp.send(host, pkt)
|
|
||||||
print("espnow ping rsp", ping_id, delay_ms, "ms", ubinascii.hexlify(host).decode())
|
|
||||||
except Exception as e:
|
|
||||||
print("espnow ping rsp failed:", e, "host", ubinascii.hexlify(host).decode(), "len", len(pkt))
|
|
||||||
|
|
||||||
|
|
||||||
async def _send_ping_rsp_delayed(host, settings, ping_id):
|
|
||||||
span = _PING_DELAY_MS_MAX - _PING_DELAY_MS_MIN
|
|
||||||
delay_ms = _PING_DELAY_MS_MIN + (urandom.getrandbits(10) % (span + 1))
|
|
||||||
await asyncio.sleep(delay_ms / 1000)
|
|
||||||
_send_ping_rsp(host, settings, ping_id, delay_ms)
|
|
||||||
|
|
||||||
|
|
||||||
def _schedule_ping_rsp(host, settings, ping_id):
|
|
||||||
span = _PING_DELAY_MS_MAX - _PING_DELAY_MS_MIN
|
|
||||||
delay_ms = _PING_DELAY_MS_MIN + (urandom.getrandbits(10) % (span + 1))
|
|
||||||
try:
|
|
||||||
import _thread
|
|
||||||
|
|
||||||
_thread.start_new_thread(_send_ping_rsp, (host, settings, ping_id, delay_ms))
|
|
||||||
except ImportError:
|
|
||||||
asyncio.create_task(_send_ping_rsp_delayed(host, settings, ping_id))
|
|
||||||
|
|
||||||
|
|
||||||
def send_boot_announce(settings):
|
|
||||||
if _esp is None:
|
|
||||||
return
|
|
||||||
pkt = pack_announce(
|
|
||||||
settings.get("name", "led"),
|
|
||||||
settings.get("num_leds", 1),
|
|
||||||
color_order=settings.get("color_order", "rgb"),
|
|
||||||
startup_mode=settings.get("startup_mode", "default"),
|
|
||||||
brightness=settings.get("brightness", 32),
|
|
||||||
)
|
|
||||||
try:
|
|
||||||
_esp.send(BROADCAST_MAC, pkt)
|
|
||||||
print("espnow announce", len(pkt), "B")
|
|
||||||
except Exception as e:
|
|
||||||
print("espnow announce failed:", e)
|
|
||||||
|
|
||||||
|
|
||||||
def _handle_packet(host, pkt, settings, presets):
|
|
||||||
global _groups_received, _ota_send
|
|
||||||
mt = wire_msg_type(pkt)
|
|
||||||
if mt is not None and MSG_OTA_FIRST <= mt <= MSG_OTA_LAST:
|
|
||||||
import espnow_ota
|
|
||||||
|
|
||||||
if _ota_send is None:
|
|
||||||
from espnow_rx import make_sender
|
|
||||||
|
|
||||||
_ota_send = make_sender(_esp)
|
|
||||||
espnow_ota.handle(host, pkt, _ota_send)
|
|
||||||
return
|
|
||||||
if mt == MSG_GROUPS:
|
|
||||||
ids = parse_groups(pkt)
|
|
||||||
if ids is not None:
|
|
||||||
dg.groups_replace(ids, settings)
|
|
||||||
_groups_received = True
|
|
||||||
print("groups", ids)
|
|
||||||
return
|
|
||||||
if mt == MSG_GROUP_CMD:
|
|
||||||
parsed = parse_group_cmd(pkt)
|
|
||||||
if parsed is None:
|
|
||||||
return
|
|
||||||
gid, env = parsed
|
|
||||||
if not dg.in_group(gid):
|
|
||||||
return
|
|
||||||
from espnow_wire import _envelope_size
|
|
||||||
|
|
||||||
need = _envelope_size(env)
|
|
||||||
save = len(env) > 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()
|
|
||||||
@@ -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("<H", int(num_leds))
|
|
||||||
+ bytes([co & 7, sm & 3, max(0, min(255, int(brightness))), device_type & 255])
|
|
||||||
)
|
|
||||||
return _pack_header(MSG_ANNOUNCE, body)
|
|
||||||
|
|
||||||
|
|
||||||
def parse_groups(payload):
|
|
||||||
if len(payload) >= 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("<I", int(ping_id) & 0xFFFFFFFF)
|
|
||||||
return _pack_header(MSG_PING_REQ, body)
|
|
||||||
|
|
||||||
|
|
||||||
def parse_ping_req(payload):
|
|
||||||
if len(payload) >= 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("<I", body[:4])[0]
|
|
||||||
|
|
||||||
|
|
||||||
def pack_ping_rsp(ping_id, name):
|
|
||||||
name_b = name.encode("utf-8")
|
|
||||||
body = struct.pack("<I", int(ping_id) & 0xFFFFFFFF) + bytes([len(name_b)]) + name_b
|
|
||||||
return _pack_header(MSG_PING_RSP, body)
|
|
||||||
|
|
||||||
|
|
||||||
def wire_msg_type(payload):
|
|
||||||
if len(payload) >= 2 and payload[0] == WIRE_MAGIC:
|
|
||||||
return payload[1]
|
|
||||||
return None
|
|
||||||
@@ -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
|
|
||||||
-174
@@ -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)
|
|
||||||
@@ -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"}
|
|
||||||
-128
@@ -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 <idx> <ticks_us>" 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
|
|
||||||
@@ -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())
|
|
||||||
@@ -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.
|
|
||||||
"""
|
|
||||||
@@ -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)
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
-156
@@ -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,
|
|
||||||
}
|
|
||||||
-324
@@ -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": <value>}
|
|
||||||
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()
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
-112
@@ -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()
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
@@ -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
|
|
||||||
-129
@@ -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
|
|
||||||
-419
@@ -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 <port> run tests/all.py
|
|
||||||
|
|
||||||
Or via dev helper::
|
|
||||||
|
|
||||||
python dev.py <port> 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()
|
|
||||||
@@ -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())
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -1,74 +0,0 @@
|
|||||||
#!/usr/bin/env python3
|
|
||||||
"""Standalone blink pattern demo (WDT-fed tick loop).
|
|
||||||
|
|
||||||
Run on device::
|
|
||||||
|
|
||||||
mpremote connect <port> 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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
|
|
||||||
@@ -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()
|
|
||||||
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
|
|
||||||
|
|
||||||
@@ -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()
|
|
||||||
|
|
||||||
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
|
|
||||||
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
|
|
||||||
|
|
||||||
@@ -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()
|
|
||||||
@@ -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()
|
|
||||||
@@ -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())
|
|
||||||
@@ -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()
|
|
||||||
@@ -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("<BBBHHB", 0x4C, 0x25, flags, idx, period, fire_in)
|
|
||||||
|
|
||||||
|
|
||||||
def run(events, tick=1):
|
|
||||||
"""events: (time_ms, frame_bytes). Returns the number of fires."""
|
|
||||||
b = BeatSync()
|
|
||||||
fires = 0
|
|
||||||
t = 0
|
|
||||||
end = events[-1][0] + 200
|
|
||||||
ev = list(events)
|
|
||||||
while t < end:
|
|
||||||
while ev and ev[0][0] <= t:
|
|
||||||
b.on_frame(ev.pop(0)[1], t)
|
|
||||||
if b.poll(t):
|
|
||||||
fires += 1
|
|
||||||
t += tick
|
|
||||||
return fires
|
|
||||||
|
|
||||||
|
|
||||||
def test_both_copies():
|
|
||||||
assert run([(0, frame(1)), (2, frame(1, fire_in=28))]) == 1
|
|
||||||
|
|
||||||
|
|
||||||
def test_only_first():
|
|
||||||
assert run([(0, frame(1))]) == 1
|
|
||||||
|
|
||||||
|
|
||||||
def test_only_second():
|
|
||||||
assert run([(2, frame(1, fire_in=28))]) == 1
|
|
||||||
|
|
||||||
|
|
||||||
def test_wraparound():
|
|
||||||
b = BeatSync()
|
|
||||||
assert b.on_frame(frame(0xFFFF), 0)
|
|
||||||
assert not b.on_frame(frame(0xFFFF), 2)
|
|
||||||
assert b.on_frame(frame(0), 500)
|
|
||||||
|
|
||||||
|
|
||||||
def test_late_old_copy_ignored():
|
|
||||||
b = BeatSync()
|
|
||||||
assert b.on_frame(frame(5), 0)
|
|
||||||
assert b.on_frame(frame(6), 500)
|
|
||||||
assert not b.on_frame(frame(5), 502)
|
|
||||||
|
|
||||||
|
|
||||||
def test_two_beats_two_fires():
|
|
||||||
ev = [(0, frame(1)), (2, frame(1)), (500, frame(2)), (502, frame(2))]
|
|
||||||
assert run(ev) == 2
|
|
||||||
|
|
||||||
|
|
||||||
def test_free_run_covers_missed_beat():
|
|
||||||
# beat 3 lost entirely: the driver still fires about once per period
|
|
||||||
ev = [(0, frame(1)), (2, frame(1)), (500, frame(2)), (502, frame(2)), (1500, frame(4)), (1502, frame(4))]
|
|
||||||
assert run(ev) == 4
|
|
||||||
|
|
||||||
|
|
||||||
def test_bad_frames():
|
|
||||||
b = BeatSync()
|
|
||||||
assert not b.on_frame(b"\x00" * 8, 0)
|
|
||||||
assert not b.on_frame(b"\xb1\x00", 0)
|
|
||||||
|
|
||||||
|
|
||||||
def test_freerun_flag_marks_invented_beats():
|
|
||||||
b = BeatSync()
|
|
||||||
b.on_frame(frame(1), 0)
|
|
||||||
assert b.poll(40) is True and b.freerun_fire is False
|
|
||||||
assert b.poll(700) is True and b.freerun_fire is True
|
|
||||||
|
|
||||||
|
|
||||||
def test_stats_count_dups_and_freerun():
|
|
||||||
b = BeatSync()
|
|
||||||
b.on_frame(frame(1), 0)
|
|
||||||
b.on_frame(frame(1), 2)
|
|
||||||
b.poll(40)
|
|
||||||
assert b.stats["fires"] == 1 and b.stats["dups"] == 1
|
|
||||||
b.poll(700)
|
|
||||||
assert b.stats["freerun"] == 1 and b.stats["fires"] == 2
|
|
||||||
|
|
||||||
|
|
||||||
def test_controller_restart_is_followed():
|
|
||||||
b = BeatSync()
|
|
||||||
assert b.on_frame(frame(29000), 0)
|
|
||||||
assert not b.on_frame(frame(1), 500) # looks old
|
|
||||||
assert not b.on_frame(frame(1), 502) # second copy of the same beat
|
|
||||||
assert not b.on_frame(frame(2), 1000)
|
|
||||||
assert b.on_frame(frame(3), 1500) # third consecutive: the counter really restarted
|
|
||||||
assert not b.on_frame(frame(3), 1502)
|
|
||||||
assert b.on_frame(frame(4), 2000)
|
|
||||||
|
|
||||||
|
|
||||||
def test_stray_old_frames_do_not_reset():
|
|
||||||
b = BeatSync()
|
|
||||||
assert b.on_frame(frame(100), 0)
|
|
||||||
assert not b.on_frame(frame(90), 100)
|
|
||||||
assert b.on_frame(frame(101), 500)
|
|
||||||
assert not b.on_frame(frame(99), 600)
|
|
||||||
assert not b.on_frame(frame(98), 700) # not consecutive upward
|
|
||||||
assert b.on_frame(frame(102), 1000)
|
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
for name, fn in list(globals().items()):
|
|
||||||
if name.startswith("test_"):
|
|
||||||
fn()
|
|
||||||
print("ok", name)
|
|
||||||
@@ -1,231 +0,0 @@
|
|||||||
#!/usr/bin/env python3
|
|
||||||
"""Ota: staging, chunk bitmap, hash checks, commit and sessions. Runs in a temp directory."""
|
|
||||||
import hashlib
|
|
||||||
import json
|
|
||||||
import os
|
|
||||||
import struct
|
|
||||||
import tempfile
|
|
||||||
|
|
||||||
import espnow_ota as o
|
|
||||||
import file_hashes
|
|
||||||
|
|
||||||
M = b"\x01\x02\x03\x04\x05\x06"
|
|
||||||
|
|
||||||
|
|
||||||
def begin(sess, path, body):
|
|
||||||
p = path.encode()
|
|
||||||
return struct.pack("<BBHI", 0x4C, o.OP_BEGIN, sess, len(body)) + hashlib.sha256(body).digest() + bytes([len(p)]) + p
|
|
||||||
|
|
||||||
|
|
||||||
def chunk(sess, body, idx):
|
|
||||||
return struct.pack("<BBHH", 0x4C, o.OP_DATA, sess, idx) + body[idx * o.CHUNK : (idx + 1) * o.CHUNK]
|
|
||||||
|
|
||||||
|
|
||||||
def cmd(op, sess):
|
|
||||||
return struct.pack("<BBH", 0x4C, op, sess)
|
|
||||||
|
|
||||||
|
|
||||||
def nchunks(body):
|
|
||||||
return (len(body) + o.CHUNK - 1) // o.CHUNK
|
|
||||||
|
|
||||||
|
|
||||||
class Rig:
|
|
||||||
def __init__(self):
|
|
||||||
self.sent, self.resets = [], 0
|
|
||||||
self.ota = o.Ota(lambda mac, f: self.sent.append(f), self._reset)
|
|
||||||
|
|
||||||
def _reset(self):
|
|
||||||
self.resets += 1
|
|
||||||
|
|
||||||
def __call__(self, pkt):
|
|
||||||
self.ota.handle(M, pkt)
|
|
||||||
if self.sent:
|
|
||||||
f = self.sent.pop()
|
|
||||||
_, t, sess, op, code = struct.unpack_from("<BBHBB", f)
|
|
||||||
assert t == o.MSG_STATUS
|
|
||||||
return op, code, f[6:]
|
|
||||||
return None
|
|
||||||
|
|
||||||
def send_file(self, sess, path, body, skip=()):
|
|
||||||
assert self(begin(sess, path, body))[1] == o.READY
|
|
||||||
for i in range(nchunks(body)):
|
|
||||||
if i not in skip:
|
|
||||||
assert self(chunk(sess, body, i)) is None # data is acked by the link, not here
|
|
||||||
return self(cmd(o.OP_END, sess))[1]
|
|
||||||
|
|
||||||
|
|
||||||
def in_tmp(fn):
|
|
||||||
def run():
|
|
||||||
old = os.getcwd()
|
|
||||||
with tempfile.TemporaryDirectory() as d:
|
|
||||||
os.chdir(d)
|
|
||||||
try:
|
|
||||||
fn()
|
|
||||||
finally:
|
|
||||||
os.chdir(old)
|
|
||||||
|
|
||||||
run.__name__ = fn.__name__
|
|
||||||
return run
|
|
||||||
|
|
||||||
|
|
||||||
BODY = bytes(range(256)) * 10 # 2560 bytes, 3 chunks
|
|
||||||
|
|
||||||
|
|
||||||
@in_tmp
|
|
||||||
def test_write_commit_and_manifest():
|
|
||||||
r = Rig()
|
|
||||||
assert r.send_file(5, "patterns/wave.py", BODY) == o.OK
|
|
||||||
assert not os.path.exists("patterns/wave.py") # staged only
|
|
||||||
op, code, arg = r(cmd(o.OP_COMMIT, 5))
|
|
||||||
assert (op, code, struct.unpack("<I", arg)[0]) == (o.OP_COMMIT, o.OK, 1)
|
|
||||||
assert open("patterns/wave.py", "rb").read() == BODY and not os.path.exists("patterns/wave.py.new")
|
|
||||||
assert file_hashes.load()["patterns/wave.py"] == hashlib.sha256(BODY).hexdigest()
|
|
||||||
assert r.resets == 1
|
|
||||||
|
|
||||||
|
|
||||||
@in_tmp
|
|
||||||
def test_same_file_is_skipped():
|
|
||||||
with open("main.py", "wb") as f:
|
|
||||||
f.write(BODY)
|
|
||||||
r = Rig()
|
|
||||||
assert r(begin(1, "main.py", BODY))[1] == o.SAME
|
|
||||||
op, code, _ = r(cmd(o.OP_COMMIT, 1))
|
|
||||||
assert code == o.OK and r.resets == 0 # nothing moved, no reset
|
|
||||||
|
|
||||||
|
|
||||||
@in_tmp
|
|
||||||
def test_out_of_order_and_duplicate_chunks():
|
|
||||||
r = Rig()
|
|
||||||
assert r(begin(2, "a.py", BODY))[1] == o.READY
|
|
||||||
for i in (2, 0, 2, 1, 0):
|
|
||||||
r(chunk(2, BODY, i))
|
|
||||||
assert r(cmd(o.OP_END, 2))[1] == o.OK
|
|
||||||
r(cmd(o.OP_COMMIT, 2))
|
|
||||||
assert open("a.py", "rb").read() == BODY
|
|
||||||
|
|
||||||
|
|
||||||
@in_tmp
|
|
||||||
def test_incomplete_then_missing_then_repair():
|
|
||||||
r = Rig()
|
|
||||||
assert r.send_file(3, "a.py", BODY, skip=(0, 2)) == o.INCOMPLETE
|
|
||||||
op, code, arg = r(cmd(o.OP_MISSING, 3))
|
|
||||||
cnt = struct.unpack_from("<H", arg)[0]
|
|
||||||
assert (op, cnt, arg[2]) == (o.OP_MISSING, 3, 0b101)
|
|
||||||
r(chunk(3, BODY, 0))
|
|
||||||
r(chunk(3, BODY, 2))
|
|
||||||
assert r(cmd(o.OP_MISSING, 3))[2][2] == 0
|
|
||||||
assert r(cmd(o.OP_END, 3))[1] == o.OK
|
|
||||||
|
|
||||||
|
|
||||||
@in_tmp
|
|
||||||
def test_bad_hash_is_not_staged():
|
|
||||||
r = Rig()
|
|
||||||
bad = bytearray(begin(4, "a.py", BODY))
|
|
||||||
bad[8] ^= 0xFF
|
|
||||||
assert r(bytes(bad))[1] == o.READY
|
|
||||||
for i in range(nchunks(BODY)):
|
|
||||||
r(chunk(4, BODY, i))
|
|
||||||
assert r(cmd(o.OP_END, 4))[1] == o.BADHASH
|
|
||||||
r(cmd(o.OP_COMMIT, 4))
|
|
||||||
assert not os.path.exists("a.py") and not os.path.exists("a.py.new") and r.resets == 0
|
|
||||||
|
|
||||||
|
|
||||||
@in_tmp
|
|
||||||
def test_bad_paths():
|
|
||||||
r = Rig()
|
|
||||||
for p in ("../x.py", "/main.py", "a/b.py", "lib//x.py", "file_hashes.json", "patterns\\x.py", "lib/../main.py"):
|
|
||||||
assert r(begin(6, p, b"x"))[1] == o.BADPATH, p
|
|
||||||
for p in ("main.py", "patterns/x.py", "lib/microdot/websocket.py"):
|
|
||||||
assert r(begin(6, p, b"x"))[1] == o.READY, p
|
|
||||||
|
|
||||||
|
|
||||||
@in_tmp
|
|
||||||
def test_new_session_discards_staged():
|
|
||||||
r = Rig()
|
|
||||||
assert r.send_file(7, "a.py", BODY) == o.OK
|
|
||||||
assert os.path.exists("a.py.new")
|
|
||||||
assert r(begin(8, "b.py", b"bb"))[1] == o.READY
|
|
||||||
assert not os.path.exists("a.py.new")
|
|
||||||
assert r(cmd(o.OP_COMMIT, 7))[1] == o.NOSESS # old session is gone
|
|
||||||
|
|
||||||
|
|
||||||
@in_tmp
|
|
||||||
def test_repeated_begin_and_end_are_idempotent():
|
|
||||||
r = Rig()
|
|
||||||
assert r(begin(9, "a.py", BODY))[1] == o.READY
|
|
||||||
r(chunk(9, BODY, 0))
|
|
||||||
assert r(begin(9, "a.py", BODY))[1] == o.READY # reply was lost, controller asks again
|
|
||||||
r(chunk(9, BODY, 1))
|
|
||||||
r(chunk(9, BODY, 2))
|
|
||||||
assert r(cmd(o.OP_END, 9))[1] == o.OK
|
|
||||||
assert r(cmd(o.OP_END, 9))[1] == o.OK
|
|
||||||
assert r(begin(9, "a.py", BODY))[1] == o.READY # already staged with that hash
|
|
||||||
|
|
||||||
|
|
||||||
@in_tmp
|
|
||||||
def test_abort_removes_staged():
|
|
||||||
r = Rig()
|
|
||||||
r.send_file(10, "a.py", BODY)
|
|
||||||
assert r(cmd(o.OP_ABORT, 10))[1] == o.OK
|
|
||||||
assert not os.path.exists("a.py.new")
|
|
||||||
assert r(cmd(o.OP_COMMIT, 10))[2] == struct.pack("<I", 0)
|
|
||||||
|
|
||||||
|
|
||||||
@in_tmp
|
|
||||||
def test_broadcast_with_loss_recovers():
|
|
||||||
# three drivers share one broadcast; each drops different chunks, then gets repaired by unicast
|
|
||||||
body = os.urandom(o.CHUNK * 7 + 100)
|
|
||||||
rigs = [Rig() for _ in range(3)]
|
|
||||||
for k, r in enumerate(rigs):
|
|
||||||
os.makedirs(str(k))
|
|
||||||
old = os.getcwd()
|
|
||||||
for k, r in enumerate(rigs):
|
|
||||||
os.chdir(str(k))
|
|
||||||
assert r(begin(11, "lib/x.py", body))[1] == o.READY
|
|
||||||
for i in range(nchunks(body)):
|
|
||||||
if (i + k) % 3:
|
|
||||||
r(chunk(11, body, i))
|
|
||||||
assert r(cmd(o.OP_END, 11))[1] == o.INCOMPLETE
|
|
||||||
arg = r(cmd(o.OP_MISSING, 11))[2]
|
|
||||||
cnt = struct.unpack_from("<H", arg)[0]
|
|
||||||
for i in range(cnt):
|
|
||||||
if arg[2 + (i >> 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("<I", pkt, 4, o.MAX_SIZE + 1)
|
|
||||||
assert r(bytes(pkt))[1] == o.TOOBIG
|
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
for name, fn in list(globals().items()):
|
|
||||||
if name.startswith("test_"):
|
|
||||||
fn()
|
|
||||||
print("ok")
|
|
||||||
Loaded 100 of 105 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user