lifx-emulator 2.2.1__tar.gz → 2.3.1__tar.gz

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/CLAUDE.md

@@ -128,8 +128,8 @@ lifx-emulator --help
 - `--multizone-extended`: Enable extended multizone support (default: True, use --no-multizone-extended to disable)
 - `--tile`: Number of tile devices
 - `--tile-count`: Tiles per device (uses product default if not specified)
-- `--tile-width`: Width of each tile in pixels (uses product default if not specified)
-- `--tile-height`: Height of each tile in pixels (uses product default if not specified)
+- `--tile-width`: Width of each tile in zones (uses product default if not specified)
+- `--tile-height`: Height of each tile in zones (uses product default if not specified)
 - `--serial-prefix`: serial prefix (6 hex chars, default: d073d5)
 - `--serial-start`: Starting serial suffix (default: 1)
 - `--api`: Enable HTTP API server for monitoring and management (default: False)
@@ -140,9 +140,9 @@ lifx-emulator --help
 **Product Defaults:**
 Device parameters like `--multizone-zones` and `--tile-count` automatically use product-specific defaults from the specs system when not specified:
 - LIFX Beam: Extended multizone support enabled and 80 zones by default
-- LIFX Tile: 5 tiles of 8x8 pixels by default
-- LIFX Candle: 1 tile of 5x6 pixels by default
-- LIFX Ceiling: 1 tile of 8x8 pixels by default
+- LIFX Tile: 5 tiles of 8x8 zones by default
+- LIFX Candle: 1 tile of 5x6 zones by default
+- LIFX Ceiling: 1 tile of 8x8 zones by default
 - These defaults can be overridden with command-line parameters
 
 **Firmware Version:**
@@ -523,6 +523,9 @@ delay = manager.get_response_delay(502, merged)  # 1.0s
 - Dataclass holding all device state (color, power, zones, tiles, firmware version, etc.)
 - Capability flags: `has_color`, `has_infrared`, `has_multizone`, `has_matrix`, `has_hev`
 - Initialized differently per device type via factory functions
+- **TileFramebuffers**: Internal dataclass for storing non-visible framebuffers (1-7) per tile
+  - Provides `get_framebuffer(fb_index, width, height)` for lazy initialization
+  - Framebuffer 0 remains in protocol-defined `tile_devices[i]["colors"]`
 
 ### Protocol Layer
 
@@ -748,6 +751,19 @@ product.supports_extended_multizone(131148)  # False (below requirement)
 - Tiles with more than 64 zones (16×8) require multiple Get64 requests with different y coordinates
 - Tile state stored in `DeviceState.tile_devices` list, each with `colors` array
 
+#### Framebuffer Support
+Matrix devices support 8 framebuffers (0-7) for advanced rendering:
+- **Framebuffer 0**: The visible buffer, stored in `tile_devices[i]["colors"]`
+- **Framebuffers 1-7**: Non-visible buffers, stored in `MatrixState.tile_framebuffers`
+- **Set64**: Respects `rect.fb_index` to update the specified framebuffer
+- **Get64**: Always returns framebuffer 0 (visible buffer) regardless of request `fb_index`
+- **CopyFrameBuffer**: Copies rectangular zones from one framebuffer to another
+  - Can copy from any FB (0-7) to any other FB (0-7)
+  - Supports source/destination offsets and partial rectangles
+  - Use to make non-visible buffers visible by copying to FB0
+- Framebuffers are lazily initialized on first access
+- Non-visible framebuffers are persisted with device state
+
 ### Testing Scenarios
 Configure via ScenarioConfig in HierarchicalScenarioManager:
 - `drop_packets`: Dict mapping packet type to drop rate (0.0-1.0, where 1.0 = always drop)

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lifx-emulator
-Version: 2.2.1
+Version: 2.3.1
 Summary: LIFX Emulator for testing LIFX LAN protocol libraries
 Author-email: Avi Miller <me@dje.li>
 Maintainer-email: Avi Miller <me@dje.li>

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/docs/advanced/device-management-api.md

@@ -266,8 +266,8 @@ Creates a new emulated device by product ID. The device will be added to the emu
 - `serial` (optional): Device serial (auto-generated if not provided)
 - `zone_count` (optional): Number of zones for multizone devices
 - `tile_count` (optional): Number of tiles for matrix devices
-- `tile_width` (optional): Width of each tile in pixels
-- `tile_height` (optional): Height of each tile in pixels
+- `tile_width` (optional): Width of each tile in zones
+- `tile_height` (optional): Height of each tile in zones
 - `firmware_major` (optional): Firmware major version
 - `firmware_minor` (optional): Firmware minor version
 

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/docs/advanced/scenario-api.md

@@ -788,8 +788,8 @@ jobs:
 | 506 | StateMultiZone | Response with zone colors |
 | 512 | ExtendedStateMultiZone | Response with extended zones |
 | 701 | GetDeviceChain | Get tile chain info |
-| 707 | Get64 | Get tile pixel data |
-| 715 | Set64 | Set tile pixel data |
+| 707 | Get64 | Get tile zone data |
+| 715 | Set64 | Set tile zone data |
 
 ## Tips and Best Practices
 

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/docs/api/device.md

@@ -90,8 +90,8 @@ Dataclass holding all stateful information for an emulated LIFX device.
 
 - **`tile_count`** (`int` = `0`) - Number of tiles in chain
 - **`tile_devices`** (`list[dict]` = `[]`) - Per-tile state (position, colors)
-- **`tile_width`** (`int` = `8`) - Width of each tile in pixels
-- **`tile_height`** (`int` = `8`) - Height of each tile in pixels
+- **`tile_width`** (`int` = `8`) - Width of each tile in zones
+- **`tile_height`** (`int` = `8`) - Height of each tile in zones
 
 #### Effects (Waveforms & Animations)
 

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/docs/api/products.md

@@ -239,8 +239,8 @@ Get detailed specifications for a product.
 - `zone_count`: Number of zones (multizone devices)
 - `extended_multizone`: Extended multizone support flag
 - `tile_count`: Default number of tiles (matrix devices)
-- `tile_width`: Tile width in pixels (matrix devices)
-- `tile_height`: Tile height in pixels (matrix devices)
+- `tile_width`: Tile width in zones (matrix devices)
+- `tile_height`: Tile height in zones (matrix devices)
 
 **Example:**
 ```python

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/docs/api/protocol.md

@@ -322,8 +322,8 @@ class TileStateDevice:
     accel_meas_z: int
     user_x: float         # User-configured X position
     user_y: float         # User-configured Y position
-    width: int            # Tile width in pixels (e.g., 8)
-    height: int           # Tile height in pixels (e.g., 8)
+    width: int            # Tile width in zones (e.g., 8)
+    height: int           # Tile height in zones (e.g., 8)
     device_version_vendor: int
     device_version_product: int
     device_version_version: int

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/docs/architecture/overview.md

@@ -253,7 +253,7 @@ Devices advertise capabilities through boolean flags:
 | `has_infrared` | IR brightness | LIFX A19 Night Vision |
 | `has_multizone` | Linear zones | LIFX Z, LIFX Beam |
 | `has_extended_multizone` | >16 zones | LIFX Beam |
-| `has_matrix` | 2D pixel grid | LIFX Tile, LIFX Candle |
+| `has_matrix` | 2D zone grid | LIFX Tile, LIFX Candle |
 | `has_hev` | HEV cleaning | LIFX Clean |
 
 ## Packet Types

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/docs/changelog.md

@@ -2,6 +2,22 @@
 
 <!-- version list -->
 
+## v2.3.1 (2025-11-18)
+
+### Bug Fixes
+
+- **tile**: Implement backwards compatibility on tile and multizone devices
+  ([`be473f7`](https://github.com/Djelibeybi/lifx-emulator/commit/be473f74f9a49be7f07082d5bfba16f5d74f46f6))
+
+
+## v2.3.0 (2025-11-18)
+
+### Features
+
+- **tile**: Implement multi-framebuffer support for matrix devices
+  ([`16a69ca`](https://github.com/Djelibeybi/lifx-emulator/commit/16a69cacbdf0472d8f7116eb0acfda9808431c5c))
+
+
 ## v2.2.1 (2025-11-18)
 
 ### Bug Fixes

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/docs/getting-started/cli.md

@@ -197,16 +197,16 @@ Number of tiles per tile device. If not specified, uses product default (5 for L
 - **Default:** `None` (uses product defaults)
 - **Example:** `--tile-count 10`
 
-### `--tile-width <PIXELS>`
+### `--tile-width <zones>`
 
-Width of each tile in pixels. If not specified, uses product default (typically 8).
+Width of each tile in zones. If not specified, uses product default (typically 8).
 
 - **Default:** `None` (uses product defaults)
 - **Example:** `--tile-width 16`
 
-### `--tile-height <PIXELS>`
+### `--tile-height <zones>`
 
-Height of each tile in pixels. If not specified, uses product default (typically 8).
+Height of each tile in zones. If not specified, uses product default (typically 8).
 
 - **Default:** `None` (uses product defaults)
 - **Example:** `--tile-height 8`

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/docs/guide/device-types.md

@@ -297,7 +297,7 @@ print(f"Tile height: {device.state.tile_height}")  # 8
 
 # Access tile devices
 for i, tile in enumerate(device.state.tile_devices):
-    print(f"Tile {i}: {tile.width}x{tile.height} pixels")
+    print(f"Tile {i}: {tile.width}x{tile.height} zones")
 ```
 
 ### Matrix Packet Types
@@ -329,6 +329,17 @@ single tile.
 # split either by row or column.
 ```
 
+### Framebuffers (v2.3+)
+
+Matrix devices support **8 framebuffers (0-7)** to enable atomic updates of tiles with more than 64 zones:
+
+- **Framebuffer 0**: Visible buffer (displayed on device)
+- **Framebuffers 1-7**: Non-visible buffers for preparing content off-screen
+
+For large tiles (>64 zones), prepare all zones in a non-visible framebuffer, then use `CopyFrameBuffer` to atomically display them without flicker.
+
+See [Framebuffer Guide](framebuffers.md) for complete documentation and examples.
+
 
 ## Using Generic create_device()
 

lifx_emulator-2.3.1/docs/guide/framebuffers.md

@@ -0,0 +1,209 @@
+# Matrix Framebuffer Support
+
+Matrix devices with more than 64 zones require multiple Set64 packets to update all zones. Framebuffers enable atomic updates by allowing you to prepare all zones off-screen before displaying them.
+
+## Overview
+
+Matrix devices support **8 framebuffers (0-7)**:
+
+- **Framebuffer 0**: The visible buffer displayed on the device
+- **Framebuffers 1-7**: Non-visible buffers for preparing content
+
+## Why Framebuffers Matter
+
+For large tiles (>64 zones), such as the LIFX Ceiling 13"x26" with 128 zones (16×8):
+
+**Without framebuffers:**
+```
+Set64(fb=0, zones 0-63)   → Visible immediately (partial update)
+Set64(fb=0, zones 64-127) → Visible immediately (flicker as zones update)
+```
+
+**With framebuffers:**
+```
+Set64(fb=1, zones 0-63)      → Prepared off-screen
+Set64(fb=1, zones 64-127)    → Prepared off-screen
+CopyFrameBuffer(fb=1 → fb=0) → All 128 zones appear atomically
+```
+
+## Framebuffer Operations
+
+### Set64 - Update Zones
+
+The `rect.fb_index` field specifies which framebuffer to update:
+
+```python
+from lifx_emulator.protocol.packets import Tile
+from lifx_emulator.protocol.protocol_types import TileBufferRect, LightHsbk
+
+# Update visible framebuffer (immediate display)
+rect = TileBufferRect(fb_index=0, x=0, y=0, width=8)
+packet = Tile.Set64(
+    tile_index=0,
+    rect=rect,
+    duration=0,
+    colors=[...64 colors...]
+)
+
+# Update non-visible framebuffer 1 (off-screen)
+rect = TileBufferRect(fb_index=1, x=0, y=0, width=8)
+packet = Tile.Set64(
+    tile_index=0,
+    rect=rect,
+    duration=0,
+    colors=[...64 colors...]
+)
+```
+
+### Get64 - Read Zones
+
+Get64 **always returns framebuffer 0** (the visible buffer), regardless of the `fb_index` in the request:
+
+```python
+# Request can specify any fb_index
+rect = TileBufferRect(fb_index=1, x=0, y=0, width=8)
+packet = Tile.Get64(tile_index=0, rect=rect)
+
+# Response will contain framebuffer 0 content
+# Response rect.fb_index is always 0
+```
+
+### CopyFrameBuffer - Atomic Display
+
+Copy zones between framebuffers to make prepared content visible:
+
+```python
+# Copy entire framebuffer 1 to framebuffer 0 (make visible)
+packet = Tile.CopyFrameBuffer(
+    tile_index=0,
+    src_fb_index=1,
+    dst_fb_index=0,
+    src_x=0,
+    src_y=0,
+    dst_x=0,
+    dst_y=0,
+    width=16,
+    height=8,
+    duration=0
+)
+```
+
+## Complete Example: Updating a 16×8 Tile
+
+```python
+from lifx_emulator import create_tile_device
+from lifx_emulator.protocol.packets import Tile
+from lifx_emulator.protocol.protocol_types import TileBufferRect, LightHsbk
+
+# Create 16×8 tile (128 zones)
+device = create_tile_device(
+    serial="d073dc000001",
+    tile_count=1,
+    tile_width=16,
+    tile_height=8
+)
+
+# Prepare colors for all 128 zones
+red = LightHsbk(hue=0, saturation=65535, brightness=65535, kelvin=3500)
+green = LightHsbk(hue=21845, saturation=65535, brightness=65535, kelvin=3500)
+
+# Step 1: Update first 64 zones in framebuffer 1 (rows 0-3)
+rect1 = TileBufferRect(fb_index=1, x=0, y=0, width=16)
+set1 = Tile.Set64(
+    tile_index=0,
+    rect=rect1,
+    duration=0,
+    colors=[red] * 64
+)
+device.process_packet(header, set1)
+
+# Step 2: Update next 64 zones in framebuffer 1 (rows 4-7)
+rect2 = TileBufferRect(fb_index=1, x=0, y=4, width=16)
+set2 = Tile.Set64(
+    tile_index=0,
+    rect=rect2,
+    duration=0,
+    colors=[green] * 64
+)
+device.process_packet(header, set2)
+
+# Step 3: Atomically display all 128 zones
+copy = Tile.CopyFrameBuffer(
+    tile_index=0,
+    src_fb_index=1,
+    dst_fb_index=0,
+    src_x=0,
+    src_y=0,
+    dst_x=0,
+    dst_y=0,
+    width=16,
+    height=8,
+    duration=0
+)
+device.process_packet(header, copy)
+
+# All 128 zones now visible without flicker
+```
+
+## Implementation Details
+
+### Storage
+
+- **Framebuffer 0**: Stored in `tile_devices[i]["colors"]` (protocol-defined)
+- **Framebuffers 1-7**: Stored in `MatrixState.tile_framebuffers` (internal)
+
+### Lazy Initialization
+
+Non-visible framebuffers are created on first access:
+
+```python
+# First Set64 to framebuffer 2 creates it automatically
+# Initialized with black (hue=0, saturation=0, brightness=0)
+```
+
+### Persistence
+
+Non-visible framebuffers are saved with device state when persistence is enabled:
+
+```bash
+lifx-emulator --persistent --tile 1
+```
+
+## Best Practices
+
+### For Tiles ≤64 Zones
+Update framebuffer 0 directly (no need for off-screen preparation):
+
+```python
+rect = TileBufferRect(fb_index=0, x=0, y=0, width=8)
+```
+
+### For Tiles >64 Zones
+Always use a non-visible framebuffer:
+
+1. Prepare all zones in framebuffer 1-7
+2. Use CopyFrameBuffer to make visible
+3. Prevents flicker during multi-packet updates
+
+### Partial Updates
+Use CopyFrameBuffer with specific rectangles:
+
+```python
+# Copy only top-left 4×4 area
+copy = Tile.CopyFrameBuffer(
+    src_fb_index=1,
+    dst_fb_index=0,
+    src_x=0,
+    src_y=0,
+    dst_x=0,
+    dst_y=0,
+    width=4,
+    height=4,
+    duration=0
+)
+```
+
+## Related Documentation
+
+- [Device Types](device-types.md#matrix-devices) - Matrix device capabilities
+- [Protocol](../architecture/protocol.md) - LIFX LAN protocol details

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/docs/guide/products-and-specs.md

@@ -31,7 +31,7 @@ Contains product-specific details not available in the upstream catalog:
 - Min/max zone counts
 - Default tile counts for matrix devices
 - Min/max tile counts
-- Tile dimensions (width x height in pixels)
+- Tile dimensions (width x height in zones)
 - Product-specific notes
 
 ### `specs.py`
@@ -81,8 +81,8 @@ products:
     default_tile_count: <number>    # Typical number of tiles in chain
     min_tile_count: <number>        # Minimum tiles supported
     max_tile_count: <number>        # Maximum tiles supported
-    tile_width: <pixels>            # Width of each tile
-    tile_height: <pixels>           # Height of each tile
+    tile_width: <zones>            # Width of each tile
+    tile_height: <zones>           # Height of each tile
     notes: "<description>"
 ```
 
@@ -95,7 +95,7 @@ products:
     max_tile_count: 5
     tile_width: 8
     tile_height: 8
-    notes: "LIFX Tile, 8x8 pixel matrix, chainable up to 5"
+    notes: "LIFX Tile, 8x8 zone matrix, chainable up to 5"
 ```
 
 **Example - LIFX Candle:**
@@ -107,7 +107,7 @@ products:
     max_tile_count: 1
     tile_width: 5
     tile_height: 6
-    notes: "LIFX Candle, 5x6 pixel matrix, single unit"
+    notes: "LIFX Candle, 5x6 zone matrix, single unit"
 ```
 
 **Example - LIFX Ceiling:**
@@ -119,7 +119,7 @@ products:
     max_tile_count: 1
     tile_width: 22
     tile_height: 22
-    notes: "LIFX Ceiling, 22x22 pixel matrix"
+    notes: "LIFX Ceiling, 22x22 zone matrix"
 ```
 
 ## How Specifications Are Used
@@ -149,16 +149,16 @@ When creating a matrix device:
 2. **Tile count**: From `specs.yml` if not specified by user
 
 ```python
-# Uses specification: 5 tiles of 8x8 pixels
+# Uses specification: 5 tiles of 8x8 zones
 device = create_device(55)
 
 # Custom tile count, specification dimensions
-device = create_device(55, tile_count=3)  # 3 tiles of 8x8 pixels
+device = create_device(55, tile_count=3)  # 3 tiles of 8x8 zones
 
-# Candle: 1 tile of 5x5 pixels (from specification)
+# Candle: 1 tile of 5x5 zones (from specification)
 device = create_device(57)
 
-# Ceiling: 1 tile of 22x22 pixels (from specification)
+# Ceiling: 1 tile of 22x22 zones (from specification)
 device = create_device(176)
 ```
 

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/docs/guide/web-interface.md

@@ -142,7 +142,7 @@ For matrix/tile devices:
 ```
 ▸ Show tiles (5)  (click to expand)
   ┌──────────┐
-  │ T1       │  (8×8 pixel grid)
+  │ T1       │  (8×8 zone grid)
   │ ████████ │
   │ ████████ │
   │ ████████ │
@@ -249,8 +249,8 @@ For matrix devices (tiles, candles, ceiling):
 
 1. Locate device in Devices section
 2. Click "▸ Show tiles" to expand
-3. Grid display shows pixel colors
-4. Each small square is one pixel
+3. Grid display shows zone colors
+4. Each small square is one zone
 5. Tiles labeled T1, T2, etc.
 6. Click again to collapse
 

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/docs/index.md

@@ -71,7 +71,7 @@ LIFX Emulator is a Python library and CLI tool that creates virtual LIFX devices
 | Infrared | LIFX A19 Night Vision | IR brightness control |
 | HEV | LIFX Clean | HEV cleaning cycle |
 | Multizone | LIFX Z, LIFX Beam | Linear zones (up to 82) |
-| Matrix | LIFX Tile, LIFX Candle | 2D pixel arrays |
+| Matrix | LIFX Tile, LIFX Candle | 2D zone arrays |
 
 ## Use Cases
 

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/docs/tutorials/04-advanced-scenarios.md

@@ -84,7 +84,7 @@ async def main():
     # Create a LIFX Tile with 5 tiles in the chain
     device = create_tile_device("d073d9000001", tile_count=5)
 
-    # Each tile is 8x8 pixels (64 zones)
+    # Each tile is 8x8 zones (64 zones)
     print(f"Tile device configuration:")
     print(f"  Tiles: {len(device.state.tile_devices)}")
     for i, tile in enumerate(device.state.tile_devices):

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lifx-emulator"
-version = "2.2.1"
+version = "2.3.1"
 description = "LIFX Emulator for testing LIFX LAN protocol libraries"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -73,7 +73,7 @@ docstring-code-format = true
 docstring-code-line-length = "dynamic"
 
 [tool.ruff.lint]
-select = ["E", "F", "I", "N", "W", "UP", "C90"]  # C90 = mccabe complexity
+select = ["E", "F", "I", "N", "W", "UP"]
 ignore = []
 
 # Complexity and code quality limits
@@ -86,12 +86,8 @@ max-branches = 12
 max-statements = 50
 
 [tool.ruff.lint.per-file-ignores]
-"src/lifx_emulator/__main__.py" = ["C901"]
-"src/lifx_emulator/devices/state_restorer.py" = ["C901"]
-"src/lifx_emulator/protocol/generator.py" = ["E501", "C901"]
+"src/lifx_emulator/protocol/generator.py" = ["E501"]
 "src/lifx_emulator/protocol/packets.py" = ["E501"]
-"src/lifx_emulator/products/registry.py" = ["C901"]
-"src/lifx_emulator/scenarios/persistence.py" = ["C901"]
 
 
 [tool.pyright]

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/src/lifx_emulator/__main__.py

@@ -286,9 +286,9 @@ async def run(
         tile: Number of tile/matrix chain devices.
         tile_count: Number of tiles per device. Uses product defaults if not
             specified (5 for Tile, 1 for Candle/Ceiling).
-        tile_width: Width of each tile in pixels. Uses product defaults if not
+        tile_width: Width of each tile in zones. Uses product defaults if not
             specified (8 for most devices).
-        tile_height: Height of each tile in pixels. Uses product defaults if
+        tile_height: Height of each tile in zones. Uses product defaults if
             not specified (8 for most devices).
         serial_prefix: Serial number prefix as 6 hex characters.
         serial_start: Starting serial suffix for auto-incrementing device serials.

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/src/lifx_emulator/api/models.py

@@ -25,10 +25,10 @@ class DeviceCreateRequest(BaseModel):
         None, description="Number of tiles for matrix devices", ge=0, le=100
     )
     tile_width: int | None = Field(
-        None, description="Width of each tile in pixels", ge=1, le=256
+        None, description="Width of each tile in zones", ge=1, le=256
     )
     tile_height: int | None = Field(
-        None, description="Height of each tile in pixels", ge=1, le=256
+        None, description="Height of each tile in zones", ge=1, le=256
     )
     firmware_major: int | None = Field(
         None, description="Firmware major version", ge=0, le=255

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/src/lifx_emulator/api/templates/dashboard.html

@@ -163,7 +163,7 @@
             gap: 2px;
             margin-top: 4px;
         }
-        .tile-pixel {
+        .tile-zone {
             width: 8px;
             height: 8px;
             border-radius: 1px;
@@ -644,7 +644,7 @@
                     `;
                 } else if (dev.has_matrix && dev.tile_devices &&
                            dev.tile_devices.length > 0) {
-                    // Render actual tile pixels
+                    // Render actual tile zones
                     const tilesHtml = dev.tile_devices.map((tile, tileIndex) => {
                         if (!tile.colors || tile.colors.length === 0) {
                             return '<div style="color: #666;">No color data</div>';
@@ -652,14 +652,14 @@
 
                         const width = tile.width || 8;
                         const height = tile.height || 8;
-                        const totalPixels = width * height;
+                        const totalzones = width * height;
 
-                        // Create grid of pixels
-                        const slicedColors = tile.colors.slice(0, totalPixels);
-                        const pixelsHtml = slicedColors.map(color => {
+                        // Create grid of zones
+                        const slicedColors = tile.colors.slice(0, totalzones);
+                        const zonesHtml = slicedColors.map(color => {
                             const rgb = hsbkToRgb(color);
                             const bgStyle = `background: ${rgb};`;
-                            return `<div class="tile-pixel" style="${bgStyle}"></div>`;
+                            return `<div class="tile-zone" style="${bgStyle}"></div>`;
                         }).join('');
 
                         const labelStyle = (
@@ -675,7 +675,7 @@
                                     T${tileIndex + 1}
                                 </div>
                                 <div class="tile-grid" style="${gridStyle}">
-                                    ${pixelsHtml}
+                                    ${zonesHtml}
                                 </div>
                             </div>
                         `;

{lifx_emulator-2.2.1 → lifx_emulator-2.3.1}/src/lifx_emulator/devices/device.py

@@ -9,7 +9,7 @@ import time
 from typing import Any
 
 from lifx_emulator.constants import LIFX_HEADER_SIZE
-from lifx_emulator.devices.states import DeviceState
+from lifx_emulator.devices.states import DeviceState, TileFramebuffers
 from lifx_emulator.handlers import HandlerRegistry, create_default_registry
 from lifx_emulator.protocol.header import LifxHeader
 from lifx_emulator.protocol.packets import (
@@ -90,10 +90,10 @@ class EmulatedLifxDevice:
         if self.state.has_matrix and self.state.tile_count > 0:
             if not self.state.tile_devices:
                 for i in range(self.state.tile_count):
-                    pixels = self.state.tile_width * self.state.tile_height
+                    zones = self.state.tile_width * self.state.tile_height
                     tile_colors = [
                         LightHsbk(hue=0, saturation=0, brightness=32768, kelvin=3500)
-                        for _ in range(pixels)
+                        for _ in range(zones)
                     ]
 
                     self.state.tile_devices.append(
@@ -114,6 +114,12 @@ class EmulatedLifxDevice:
                         }
                     )
 
+            # Initialize framebuffer storage for each tile (framebuffers 1-7)
+            # Framebuffer 0 is stored in tile_devices[i]["colors"]
+            if not self.state.tile_framebuffers:
+                for i in range(self.state.tile_count):
+                    self.state.tile_framebuffers.append(TileFramebuffers(tile_index=i))
+
         # Save initial state if persistence is enabled
         # This ensures newly created devices are immediately persisted
         if self.storage: