Ready for release

Author: Thulrus

LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Vegetronix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,3 +1,36 @@
 # VegeHub on HACS
 
-This is a Home Assistant integration designed to interface with the Vegetronix VegeHub. The version in this repository is intended to be accessed through HACS, but can also be manually installed into the `custom_components` folder of your Home Assistant server if desired.
+[![vegetronix_badge](https://img.shields.io/badge/VEGETRONIX-VEGEHUB-green)](https://www.vegetronix.com/Products/VG-HUB-RELAY/)
+
+This is a [Home Assistant](https://www.home-assistant.io/) integration designed to interface with the [Vegetronix VegeHub](https://www.vegetronix.com/Products/VG-HUB-RELAY/). The version in this repository is intended to be accessed through [HACS](https://hacs.xyz/), but can also be manually installed into the `custom_components` folder of your Home Assistant server if desired.
+
+This integration allows Home Assistant to automatically detect the presence of VegeHub devices on the local network, and to set them up to report their data to Home Assistant. It also allows Home Assistant to control actuators on the VegeHub (as long as the VegeHub is awake).
+
+## Installation
+
+### HACS
+
+The easiest way to install this integration is through the Home Assistant Community Store [HACS](https://hacs.xyz/). Instructions for installing HACS can be found at their [website](https://hacs.xyz/docs/use/).
+
+Once HACS is installed, open it in Home Assistant, and search for VegeHub. Click the VegeHub integration, and then click `install`.
+
+If the integration does not show up in a HACS search, you can also add this repository as a `Custom repository` buy clicking the three dots in the top right corner of HACS and selecting `Custom repositories`. There you can add the URL of this repository and set the `type` to `integration`, and HACS will add it to its list of integrations.
+
+### Manual
+
+The integration can also be manually by copying the `vegehub` folder from the `custom_components` folder in this project into the `config->custom_components` folder in your Home Assistant instance. After the folder is copied into Home Assistant, Home Assistant should be restarted so that it can install the integration.
+
+## Instructions
+
+Once you have installed the integration, Home Assistant will start watching the local network for VegeHub devices. Whe it identifies one, it will present it in the `Discovered` devices in the `Settings->Devices & Services` menu. Click `Add`, and Home Assistant will contact the VegeHub, and set it up to report its data to Home Assistant.
+
+If your VegeHub does not show up in Home Assistant, make sure the device is awake, and connected to the same network as Home Assistant. Also make sure that the VegeHub device is awake throughout the integration setup process.
+
+> [!IMPORTANT]  
+> When the VegeHub gets set up, it points its data updates at your Home Assistant's IP address. If your Home Assistant instance changes IP address, the VegeHub will no longer be able to send it data, and you will have to do the setup process over again.
+
+Once setup is complete, the VegeHub device will be available in Home Assistant. If your device has actuators, they will show up as switches, and if your device has sensor inputs, they will show up as sensors.
+
+With a configured device in Home Assistant, you can go into the `Settings->Devices & Services` menu, and click on the VegeHub integration. With that open, you should see your device listed under `Integration entries`. Here you can click `configure` to select what kinds of sensors you are using on each channel of your VegeHub, as well as the default actuator command duration, if your device has actuators.
+
+If you click your device under `Integration entries`, you can use the pencil icon in the top bar to change its name, or click the individual sensors or switches to change their names, icons, units of measurement, etc.

custom_components/vegehub/__init__.py

@@ -6,7 +6,6 @@
 
 from aiohttp.hdrs import METH_POST
 from aiohttp.web import Request, Response
-from vegehub import VegeHub
 
 from homeassistant.components.http import HomeAssistantView
 from homeassistant.components.webhook import (
@@ -21,6 +20,7 @@
     EVENT_HOMEASSISTANT_STOP,
 )
 from homeassistant.core import HomeAssistant
+from vegehub import VegeHub
 
 from .const import DOMAIN, NAME, PLATFORMS
 from .coordinator import VegeHubConfigEntry, VegeHubCoordinator
@@ -50,6 +50,8 @@ async def unregister_webhook(_: Any) -> None:
 
     async def register_webhook() -> None:
         webhook_name = f"{NAME} {device_mac}"
+        if entry.data[CONF_WEBHOOK_ID] in hass.data.get("webhook", {}):
+            webhook_unregister(hass, entry.data[CONF_WEBHOOK_ID])
 
         webhook_register(
             hass,

custom_components/vegehub/config_flow.py

@@ -3,25 +3,31 @@
 import logging
 from typing import Any
 
-from vegehub import VegeHub
 import voluptuous as vol
 
 from homeassistant.components.webhook import (
     async_generate_id as webhook_generate_id,
     async_generate_url as webhook_generate_url,
 )
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.config_entries import (
+    ConfigEntry,
+    ConfigFlow,
+    ConfigFlowResult,
+    OptionsFlow,
+)
 from homeassistant.const import (
     CONF_DEVICE,
     CONF_HOST,
     CONF_IP_ADDRESS,
     CONF_MAC,
     CONF_WEBHOOK_ID,
 )
+from homeassistant.core import callback
 from homeassistant.helpers.service_info import zeroconf
 from homeassistant.util.network import is_ip_address
+from vegehub import VegeHub
 
-from .const import DOMAIN
+from .const import DOMAIN, OPTION_DATA_TYPE_CHOICES
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -166,3 +172,72 @@ async def _create_entry(self) -> ConfigFlowResult:
 
         # Create the config entry for the new device
         return self.async_create_entry(title=self._hostname, data=info_data)
+
+    @staticmethod
+    @callback
+    def async_get_options_flow(config_entry: ConfigEntry) -> OptionsFlow:
+        """Return the options flow handler for this integration."""
+        return VegehubOptionsFlowHandler(config_entry)
+
+
+class VegehubOptionsFlowHandler(OptionsFlow):
+    """Handle an options flow for VegeHub."""
+
+    def __init__(self, config_entry) -> None:
+        """Initialize VegeHub options flow."""
+        self.coordinator = config_entry.runtime_data
+
+    async def async_step_init(self, user_input=None) -> ConfigFlowResult:
+        """Manage the options for VegeHub."""
+        if user_input is not None:
+            # Update the config entry options with the new user input
+            self.hass.config_entries.async_update_entry(
+                self.config_entry, options=user_input
+            )
+
+            # Trigger a reload of the config entry to apply the new options
+            await self.hass.config_entries.async_reload(self.config_entry.entry_id)
+
+            # Process the user inputs and update the config entry options
+            return self.async_create_entry(title="", data=user_input)
+
+        num_sensors = self.coordinator.vegehub.num_sensors
+        num_actuators = self.coordinator.vegehub.num_actuators
+
+        options_schema: dict[Any, Any] = {}
+
+        if num_sensors > 0:
+            # Define the schema for the options that the user can modify
+            options_schema.update(
+                {
+                    vol.Required(
+                        f"data_type_{i + 1}",
+                        default=self.config_entry.options.get(
+                            f"data_type_{i + 1}", OPTION_DATA_TYPE_CHOICES[0]
+                        ),
+                    ): vol.In(OPTION_DATA_TYPE_CHOICES)
+                    for i in range(num_sensors)
+                }
+            )
+
+        # Check to see if there are actuators. If there are, add the duration field.
+        if num_actuators > 0:
+            # Get the current duration value from the config entry
+            current_duration = self.config_entry.options.get("user_act_duration", 0)
+            if current_duration <= 0:
+                current_duration = 600
+
+            options_schema.update(
+                {vol.Required("user_act_duration", default=current_duration): int}
+            )
+
+        _LOGGER.debug(
+            # Print the options schema to the log for debugging
+            "Options schema: %s",
+            options_schema,
+        )
+
+        # Show the form to the user with the current options
+        return self.async_show_form(
+            step_id="init", data_schema=vol.Schema(options_schema)
+        )

custom_components/vegehub/const.py

@@ -4,6 +4,11 @@
 
 DOMAIN = "vegehub"
 NAME = "VegeHub"
-PLATFORMS = [Platform.SENSOR]
+PLATFORMS = [Platform.SENSOR, Platform.SWITCH]
 MANUFACTURER = "vegetronix"
 MODEL = "VegeHub"
+OPTION_DATA_TYPE_CHOICES = [
+    "Raw Voltage",
+    "VH400",
+    "THERM200",
+]

custom_components/vegehub/coordinator.py

@@ -5,11 +5,10 @@
 import logging
 from typing import Any
 
-from vegehub import VegeHub, update_data_to_latest_dict
-
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+from vegehub import VegeHub, update_data_to_latest_dict
 
 _LOGGER = logging.getLogger(__name__)
 

custom_components/vegehub/sensor.py

@@ -1,27 +1,46 @@
 """Sensor configuration for VegeHub integration."""
 
 from itertools import count
+import logging
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
     SensorEntityDescription,
 )
-from homeassistant.const import UnitOfElectricPotential
+from homeassistant.const import PERCENTAGE, UnitOfElectricPotential, UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from vegehub import therm200_transform, vh400_transform
 
+from .const import OPTION_DATA_TYPE_CHOICES
 from .coordinator import VegeHubConfigEntry, VegeHubCoordinator
 from .entity import VegeHubEntity
 
+_LOGGING = logging.getLogger(__name__)
+
 SENSOR_TYPES: dict[str, SensorEntityDescription] = {
-    "analog_sensor": SensorEntityDescription(
+    OPTION_DATA_TYPE_CHOICES[0]: SensorEntityDescription(
         key="analog_sensor",
         translation_key="analog_sensor",
         device_class=SensorDeviceClass.VOLTAGE,
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         suggested_display_precision=2,
     ),
+    OPTION_DATA_TYPE_CHOICES[1]: SensorEntityDescription(
+        key="vh400_sensor",
+        translation_key="vh400_sensor",
+        device_class=SensorDeviceClass.MOISTURE,
+        native_unit_of_measurement=PERCENTAGE,
+        suggested_display_precision=2,
+    ),
+    OPTION_DATA_TYPE_CHOICES[2]: SensorEntityDescription(
+        key="therm200_sensor",
+        translation_key="therm200_sensor",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        suggested_display_precision=2,
+    ),
     "battery": SensorEntityDescription(
         key="battery",
         translation_key="battery",
@@ -45,12 +64,24 @@ async def async_setup_entry(
     # each sensor. This index is 1-based.
     update_index = count(1)
 
+    _LOGGING.debug("Options contents: %s", config_entry.options)
+
     # Add each analog sensor input
     for _i in range(coordinator.vegehub.num_sensors):
+        index = next(update_index)
+        data_type = config_entry.options.get(
+            f"data_type_{index}", OPTION_DATA_TYPE_CHOICES[0]
+        )
+        _LOGGING.debug(
+            "Sensor %s: %s = %s",
+            _i,
+            f"data_type_{index}",
+            data_type,
+        )
         sensor = VegeHubSensor(
-            index=next(update_index),
+            index=index,
             coordinator=coordinator,
-            description=SENSOR_TYPES["analog_sensor"],
+            description=SENSOR_TYPES[data_type],
         )
         sensors.append(sensor)
 
@@ -69,8 +100,6 @@ async def async_setup_entry(
 class VegeHubSensor(VegeHubEntity, SensorEntity):
     """Class for VegeHub Analog Sensors."""
 
-    _attr_device_class = SensorDeviceClass.VOLTAGE
-    _attr_native_unit_of_measurement = UnitOfElectricPotential.VOLT
     _attr_suggested_display_precision = 2
 
     def __init__(
@@ -84,13 +113,28 @@ def __init__(
         self.entity_description = description
         # Set unique ID for pulling data from the coordinator
         self._attr_unique_id = f"{self._mac_address}_{index}".lower()
-        if description.key == "analog_sensor":
+        if description.key != "battery":
             self._attr_translation_placeholders = {"index": str(index)}
         self._attr_available = False
+        self._attr_device_class = description.device_class
+        self._attr_native_unit_of_measurement = description.native_unit_of_measurement
 
     @property
     def native_value(self) -> float | None:
         """Return the sensor's current value."""
         if self.coordinator.data is None or self._attr_unique_id is None:
             return None
-        return self.coordinator.data.get(self._attr_unique_id)
+        val = self.coordinator.data.get(self._attr_unique_id)
+        _LOGGING.debug(
+            "Sensor %s: %s = %s",
+            self._attr_unique_id,
+            self.entity_description.key,
+            val,
+        )
+        if self.entity_description.key == "vh400_sensor":
+            # Convert the vh400 sensor value to percentage
+            return vh400_transform(val)
+        if self.entity_description.key == "therm200_sensor":
+            # Convert the therm200 sensor value to Celsius
+            return therm200_transform(val)
+        return val

custom_components/vegehub/strings.json

@@ -14,8 +14,8 @@
         }
       },
       "zeroconf_confirm": {
-        "title": "[%key:component::vegehub::config::step::user::title%]",
-        "description": "[%key:component::vegehub::config::step::user::description%]"
+        "title": "Set up VegeHub",
+        "description": "Do you want to set up this VegeHub?"
       }
     },
     "error": {
@@ -36,9 +36,49 @@
       "analog_sensor": {
         "name": "Input {index}"
       },
+      "vh400_sensor": {
+        "name": "Input {index} (moisture)"
+      },
+      "therm200_sensor": {
+        "name": "Input {index} (temperature)"
+      },
       "battery": {
         "name": "Battery"
       }
+    },
+    "switch": {
+      "switch": {
+        "name": "Actuator {index}"
+      }
+    }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "title": "Configure VegeHub",
+        "data": {
+          "user_act_duration": "Default actuator duration (in seconds)",
+          "data_type_1": "Input 1 sensor type",
+          "data_type_2": "Input 2 sensor type",
+          "data_type_3": "Input 3 sensor type",
+          "data_type_4": "Input 4 sensor type",
+          "data_type_5": "Input 5 sensor type",
+          "data_type_6": "Input 6 sensor type",
+          "data_type_7": "Input 7 sensor type",
+          "data_type_8": "Input 8 sensor type"
+        },
+        "data_description": {
+          "user_act_duration": "Length of time that an actuator command will endure",
+          "data_type_1": "Select the type of sensor connected to input 1",
+          "data_type_2": "Select the type of sensor connected to input 2",
+          "data_type_3": "Select the type of sensor connected to input 3",
+          "data_type_4": "Select the type of sensor connected to input 4",
+          "data_type_5": "Select the type of sensor connected to input 5",
+          "data_type_6": "Select the type of sensor connected to input 6",
+          "data_type_7": "Select the type of sensor connected to input 7",
+          "data_type_8": "Select the type of sensor connected to input 8"
+        }
+      }
     }
   }
-}
+}