Merge pull request #6 from fa-yoshinobu/codex/slmp-q-runtime-ranges

Codex/slmp q runtime ranges

Author: fa-yoshinobu

internal_docs/iqr_192_168_250_100_tcp1025/g_u0_direct_coverage_20260430.md

@@ -0,0 +1,22 @@
+# G/HG Extended Device Coverage Report
+
+- Date: 2026-04-30 20:42:10
+- Host: 192.168.250.100
+- Port: 1025
+- Transports: tcp
+- Series: iqr
+- Targets: SELF(network=0x00, station=0xFF, module_io=0x03FF, multidrop=0x00)
+- Devices: U0\G10, U0\G30
+- Point counts: 1, 4
+- Direct memory values: 0xFA
+- Mode: read_only
+- Restore enabled: yes
+- Preferred write base: 0x001E
+- Summary: OK=4, NG=0, SKIP=0
+
+| Item | Status | Detail |
+|---|---|---|
+| SELF U0\G10 points=1 direct=0xFA | OK | device=U0\G10, points=1, before=[0x0000], mode=read_only |
+| SELF U0\G10 points=4 direct=0xFA | OK | device=U0\G10, points=4, before=[0x0000, 0x0000, 0x0000, 0x0000], mode=read_only |
+| SELF U0\G30 points=1 direct=0xFA | OK | device=U0\G30, points=1, before=[0x0000], mode=read_only |
+| SELF U0\G30 points=4 direct=0xFA | OK | device=U0\G30, points=4, before=[0x0000, 0x0000, 0x0000, 0x0000], mode=read_only |

internal_docs/iqr_192_168_250_100_tcp1025/mixed_block_compare_tcp1025_20260430.md

@@ -0,0 +1,101 @@
+# Mixed Block Comparison Report
+
+- Date: 2026-04-30 20:42:30
+- Host: 192.168.250.100
+- Port: 1025
+- Transport: tcp
+- Series: iqr
+- Model: R08CPU
+- Target: network=0x00, station=0xFF, module_io=0x03FF, multidrop=0x00
+- Word block: D300 x2 -> [0x87F7, 0x80BE]
+- Bit block: M200 x1 packed -> [0x6DFE]
+- Mixed write options: split_mixed_blocks=False, retry_mixed_on_error=True
+- Keep written value: False
+- First-pass comparison recommendation: keep both mixed-write fallback options disabled so the first PLC response is preserved
+- Note: if retry_mixed_on_error=True triggers an internal retry, the reported memory-changed state is the post-call state, not an observation between the first failed request and the retry
+
+| Scenario | Status | End codes | Memory changed | Trace count | Notes |
+|---|---|---|---|---|---|
+| readBlock words+bits | OK | 0x0000 | n/a | 1 | words=[0x0000, 0x0000], bits=[0x0000] |
+| writeBlock words only | OK | 0x0000 | yes | 1 | after=[0x87F7, 0x80BE], restore=OK |
+| writeBlock bits only | OK | 0x0000 | yes | 1 | after=[0x6DFE], restore=OK |
+| writeBlock mixed | OK | 0xC05B -> 0x0000 -> 0x0000 | yes | 3 | after_words=[0x87F7, 0x80BE], after_bits=[0x6DFE], request_count=3 |
+
+## readBlock words+bits
+
+- API: read_block(word_blocks=[('D300', 2)], bit_blocks=[('M200', 1)], split_mixed_blocks=False)
+- Devices: word=D300 x2, bit=M200 x1 packed
+- Warnings: none
+- Error: none
+- Returned words: [0x0000, 0x0000]
+- Returned bits: [0x0000]
+
+```text
+attempt 1: end_code=0x0000
+request: 54 00 03 00 00 00 00 FF FF 03 00 18 00 10 00 06 04 02 00 01 01 2C 01 00 00 A8 00 02 00 C8 00 00 00 90 00 01 00
+response: D4 00 03 00 00 00 00 FF FF 03 00 08 00 00 00 00 00 00 00 00 00
+```
+
+## writeBlock words only
+
+- API: write_block(word_blocks=[('D300', [0x87F7, 0x80BE])], bit_blocks=[])
+- Before words: [0x0000, 0x0000]
+- Test words: [0x87F7, 0x80BE]
+- After words: [0x87F7, 0x80BE]
+- Restore status: OK
+- Restored words: [0x0000, 0x0000]
+- Warnings: none
+- Error: none
+
+```text
+attempt 1: end_code=0x0000
+request: 54 00 04 00 00 00 00 FF FF 03 00 14 00 10 00 06 14 02 00 01 00 2C 01 00 00 A8 00 02 00 F7 87 BE 80
+response: D4 00 04 00 00 00 00 FF FF 03 00 02 00 00 00
+```
+
+## writeBlock bits only
+
+- API: write_block(word_blocks=[], bit_blocks=[('M200', [0x6DFE])])
+- Before bits: [0x0000]
+- Test bits: [0x6DFE]
+- After bits: [0x6DFE]
+- Restore status: OK
+- Restored bits: [0x0000]
+- Warnings: none
+- Error: none
+
+```text
+attempt 1: end_code=0x0000
+request: 54 00 08 00 00 00 00 FF FF 03 00 12 00 10 00 06 14 02 00 00 01 C8 00 00 00 90 00 01 00 FE 6D
+response: D4 00 08 00 00 00 00 FF FF 03 00 02 00 00 00
+```
+
+## writeBlock mixed
+
+- API: write_block(word_blocks=[('D300', [0x87F7, 0x80BE])], bit_blocks=[('M200', [0x6DFE])], split_mixed_blocks=False, retry_mixed_on_error=True)
+- Before words: [0x0000, 0x0000]
+- Before bits: [0x0000]
+- Test words: [0x87F7, 0x80BE]
+- Test bits: [0x6DFE]
+- After words: [0x87F7, 0x80BE]
+- After bits: [0x6DFE]
+- Request count: 3
+- Restore status: OK
+- Restored words: [0x0000, 0x0000]
+- Restored bits: [0x0000]
+- Warnings: mixed block write was rejected with 0xC05B; retrying as separate word-only and bit-only block writes
+- Error: none
+
+```text
+attempt 1: end_code=0xC05B
+request: 54 00 0C 00 00 00 00 FF FF 03 00 1E 00 10 00 06 14 02 00 01 01 2C 01 00 00 A8 00 02 00 C8 00 00 00 90 00 01 00 F7 87 BE 80 FE 6D
+response: D4 00 0C 00 00 00 00 FF FF 03 00 0B 00 5B C0 00 FF FF 03 00 06 14 02 00
+
+attempt 2: end_code=0x0000
+request: 54 00 0D 00 00 00 00 FF FF 03 00 14 00 10 00 06 14 02 00 01 00 2C 01 00 00 A8 00 02 00 F7 87 BE 80
+response: D4 00 0D 00 00 00 00 FF FF 03 00 02 00 00 00
+
+attempt 3: end_code=0x0000
+request: 54 00 0E 00 00 00 00 FF FF 03 00 12 00 10 00 06 14 02 00 00 01 C8 00 00 00 90 00 01 00 FE 6D
+response: D4 00 0E 00 00 00 00 FF FF 03 00 02 00 00 00
+```

slmp/device_ranges.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from enum import Enum
 from typing import Any, cast
 
@@ -133,6 +133,14 @@ class _RangeProfile:
     "SD",
 )
 
+_MAX_RUNTIME_RANGE_PROBE_COUNT = 1_048_576
+_ZR_RUNTIME_FAMILIES = {
+    SlmpDeviceRangeFamily.QCpu,
+    SlmpDeviceRangeFamily.LCpu,
+    SlmpDeviceRangeFamily.QnU,
+    SlmpDeviceRangeFamily.QnUDV,
+}
+
 _ROWS: dict[str, _RangeRow] = {
     "X": _RangeRow(SlmpDeviceRangeCategory.Bit, (("X", True),), SlmpDeviceRangeNotation.Base16),
     "Y": _RangeRow(SlmpDeviceRangeCategory.Bit, (("Y", True),), SlmpDeviceRangeNotation.Base16),
@@ -411,7 +419,7 @@ def _undefined(notes: str) -> _RangeValueSpec:
             "LT": _unsupported("Not supported on LCPU."),
             "LST": _unsupported("Not supported on LCPU."),
             "LC": _unsupported("Not supported on LCPU."),
-            "Z": _word(305, "SD305", "Requires ZZ = FFFFh for the reported upper bound."),
+            "Z": _fixed(20, "Fixed family limit"),
             "LZ": _unsupported("Not supported on LCPU."),
             "ZR": _dword(306, "SD306-SD307 (32-bit)"),
             "RD": _unsupported("Not supported on LCPU."),
@@ -443,7 +451,7 @@ def _undefined(notes: str) -> _RangeValueSpec:
             "LT": _unsupported("Not supported on QnU."),
             "LST": _unsupported("Not supported on QnU."),
             "LC": _unsupported("Not supported on QnU."),
-            "Z": _word(305, "SD305", "Requires ZZ = FFFFh for the reported upper bound."),
+            "Z": _fixed(20, "Fixed family limit"),
             "LZ": _unsupported("Not supported on QnU."),
             "ZR": _dword(306, "SD306-SD307 (32-bit)"),
             "RD": _unsupported("Not supported on QnU."),
@@ -475,7 +483,7 @@ def _undefined(notes: str) -> _RangeValueSpec:
             "LT": _unsupported("Not supported on QnUDV."),
             "LST": _unsupported("Not supported on QnUDV."),
             "LC": _unsupported("Not supported on QnUDV."),
-            "Z": _word(305, "SD305", "Requires ZZ = FFFFh for the reported upper bound."),
+            "Z": _fixed(20, "Fixed family limit"),
             "LZ": _unsupported("Not supported on QnUDV."),
             "ZR": _dword(306, "SD306-SD307 (32-bit)"),
             "RD": _unsupported("Not supported on QnUDV."),
@@ -568,7 +576,8 @@ def read_device_range_catalog_for_family_sync(
         client.read_devices(DeviceRef("SD", profile.register_start), profile.register_count, bit_unit=False),
     )
     registers = {profile.register_start + index: int(value) for index, value in enumerate(words)}
-    return build_device_range_catalog_for_family(normalized_family, registers)
+    catalog = build_device_range_catalog_for_family(normalized_family, registers)
+    return _resolve_runtime_limits_sync(client, catalog)
 
 
 async def read_device_range_catalog_for_family(
@@ -584,7 +593,164 @@ async def read_device_range_catalog_for_family(
         await client.read_devices(DeviceRef("SD", profile.register_start), profile.register_count, bit_unit=False),
     )
     registers = {profile.register_start + index: int(value) for index, value in enumerate(words)}
-    return build_device_range_catalog_for_family(normalized_family, registers)
+    catalog = build_device_range_catalog_for_family(normalized_family, registers)
+    return await _resolve_runtime_limits_async(client, catalog)
+
+
+def _resolve_runtime_limits_sync(client: Any, catalog: SlmpDeviceRangeCatalog) -> SlmpDeviceRangeCatalog:
+    if catalog.family not in _ZR_RUNTIME_FAMILIES:
+        return catalog
+
+    if catalog.family is SlmpDeviceRangeFamily.QCpu:
+        z_count = 16 if _can_read_one_word_sync(client, "Z15") else 10
+        catalog = _replace_fixed_point_count(
+            catalog,
+            "Z",
+            z_count,
+            "Runtime access check",
+            "QCPU Z register count is selected by probing Z15.",
+        )
+
+    zr_count = _resolve_readable_point_count_sync(client, "ZR")
+    catalog = _replace_fixed_point_count(
+        catalog,
+        "ZR",
+        zr_count,
+        "Runtime access check",
+        "ZR register count is selected by probing readable ZR addresses.",
+    )
+    return _replace_fixed_point_count(
+        catalog,
+        "R",
+        min(zr_count, 32768),
+        "Runtime access check",
+        "R register count follows the probed ZR count and is capped at R32767.",
+    )
+
+
+async def _resolve_runtime_limits_async(client: Any, catalog: SlmpDeviceRangeCatalog) -> SlmpDeviceRangeCatalog:
+    if catalog.family not in _ZR_RUNTIME_FAMILIES:
+        return catalog
+
+    if catalog.family is SlmpDeviceRangeFamily.QCpu:
+        z_count = 16 if await _can_read_one_word_async(client, "Z15") else 10
+        catalog = _replace_fixed_point_count(
+            catalog,
+            "Z",
+            z_count,
+            "Runtime access check",
+            "QCPU Z register count is selected by probing Z15.",
+        )
+
+    zr_count = await _resolve_readable_point_count_async(client, "ZR")
+    catalog = _replace_fixed_point_count(
+        catalog,
+        "ZR",
+        zr_count,
+        "Runtime access check",
+        "ZR register count is selected by probing readable ZR addresses.",
+    )
+    return _replace_fixed_point_count(
+        catalog,
+        "R",
+        min(zr_count, 32768),
+        "Runtime access check",
+        "R register count follows the probed ZR count and is capped at R32767.",
+    )
+
+
+def _resolve_readable_point_count_sync(client: Any, device: str) -> int:
+    if not _can_read_one_word_sync(client, f"{device}0"):
+        return 0
+
+    upper_limit = _MAX_RUNTIME_RANGE_PROBE_COUNT - 1
+    low = 0
+    high = 1
+    while high < upper_limit and _can_read_one_word_sync(client, f"{device}{high}"):
+        low = high
+        high = min(upper_limit, (high * 2) + 1)
+
+    if high == upper_limit and _can_read_one_word_sync(client, f"{device}{high}"):
+        return _MAX_RUNTIME_RANGE_PROBE_COUNT
+
+    left = low + 1
+    right = high - 1
+    while left <= right:
+        mid = left + ((right - left) // 2)
+        if _can_read_one_word_sync(client, f"{device}{mid}"):
+            low = mid
+            left = mid + 1
+        else:
+            right = mid - 1
+
+    return low + 1
+
+
+async def _resolve_readable_point_count_async(client: Any, device: str) -> int:
+    if not await _can_read_one_word_async(client, f"{device}0"):
+        return 0
+
+    upper_limit = _MAX_RUNTIME_RANGE_PROBE_COUNT - 1
+    low = 0
+    high = 1
+    while high < upper_limit and await _can_read_one_word_async(client, f"{device}{high}"):
+        low = high
+        high = min(upper_limit, (high * 2) + 1)
+
+    if high == upper_limit and await _can_read_one_word_async(client, f"{device}{high}"):
+        return _MAX_RUNTIME_RANGE_PROBE_COUNT
+
+    left = low + 1
+    right = high - 1
+    while left <= right:
+        mid = left + ((right - left) // 2)
+        if await _can_read_one_word_async(client, f"{device}{mid}"):
+            low = mid
+            left = mid + 1
+        else:
+            right = mid - 1
+
+    return low + 1
+
+
+def _can_read_one_word_sync(client: Any, address: str) -> bool:
+    try:
+        client.read_devices(address, 1, bit_unit=False)
+        return True
+    except SlmpError:
+        return False
+
+
+async def _can_read_one_word_async(client: Any, address: str) -> bool:
+    try:
+        await client.read_devices(address, 1, bit_unit=False)
+        return True
+    except SlmpError:
+        return False
+
+
+def _replace_fixed_point_count(
+    catalog: SlmpDeviceRangeCatalog,
+    device: str,
+    point_count: int,
+    source: str,
+    note: str,
+) -> SlmpDeviceRangeCatalog:
+    upper_bound = None if point_count <= 0 else point_count - 1
+    entries = [
+        replace(
+            entry,
+            upper_bound=upper_bound,
+            point_count=point_count,
+            address_range=_format_address_range(entry.device, entry.notation, upper_bound),
+            source=source,
+            notes=note if not entry.notes else f"{entry.notes} {note}",
+        )
+        if entry.device == device
+        else entry
+        for entry in catalog.entries
+    ]
+    return replace(catalog, entries=entries)
 
 
 def _evaluate_point_count(spec: _RangeValueSpec, registers: Mapping[int, int]) -> int | None: