160 lines
8.7 KiB
Python
160 lines
8.7 KiB
Python
"""DEIF XDi-192 observations from CAN analysis dated 2026-10-03.
|
||
|
||
Based on DEIF 4189350066D, sections 3.2, 11 and appendix 9.
|
||
Angle and AC2 percent use the verified working-library resolution of 0.1.
|
||
Absolute AC2 power remains RAW until its physical unit is confirmed.
|
||
"""
|
||
from protocan import protocan as pc
|
||
|
||
SELECTORS = {
|
||
bytes.fromhex("01 01 30 07"): "Азимут / руль — задание",
|
||
bytes.fromhex("01 81 30 02"): "RPM / обороты",
|
||
bytes.fromhex("01 91 30 02"): "Обороты винта, %",
|
||
bytes.fromhex("01 21 34 02"): "Электрическая мощность AC2",
|
||
bytes.fromhex("01 31 34 02"): "Электрическая мощность AC2, %",
|
||
}
|
||
MASTER_SELECTORS = tuple(SELECTORS)
|
||
SELECTORS[bytes.fromhex("01 01 30 02")] = "Азимут / руль — фактическое значение"
|
||
|
||
OBJECTS = {
|
||
0x3000: ("Азимут / руль", "°"),
|
||
0x3080: ("Обороты винта", "rpm"),
|
||
0x3090: ("Обороты винта, %", "%"),
|
||
0x3420: ("Электрическая мощность AC2", None),
|
||
0x3430: ("Электрическая мощность AC2, %", "%"),
|
||
}
|
||
|
||
|
||
def decode(frame):
|
||
result = pc.Decoded(pc.ProtoCanId(frame.can_id, 0, 0, 0, 0, 0, 0),
|
||
len(frame.data), bytes(frame.data), ide=frame.ide,
|
||
rtr=frame.rtr, protocol="DEIF XDi-192")
|
||
result.fields = [("Протокол", "DEIF XDi-net / CANopen SAM-MPDO"),
|
||
("CAN ID", "0x%03X" % frame.can_id)]
|
||
def reject(message):
|
||
result.summary = message
|
||
result.warnings.append(message)
|
||
return result
|
||
if frame.ide or frame.rtr:
|
||
return reject("DEIF: ожидается STD data frame; EXT/RTR не интерпретируется")
|
||
if 0x701 <= frame.can_id <= 0x77F:
|
||
node = frame.can_id - 0x700
|
||
result.device_label = "Node %d" % node
|
||
result.message_label = "Heartbeat / Boot-up"
|
||
result.fields.append(("Node-ID", str(node)))
|
||
if len(frame.data) != 1:
|
||
return reject("DEIF: Heartbeat Node %d — ожидается DLC=1" % node)
|
||
state = {0: "Boot-up", 5: "Operational"}.get(frame.data[0])
|
||
if state is None:
|
||
state = "состояние 0x%02X (не описано в журнале)" % frame.data[0]
|
||
result.fields.append(("Состояние", state))
|
||
result.summary = "Node %d: %s" % (node, state)
|
||
return result
|
||
if not 0x201 <= frame.can_id <= 0x57F:
|
||
result.summary = "DEIF: CAN ID не описан в журнале"
|
||
return result
|
||
node = frame.can_id - 0x200
|
||
result.message_label = "XDi-net broadcast / SAM-MPDO"
|
||
result.fields.append(("COB-ID", "0x%03X" % frame.can_id))
|
||
if len(frame.data) != 8:
|
||
return reject("DEIF RPDO1: ожидается DLC=8")
|
||
selector = frame.data[:4]
|
||
result.fields.append(("Селектор Byte0..3", selector.hex(" ").upper()))
|
||
source = frame.data[0] & 0x7F
|
||
index = int.from_bytes(frame.data[1:3], "little")
|
||
subindex = frame.data[3]
|
||
result.fields.extend([("Источник Node-ID", str(source)),
|
||
("Индекс объекта", "0x%04X" % index),
|
||
("Подиндекс", "0x%02X" % subindex)])
|
||
dam = bool(frame.data[0] & 0x80)
|
||
if dam:
|
||
result.fields = [(key, value) for key, value in result.fields if key != "Источник Node-ID"]
|
||
result.fields.append(("Получатель Node-ID", str(source)))
|
||
result.message_label = "CANopen DAM-MPDO"
|
||
if not source or frame.can_id - source not in (0x200, 0x300, 0x400, 0x500):
|
||
return reject("DEIF: получатель не соответствует RPDO COB-ID")
|
||
elif not source or not 0x201 <= frame.can_id <= 0x27F or (node != 127 and source != node):
|
||
return reject("DEIF: источник не соответствует COB-ID")
|
||
result.device_label = ("Получатель Node %d" if dam else "Источник Node %d") % source
|
||
result.fields[0] = ("Протокол", "CANopen DAM-MPDO" if dam else "DEIF XDi-net / CANopen SAM-MPDO")
|
||
family, instance = index & 0xFFF0, index & 0xF
|
||
if family not in OBJECTS or not instance or subindex not in (2, 7):
|
||
return reject("DEIF: неизвестный объект/подиндекс 0x%04X:%02X" % (index, subindex))
|
||
name, unit = OBJECTS[family]
|
||
kind = "фактическое значение" if subindex == 2 else "задание"
|
||
name = "%s №%d — %s" % (name, instance, kind)
|
||
raw = int.from_bytes(frame.data[4:6], "little", signed=True)
|
||
result.fields.extend([("Параметр", name),
|
||
("RAW INT16 LE", str(raw)),
|
||
("Byte6..7", frame.data[6:].hex(" ").upper())])
|
||
result.summary = "Node %d · 0x%04X:%02X · %s: RAW=%d" % (source, index, subindex, name, raw)
|
||
if raw in (-32768, 32766, 32767):
|
||
status = {-32768: "ниже диапазона", 32766: "выше диапазона", 32767: "ошибка данных"}[raw]
|
||
result.fields.append(("Статус", status))
|
||
result.summary += "; " + status
|
||
result.warnings.append(status)
|
||
elif unit and (subindex == 2 or family == 0x3000):
|
||
value = "%.1f %s" % (raw / 10, unit)
|
||
result.fields.append(("Значение", value))
|
||
result.fields.append(("Масштаб", "RAW ×0.1"))
|
||
result.summary += "; " + value
|
||
elif family == 0x3420 and subindex == 2:
|
||
result.fields.append(("Масштаб / единицы", "RAW ×1; физическая единица не подтверждена"))
|
||
result.summary += "; RAW ×1 (физическая единица не подтверждена)"
|
||
else:
|
||
result.fields.append(("Масштаб / единицы", "не установлены"))
|
||
result.summary += "; масштаб и единицы не установлены"
|
||
if frame.data[6:] != b"\x00\x00":
|
||
result.warnings.append("Byte6..7: для I16 ожидается нулевое заполнение")
|
||
return result
|
||
|
||
|
||
def master_frames(node_id, raw_values, can_id=None, mode="sam", angle_subindex=7):
|
||
"""Build a five-parameter STD RPDO1 cycle, using signed INT16 LE values."""
|
||
from .can_transport import build_frame
|
||
if not isinstance(node_id, int) or not 1 <= node_id <= 127:
|
||
raise ValueError("Node-ID должен быть от 1 до 127")
|
||
identifier = 0x200 + node_id if can_id is None else can_id
|
||
if mode not in ("sam", "dam"):
|
||
raise ValueError("Выберите SAM или DAM")
|
||
if angle_subindex not in (2, 7):
|
||
raise ValueError("Угол: 0x02 — фактический, 0x07 — задание")
|
||
if not isinstance(identifier, int) or not 0x201 <= identifier <= 0x57F:
|
||
raise ValueError("STD ID вне диапазона RPDO")
|
||
if mode == "sam" and identifier not in (0x200 + node_id, 0x27F):
|
||
raise ValueError("XDi-net STD ID: 0x200 + источник или 0x27F")
|
||
if mode == "dam" and identifier - node_id not in (0x200, 0x300, 0x400, 0x500):
|
||
raise ValueError("CANopen DAM: STD ID = база RPDO (200/300/400/500 hex) + получатель")
|
||
values = list(raw_values)
|
||
if len(values) != len(MASTER_SELECTORS):
|
||
raise ValueError("Нужны пять RAW-параметров")
|
||
frames = []
|
||
for selector, value in zip(MASTER_SELECTORS, values):
|
||
if selector[1:] == bytes.fromhex("01 30 07"):
|
||
selector = selector[:3] + bytes([angle_subindex])
|
||
if not isinstance(value, int) or not -32768 <= value <= 32767:
|
||
raise ValueError("RAW должен быть INT16: -32768…32767")
|
||
data = bytes([node_id | (0x80 if mode == "dam" else 0)]) + selector[1:] + value.to_bytes(2, "little", signed=True) + b"\x00\x00"
|
||
frames.append(build_frame(identifier, data, ide=False))
|
||
return frames
|
||
|
||
|
||
# Display binding catalogue. None means library-dependent resolution, not degrees/%.
|
||
DISPLAY_PRESETS = {
|
||
"power": ("POWER · AC2 (RAW)", 0x3420, 2, None),
|
||
"rpm": ("RPM · обороты (×0.1)", 0x3080, 2, 0.1),
|
||
"angle": ("Угол · задание (×0.1°)", 0x3000, 7, 0.1),
|
||
"angle_actual": ("Угол · фактический (×0.1°)", 0x3000, 2, 0.1),
|
||
"power_percent": ("POWER% · AC2 (×0.1%)", 0x3430, 2, 0.1),
|
||
"rpm_percent": ("RPM% (×0.1)", 0x3090, 2, 0.1),
|
||
}
|
||
|
||
|
||
def display_preset(key, node, instance=1, dam=False):
|
||
"""Return a catalogue selector and its known scale, or None for RAW."""
|
||
if not 1 <= node <= 127 or not 1 <= instance <= 15:
|
||
raise ValueError("Node-ID: 1…127; instance: 1…15")
|
||
_, base, subindex, scale = DISPLAY_PRESETS[key]
|
||
selector = bytes([node | (0x80 if dam else 0)]) + (base + instance).to_bytes(2, "little") + bytes([subindex])
|
||
return selector.hex(" ").upper(), scale
|