lifx-emulator 2.2.1__py3-none-any.whl → 2.3.1__py3-none-any.whl

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/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/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/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:

lifx_emulator/devices/state_serializer.py

@@ -97,6 +97,17 @@ def serialize_device_state(device_state: Any) -> dict[str, Any]:
             }
             for t in device_state.tile_devices
         ]
+        # Serialize tile framebuffers (non-visible framebuffers 1-7)
+        state_dict["tile_framebuffers"] = [
+            {
+                "tile_index": fb.tile_index,
+                "framebuffers": {
+                    str(fb_idx): [serialize_hsbk(c) for c in colors]
+                    for fb_idx, colors in fb.framebuffers.items()
+                },
+            }
+            for fb in device_state.tile_framebuffers
+        ]
 
     return state_dict
 
@@ -127,4 +138,20 @@ def deserialize_device_state(state_dict: dict[str, Any]) -> dict[str, Any]:
         for tile_dict in state_dict["tile_devices"]:
             tile_dict["colors"] = [deserialize_hsbk(c) for c in tile_dict["colors"]]
 
+    # Deserialize tile framebuffers if present (for backwards compatibility)
+    if "tile_framebuffers" in state_dict:
+        from lifx_emulator.devices.states import TileFramebuffers
+
+        deserialized_fbs = []
+        for fb_dict in state_dict["tile_framebuffers"]:
+            tile_fb = TileFramebuffers(tile_index=fb_dict["tile_index"])
+            # Deserialize each framebuffer's colors
+            for fb_idx_str, colors_list in fb_dict["framebuffers"].items():
+                fb_idx = int(fb_idx_str)
+                tile_fb.framebuffers[fb_idx] = [
+                    deserialize_hsbk(c) for c in colors_list
+                ]
+            deserialized_fbs.append(tile_fb)
+        state_dict["tile_framebuffers"] = deserialized_fbs
+
     return state_dict

lifx_emulator/devices/states.py

@@ -82,6 +82,32 @@ class MultiZoneState:
     effect_speed: int = 5  # Duration of one cycle in seconds
 
 
+@dataclass
+class TileFramebuffers:
+    """Internal storage for non-visible tile framebuffers (1-7).
+
+    Framebuffer 0 is stored in tile_devices[i]["colors"] (the visible buffer).
+    Framebuffers 1-7 are stored here for Set64/CopyFrameBuffer operations.
+    Each framebuffer is a list of LightHsbk colors with length = width * height.
+    """
+
+    tile_index: int  # Which tile this belongs to
+    framebuffers: dict[int, list[LightHsbk]] = field(default_factory=dict)
+
+    def get_framebuffer(
+        self, fb_index: int, width: int, height: int
+    ) -> list[LightHsbk]:
+        """Get framebuffer by index, creating it if needed."""
+        if fb_index not in self.framebuffers:
+            # Initialize with default black color
+            zones = width * height
+            self.framebuffers[fb_index] = [
+                LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
+                for _ in range(zones)
+            ]
+        return self.framebuffers[fb_index]
+
+
 @dataclass
 class MatrixState:
     """Matrix (tile/candle) capability state."""
@@ -101,6 +127,9 @@ class MatrixState:
     effect_cloud_sat_max: int = (
         0  # Max cloud saturation 0-200 (only when effect_type=5)
     )
+    # Internal storage for non-visible framebuffers (1-7) per tile
+    # Framebuffer 0 remains in tile_devices[i]["colors"]
+    tile_framebuffers: list[TileFramebuffers] = field(default_factory=list)
 
 
 @dataclass
@@ -215,6 +244,7 @@ class DeviceState:
         "tile_effect_sky_type": ("matrix", "effect_sky_type"),
         "tile_effect_cloud_sat_min": ("matrix", "effect_cloud_sat_min"),
         "tile_effect_cloud_sat_max": ("matrix", "effect_cloud_sat_max"),
+        "tile_framebuffers": "matrix",
     }
 
     # Default values for optional state attributes when state object is None
@@ -240,6 +270,7 @@ class DeviceState:
         "tile_effect_sky_type": 0,
         "tile_effect_cloud_sat_min": 0,
         "tile_effect_cloud_sat_max": 0,
+        "tile_framebuffers": [],
     }
 
     def get_target_bytes(self) -> bytes:

lifx_emulator/factories/builder.py

@@ -136,8 +136,8 @@ class DeviceBuilder:
         """Set tile dimensions for matrix devices.
 
         Args:
-            width: Tile width in pixels
-            height: Tile height in pixels
+            width: Tile width in zones
+            height: Tile height in zones
 
         Returns:
             Self for method chaining

lifx_emulator/factories/factory.py

@@ -104,8 +104,8 @@ def create_tile_device(
     Args:
         serial: Optional serial
         tile_count: Optional tile count (uses product default)
-        tile_width: Optional tile width in pixels (uses product default)
-        tile_height: Optional tile height in pixels (uses product default)
+        tile_width: Optional tile width in zones (uses product default)
+        tile_height: Optional tile height in zones (uses product default)
         firmware_version: Optional firmware version tuple (major, minor)
         storage: Optional storage for persistence
         scenario_manager: Optional scenario manager
@@ -164,8 +164,8 @@ def create_device(
         zone_count: Number of zones for multizone devices (auto-determined)
         extended_multizone: Enable extended multizone requests
         tile_count: Number of tiles for matrix devices (default: 5)
-        tile_width: Width of each tile in pixels (default: 8)
-        tile_height: Height of each tile in pixels (default: 8)
+        tile_width: Width of each tile in zones (default: 8)
+        tile_height: Height of each tile in zones (default: 8)
         firmware_version: Optional firmware version tuple (major, minor).
                          If not specified, uses 3.70 for extended_multizone
                          or 2.60 otherwise

lifx_emulator/handlers/light_handlers.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, Any
 
 from lifx_emulator.handlers.base import PacketHandler
 from lifx_emulator.protocol.packets import Light
-from lifx_emulator.protocol.protocol_types import LightLastHevCycleResult
+from lifx_emulator.protocol.protocol_types import LightHsbk, LightLastHevCycleResult
 
 if TYPE_CHECKING:
     from lifx_emulator.devices import DeviceState
@@ -15,6 +15,72 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+def _compute_average_color(colors: list[LightHsbk]) -> LightHsbk:
+    """Compute average HSBK color from a list of LightHsbk colors.
+
+    Uses circular mean for hue to correctly handle hue wraparound
+    (e.g., average of 10° and 350° is 0°, not 180°).
+
+    Args:
+        colors: List of LightHsbk colors to average
+
+    Returns:
+        LightHsbk with averaged values using circular mean for hue
+    """
+    import math
+
+    if not colors:
+        return LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
+
+    # Convert uint16 values to proper ranges and calculate circular mean
+    hue_x_total = 0.0
+    hue_y_total = 0.0
+    saturation_total = 0.0
+    brightness_total = 0.0
+    kelvin_total = 0
+
+    for color in colors:
+        # Convert uint16 hue (0-65535) to degrees (0-360)
+        hue_deg = round(float(color.hue) * 360 / 0x10000, 2)
+
+        # Convert uint16 sat/bright (0-65535) to float (0-1)
+        sat_float = round(float(color.saturation) / 0xFFFF, 4)
+        bright_float = round(float(color.brightness) / 0xFFFF, 4)
+
+        # Circular mean calculation for hue using sin/cos
+        hue_x_total += math.sin(hue_deg * 2.0 * math.pi / 360)
+        hue_y_total += math.cos(hue_deg * 2.0 * math.pi / 360)
+
+        # Regular sums for other components
+        saturation_total += sat_float
+        brightness_total += bright_float
+        kelvin_total += color.kelvin
+
+    # Calculate circular mean for hue
+    hue = math.atan2(hue_x_total, hue_y_total) / (2.0 * math.pi)
+    if hue < 0.0:
+        hue += 1.0
+    hue *= 360
+    hue = round(hue, 4)
+
+    # Calculate arithmetic means for other components
+    saturation = round(saturation_total / len(colors), 4)
+    brightness = round(brightness_total / len(colors), 4)
+    kelvin = round(kelvin_total / len(colors))
+
+    # Convert back to uint16 values
+    uint16_hue = int(round(0x10000 * hue) / 360) % 0x10000
+    uint16_saturation = int(round(0xFFFF * saturation))
+    uint16_brightness = int(round(0xFFFF * brightness))
+
+    return LightHsbk(
+        hue=uint16_hue,
+        saturation=uint16_saturation,
+        brightness=uint16_brightness,
+        kelvin=kelvin,
+    )
+
+
 class GetColorHandler(PacketHandler):
     """Handle LightGet (101) -> LightState (107)."""
 
@@ -23,9 +89,24 @@ class GetColorHandler(PacketHandler):
     def handle(
         self, device_state: DeviceState, packet: Any | None, res_required: bool
     ) -> list[Any]:
+        # For multizone/matrix devices, compute average color from all zones
+        # This provides backwards compatibility with clients that don't use
+        # zone-specific or tile-specific packets
+        color_to_return = device_state.color
+
+        if device_state.has_multizone and device_state.zone_colors:
+            # Return average of all zone colors
+            color_to_return = _compute_average_color(device_state.zone_colors)
+        elif device_state.has_matrix and device_state.tile_devices:
+            # Collect all zone colors from all tiles
+            all_zones = []
+            for tile in device_state.tile_devices:
+                all_zones.extend(tile["colors"])
+            color_to_return = _compute_average_color(all_zones)
+
         return [
             Light.StateColor(
-                color=device_state.color,
+                color=color_to_return,
                 power=device_state.power_level,
                 label=device_state.label,
             )
@@ -46,10 +127,36 @@ class SetColorHandler(PacketHandler):
         if packet:
             device_state.color = packet.color
             c = packet.color
-            logger.info(
-                f"Color set to HSBK({c.hue}, {c.saturation}, "
-                f"{c.brightness}, {c.kelvin}), duration={packet.duration}ms"
-            )
+
+            # For backwards compatibility: propagate color to all zones
+            # Multizone devices: update all zone colors
+            if device_state.has_multizone and device_state.zone_colors:
+                for i in range(len(device_state.zone_colors)):
+                    device_state.zone_colors[i] = packet.color
+                logger.info(
+                    f"Color set to HSBK({c.hue}, {c.saturation}, "
+                    f"{c.brightness}, {c.kelvin}) across all "
+                    f"{len(device_state.zone_colors)} zones, "
+                    f"duration={packet.duration}ms"
+                )
+            # Matrix devices: update all tile zones
+            elif device_state.has_matrix and device_state.tile_devices:
+                total_zones = 0
+                for tile in device_state.tile_devices:
+                    for i in range(len(tile["colors"])):
+                        tile["colors"][i] = packet.color
+                    total_zones += len(tile["colors"])
+                logger.info(
+                    f"Color set to HSBK({c.hue}, {c.saturation}, "
+                    f"{c.brightness}, {c.kelvin}) across all {total_zones} zones, "
+                    f"duration={packet.duration}ms"
+                )
+            else:
+                # Simple color device
+                logger.info(
+                    f"Color set to HSBK({c.hue}, {c.saturation}, "
+                    f"{c.brightness}, {c.kelvin}), duration={packet.duration}ms"
+                )
 
         if res_required:
             return [
@@ -120,6 +227,17 @@ class SetWaveformHandler(PacketHandler):
             if not packet.transient:
                 device_state.color = packet.color
 
+                # For backwards compatibility: propagate color to all zones
+                # Multizone devices: update all zone colors
+                if device_state.has_multizone and device_state.zone_colors:
+                    for i in range(len(device_state.zone_colors)):
+                        device_state.zone_colors[i] = packet.color
+                # Matrix devices: update all tile zones
+                elif device_state.has_matrix and device_state.tile_devices:
+                    for tile in device_state.tile_devices:
+                        for i in range(len(tile["colors"])):
+                            tile["colors"][i] = packet.color
+
             logger.info(
                 f"Waveform set: type={packet.waveform}, "
                 f"transient={packet.transient}, period={packet.period}ms, "
@@ -127,13 +245,9 @@ class SetWaveformHandler(PacketHandler):
             )
 
         if res_required:
-            return [
-                Light.StateColor(
-                    color=device_state.color,
-                    power=device_state.power_level,
-                    label=device_state.label,
-                )
-            ]
+            # Use GetColorHandler to get proper averaged color if needed
+            handler = GetColorHandler()
+            return handler.handle(device_state, None, res_required)
         return []
 
 
@@ -168,6 +282,31 @@ class SetWaveformOptionalHandler(PacketHandler):
                 if packet.set_kelvin:
                     device_state.color.kelvin = packet.color.kelvin
 
+                # Backwards compatibility propagates color changes to zones
+                # Multizone devices: update all zone colors
+                if device_state.has_multizone and device_state.zone_colors:
+                    for zone_color in device_state.zone_colors:
+                        if packet.set_hue:
+                            zone_color.hue = packet.color.hue
+                        if packet.set_saturation:
+                            zone_color.saturation = packet.color.saturation
+                        if packet.set_brightness:
+                            zone_color.brightness = packet.color.brightness
+                        if packet.set_kelvin:
+                            zone_color.kelvin = packet.color.kelvin
+                # Matrix devices: update all tile zones
+                elif device_state.has_matrix and device_state.tile_devices:
+                    for tile in device_state.tile_devices:
+                        for zone_color in tile["colors"]:
+                            if packet.set_hue:
+                                zone_color.hue = packet.color.hue
+                            if packet.set_saturation:
+                                zone_color.saturation = packet.color.saturation
+                            if packet.set_brightness:
+                                zone_color.brightness = packet.color.brightness
+                            if packet.set_kelvin:
+                                zone_color.kelvin = packet.color.kelvin
+
             # Store the waveform color (all components)
             device_state.waveform_color = packet.color
 
@@ -180,13 +319,9 @@ class SetWaveformOptionalHandler(PacketHandler):
             )
 
         if res_required:
-            return [
-                Light.StateColor(
-                    color=device_state.color,
-                    power=device_state.power_level,
-                    label=device_state.label,
-                )
-            ]
+            # Use GetColorHandler to get proper averaged color if needed
+            handler = GetColorHandler()
+            return handler.handle(device_state, None, res_required)
         return []
 
 

lifx_emulator/handlers/tile_handlers.py

@@ -12,6 +12,7 @@ from lifx_emulator.protocol.protocol_types import (
     DeviceStateVersion,
     LightHsbk,
     TileAccelMeas,
+    TileBufferRect,
     TileEffectParameter,
     TileEffectSettings,
     TileEffectType,
@@ -137,13 +138,17 @@ class Get64Handler(PacketHandler):
         tile_width = tile["width"]
         tile_height = tile["height"]
 
-        # Calculate how many rows fit in 64 pixels
+        # Get64 always returns framebuffer 0 (the visible buffer)
+        # regardless of which fb_index is in the request
+        tile_colors = tile["colors"]
+
+        # Calculate how many rows fit in 64 zones
         rows_to_return = 64 // rect.width if rect.width > 0 else 1
         rows_to_return = min(rows_to_return, tile_height - rect.y)
 
         # Extract colors from the requested rectangle
         colors = []
-        pixels_extracted = 0
+        zones_extracted = 0
 
         for row in range(rows_to_return):
             y = rect.y + row
@@ -152,28 +157,35 @@ class Get64Handler(PacketHandler):
 
             for col in range(rect.width):
                 x = rect.x + col
-                if x >= tile_width or pixels_extracted >= 64:
+                if x >= tile_width or zones_extracted >= 64:
                     colors.append(
                         LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
                     )
-                    pixels_extracted += 1
+                    zones_extracted += 1
                     continue
 
-                # Calculate pixel index in flat color array
-                pixel_idx = y * tile_width + x
-                if pixel_idx < len(tile["colors"]):
-                    colors.append(tile["colors"][pixel_idx])
+                # Calculate zone index in flat color array
+                zone_idx = y * tile_width + x
+                if zone_idx < len(tile_colors):
+                    colors.append(tile_colors[zone_idx])
                 else:
                     colors.append(
                         LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
                     )
-                pixels_extracted += 1
+                zones_extracted += 1
 
         # Pad to exactly 64 colors
         while len(colors) < 64:
             colors.append(LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500))
 
-        return [Tile.State64(tile_index=tile_index, rect=rect, colors=colors)]
+        # Return with fb_index forced to 0 (visible buffer)
+        return_rect = TileBufferRect(
+            fb_index=0,  # Always return FB0
+            x=rect.x,
+            y=rect.y,
+            width=rect.width,
+        )
+        return [Tile.State64(tile_index=tile_index, rect=return_rect, colors=colors)]
 
 
 class Set64Handler(PacketHandler):
@@ -188,16 +200,58 @@ class Set64Handler(PacketHandler):
             return []
 
         tile_index = packet.tile_index
+        fb_index = packet.rect.fb_index
 
-        if tile_index < len(device_state.tile_devices):
-            # Update colors from packet
-            for i, color in enumerate(packet.colors[:64]):
-                if i < len(device_state.tile_devices[tile_index]["colors"]):
-                    device_state.tile_devices[tile_index]["colors"][i] = color
+        if tile_index >= len(device_state.tile_devices):
+            return []
 
-            logger.info(
-                f"Tile {tile_index} set 64 colors, duration={packet.duration}ms"
-            )
+        tile = device_state.tile_devices[tile_index]
+        tile_width = tile["width"]
+        tile_height = tile["height"]
+        rect = packet.rect
+
+        # Determine which framebuffer to update
+        if fb_index == 0:
+            # Update visible framebuffer (stored in tile_devices)
+            target_colors = tile["colors"]
+        else:
+            # Update non-visible framebuffer (stored in tile_framebuffers)
+            if tile_index < len(device_state.tile_framebuffers):
+                fb_storage = device_state.tile_framebuffers[tile_index]
+                target_colors = fb_storage.get_framebuffer(
+                    fb_index, tile_width, tile_height
+                )
+            else:
+                logger.warning(f"Tile {tile_index} framebuffer storage not initialized")
+                return []
+
+        # Update colors in the specified rectangle
+        # Calculate how many rows fit in 64 zones
+        rows_to_write = 64 // rect.width if rect.width > 0 else 1
+        rows_to_write = min(rows_to_write, tile_height - rect.y)
+
+        zones_written = 0
+        for row in range(rows_to_write):
+            y = rect.y + row
+            if y >= tile_height:
+                break
+
+            for col in range(rect.width):
+                x = rect.x + col
+                if x >= tile_width or zones_written >= 64:
+                    zones_written += 1
+                    continue
+
+                # Calculate zone index in flat color array
+                zone_idx = y * tile_width + x
+                if zone_idx < len(target_colors) and zones_written < len(packet.colors):
+                    target_colors[zone_idx] = packet.colors[zones_written]
+                zones_written += 1
+
+        logger.info(
+            f"Tile {tile_index} FB{fb_index} set {zones_written} colors at "
+            f"({rect.x},{rect.y}), duration={packet.duration}ms"
+        )
 
         # Tiles never return a response to Set64 regardless of res_required
         # https://lan.developer.lifx.com/docs/changing-a-device#set64---packet-715
@@ -212,12 +266,83 @@ class CopyFrameBufferHandler(PacketHandler):
     def handle(
         self, device_state: DeviceState, packet: Any | None, res_required: bool
     ) -> list[Any]:
-        if not device_state.has_matrix:
+        if not device_state.has_matrix or not packet:
             return []
 
-        logger.debug("Tile copy frame buffer command received (no-op in emulator)")
-        # In a real device, this would copy the frame buffer to display
-        # In emulator, we don't need to do anything special
+        tile_index = packet.tile_index
+        if tile_index >= len(device_state.tile_devices):
+            return []
+
+        tile = device_state.tile_devices[tile_index]
+        tile_width = tile["width"]
+        tile_height = tile["height"]
+
+        src_fb_index = packet.src_fb_index
+        dst_fb_index = packet.dst_fb_index
+
+        # Get source framebuffer
+        if src_fb_index == 0:
+            src_colors = tile["colors"]
+        else:
+            if tile_index < len(device_state.tile_framebuffers):
+                fb_storage = device_state.tile_framebuffers[tile_index]
+                src_colors = fb_storage.get_framebuffer(
+                    src_fb_index, tile_width, tile_height
+                )
+            else:
+                logger.warning(f"Tile {tile_index} framebuffer storage not initialized")
+                return []
+
+        # Get destination framebuffer
+        if dst_fb_index == 0:
+            dst_colors = tile["colors"]
+        else:
+            if tile_index < len(device_state.tile_framebuffers):
+                fb_storage = device_state.tile_framebuffers[tile_index]
+                dst_colors = fb_storage.get_framebuffer(
+                    dst_fb_index, tile_width, tile_height
+                )
+            else:
+                logger.warning(f"Tile {tile_index} framebuffer storage not initialized")
+                return []
+
+        # Copy the specified rectangle from source to destination
+        src_x = packet.src_x
+        src_y = packet.src_y
+        dst_x = packet.dst_x
+        dst_y = packet.dst_y
+        width = packet.width
+        height = packet.height
+
+        zones_copied = 0
+        for row in range(height):
+            src_row = src_y + row
+            dst_row = dst_y + row
+
+            if src_row >= tile_height or dst_row >= tile_height:
+                break
+
+            for col in range(width):
+                src_col = src_x + col
+                dst_col = dst_x + col
+
+                if src_col >= tile_width or dst_col >= tile_width:
+                    continue
+
+                src_idx = src_row * tile_width + src_col
+                dst_idx = dst_row * tile_width + dst_col
+
+                if src_idx < len(src_colors) and dst_idx < len(dst_colors):
+                    dst_colors[dst_idx] = src_colors[src_idx]
+                    zones_copied += 1
+
+        logger.info(
+            f"Tile {tile_index} copied {zones_copied} zones from "
+            f"FB{src_fb_index}({src_x},{src_y}) to "
+            f"FB{dst_fb_index}({dst_x},{dst_y}), "
+            f"size={width}x{height}, duration={packet.duration}ms"
+        )
+
         return []
 
 

lifx_emulator/products/generator.py

@@ -806,8 +806,8 @@ def _generate_yaml_header() -> list[str]:
         "#     default_tile_count: <number>      # Default number of tiles in chain",
         "#     min_tile_count: <number>          # Minimum tiles supported",
         "#     max_tile_count: <number>          # Maximum tiles supported",
-        "#     tile_width: <number>              # Width of each tile in pixels",
-        "#     tile_height: <number>             # Height of each tile in pixels",
+        "#     tile_width: <number>              # Width of each tile in zones",
+        "#     tile_height: <number>             # Height of each tile in zones",
         "#",
         "#     # Host firmware version (optional, overrides auto firmware selection)",
         "#     default_firmware_major: <number>  # Firmware major version (e.g., 3)",

lifx_emulator/products/specs.py

@@ -25,8 +25,8 @@ class ProductSpecs:
         default_tile_count: Default number of tiles in chain
         min_tile_count: Minimum tiles supported
         max_tile_count: Maximum tiles supported
-        tile_width: Width of each tile in pixels
-        tile_height: Height of each tile in pixels
+        tile_width: Width of each tile in zones
+        tile_height: Height of each tile in zones
         default_firmware_major: Default firmware major version
         default_firmware_minor: Default firmware minor version
         notes: Human-readable notes about this product

lifx_emulator/products/specs.yml

@@ -21,8 +21,8 @@
 #     default_tile_count: <number>      # Default number of tiles in chain
 #     min_tile_count: <number>          # Minimum tiles supported
 #     max_tile_count: <number>          # Maximum tiles supported
-#     tile_width: <number>              # Width of each tile in pixels
-#     tile_height: <number>             # Height of each tile in pixels
+#     tile_width: <number>              # Width of each tile in zones
+#     tile_height: <number>             # Height of each tile in zones
 #
 #     # Host firmware version (optional, overrides automatic firmware selection)
 #     default_firmware_major: <number>  # Firmware major version (e.g., 3)
@@ -167,29 +167,29 @@ products:
   # Matrix Products (Tiles, Candles, etc.)
   # ========================================
 
-  55:  # LIFX Tile, 8x8 pixel matrix, chainable up to 5
+  55:  # LIFX Tile, 8x8 zone matrix, chainable up to 5
     default_tile_count: 5
     min_tile_count: 1
     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
 
-  57:  # LIFX Candle, 5x6 pixel matrix, single unit
+  57:  # LIFX Candle, 5x6 zone matrix, single unit
     default_tile_count: 1
     min_tile_count: 1
     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
 
-  68:  # LIFX Candle variant, 5x6 pixel matrix
+  68:  # LIFX Candle variant, 5x6 zone matrix
     default_tile_count: 1
     min_tile_count: 1
     max_tile_count: 1
     tile_width: 5
     tile_height: 6
-    notes: LIFX Candle variant, 5x6 pixel matrix
+    notes: LIFX Candle variant, 5x6 zone matrix
 
   137:  # LIFX Candle Color US 5x6 variant
     default_tile_count: 1

{lifx_emulator-2.2.1.dist-info → lifx_emulator-2.3.1.dist-info}/METADATA

@@ -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.dist-info → lifx_emulator-2.3.1.dist-info}/RECORD

@@ -1,10 +1,10 @@
 lifx_emulator/__init__.py,sha256=vjhtpAQRSsUZtaUGCQKbmPALvwZ_BF8Mko8w6jzVqBw,819
-lifx_emulator/__main__.py,sha256=zaul9OQhN5csqOqxGWXkVrlurfo2R_-YvM6URk4QAME,21680
+lifx_emulator/__main__.py,sha256=C1Khr8MdrDJnRUM5Y-CV1MPf7CqS2qM-vynGDJjdMYg,21678
 lifx_emulator/constants.py,sha256=DFZkUsdewE-x_3MgO28tMGkjUCWPeYc3xLj_EXViGOw,1032
 lifx_emulator/server.py,sha256=r2JYFcpZIqqhue-Nfq7FbN0KfC3XDf3XDb6b43DsiCk,16438
 lifx_emulator/api/__init__.py,sha256=FoEPw_In5-H_BDQ-XIIONvgj-UqIDVtejIEVRv9qmV8,647
 lifx_emulator/api/app.py,sha256=IxK8sC7MgdtkoLz8iXcEt02nPDaVgdKJgEiGnzTs-YE,4880
-lifx_emulator/api/models.py,sha256=eBx80Ece_4Wv6aqxb1CsZEob9CF0WmR9oJGz3hh14x8,3973
+lifx_emulator/api/models.py,sha256=qFNo0sOl31yuZLtWmLroSW6f6jck-RhP05tx972xsWA,3971
 lifx_emulator/api/mappers/__init__.py,sha256=ZPCOQR9odcwn0C58AjFW6RvBXe5gOll_QS5lAabgorQ,152
 lifx_emulator/api/mappers/device_mapper.py,sha256=EGOpdao9ZS-vT4T8IoV-AoN5WucTnqpQO92dYizo3vw,4151
 lifx_emulator/api/routers/__init__.py,sha256=kbMefnuXrEsYeMA9J4YK_wVs87_XcH7hwkEifR-zgMc,369
@@ -13,33 +13,33 @@ lifx_emulator/api/routers/monitoring.py,sha256=qgVBNm6iMESf1W6EE22DvLalMnxkr0pRb
 lifx_emulator/api/routers/scenarios.py,sha256=0axSQ9r6rByvXLvqRqOU2ma5nTvZgZ0IIzEXdtzoPnM,9743
 lifx_emulator/api/services/__init__.py,sha256=ttjjZfAxbDQC_Ep0LkXjopNiVZOFPsFDSOHhBN98v5s,277
 lifx_emulator/api/services/device_service.py,sha256=r3uFWApC8sVQMCuuzkyjm27K4LDpZnnHmQNgXWX40ok,6294
-lifx_emulator/api/templates/dashboard.html,sha256=YXQ9jrs30DZIxtMWFE4E2HqmsgHQ-NeWTTQxQ-7BfHk,33800
+lifx_emulator/api/templates/dashboard.html,sha256=h-PeOH_La5bVOUBcXmTY2leRlMdL8D8yJ-NCx3S16-A,33792
 lifx_emulator/devices/__init__.py,sha256=QlBTPnFErJcSKLvGyeDwemh7xcpjYvB_L5siKsjr3s8,1089
-lifx_emulator/devices/device.py,sha256=LMdg__95n6geG_32j7qp5yl51WNS3ZbCXn-xMfVVikE,13294
+lifx_emulator/devices/device.py,sha256=24rknbLw_EWF8dheED89wvovKjvC2CdfifLvG7g3SiQ,13648
 lifx_emulator/devices/manager.py,sha256=XDrT82um5sgNpNihLj5RsNvHqdVI1bK9YY2eBzWIcf0,8162
 lifx_emulator/devices/observers.py,sha256=-KnUgFcKdhlNo7CNVstP-u0wU2W0JAGg055ZPV15Sj0,3874
 lifx_emulator/devices/persistence.py,sha256=9Mhj46-xrweOmyzjORCi2jKIwa8XJWpQ5CgaKcw6U98,10513
 lifx_emulator/devices/state_restorer.py,sha256=eDsRSW-2RviP_0Qlk2DHqMaB-zhV0X1cNQECv2lD1qc,9809
-lifx_emulator/devices/state_serializer.py,sha256=O4Cp3bbGkd4eZf5jzb0MKzWDTgiNhrSGgypmMWaB4dg,5097
-lifx_emulator/devices/states.py,sha256=mVZz7FQeIHLpv2SokmhlQlSBIyVj3GuhGMHBVoFlJqk,10836
+lifx_emulator/devices/state_serializer.py,sha256=aws4LUmXBJS8oBrQziJtlV0XMvCTm5X4dGkGlO_QHcM,6281
+lifx_emulator/devices/states.py,sha256=szWmarFjTBZO1UljEdjvS4W-nanYOzgE3P5df36T5bY,12092
 lifx_emulator/factories/__init__.py,sha256=yN8i_Hu_cFEryWZmh0TiOQvWEYFVIApQSs4xeb0EfBk,1170
-lifx_emulator/factories/builder.py,sha256=OaDqQDGkAyZCSO-4HAsFSd5UzsHpHvRyBk-Fotl1mAY,12056
+lifx_emulator/factories/builder.py,sha256=6b0frEUMnM-RE2yjoVJzKUav3xn9bOElJPOETSG4NWk,12054
 lifx_emulator/factories/default_config.py,sha256=FTcxKDfeTmO49GTSki8nxnEIZQzR0Lg0hL_PwHUrkVQ,4828
-lifx_emulator/factories/factory.py,sha256=VQfU5M8zrpFyNHjpGP1q-3bpek9MltBdoAUSvIvt7Bs,7583
+lifx_emulator/factories/factory.py,sha256=Q2Yr21EC2bLOWwLyqqoUIsJKwWt7MTNODERhTRH6llk,7579
 lifx_emulator/factories/firmware_config.py,sha256=tPN5Hq-uNb1xzW9Q0A9jD-G0-NaGfINcD0i1XZRUMoE,2711
 lifx_emulator/factories/serial_generator.py,sha256=MbaXoommsj76ho8_ZoKuUDnffDf98YvwQiXZSWsUsEs,2507
 lifx_emulator/handlers/__init__.py,sha256=3Hj1hRo3yL3E7GKwG9TaYh33ymk_N3bRiQ8nvqSQULA,1306
 lifx_emulator/handlers/base.py,sha256=0avCLXY_rNlw16PpJ5JrRCwXNE4uMpBqF3PfSfNJ0b8,1654
 lifx_emulator/handlers/device_handlers.py,sha256=1AmslA4Ut6L7b3SfduDdvnQizTpzUB3KKWBXmp4WYLQ,9462
-lifx_emulator/handlers/light_handlers.py,sha256=Ryz-_fzoVCT6DBkXhW9YCOYJYaMRcBOIguL3HrQXhAw,11471
+lifx_emulator/handlers/light_handlers.py,sha256=255aoiIjSIL63kbHQa6wqUpEwFzFFx7SG6P1nWM9jgU,17769
 lifx_emulator/handlers/multizone_handlers.py,sha256=2dYsitq0KzEaxEAJmz7ixtir1tvFMOAnfkBQqslqbPM,7914
 lifx_emulator/handlers/registry.py,sha256=s1ht4PmPhXhAcwu1hoY4yW39wy3SPJBMY-9Uxd0FWuE,3292
-lifx_emulator/handlers/tile_handlers.py,sha256=Ci_SrOldf2I8djEd2JJZZ5iR5b4_HvzlWTkaBiCTx7c,12785
+lifx_emulator/handlers/tile_handlers.py,sha256=L4fNKGTSSIxRuqKrfDrMSrNPvDJr3aIuaEqbhRCOt04,17176
 lifx_emulator/products/__init__.py,sha256=qcNop_kRYFF3zSjNemzQEgu3jPrIxfyQyLv9GsnaLEI,627
-lifx_emulator/products/generator.py,sha256=5zcq0iKgwjtg0gePnBEOdIkumesvfzEcKRdBZFPyGtk,33538
+lifx_emulator/products/generator.py,sha256=WsbAr2dXXMtLyOlFFkt-xM9kT5WpiUzj6_FKRf16Tng,33536
 lifx_emulator/products/registry.py,sha256=qkm2xgGZo_ds3wAbYplLu4gb0cxhjZXjnCc1V8etpHw,46517
-lifx_emulator/products/specs.py,sha256=RxToCvu-iwF6QMcmYgI5CblLOr8hpDZ3k3WT1fZcKe8,8730
-lifx_emulator/products/specs.yml,sha256=eM_r1lTRQHii4dyvnsZWx1P7NzDSZzJl03aR86TY564,9683
+lifx_emulator/products/specs.py,sha256=epqz2DPyNOOOFHhmI_wlk7iEbgN0vCugHz-hWx9FlAI,8728
+lifx_emulator/products/specs.yml,sha256=-91JNzGhwcO_zybOWY8dFBncN2TnnxtSkkHdi31KT94,9675
 lifx_emulator/protocol/__init__.py,sha256=-wjC-wBcb7fxi5I-mJr2Ad8K2YRflJFdLLdobfD-W1Q,56
 lifx_emulator/protocol/base.py,sha256=V6t0baSgIXjrsz2dBuUn_V9xwradSqMxBFJHAUtnfCs,15368
 lifx_emulator/protocol/const.py,sha256=ilhv-KcQpHtKh2MDCaIbMLQAsxKO_uTaxyR63v1W8cc,226
@@ -55,8 +55,8 @@ lifx_emulator/scenarios/__init__.py,sha256=CGjudoWvyysvFj2xej11N2cr3mYROGtRb9zVH
 lifx_emulator/scenarios/manager.py,sha256=1esxRdz74UynNk1wb86MGZ2ZFAuMzByuu74nRe3D-Og,11163
 lifx_emulator/scenarios/models.py,sha256=BKS_fGvrbkGe-vK3arZ0w2f9adS1UZhiOoKpu7GENnc,4099
 lifx_emulator/scenarios/persistence.py,sha256=3vjtPNFYfag38tUxuqxkGpWhQ7uBitc1rLroSAuw9N8,8881
-lifx_emulator-2.2.1.dist-info/METADATA,sha256=AWoxTE55eL8Ga1ORQaXG0gammepJigzKqTrxDj-1UqA,4549
-lifx_emulator-2.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lifx_emulator-2.2.1.dist-info/entry_points.txt,sha256=R9C_K_tTgt6yXEmhzH4r2Yx2Tu1rLlnYzeG4RFUVzSc,62
-lifx_emulator-2.2.1.dist-info/licenses/LICENSE,sha256=eBz48GRA3gSiWn3rYZAz2Ewp35snnhV9cSqkVBq7g3k,1832
-lifx_emulator-2.2.1.dist-info/RECORD,,
+lifx_emulator-2.3.1.dist-info/METADATA,sha256=L3tETYNKBl5pR1wfSXTsWijV0olIPspASI1du2HMO94,4549
+lifx_emulator-2.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lifx_emulator-2.3.1.dist-info/entry_points.txt,sha256=R9C_K_tTgt6yXEmhzH4r2Yx2Tu1rLlnYzeG4RFUVzSc,62
+lifx_emulator-2.3.1.dist-info/licenses/LICENSE,sha256=eBz48GRA3gSiWn3rYZAz2Ewp35snnhV9cSqkVBq7g3k,1832
+lifx_emulator-2.3.1.dist-info/RECORD,,