mirror of
https://github.com/maziggy/bambuddy.git
synced 2026-09-30 11:12:35 +02:00
maziggy
e77e10896f
The firmware's runout HMS text says "insert into the same AMS slot", which is wrong under AMS Filament Backup: the firmware won't re-accept the depleted slot and advances to the next compatible one. Bambuddy parsed print.ams.tray_now only and dropped tray_tar/tray_pre, so the expected slot never reached the UI. Capture tray_tar/tray_pre on PrinterState and, while paused, resolve them to global tray IDs (expected_tray/previous_tray) on both the REST and WebSocket status payloads via a shared resolver: single-AMS passthrough, multi-AMS snow-mapping resolution, AMS-HT/external passthrough, and an honest null when the slot can't be placed. The AMS graphic highlights the expected slot (amber) and the ran-out slot (red); the HMS modal re-describes runout codes to name both, falling back to "check the printer" when unresolved. Runout copy translated in all 11 locales. Reporter @Jostxxl confirmed tray_pre=1/tray_tar=2 during the pause (ran out in Slot 2, printer expected Slot 3).
120 lines
4.6 KiB
Python
120 lines
4.6 KiB
Python
"""Unit tests for runout expected-slot resolution (#2587).
|
|
|
|
When a print pauses on an AMS filament runout, the firmware reports the slot it
|
|
now expects (``tray_tar``) and the slot that ran out (``tray_pre``) as bare
|
|
numbers whose meaning depends on the AMS layout. ``resolve_expected_tray``
|
|
globalises them to the same numbering the AMS graphic already highlights, so the
|
|
UI can point the operator at the right physical slot — critical with AMS
|
|
Filament Backup, which advances to the next compatible slot rather than
|
|
re-accepting the depleted one (reporter @Jostxxl saw the print wait on Slot 3
|
|
after Slot 2 ran out).
|
|
"""
|
|
|
|
from backend.app.services.printer_manager import resolve_expected_tray
|
|
|
|
|
|
def _single_regular():
|
|
return [(0, False)]
|
|
|
|
|
|
def _dual_regular():
|
|
return [(0, False), (1, False)]
|
|
|
|
|
|
class TestSingleRegularAms:
|
|
"""One 4-slot AMS: the local slot IS the global tray ID (matches tray_now)."""
|
|
|
|
def test_reporter_scenario_tray_tar_2_is_slot_3(self):
|
|
# @Jostxxl: tray_tar=2 (zero-based) -> physical Slot 3.
|
|
assert resolve_expected_tray(2, _single_regular(), None) == 2
|
|
|
|
def test_reporter_scenario_tray_pre_1_is_slot_2(self):
|
|
# @Jostxxl: tray_pre=1 (zero-based) -> physical Slot 2 (the one that ran out).
|
|
assert resolve_expected_tray(1, _single_regular(), None) == 1
|
|
|
|
def test_all_four_slots_pass_through(self):
|
|
for slot in range(4):
|
|
assert resolve_expected_tray(slot, _single_regular(), None) == slot
|
|
|
|
def test_single_ams_with_nonzero_id(self):
|
|
# A lone AMS reporting id=1 globalises to 4+slot, not the bare slot.
|
|
assert resolve_expected_tray(2, [(1, False)], None) == 6
|
|
|
|
|
|
class TestSentinels:
|
|
"""255 = none/idle, 254 = external spool, -1 = never-set."""
|
|
|
|
def test_none_input(self):
|
|
assert resolve_expected_tray(None, _single_regular(), None) is None
|
|
|
|
def test_255_is_none(self):
|
|
assert resolve_expected_tray(255, _single_regular(), None) is None
|
|
|
|
def test_minus_one_is_none(self):
|
|
assert resolve_expected_tray(-1, _single_regular(), None) is None
|
|
|
|
def test_254_external_passes_through(self):
|
|
assert resolve_expected_tray(254, _single_regular(), None) == 254
|
|
|
|
|
|
class TestAmsHt:
|
|
"""AMS-HT reports a global ID (128-135) directly — return it unchanged."""
|
|
|
|
def test_ht_global_id_passthrough(self):
|
|
assert resolve_expected_tray(129, [(129, True)], None) == 129
|
|
|
|
def test_ht_alongside_regular(self):
|
|
layout = [(0, False), (128, True)]
|
|
assert resolve_expected_tray(128, layout, None) == 128
|
|
# A 0-3 target still resolves against the single regular unit.
|
|
assert resolve_expected_tray(3, layout, None) == 3
|
|
|
|
|
|
class TestMultiRegularAms:
|
|
"""Several 4-slot AMS: local slot is ambiguous; resolve via the mapping field.
|
|
|
|
The snow-encoded mapping is ``ams_hw_id*256 + slot`` per entry.
|
|
"""
|
|
|
|
def test_resolves_unambiguous_slot_via_mapping(self):
|
|
# Mapping says slot 2 lives on AMS 1 -> global 1*4+2 = 6.
|
|
mapping = [1 * 256 + 2]
|
|
assert resolve_expected_tray(2, _dual_regular(), mapping) == 6
|
|
|
|
def test_resolves_slot_on_ams0(self):
|
|
mapping = [0 * 256 + 3]
|
|
assert resolve_expected_tray(3, _dual_regular(), mapping) == 3
|
|
|
|
def test_ambiguous_when_two_units_match_returns_none(self):
|
|
# Both AMS 0 and AMS 1 have slot 1 mapped -> can't disambiguate.
|
|
mapping = [0 * 256 + 1, 1 * 256 + 1]
|
|
assert resolve_expected_tray(1, _dual_regular(), mapping) is None
|
|
|
|
def test_no_mapping_returns_none(self):
|
|
# Honest "can't determine" rather than guessing AMS 0.
|
|
assert resolve_expected_tray(2, _dual_regular(), None) is None
|
|
|
|
def test_unmapped_sentinel_ignored(self):
|
|
# 65535 = unmapped; only the real entry counts.
|
|
mapping = [65535, 1 * 256 + 0]
|
|
assert resolve_expected_tray(0, _dual_regular(), mapping) == 4
|
|
|
|
def test_ht_in_multi_layout_via_mapping(self):
|
|
# A slot-0 target that maps to an AMS-HT hw id resolves to that global ID.
|
|
layout = [(0, False), (1, False), (128, True)]
|
|
mapping = [128 * 256 + 0]
|
|
assert resolve_expected_tray(0, layout, mapping) == 128
|
|
|
|
|
|
class TestGlobalAndOutOfRange:
|
|
def test_already_global_regular_id_passthrough(self):
|
|
# 4-15 is already a global regular-AMS ID.
|
|
assert resolve_expected_tray(6, _dual_regular(), None) == 6
|
|
|
|
def test_out_of_range_returns_none(self):
|
|
assert resolve_expected_tray(200, _single_regular(), None) is None
|
|
|
|
def test_zero_slot_no_regular_ams_returns_none(self):
|
|
# Only an AMS-HT present but a 0-3 target — can't place it.
|
|
assert resolve_expected_tray(1, [(128, True)], None) is None
|