Serial for url (#76)

turbokongen · web-flow · commit 43f0cee30eba · 2022-07-10T18:27:09.000+02:00
* Change to serial_for_url

Replace Serial() by serial_for_url()

* First go at adding support for tcp/ip

* Remove data for schema

* Catch serial exceptions

* TCP also needs to know parity and baudrate

* hacsfest

* hacsfest
diff --git a/custom_components/ams/__init__.py b/custom_components/ams/__init__.py
@@ -23,7 +23,10 @@
     CONF_BAUDRATE,
     CONF_METER_MANUFACTURER,
     CONF_PARITY,
+    CONF_PROTOCOL,
     CONF_SERIAL_PORT,
+    CONF_TCP_HOST,
+    CONF_TCP_PORT,
     DEFAULT_BAUDRATE,
     DEFAULT_METER_MANUFACTURER,
     DEFAULT_PARITY,
@@ -37,7 +40,9 @@
     KAIFA_METER_SEQ,
     KAIFA_SE_METER_SEQ,
     KAMSTRUP_METER_SEQ,
+    NETWORK,
     SENSOR_ATTR,
+    SERIAL,
     SIGNAL_NEW_AMS_SENSOR,
     SIGNAL_UPDATE_AMS
 )
@@ -115,22 +120,40 @@ class AmsHub:
 
     def __init__(self, hass, entry):
         """Initialize the AMS hub."""
+        _LOGGER.debug("config entry = %s", entry)
         self._hass = hass
-        port = entry.get(CONF_SERIAL_PORT)
-        _LOGGER.debug("Connecting to HAN using port %s", port)
-        parity = entry.get(CONF_PARITY)
         self.meter_manufacturer = entry.get(CONF_METER_MANUFACTURER)
         self.sensor_data = {}
         self._attrs = {}
         self._running = True
-        self._ser = serial.Serial(
-            port=port,
-            baudrate=entry.get(CONF_BAUDRATE, DEFAULT_BAUDRATE),
-            parity=parity,
-            stopbits=serial.STOPBITS_ONE,
-            bytesize=serial.EIGHTBITS,
-            timeout=DEFAULT_TIMEOUT,
-        )
+        if entry.get(CONF_PROTOCOL) == SERIAL:
+            port = entry.get(CONF_SERIAL_PORT)
+            _LOGGER.debug("Connecting to HAN using serialport %s", port)
+            try:
+                self._ser = serial.serial_for_url(
+                    port,
+                    baudrate=entry.get(CONF_BAUDRATE),
+                    parity=entry.get(CONF_PARITY),
+                    stopbits=serial.STOPBITS_ONE,
+                    bytesize=serial.EIGHTBITS,
+                    timeout=DEFAULT_TIMEOUT,
+                )
+            except serial.serialutil.SerialException as ex:
+                _LOGGER.warning("Serial error: %", ex)
+        if entry.get(CONF_PROTOCOL) == NETWORK:
+            port = f"socket://{entry.get(CONF_TCP_HOST)}:{entry.get(CONF_TCP_PORT)}"
+            _LOGGER.debug("Connecting to HAN using TCP/IP %s", port)
+            try:
+                self._ser = serial.serial_for_url(
+                    port,
+                    baudrate=entry.get(CONF_BAUDRATE, DEFAULT_BAUDRATE),
+                    parity=entry.get(CONF_PARITY, DEFAULT_PARITY),
+                    stopbits=serial.STOPBITS_ONE,
+                    bytesize=serial.EIGHTBITS,
+                    timeout=DEFAULT_TIMEOUT,
+                )
+            except serial.serialutil.SerialException as ex:
+                _LOGGER.warning("Serial error: %s", ex)
         self.connection = threading.Thread(target=self.connect, daemon=True)
         self.connection.start()
         _LOGGER.debug("Finish init of AMS")
diff --git a/custom_components/ams/config_flow.py b/custom_components/ams/config_flow.py
@@ -10,14 +10,37 @@
     CONF_BAUDRATE,
     CONF_METER_MANUFACTURER,
     CONF_PARITY,
+    CONF_PROTOCOL,
+    CONF_TCP_HOST,
+    CONF_TCP_PORT,
     CONF_SERIAL_PORT,
     DEFAULT_BAUDRATE,
     DEFAULT_METER_MANUFACTURER,
     DEFAULT_PARITY,
     DOMAIN,
-    MANUFACTURER_OPTIONS
+    NETWORK,
+    MANUFACTURER_OPTIONS,
+    SERIAL,
+)
+DATA_SCHEMA_SELECT_PROTOCOL = vol.Schema(
+    {vol.Required("type"): vol.In([SERIAL, NETWORK])}
+)
+DATA_SCHEMA_NETWORK_DATA = vol.Schema(
+    {
+        vol.Required(CONF_TCP_HOST): str,
+        vol.Required(CONF_TCP_PORT): vol.All(vol.Coerce(int), vol.Range(0, 65535)),
+        vol.Required(
+            CONF_METER_MANUFACTURER,
+            default=DEFAULT_METER_MANUFACTURER
+        ): vol.In(MANUFACTURER_OPTIONS),
+        vol.Optional(
+            CONF_PARITY, default=DEFAULT_PARITY
+        ): vol.All(str),
+        vol.Optional(
+            CONF_BAUDRATE, default=DEFAULT_BAUDRATE
+        ): vol.All(int),
+    }
 )
-
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -30,25 +53,44 @@ class AmsFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
     def __init__(self):
         """Initialize."""
         self._errors = {}
+        self.connection_type = None
 
     async def async_step_user(self, user_input=None):
-        """Handle a flow initialized by the user."""
+        """Handle selection of protocol."""
+        if user_input is not None:
+            self.connection_type = user_input["type"]
+            if self.connection_type == NETWORK:
+                return await self.async_step_network_connection()
+            if self.connection_type == SERIAL:
+                return await self.async_step_serial_connection()
+
+        return self.async_show_form(
+            step_id="user", data_schema=DATA_SCHEMA_SELECT_PROTOCOL, errors=self._errors
+        )
+
+    async def async_step_serial_connection(self, user_input=None):
+        """Handle the serialport connection step."""
         portdata = await self.hass.async_add_executor_job(devices.comports)
         ports = [(comport.device + ": " + comport.description) for
                  comport in portdata]
 
         if user_input is not None:
+            user_input[CONF_PROTOCOL] = self.connection_type
             user_selection = user_input[CONF_SERIAL_PORT]
             port = portdata[ports.index(user_selection)]
             serial_by_id = await self.hass.async_add_executor_job(
                 get_serial_by_id, port.device
             )
             user_input[CONF_SERIAL_PORT] = serial_by_id
-            return self.async_create_entry(title="AMS Reader",
-                                           data=user_input)
+            entry_result = self.async_create_entry(
+                title="AMS Reader", data=user_input,
+            )
+            if entry_result:
+                return entry_result
+
         _LOGGER.debug(ports)
         return self.async_show_form(
-            step_id="user",
+            step_id="serial_connection",
             data_schema=vol.Schema(
                 {
                     vol.Required(
@@ -66,15 +108,25 @@ async def async_step_user(self, user_input=None):
                     ): vol.All(int),
                 }
             ),
-            description_placeholders={
-                CONF_SERIAL_PORT: ports,
-                CONF_METER_MANUFACTURER: MANUFACTURER_OPTIONS,
-                CONF_PARITY: DEFAULT_PARITY,
-                CONF_BAUDRATE: DEFAULT_BAUDRATE,
-            },
             errors=self._errors,
         )
 
+    async def async_step_network_connection(self, user_input=None):
+        """Handle the network connection step."""
+        if user_input:
+            user_input[CONF_PROTOCOL] = self.connection_type
+            entry_result = self.async_create_entry(
+                title="AMS Reader", data=user_input,
+            )
+            if entry_result:
+                return entry_result
+
+        return self.async_show_form(
+            step_id="network_connection",
+            data_schema=DATA_SCHEMA_NETWORK_DATA,
+            errors={},
+        )
+
     async def async_step_import(self, import_config):
         """Import a config flow from configuration."""
         if self._async_current_entries():
diff --git a/custom_components/ams/const.py b/custom_components/ams/const.py
@@ -54,11 +54,17 @@
 CONF_METER_MANUFACTURER = HAN_METER_MANUFACTURER
 CONF_PARITY = "parity"
 CONF_SERIAL_PORT = "serial_port"
+CONF_TCP_PORT = "tcp_port"
+CONF_TCP_HOST = "tcp_host"
+CONF_PROTOCOL = "protocol"
+CONF_PROTOCOL_CONFIG = "protocol_config"
 
 ATTR_DEVICE_CLASS = "device_class"
 ATTR_LAST_RESET = "last_reset"
 ATTR_STATE_CLASS = "state_class"
 DEVICE_CLASS_ENERGY = "energy"
+SERIAL = "Serial port"
+NETWORK = "TCP/IP"
 STATE_CLASS_TOTAL_INCREASING = "total_increasing"
 
 DOMAIN = "ams"
diff --git a/custom_components/ams/translations/en.json b/custom_components/ams/translations/en.json
@@ -6,12 +6,28 @@
         "title": "AMS Reader",
         "step": {
             "user": {
-                "description": "Setup AMS sensors",
+                "description": "Choose protocol for communications",
+                "data": {
+                    "type": "Protocol type"
+                }
+            },
+            "network_connection": {
+                "description": "Setup options for TCP/IP connection",
+                "data": {
+                    "tcp_host": "IP address",
+                    "tcp_port": "Port",
+                    "parity": "Parity",
+                    "baudrate": "Baud rate",
+                    "meter_manufacturer": "Meter manufacturer"
+                }
+            },
+            "serial_connection": {
+                "description": "Setup options for serial communication",
                 "data": {
                     "serial_port": "Serial Port",
                     "parity": "Parity",
                     "meter_manufacturer": "Meter manufacturer",
-                    "baudrate": "Baudrate"
+                    "baudrate": "Baud rate"
                 }
             }
         },
diff --git a/custom_components/ams/translations/nb.json b/custom_components/ams/translations/nb.json
@@ -3,10 +3,25 @@
         "abort": {
            "single_instance_allowed": "Kun en oppføring av hass-AMS er tillatt"
         },
-        "title": "AMS Leser",
         "step": {
             "user": {
-                "description": "Installer sensorer for AMS leser",
+                "description": "Velg kommunikasjonsprotokoll for inndata",
+                "data":{
+                    "type": "Protokolltype"
+                }
+            },
+            "network_connection": {
+                "description": "Velg data for TCP/IP tilkobling",
+                "data": {
+                    "tcp_host": "IP adresse",
+                    "tcp_port": "Port",
+                    "parity": "Paritet",
+                    "baudrate": "Baudrate",
+                    "meter_manufacturer": "Måler produsent"
+                }
+            },
+            "serial_connection": {
+                "description": "Velg portdata for serietilkobling",
                 "data": {
                     "serial_port": "Serieport",
                     "parity": "Paritet",
diff --git a/custom_components/ams/translations/nn.json b/custom_components/ams/translations/nn.json
@@ -6,7 +6,25 @@
         "title": "AMS Lesar",
         "step": {
             "user": {
-                "description": "Installerar sensorar for AMS Lesar",
+                "description": "Velg kommunikasjonsprotokoll for inndata",
+                "data": {
+                    "type": "Protokolltype"
+                }
+            },
+            "network_connection": {
+                "title": "AMS Lesar",
+                "description": "Vel data for TCP/IP tilkobling",
+                "data": {
+                    "tcp_host": "IP adresse",
+                    "tcp_port": "Port",
+                    "parity": "Paritet",
+                    "baudrate": "Baudrate",
+                    "meter_manufacturer": "Målar produsent"
+                }
+            },
+            "serial_connection": {
+                "title": "AMS Noreg",
+                "description": "Vel portdata for serietilkobling",
                 "data": {
                     "serial_port": "Serieport",
                     "parity": "Paritet",
diff --git a/custom_components/ams/translations/no.json b/custom_components/ams/translations/no.json
@@ -6,7 +6,23 @@
         "title": "AMS Leser",
         "step": {
             "user": {
-                "description": "Installer sensorer for AMS i Norge",
+                "description": "Velg kommunikasjonsprotokoll for inndata",
+                "data":{
+                    "type": "Protokolltype"
+                }
+            },
+            "network_connection": {
+                "description": "Velg data for TCP/IP tilkobling",
+                "data": {
+                    "tcp_host": "IP adresse",
+                    "tcp_port": "Port",
+                    "parity": "Paritet",
+                    "baudrate": "Baudrate",
+                    "meter_manufacturer": "Måler produsent"
+                }
+            },
+            "serial_connection": {
+                "description": "Velg portdata for serietilkobling",
                 "data": {
                     "serial_port": "Serieport",
                     "parity": "Paritet",
diff --git a/custom_components/ams/translations/se.json b/custom_components/ams/translations/se.json
@@ -6,7 +6,23 @@
         "title": "AMS Reader",
         "step": {
             "user": {
-                "description": "Installera sensor för AMS läsare",
+                "description": "Välj kommunikastionsprotokoll för inndata",
+                "data":{
+                    "type": "Protokolltyp"
+                }
+            },
+            "network_connection": {
+                "description": "Välj data för TCP/IP tilkobling",
+                "data": {
+                    "tcp_host": "IP adress",
+                    "tcp_port": "Port",
+                    "parity": "Paritet",
+                    "baudrate": "Baudrate",
+                    "meter_manufacturer": "Mätartilverkare"
+                }
+            },
+            "serial_connection": {
+                "description": "Välj data for seriell anslutning",
                 "data": {
                     "serial_port": "Serieport",
                     "parity": "Paritet",
