update 0.0.1

script0803 · script0803 · commit 3384c5999044 · 2024-08-28T14:37:54.000+08:00
diff --git a/custom_components/bituopmd/button.py b/custom_components/bituopmd/button.py
@@ -30,16 +30,20 @@ async def async_setup_entry(hass, entry, async_add_entities):
         device_info = await coordinator.fetch_device_info()
     except UpdateFailed:
         _LOGGER.error("Failed to fetch device info for %s", host_ip)
-        device_info = {"model": "Unknown Model", "fw_version": "Unknown"}
+        device_info = {"model": "Unknown Model", "fw_version": "Unknown", "manufacturer": "Unknown", "MCUVersion": "Unknown", "manufacturer": "Unknown", "mcu_version": "Unknown"}
 
     buttons = []
+
+    sensor_coordinator = hass.data[DOMAIN][entry.entry_id]['sensor_coordinator']
+    buttons.append(DataRefreshButton(sensor_coordinator, host_ip, device_info["model"], device_info["fw_version"], device_info["manufacturer"], device_info["mcu_version"]))
+
     if coordinator.data:
         for field, action in coordinator.data.items():
             if "switch" in field.lower():
                 continue  # Skip buttons with 'switch' in the name
             if field == "zero":
                 field = "zero_Energy"  # Rename 'zero' to 'zeroenergy'
-            buttons.append(BituoButton(coordinator, host_ip, field, action, device_info["model"], device_info["fw_version"]))
+            buttons.append(BituoButton(coordinator, host_ip, field, action, device_info["model"], device_info["fw_version"], device_info["manufacturer"], device_info["mcu_version"]))
 
     async_add_entities(buttons, True)
 
@@ -71,26 +75,30 @@ async def fetch_device_info(self):
             return {
                 "model": data.get("productModel") or data.get("ProductModel", "Unknown Model"),
                 "fw_version": data.get("FWVersion") or data.get("fwVersion", "Unknown"),
+                "manufacturer": data.get("Manufactor", "Unknown"),
+                "mcu_version": data.get("MCUVersion", "Unknown"),
             }
         except Exception as err:
             raise UpdateFailed(f"Error fetching device info: {err}")
 
 class BituoButton(CoordinatorEntity, ButtonEntity):
     """Representation of a Button."""
 
-    def __init__(self, coordinator, host_ip, field, action, model, fw_version):
+    def __init__(self, coordinator, host_ip, field, action, model, fw_version, manufacturer, mcu_version):
         """Initialize the button."""
         super().__init__(coordinator)
         self._field = field
         self._action = action
         self._attr_name = f"{field.replace('_', ' ').title()}"
         self._attr_unique_id = f"{host_ip}_{field}"
+        self.entity_id = f"button.{host_ip.replace('.', '_')}_{self.format_field_entity_id(field)}"
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, host_ip)},
             name=f"{model} - {host_ip}",
-            manufacturer="BituoTechnik",
+            manufacturer=manufacturer,
             model=model,
-            sw_version=fw_version,
+            sw_version=f"S{fw_version}_M{self.format_version(mcu_version)}",
+            configuration_url=f"http://{host_ip}"  # embed URL
         )
         self._host_ip = host_ip
 
@@ -99,5 +107,71 @@ async def async_press(self):
         await self.hass.async_add_executor_job(
             requests.get, f"http://{self._host_ip}/{self._action}"
         )
+    
+    @staticmethod
+    def format_field_entity_id(field):
+        """Format field name to be more suitable for unique_id."""
+        formatted_name = ''.join(['_' + char.lower() if char.isupper() else char for char in field])
+        return formatted_name.strip('_')
+    
+    @staticmethod
+    def format_version(version):
+        if version.lower() == "unknown":
+            return version 
+        parts = version.split('.')
+        formatted_parts = [] 
+        for part in parts:
+            if part.strip():  # 检查部分是否为空
+                try:
+                    formatted_parts.append(str(int(part)))
+                except ValueError:
+                    formatted_parts.append('unknown')
+            else:
+                formatted_parts.append('unknown')  # 如果部分为空，设置为 'unknown'
+        
+        formatted_version = '.'.join(formatted_parts)
+        return formatted_version
+    
+class DataRefreshButton(CoordinatorEntity, ButtonEntity):
+    """Representation of a Data Refresh Button."""
+
+    def __init__(self, coordinator, host_ip, model, fw_version, manufacturer, mcu_version):
+        """Initialize the button."""
+        super().__init__(coordinator)
+        self._attr_name = "Data Refresh"
+        self._attr_unique_id = f"{host_ip}_data_refresh"
+        self.entity_id = f"button.{host_ip.replace('.', '_')}_data_refresh"
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, host_ip)},
+            name=f"{model} - {host_ip}",
+            manufacturer=manufacturer,
+            model=model,
+            sw_version=f"S{fw_version}_M{self.format_version(mcu_version)}",
+            configuration_url=f"http://{host_ip}"  # embed URL
+        )
+        self._host_ip = host_ip
+        self._attr_icon = "mdi:refresh"
+
+    async def async_press(self):
+        """Handle the button press to refresh data."""
+        await self.coordinator.async_request_refresh()
+
+    @staticmethod
+    def format_version(version):
+        if version.lower() == "unknown":
+            return version 
+        parts = version.split('.')
+        formatted_parts = [] 
+        for part in parts:
+            if part.strip():  # 检查部分是否为空
+                try:
+                    formatted_parts.append(str(int(part)))
+                except ValueError:
+                    formatted_parts.append('unknown')
+            else:
+                formatted_parts.append('unknown')  # 如果部分为空，设置为 'unknown'
+        
+        formatted_version = '.'.join(formatted_parts)
+        return formatted_version
 
 # by Script0803
diff --git a/custom_components/bituopmd/config_flow.py b/custom_components/bituopmd/config_flow.py
@@ -18,6 +18,7 @@ def __init__(self):
         self.host = None
         self.name = None
         self.devices = []
+        self._manual_scan_active = False
 
     async def async_step_user(self, user_input=None):
         errors = {}
@@ -45,6 +46,11 @@ async def async_step_zeroconf(self, discovery_info: ZeroconfServiceInfo):
 
         if "bituotechnik" not in self.name.lower():
             return self.async_abort(reason="not_bituotechnik_device")
+        
+        existing_entries = self._async_current_entries()
+        if any(entry.data.get(CONF_HOST_IP) == self.host for entry in existing_entries):
+            _LOGGER.info(f"Device {self.name} at {self.host} already configured, ignoring discovery.")
+            return self.async_abort(reason="already_configured")
 
         await self.async_set_unique_id(self.host)
         self._abort_if_unique_id_configured()
@@ -61,12 +67,22 @@ async def async_step_zeroconf(self, discovery_info: ZeroconfServiceInfo):
     async def async_step_zeroconf_confirm(self, user_input=None):
         """Handle zeroconf discovery confirmation."""
         if user_input is not None:
+            # 检查设备是否已经存在于当前配置的设备列表中
+            existing_entries = self._async_current_entries()
+            if any(entry.data.get(CONF_HOST_IP) == self.host for entry in existing_entries):
+                _LOGGER.info(f"Device {self.name} at {self.host} is already configured, aborting configuration.")
+                return self.async_abort(reason="already_configured")
+
+            # 如果设备没有配置，继续创建配置条目
             entry = self.async_create_entry(
                 title=self.name,
                 data={CONF_HOST_IP: self.host}
             )
-            # remove paired device
+            
+            # 在设备配对成功后，移除已配对的设备
             self.devices = [device for device in self.devices if device["ip"] != self.host]
+            await self.async_remove_discovered_device(self.host)
+            
             return entry
 
         data_schema = vol.Schema({
@@ -116,9 +132,32 @@ async def async_step_zeroconf_discovery_selected(self, user_input=None):
         if user_input is not None:
             selected_device_ip = user_input["device"]
             selected_device_name = next(device["name"] for device in self.devices if device["ip"] == selected_device_ip)
-            return self.async_create_entry(title=f"{selected_device_name} - {selected_device_ip}", data={CONF_HOST_IP: selected_device_ip})
+
+            # 检查设备是否已经配置
+            existing_entries = self._async_current_entries()
+            if any(entry.data.get(CONF_HOST_IP) == selected_device_ip for entry in existing_entries):
+                _LOGGER.info(f"Device {selected_device_name} at {selected_device_ip} already configured, ignoring.")
+                return self.async_abort(reason="already_configured")  # 终止重复配置
+
+            # 创建配置条目
+            entry = self.async_create_entry(title=f"{selected_device_name} - {selected_device_ip}", data={CONF_HOST_IP: selected_device_ip})
+
+            # 成功配对后移除设备
+            await self.async_remove_discovered_device(selected_device_ip)
+
+            return entry
 
         return self.async_abort(reason="no_device_selected")
+    
+    async def async_remove_discovered_device(self, host_ip):
+        """Remove the discovered device from the discovered list."""
+        for flow in self.hass.config_entries.flow.async_progress():
+            if flow["context"]["source"] == 'zeroconf':
+                if flow["context"]["unique_id"] == host_ip:
+                    self.hass.config_entries.flow.async_abort(flow["flow_id"])
+                    break
+        else:
+            _LOGGER.info(f"No matching flow found for IP: {host_ip}.")
 
     async def async_step_manual(self, user_input=None):
         errors = {}
@@ -197,7 +236,9 @@ def _on_service_state_change(self, zeroconf, service_type, name, state_change):
                 address = socket.inet_ntoa(info.addresses[0])
                 if "bituotechnik" in name.lower():  # Ensure the device name contains 'bituotechnik'
                     # Check if the device is already in the list or already configured
-                    if not any(device["ip"] == address for device in self.devices):
-                        existing_entries = self._async_current_entries()
-                        if not any(entry.data.get(CONF_HOST_IP) == address for entry in existing_entries):
+                    existing_entries = self._async_current_entries()
+                    
+                    # 过滤掉已存在的设备
+                    if not any(entry.data.get(CONF_HOST_IP) == address for entry in existing_entries):
+                        if not any(device["ip"] == address for device in self.devices):
                             self.devices.append({"ip": address, "name": name.split(".")[0]})
diff --git a/custom_components/bituopmd/ota_versions.json b/custom_components/bituopmd/ota_versions.json
@@ -1,6 +1,6 @@
 {
-    "SPM01": "1.1.5",
-    "SPM02": "1.1.5",
-    "SDM01": "3.3.2",
+    "SPM01": "1.1.6",
+    "SPM02": "1.1.6",
+    "SDM01": "3.3.3",
     "SDM02": "1.1.1"
 }
diff --git a/custom_components/bituopmd/sensor.py b/custom_components/bituopmd/sensor.py
@@ -61,6 +61,8 @@ def load_ota_versions():
 settings = load_settings()
 ota_versions = load_ota_versions()
 
+
+
 UNIT_MAPPING = {
     "unbalancelinecurrents": PERCENTAGE,
     "powerfactor": None,
@@ -83,7 +85,7 @@ def load_ota_versions():
     "rssi": SensorStateClass.MEASUREMENT,
 }
 
-EXCLUDE_FIELDS = {"post", "Post", "Config485", "MqttStatus", "productModel", "ProductModel", "Serialnumber", "SerialNumber", "devicetype", "DeviceType", "FWVersion"}
+EXCLUDE_FIELDS = {"Post", "Config485", "MqttStatus", "ProductModel", "SerialNumber", "DeviceType", "FWVersion", "MCUVersion", "Manufactor"}
 
 async def async_setup_entry(hass, entry, async_add_entities):
     """Set up sensor platform."""
@@ -92,6 +94,12 @@ async def async_setup_entry(hass, entry, async_add_entities):
     coordinator = BituoDataUpdateCoordinator(hass, host_ip, current_scan_interval)
     await coordinator.async_config_entry_first_refresh()
 
+    # Store the coordinator so it can be accessed by other platforms like button
+    hass.data.setdefault(DOMAIN, {})
+    hass.data[DOMAIN][entry.entry_id] = {
+        'sensor_coordinator': coordinator
+    }
+
     # Fetch device model and firmware version
     try:
         device_info = await coordinator.fetch_device_info()
@@ -101,11 +109,11 @@ async def async_setup_entry(hass, entry, async_add_entities):
 
     # Create sensor entities for each data field
     sensors = [
-        BituoSensor(coordinator, host_ip, field, device_info.get("model", "Unknown Model"), device_info.get("fw_version", "Unknown"))
+        BituoSensor(coordinator, host_ip, field, device_info.get("model", "Unknown Model"), device_info.get("fw_version", "Unknown"), device_info.get("manufacturer", "Unknown"), device_info.get("mcu_version", "Unknown"))
         for field in coordinator.data.keys()
         if field not in EXCLUDE_FIELDS
     ]
-    ota_sensor = BituoOTASensor(coordinator, host_ip, device_info.get("model", "Unknown Model"), device_info.get("fw_version", "Unknown"))
+    ota_sensor = BituoOTASensor(coordinator, host_ip, device_info.get("model", "Unknown Model"), device_info.get("fw_version", "Unknown"), device_info.get("manufacturer", "Unknown"), device_info.get("mcu_version", "Unknown"))
     sensors.append(ota_sensor)
 
     # Assign the OTA sensor to the coordinator
@@ -195,8 +203,10 @@ async def fetch_device_info(self):
             response.raise_for_status()
             data = response.json()
             return {
-                "model": data.get("productModel") or data.get("ProductModel", "Unknown Model"),
-                "fw_version": data.get("FWVersion") or data.get("fwVersion", "Unknown"),
+                "model": data.get("ProductModel", "Unknown Model"),
+                "fw_version": data.get("FWVersion", "Unknown"),
+                "manufacturer": data.get("Manufactor", "Unknown"),
+                "mcu_version": data.get("MCUVersion", "Unknown"),
             }
         except Exception as err:
             raise UpdateFailed(f"Error fetching device info: {err}")
@@ -229,19 +239,20 @@ async def _schedule_ota_update_checks(self):
 class BituoSensor(CoordinatorEntity, SensorEntity):
     """Representation of a Sensor."""
 
-    def __init__(self, coordinator, host_ip, field, model, fw_version):
+    def __init__(self, coordinator, host_ip, field, model, fw_version, manufacturer, mcu_version):
         """Initialize the sensor."""
         super().__init__(coordinator)
         self._field = field
         self._attr_name = self.format_field_name(field)
         self._attr_unique_id = f"{host_ip}_{field}"
+        self.entity_id = f"sensor.{host_ip.replace('.', '_')}_{self.format_field_entity_id(field)}"
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, host_ip)},
             name=f"{model} - {host_ip}",
-            manufacturer="BituoTechnik",
+            manufacturer=manufacturer,
             model=model,
-            sw_version=fw_version,
-            configuration_url=f"http://{host_ip}"  # 新增的配置 URL
+            sw_version=f"S{fw_version}_M{self.format_version(mcu_version)}",
+            configuration_url=f"http://{host_ip}"  # embed URL
         )
         self._host_ip = host_ip
         self._native_unit_of_measurement = self.get_initial_unit_of_measurement()
@@ -299,6 +310,31 @@ def format_field_name(field):
         formatted_name = ''.join([' ' + char if char.isupper() else char for char in field]).title().strip()
         formatted_name = formatted_name.replace("X", " X").replace("Y", " Y").replace("Z", " Z")
         return formatted_name
+    
+    @staticmethod
+    def format_field_entity_id(field):
+        """Format field name to be more suitable for unique_id."""
+        formatted_name = ''.join(['_' + char.lower() if char.isupper() else char for char in field])
+        formatted_name = formatted_name.replace("x", "_x").replace("y", "_y").replace("z", "_z")
+        return formatted_name.strip('_')
+
+    @staticmethod
+    def format_version(version):
+        if version.lower() == "unknown":
+            return version 
+        parts = version.split('.')
+        formatted_parts = [] 
+        for part in parts:
+            if part.strip():  # 检查部分是否为空
+                try:
+                    formatted_parts.append(str(int(part)))
+                except ValueError:
+                    formatted_parts.append('unknown')
+            else:
+                formatted_parts.append('unknown')  # 如果部分为空，设置为 'unknown'
+        
+        formatted_version = '.'.join(formatted_parts)
+        return formatted_version
 
     @property
     def native_value(self):
@@ -318,23 +354,42 @@ def device_class(self):
 class BituoOTASensor(CoordinatorEntity, SensorEntity):
     """Representation of an OTA status sensor."""
 
-    def __init__(self, coordinator, host_ip, model, fw_version):
+    def __init__(self, coordinator, host_ip, model, fw_version, manufacturer, mcu_version):
         """Initialize the OTA status sensor."""
         super().__init__(coordinator)
         self._attr_name = "OTA Status"
         self._attr_unique_id = f"{host_ip}_ota_status"
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, host_ip)},
             name=f"{model} - {host_ip}",
-            manufacturer="BituoTechnik",
+            manufacturer=manufacturer,
             model=model,
-            sw_version=fw_version,
+            sw_version=f"S{fw_version}_M{self.format_version(mcu_version)}",
+            configuration_url=f"http://{host_ip}"  # embed URL
         )
         self._host_ip = host_ip
-        self._attr_state = "Unknown"
+        self._attr_state = "unknown"
         coordinator.ota_entity = self  # 存储自身的引用到协调器中
         self._attr_icon = "mdi:update"
         self.entity_id = f"sensor.{self._attr_unique_id.replace('.', '_')}"
+    
+    @staticmethod
+    def format_version(version):
+        if version.lower() == "unknown":
+            return version 
+        parts = version.split('.')
+        formatted_parts = [] 
+        for part in parts:
+            if part.strip():  # 检查部分是否为空
+                try:
+                    formatted_parts.append(str(int(part)))
+                except ValueError:
+                    formatted_parts.append('unknown')
+            else:
+                formatted_parts.append('unknown')  # 如果部分为空，设置为 'unknown'
+        
+        formatted_version = '.'.join(formatted_parts)
+        return formatted_version
 
     @property
     def native_value(self):
diff --git a/custom_components/bituopmd/settings.json b/custom_components/bituopmd/settings.json
@@ -1 +1 @@
-{"devices": {"192.168.3.76": {"scan_interval": 5}, "192.168.3.143": {"scan_interval": 10}, "192.168.3.58": {"scan_interval": 10}}}
+{"devices": {}}
diff --git a/custom_components/bituopmd/strings.json b/custom_components/bituopmd/strings.json
diff --git a/custom_components/bituopmd/switch.py b/custom_components/bituopmd/switch.py

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`		`- "SPM01": "1.1.5",`
`3`		`- "SPM02": "1.1.5",`
`4`		`- "SDM01": "3.3.2",`
	`2`	`+ "SPM01": "1.1.6",`
	`3`	`+ "SPM02": "1.1.6",`
	`4`	`+ "SDM01": "3.3.3",`
`5`	`5`	`"SDM02": "1.1.1"`
`6`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-{"devices": {"192.168.3.76": {"scan_interval": 5}, "192.168.3.143": {"scan_interval": 10}, "192.168.3.58": {"scan_interval": 10}}}`
	`1`	`+{"devices": {}}`