@@ -120,6 +120,34 @@ def _state_label(value) -> str:
     return f"{label} ({code})"
 
 
+def _fault_label(value) -> str:
+    """Return a human-readable label for a raw fault code value."""
+    try:
+        from collector.fault_codes import fault_code_text
+    except Exception:
+        return ""
+    try:
+        code = int(value)
+    except (TypeError, ValueError):
+        return ""
+    text = fault_code_text(code)
+    return text if text else ""
+
+
+def _warning_label(value) -> str:
+    """Return a human-readable label for a raw warning code value."""
+    try:
+        from collector.fault_codes import warning_code_text
+    except Exception:
+        return ""
+    try:
+        code = int(value)
+    except (TypeError, ValueError):
+        return ""
+    text = warning_code_text(code)
+    return text if text else ""
+
+
 # ── endpoints ────────────────────────────────────────────────────────────────
 
 @app.get("/api/status")
@@ -156,6 +184,20 @@ def api_status():
                 "unit": "",
             }
 
+        # Human-readable fault/warning labels alongside the raw codes.
+        for raw_name, label_name, label_fn in (
+            ("fault_code", "fault_code_text", _fault_label),
+            ("warning_code", "warning_code_text", _warning_label),
+            ("internal_fault", "internal_fault_text", _fault_label),
+            ("bms_fault_code", "bms_fault_code_text", _fault_label),
+            ("bms_warning_code", "bms_warning_code_text", _warning_label),
+        ):
+            if raw_name in registers:
+                registers[label_name] = {
+                    "value": label_fn(registers[raw_name]["value"]),
+                    "unit": "",
+                }
+
         return {
             "snapshot_id": snap_id,
             "timestamp": ts_aware.isoformat(),
@@ -438,6 +480,20 @@ def api_summary():
                 "unit": "",
             }
 
+        # Human-readable fault/warning labels alongside the raw codes.
+        for raw_name, label_name, label_fn in (
+            ("fault_code", "fault_code_text", _fault_label),
+            ("warning_code", "warning_code_text", _warning_label),
+            ("internal_fault", "internal_fault_text", _fault_label),
+            ("bms_fault_code", "bms_fault_code_text", _fault_label),
+            ("bms_warning_code", "bms_warning_code_text", _warning_label),
+        ):
+            if raw_name in registers:
+                registers[label_name] = {
+                    "value": label_fn(registers[raw_name]["value"]),
+                    "unit": "",
+                }
+
         return {
             "snapshot_id": snap_id,
             "timestamp": ts_aware.isoformat(),
 
@@ -633,7 +633,9 @@ <h3>Timer Schedule</h3>
       ${prop('Frequency','eps_frequency',{suffix:' Hz', digits:2})}
       ${prop('State','state',{int:1})}
       ${prop('Fault Code','fault_code',{int:1})}
+      ${prop('Fault','fault_code_text')}
       ${prop('Warning Code','warning_code',{int:1})}
+      ${prop('Warning','warning_code_text')}
       ${prop('Runtime','runtime',{suffix:' s', int:1})}
     </div></div></div><div class="card"><div class="card-section"><h3>Temperatures</h3><div class="props">
       ${prop('Inverter','temp_inverter',{suffix:' °C'})}
@@ -719,11 +721,17 @@ <h3>Timer Schedule</h3>
     content.querySelectorAll('[data-reg]').forEach(el => {
       const v = val(liveData, el.dataset.reg, null);
       if (v !== null && v !== undefined) {
-        const fmtFn = el.dataset.int ? fmtInt : (el.dataset.digits ? (n=>fmt(n, Number(el.dataset.digits))) : fmt);
-        let text = fmtFn(v);
-        if (text === null || text === undefined) text = '--';
-        if (el.dataset.suffix) text += el.dataset.suffix;
-        el.textContent = text;
+        // String values (e.g. fault/warning text) are shown as-is; numeric
+        // values go through the formatter.
+        if (typeof v === 'string') {
+          el.textContent = v || '—';
+        } else {
+          const fmtFn = el.dataset.int ? fmtInt : (el.dataset.digits ? (n=>fmt(n, Number(el.dataset.digits))) : fmt);
+          let text = fmtFn(v);
+          if (text === null || text === undefined) text = '--';
+          if (el.dataset.suffix) text += el.dataset.suffix;
+          el.textContent = text;
+        }
       }
     });
   }
 
@@ -0,0 +1,128 @@
+"""Fault and warning code tables for the LuxPower / EG4 inverter family.
+
+These tables translate the raw integer codes reported in the input registers
+(6 = internal fault, 60-61 = fault code, 62-63 = warning code, 99 = BMS fault,
+100 = BMS warning) into human-readable descriptions.
+
+Source: the official LuxPower Modbus protocol PDF (06-01-01-PTC-Luxpower
+MODBUS Protocol_2024.04.26.pdf) and the EG4 18KPV Modbus protocol PDF, as
+extracted into `docs/reference/luxpower-ha-register-map.md`. LuxPower and EG4
+share the protocol, so these tables apply across the whole family.
+
+The codes are bit-packed 32-bit values (low word + high word). A single
+register can carry multiple simultaneous faults/warnings, so the decode
+helpers return a list of descriptions rather than a single string.
+"""
+from __future__ import annotations
+
+from typing import List, Optional
+
+# ── Fault codes (input registers 6, 60-61) ─────────────────────────────────
+
+FAULT_CODES: dict[int, str] = {
+    0: "Internal communication failure 1",
+    1: "Model fault",
+    8: "Parallel CAN communication failure",
+    9: "The host is missing",
+    10: "Inconsistent rated power",
+    11: "Inconsistent AC or safety settings",
+    12: "UPS short circuit",
+    13: "UPS reverse current",
+    14: "BUS short circuit",
+    15: "Abnormal phase in three-phase system",
+    16: "Relay failure",
+    17: "Internal communication failure 2",
+    18: "Internal communication failure 3",
+    19: "BUS overvoltage",
+    20: "EPS connection fault",
+    21: "PV overvoltage",
+    22: "Overcurrent protection",
+    23: "Neutral fault",
+    24: "PV short circuit",
+    25: "Heatsink temperature out of range",
+    26: "Internal failure",
+    27: "Consistency failure",
+    28: "Inconsistent generator connection",
+    29: "Parallel sync signal loss",
+    31: "Internal communication failure 4",
+}
+
+# ── Warning codes (input registers 62-63, 100) ─────────────────────────────
+
+WARNING_CODES: dict[int, str] = {
+    0: "Battery communication failed",
+    1: "AFCI communication failure",
+    2: "Battery low temperature",
+    3: "Meter communication failed",
+    4: "Battery cannot be charged/discharged",
+    5: "Automated test failed",
+    6: "RSD active",
+    7: "LCD communication failure",
+    8: "Software version mismatch",
+    9: "Fan is stuck",
+    10: "Grid overload",
+    11: "Parallel secondaries exceed limit",
+    12: "Battery reverse MOS abnormal",
+    13: "Radiator temperature out of range",
+    14: "Multiple primary units in parallel",
+    15: "Battery reverse",
+    16: "No grid connection",
+    17: "Grid voltage out of range",
+    18: "Grid frequency out of range",
+    20: "Insulation resistance low",
+    21: "Leakage current too high",
+    22: "DCI exceeded standard",
+    23: "PV short circuit",
+    25: "Battery overvoltage",
+    26: "Battery undervoltage",
+    27: "Battery open circuit",
+    28: "EPS overload",
+    29: "EPS voltage high",
+    30: "Meter reversed",
+    31: "DCV exceeded standard",
+}
+
+
+def _decode_bits(value: int, table: dict[int, str]) -> List[str]:
+    """Decode a bit-packed code value into a list of descriptions.
+
+    Each set bit (or, for the single-register internal/BMS codes, the raw
+    integer value) maps to a description. Returns an empty list when the
+    value is 0 (no fault/warning) or has no known bits set.
+    """
+    if value is None or value == 0:
+        return []
+
+    # Single-register codes (internal fault, BMS fault/warning) are plain
+    # integers, not bitmasks. Try a direct lookup first.
+    if value in table:
+        return [table[value]]
+
+    # Bit-packed 32-bit codes: each set bit is a distinct fault/warning.
+    names: List[str] = []
+    for bit in range(32):
+        if value & (1 << bit):
+            name = table.get(bit)
+            if name:
+                names.append(name)
+    return names
+
+
+def decode_fault_code(value: Optional[int]) -> List[str]:
+    """Return the list of fault descriptions for a raw fault code value."""
+    return _decode_bits(value, FAULT_CODES)
+
+
+def decode_warning_code(value: Optional[int]) -> List[str]:
+    """Return the list of warning descriptions for a raw warning code value."""
+    return _decode_bits(value, WARNING_CODES)
+
+
+def fault_code_text(value: Optional[int]) -> str:
+    """Return a comma-joined human-readable fault string ('' when none)."""
+    return ", ".join(decode_fault_code(value))
+
+
+def warning_code_text(value: Optional[int]) -> str:
+    """Return a comma-joined human-readable warning string ('' when none)."""
+    return ", ".join(decode_warning_code(value))
@@ -0,0 +1,70 @@
+"""Tests for the fault/warning code decode tables."""
+
+import pytest
+
+from collector.fault_codes import (
+    FAULT_CODES,
+    WARNING_CODES,
+    decode_fault_code,
+    decode_warning_code,
+    fault_code_text,
+    warning_code_text,
+)
+
+
+def test_fault_code_single_register():
+    # Internal fault register 6 = 19 -> BUS overvoltage
+    assert fault_code_text(19) == "BUS overvoltage"
+
+
+def test_fault_code_bitmask_multiple():
+    # Bits 19 (BUS overvoltage) + 21 (PV overvoltage)
+    raw = (1 << 19) | (1 << 21)
+    names = decode_fault_code(raw)
+    assert "BUS overvoltage" in names
+    assert "PV overvoltage" in names
+
+
+def test_warning_code_bitmask_multiple():
+    # Bits 16 (no grid) + 17 (grid voltage out of range)
+    raw = (1 << 16) | (1 << 17)
+    names = decode_warning_code(raw)
+    assert "No grid connection" in names
+    assert "Grid voltage out of range" in names
+
+
+def test_zero_code_returns_empty():
+    assert decode_fault_code(0) == []
+    assert decode_warning_code(0) == []
+    assert fault_code_text(0) == ""
+    assert warning_code_text(0) == ""
+
+
+def test_none_code_returns_empty():
+    assert decode_fault_code(None) == []
+    assert decode_warning_code(None) == []
+
+
+def test_unknown_code_returns_empty():
+    # A bit with no known mapping (e.g. bit 30 for fault) -> empty
+    assert decode_fault_code(1 << 30) == []
+
+
+def test_tables_are_complete():
+    # Sanity: the tables contain the known code ranges from the protocol doc.
+    assert 19 in FAULT_CODES  # BUS overvoltage
+    assert 23 in FAULT_CODES  # Neutral fault
+    assert 16 in WARNING_CODES  # No grid connection
+    assert 31 in WARNING_CODES  # DCV exceeded standard
+
+
+def test_api_fault_label():
+    from api import _fault_label, _warning_label
+    assert _fault_label(19) == "BUS overvoltage"
+    assert _fault_label(0) == ""
+    assert _warning_label(16) == "No grid connection"
+    assert _warning_label(0) == ""
+    # 32-bit packed fault code (bits 19 + 21)
+    packed = (1 << 19) | (1 << 21)
+    assert "BUS overvoltage" in _fault_label(packed)
+    assert "PV overvoltage" in _fault_label(packed)