@@ -47,12 +47,7 @@ def get_sensor_info(sensor: Sensor | str | None) -> str:
         """Sensor info."""
         if not sensor:
             return ""
-        if isinstance(sensor, str):
-            return sensor
-        reg = (
-            str(sensor.address[0]) if len(sensor.address) == 1 else str(sensor.address)
-        )
-        return reg
+        return sensor if isinstance(sensor, str) else sensor.source
 
     headers = ["Name", *sorted(all_defs), "Group"]
     data = table_data(sensors.values(), headers)
 
@@ -6,6 +6,7 @@
 from pathlib import Path
 
 from sunsynk import VERSION
+from sunsynk.utils import pretty_table_sensors
 
 from .a_inverter import STATE
 from .a_sensor import MQTT, SS_TOPIC
@@ -66,6 +67,11 @@ async def main_loop() -> int:
             await ist.hass_discover_sensors()
             ist.cb = build_callback_schedule(ist)
             CALLBACKS.append(ist.cb)
+
+            # Add info from the callback schedules?
+            tab = pretty_table_sensors(list(SOPT), ist.inv, {})
+            _LOG.info("Inverter %s\n%s", ist.inv.port, tab)
+
         except (ConnectionError, ValueError) as err:
             ist.log_bold(str(err))
             _LOG.critical(
 
@@ -11,6 +11,7 @@
 from sunsynk.helpers import slug
 from sunsynk.rwsensors import RWSensor
 from sunsynk.sunsynk import Sensor, Sunsynk, ValType
+from sunsynk.utils import pretty_table_sensors
 
 from .a_sensor import MQTT, SS_TOPIC, ASensor
 from .options import OPT, InverterOptions
@@ -133,20 +134,19 @@ async def connect(self) -> None:
             raise ValueError(
                 f"Serial number mismatch. Expected {expected_ser}, got {actual_ser}"
             )
-        self.log_bold(f"Inverter serial number '****{actual_ser[-4:]}'")
 
-        _LOG.info(
-            "Device type: %s, using the %s sensor definitions",
-            self.inv.state[DEFS.device_type],
-            OPT.sensor_definitions,
-        )
+        # All seem ok
+        add_info = {"device_type": f"\n(config: {OPT.sensor_definitions})"}
 
-        _LOG.info("Protocol version: %s", self.inv.state[DEFS.protocol])
+        tab = pretty_table_sensors(sensors, self.inv, add_info=add_info)
+        _LOG.info("Inverter %s - startup sensors\n%s", self.inv.port, tab)
 
         # Initial read for all sensors
         sensors = list(SOPT)
-        _LOG.info("Reading all sensors %s", ", ".join(s.name for s in sensors))
+        _LOG.info("Reading configured sensors %s", len(sensors))
         await self.read_sensors(sensors=sensors)
+        # tab = pretty_table_sensors(sensors, self.inv)
+        # _LOG.info("Inverter %s - active sensors\n%s", self.inv.port, tab)
 
     @property
     def rated_power(self) -> float:
 
@@ -35,6 +35,21 @@ def id(self) -> str:
         """Get the sensor ID."""
         return slug(self.name)
 
+    @property
+    def source(self) -> str:
+        """Return the source of the sensor."""
+        res = (
+            f"[{self.address[0]}]"
+            if len(self.address) == 1
+            else str(self.address).replace("(", "[").replace(")", "]").replace(" ", "")
+        )
+        if self.bitmask:
+            res += f" & 0x{self.bitmask:02X}"
+        sig = " S" if self.factor == -1 else ""
+        if abs(self.factor) != 1:
+            res += f" * {abs(self.factor)}"
+        return f"{res}{sig}"
+
     def reg_to_value(self, regs: RegType) -> ValType:
         """Return the value from the registers."""
         regs = self.masked(regs)
 
@@ -6,10 +6,14 @@
 from pathlib import Path
 from textwrap import wrap
 from types import ModuleType
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from prettytable import PrettyTable
 
+if TYPE_CHECKING:
+    from sunsynk.sensors import Sensor
+    from sunsynk.sunsynk import Sunsynk
+
 
 def import_module(mod_name: str, folder: str | Path | None = None) -> ModuleType:
     """import_module."""
@@ -57,15 +61,9 @@ def pretty_table[T](
         if calculated_cols:
             for colidx, func in calculated_cols.items():
                 row[int(colidx)] = func(row_any)
-
-        if wrap_length == 0 or not any(len(v) > wrap_length for v in row):
-            table.add_row(row)
-            continue
-
-        row_wrap = [wrap(v, wrap_length) for v in row]
-        while any(row_wrap):
-            table.add_row([r[0] if r else "" for r in row_wrap])
-            row_wrap = [r[1:] for r in row_wrap]
+        if wrap_length > 0:
+            row = ["\n".join(wrap(v, wrap_length)) for v in row]
+        table.add_row(row)
 
     return table
 
@@ -77,3 +75,19 @@ def table_data[T](
     if headers is None:
         headers = list({k for v in data for k in v.keys()})
     return headers, [[v.get(k) for k in headers] for v in data]
+
+
+def pretty_table_sensors(
+    sensors: list["Sensor"], inv: "Sunsynk", add_info: dict[str, str]
+) -> PrettyTable:
+    """Generate a pretty table for the given sensors."""
+    data: list[list[str]] = []
+    for sen in sorted(sensors, key=lambda s: s.address):
+        row = [sen.id, sen.source, f"{inv.state[sen]} {sen.unit}"]
+        if sen.id == "serial":
+            row[2] = f"****{row[2][-4:]}"
+        if addi := add_info.get(sen.id):
+            row[2] += f"{addi}"
+        data.append(row)
+
+    return pretty_table(["Sensor", "Source", "Value"], data, wrap_length=0)
@@ -274,3 +274,15 @@ def test_decode_fault() -> None:
     assert s.reg_to_value(regs) == "F32"
     regs = (0x0, 0x0, 0x1, 0x0)
     assert s.reg_to_value(regs) == "F33"
+
+
+def test_source() -> None:
+    """Test sensor source."""
+    assert Sensor(1, "test_sensor", "V", -1).source == "[1] S"
+    assert Sensor((1, 2), "test_sensor", "V", 10).source == "[1,2] * 10"
+    assert Sensor((1, 2), "test_sensor", "V", bitmask=0xA).source == "[1,2] & 0x0A"
+    assert (
+        Sensor((1, 2), "test_sensor", "V", bitmask=0xA, factor=-1).source
+        == "[1,2] & 0x0A S"
+    )
+    assert Sensor((1, 2), "test_sensor", "V", bitmask=0xEF1A).source == "[1,2] & 0xEF1A"