feat: 更新协议

custom_components/jackery/README.md

@@ -0,0 +1,291 @@
+# Jackery - Home Assistant 自定义集成
+
+这是一个 Home Assistant 自定义集成，用于通过 MQTT 接收能源监控数据并创建传感器实体。
+
+## 功能特性
+
+该集成采用**协调器模式**（Coordinator Pattern），所有传感器共享一个 `JackeryDataCoordinator` 实例，统一管理 MQTT 订阅和数据请求，提高效率并减少资源占用。
+
+### 功率传感器（实时监测）
+
+- **Solar Power** (太阳能发电功率) - 单位：W
+- **Home Power** (家庭负载功率) - 单位：W
+- **Grid Import** (电网购买功率) - 单位：W
+- **Grid Export** (电网出售功率) - 单位：W
+- **Battery Charge** (电池充电功率) - 单位：W
+- **Battery Discharge** (电池放电功率) - 单位：W
+- **Battery State of Charge** (电池电量) - 单位：%
+
+### 能源传感器（用于能源仪表板）
+
+- **Solar Energy** (太阳能发电总量) - 单位：kWh
+- **Home Energy** (家庭用电总量) - 单位：kWh
+- **Grid Import Energy** (电网购买总量) - 单位：kWh
+- **Grid Export Energy** (电网出售总量) - 单位：kWh
+- **Battery Charge Energy** (电池充电总量) - 单位：kWh
+- **Battery Discharge Energy** (电池放电总量) - 单位：kWh
+
+## 前置要求
+
+⚠️ **重要：本集成依赖 Home Assistant 的 MQTT 集成**
+
+在安装 Jackery 之前，您必须先配置 MQTT 集成：
+
+1. 进入 Home Assistant 的 **设置** → **设备与服务**
+2. 点击 **添加集成**，搜索 **MQTT**
+3. 配置您的 MQTT broker 连接信息：
+   - **Broker**: MQTT broker 地址（例如：`localhost`、`core-mosquitto` 或 IP 地址）
+   - **Port**: 端口号（默认：`1883`）
+   - **Username/Password**: 如需要认证，请填写
+
+## 安装步骤
+
+### 方式 A：通过 HACS 安装（推荐）
+
+1. 确保已安装 [HACS](https://hacs.xyz/)
+2. 进入 HACS → 集成
+3. 点击右上角菜单 → 自定义仓库
+4. 添加此仓库 URL 并选择类别为"集成"
+5. 搜索 "Jackery" 并安装
+6. 重启 Home Assistant
+
+### 方式 B：手动安装
+
+将 `custom_components/Jackery` 文件夹复制到 Home Assistant 的 `config/custom_components/` 目录下：
+
+```
+config/
+  custom_components/
+    Jackery/
+      __init__.py
+      manifest.json
+      sensor.py
+      config_flow.py
+      strings.json
+      translations/
+```
+
+然后重启 Home Assistant。
+
+### 配置集成
+
+1. 进入 Home Assistant 的 **设置** → **设备与服务**
+2. 点击右下角的 **添加集成** 按钮
+3. 搜索 "Jackery"
+4. 输入 MQTT 主题前缀（可选，默认：`homeassistant/sensor`）
+5. 点击提交完成配置
+
+如果 MQTT 集成未配置或不可用，将显示错误提示。
+
+## 架构设计
+
+### 协调器模式
+
+集成使用 `JackeryDataCoordinator` 类统一管理所有传感器的数据获取：
+
+- **单一协调器实例**：所有传感器共享一个协调器，避免重复订阅和请求
+- **统一数据请求**：每 5 秒发送一次 `data_get` 请求，包含所有传感器的 `meter_sn`
+- **自动分发数据**：协调器接收响应后，根据 `meter_sn` 自动分发给对应的传感器
+- **设备序列号管理**：通过 LWT 消息自动获取和更新设备序列号
+
+### 数据流程
+
+1. **启动阶段**：
+   - 协调器订阅 LWT 主题 (`v1/iot_gw/gw_lwt`) 获取设备序列号
+   - 协调器订阅数据响应主题 (`v1/iot_gw/gw/data`)
+   - 启动定时任务，每 5 秒发送一次数据请求
+
+2. **数据请求**：
+   - 协调器收集所有传感器的 `meter_sn`
+   - 构造包含所有 `meter_sn` 的 `data_get` 请求
+   - 发送到 `v1/iot_gw/cloud/data` 主题
+
+3. **数据处理**：
+   - 接收设备响应（JSON 格式）
+   - 解析 `meter_list` 中的 `[meter_sn, meter_value]` 数据
+   - 根据 `meter_sn` 匹配对应的传感器实体
+   - 调用传感器的 `_process_meter_value()` 处理特殊值（如正负分离）
+   - 更新传感器状态并通知 Home Assistant
+
+## MQTT 主题格式
+
+集成会订阅以下 MQTT 主题来接收设备数据：
+
+- **LWT 主题**: `v1/iot_gw/gw_lwt` - 接收设备上线/离线状态和序列号
+  ```json
+  {
+    "gw_sn": "26392658575364"
+  }
+  ```
+
+- **数据响应主题**: `v1/iot_gw/gw/data` - 接收设备响应的传感器数据
+  ```json
+  {
+    "cmd": "data_get",
+    "info": {
+      "dev_list": [
+        {
+          "dev_sn": "ems_26392658575364",
+          "meter_list": [
+            ["1026001", 2500.0],
+            ["21171201", 1800.0],
+            ...
+          ]
+        }
+      ]
+    }
+  }
+  ```
+
+集成会定期向以下主题发送数据请求：
+
+- **请求主题**: `v1/iot_gw/cloud/data` - 发送 `data_get` 命令请求传感器数据
+  ```json
+  {
+    "cmd": "data_get",
+    "gw_sn": "26392658575364",
+    "timestamp": "1234567890123",
+    "token": "5678",
+    "info": {
+      "dev_list": [
+        {
+          "dev_sn": "ems_26392658575364",
+          "meter_list": ["1026001", "21171201", "16930817", ...]
+        }
+      ]
+    }
+  }
+  ```
+
+### 数据请求间隔
+
+- **默认间隔**：5 秒（`REQUEST_INTERVAL = 5`）
+- 所有传感器共享同一个请求，减少 MQTT 消息数量
+
+## 与模拟器配合使用
+
+本集成与 `main.py` 模拟器完美配合：
+
+1. 确保 Home Assistant 已配置好 MQTT 集成并连接到同一个 MQTT broker
+2. 运行 `main.py` 模拟器：
+   ```bash
+   python main.py
+   ```
+3. 模拟器会自动发布传感器数据到 MQTT
+4. Home Assistant 的 Jackery 集成会自动接收并显示数据
+
+## 查看传感器
+
+配置完成后，你可以在以下位置查看传感器：
+
+- **开发者工具** → **状态** → 搜索 "jackery" 或传感器名称
+- 传感器实体 ID 格式：`sensor.solar_power`、`sensor.home_power`、`sensor.solar_energy` 等
+- 每个传感器包含以下属性：
+  - `sensor_id`: 传感器内部标识
+  - `meter_sn`: 对应的 meter 序列号
+  - `device_sn`: 设备序列号（从 LWT 消息获取）
+
+## 在 Lovelace 中使用
+
+你可以使用这些传感器创建能源流图表。例如使用 Energy Flow Card：
+
+```yaml
+type: custom:energy-flow-card-plus
+entities:
+  solar:
+    entity: sensor.solar_power
+  grid:
+    entity:
+      consumption: sensor.grid_import
+      production: sensor.grid_export
+  battery:
+    entity:
+      consumption: sensor.battery_charge
+      production: sensor.battery_discharge
+    state_of_charge: sensor.battery_soc
+  home:
+    entity: sensor.home_power
+```
+
+## 故障排除
+
+### MQTT 连接错误
+
+如果看到 "Host is unreachable" 或 "MQTT not ready" 错误：
+
+1. **检查 MQTT 集成**：确保 MQTT 集成已配置且连接正常
+2. **验证 Broker 地址**：确认 MQTT broker 地址和端口正确
+3. **测试连接**：在终端使用 `mosquitto_sub` 测试 MQTT 连接
+4. **查看详细日志**：启用调试日志查看更多信息
+
+详细的故障排除指南请参考：[TROUBLESHOOTING.md](../../../TROUBLESHOOTING.md)
+
+### 传感器不显示数据
+
+1. 检查 MQTT broker 是否正常运行
+2. 确认设备已连接并发送 LWT 消息到 `v1/iot_gw/gw_lwt`
+3. 使用 MQTT Explorer 监听 `v1/iot_gw/#` 主题查看消息
+4. 查看 Home Assistant 日志：**设置** → **系统** → **日志**
+5. 确认传感器属性中的 `device_sn` 是否正确
+6. 检查协调器是否已启动：日志中应看到 "Coordinator subscribed to LWT topic" 和 "Coordinator subscribed to data topic"
+7. 确认数据请求是否发送：日志中应看到 "Coordinator sent data_get request"
+8. 验证设备响应格式：响应应包含 `cmd: "data_get"` 和正确的 `meter_list` 结构
+
+### 启用调试日志
+
+在 `configuration.yaml` 中添加：
+
+```yaml
+logger:
+  default: info
+  logs:
+    custom_components.jackery: debug
+    homeassistant.components.mqtt: debug
+```
+
+## 传感器值处理逻辑
+
+集成会根据传感器类型对原始 `meter_value` 进行特殊处理：
+
+- **Grid Import**：仅显示负值（取绝对值），正值显示为 0
+- **Grid Export**：仅显示正值，负值显示为 0
+- **Battery Charge**：仅显示负值（取绝对值），正值显示为 0
+- **Battery Discharge**：仅显示正值，负值显示为 0
+- **Battery SOC**：原始值乘以 0.1 转换为百分比
+- **其他传感器**：直接使用原始值
+
+## Meter SN 映射
+
+每个传感器对应一个唯一的 `meter_sn`，用于在设备响应中识别数据：
+
+| 传感器 ID | Meter SN |
+|----------|----------|
+| `solar_power` | 1026001 |
+| `home_power` | 21171201 |
+| `grid_import_power` / `grid_export_power` | 16930817 |
+| `battery_charge_power` / `battery_discharge_power` | 16931841 |
+| `battery_soc` | 21548033 |
+| `solar_energy` | 16961537 |
+| `home_energy` | 16936961 |
+| `grid_import_energy` | 16959489 |
+| `grid_export_energy` | 16960513 |
+| `battery_charge_energy` | 16952321 |
+| `battery_discharge_energy` | 16953345 |
+
+## 技术细节
+
+- **架构模式**: 协调器模式（Coordinator Pattern）
+- **依赖**: Home Assistant MQTT 集成
+- **协议**: MQTT (QoS 1)
+- **更新方式**: 主动请求 + 推送响应（每 5 秒）
+- **传感器类型**: 功率传感器、能源传感器、电池传感器
+- **状态类**: 
+  - 功率传感器：`MEASUREMENT`（测量值）
+  - 能源传感器：`TOTAL_INCREASING`（累计递增）
+  - 电池传感器：`MEASUREMENT`（测量值）
+- **设备类**: `POWER`、`ENERGY`、`BATTERY`
+
+## 许可证
+
+MIT License
+

custom_components/jackery/__init__.py

@@ -0,0 +1,61 @@
+"""Energy Monitor MQTT Integration for Home Assistant."""
+import logging
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.const import Platform
+from homeassistant.components import mqtt
+
+_LOGGER = logging.getLogger(__name__)
+
+DOMAIN = "jackery"
+PLATFORMS = [Platform.SENSOR]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Set up Jackery from a config entry."""
+    _LOGGER.info("Setting up Jackery integration")
+    
+    # 检查 MQTT 集成是否已配置和可用
+    if not await mqtt.async_wait_for_mqtt_client(hass):
+        _LOGGER.error(
+            "MQTT integration is not available or not configured. "
+            "Please set up the MQTT integration first: "
+            "Settings -> Devices & Services -> Add Integration -> MQTT"
+        )
+        return False
+    
+    _LOGGER.info("MQTT integration is available and ready")
+    
+    # 初始化存储结构
+    hass.data.setdefault(DOMAIN, {})
+    hass.data[DOMAIN][entry.entry_id] = {
+        "config": entry.data,
+        "coordinator": None,  # 将在 sensor.py 中设置
+    }
+    
+    # 加载传感器平台
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+    
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Unload a config entry."""
+    _LOGGER.info("Unloading Jackery integration")
+    
+    # 停止协调器
+    entry_data = hass.data[DOMAIN].get(entry.entry_id, {})
+    coordinator = entry_data.get("coordinator")
+    if coordinator:
+        await coordinator.async_stop()
+        _LOGGER.info("Coordinator stopped")
+    
+    # 卸载传感器平台
+    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    
+    if unload_ok:
+        hass.data[DOMAIN].pop(entry.entry_id)
+    
+    return unload_ok
+

custom_components/jackery/config_flow.py

@@ -0,0 +1,68 @@
+"""Config flow for Energy Monitor integration."""
+import logging
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant import config_entries
+from homeassistant.core import HomeAssistant
+from homeassistant.data_entry_flow import FlowResult
+from homeassistant.components import mqtt
+
+from . import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+# 配置数据模式
+DATA_SCHEMA = vol.Schema(
+    {
+        vol.Optional(
+            "topic_prefix",
+            default="hb"
+        ): str,
+    }
+)
+
+
+class JackeryConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Jackery."""
+
+    VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> FlowResult:
+        """Handle the initial step."""
+        if self._async_current_entries():
+            return self.async_abort(reason="single_instance_allowed")
+        
+        errors = {}
+
+        if user_input is not None:
+            # 检查 MQTT 集成是否已配置
+            if not await mqtt.async_wait_for_mqtt_client(self.hass):
+                errors["base"] = "mqtt_not_configured"
+            else:
+                _LOGGER.info(
+                    f"Creating Jackery config entry with topic_prefix: "
+                    f"{user_input.get('topic_prefix', 'hb')}"
+                )
+                
+                return self.async_create_entry(
+                    title="Jackery",
+                    data=user_input,
+                )
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=DATA_SCHEMA,
+            errors=errors,
+            description_placeholders={
+                "topic_prefix": "Protocol root topic (default: hb)",
+            },
+        )
+
+    async def async_step_import(self, import_config: dict[str, Any]) -> FlowResult:
+        """Import a config entry from configuration.yaml."""
+        return await self.async_step_user(import_config)
+

custom_components/jackery/manifest.json

@@ -0,0 +1,15 @@
+{
+    "domain": "jackery",
+    "name": "Jackery",
+    "codeowners": [
+        "@suyulin"
+    ],
+    "config_flow": true,
+    "dependencies": [
+        "mqtt"
+    ],
+    "documentation": "https://github.com/suyulin/jackery",
+    "issue_tracker": "https://github.com/suyulin/jackery/issues",
+    "iot_class": "local_push",
+    "version": "1.1.35"
+}

custom_components/jackery/sensor.py

@@ -0,0 +1,376 @@
+"""Jackery Sensor Platform."""
+import asyncio
+import json
+import logging
+import time
+import random
+import re
+from typing import Any, Callable
+
+from homeassistant.components import mqtt as ha_mqtt
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorStateClass,
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.const import UnitOfPower, UnitOfEnergy, PERCENTAGE, UnitOfTemperature
+
+from . import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+# 常量定义
+REQUEST_INTERVAL = 10  # 数据请求间隔（秒）
+
+# 传感器配置
+SENSORS = {
+    # 电池相关
+    "battery_soc": {
+        "json_key": "batSoc",
+        "name": "Battery SOC",
+        "unit": PERCENTAGE,
+        "icon": "mdi:battery-50",
+        "device_class": SensorDeviceClass.BATTERY,
+        "state_class": SensorStateClass.MEASUREMENT,
+    },
+    "battery_charge_power": {
+        "json_key": "batInPw",
+        "name": "Battery Charge Power",
+        "unit": UnitOfPower.WATT,
+        "icon": "mdi:battery-charging",
+        "device_class": SensorDeviceClass.POWER,
+        "state_class": SensorStateClass.MEASUREMENT,
+    },
+    "battery_discharge_power": {
+        "json_key": "batOutPw",
+        "name": "Battery Discharge Power",
+        "unit": UnitOfPower.WATT,
+        "icon": "mdi:battery-minus",
+        "device_class": SensorDeviceClass.POWER,
+        "state_class": SensorStateClass.MEASUREMENT,
+    },
+    "battery_temperature": {
+        "json_key": "cellTemp",
+        "name": "Battery Temperature",
+        "unit": UnitOfTemperature.CELSIUS,
+        "icon": "mdi:thermometer",
+        "device_class": SensorDeviceClass.TEMPERATURE,
+        "state_class": SensorStateClass.MEASUREMENT,
+    },
+    "battery_count": {
+        "json_key": "batNum",
+        "name": "Battery Count",
+        "unit": None,
+        "icon": "mdi:battery-multiple",
+        "device_class": None,
+        "state_class": SensorStateClass.MEASUREMENT,
+    },
+    
+    # 太阳能
+    "solar_power": {
+        "json_key": "pvPw",
+        "name": "Solar Power",
+        "unit": UnitOfPower.WATT,
+        "icon": "mdi:solar-power",
+        "device_class": SensorDeviceClass.POWER,
+        "state_class": SensorStateClass.MEASUREMENT,
+    },
+    
+    # 电网相关
+    "grid_import_power": { # Grid -> System (outOngridPw)
+        "json_key": "outOngridPw",
+        "name": "Grid Import Power",
+        "unit": UnitOfPower.WATT,
+        "icon": "mdi:transmission-tower-import",
+        "device_class": SensorDeviceClass.POWER,
+        "state_class": SensorStateClass.MEASUREMENT,
+    },
+    "grid_export_power": { # System -> Grid/Home (inOngirdPw)
+        "json_key": "inOngirdPw",
+        "name": "Grid Export Power",
+        "unit": UnitOfPower.WATT,
+        "icon": "mdi:transmission-tower-export",
+        "device_class": SensorDeviceClass.POWER,
+        "state_class": SensorStateClass.MEASUREMENT,
+    },
+    
+    # EPS (离网输出)
+    "eps_power": { 
+        "json_key": "swEpsOutPw", 
+        "name": "EPS Output Power",
+        "unit": UnitOfPower.WATT,
+        "icon": "mdi:power-plug",
+        "device_class": SensorDeviceClass.POWER,
+        "state_class": SensorStateClass.MEASUREMENT,
+    },
+    "eps_state": {
+         "json_key": "swEpsState",
+         "name": "EPS State",
+         "unit": None,
+         "icon": "mdi:power-settings",
+         "device_class": None,
+         "state_class": None,
+    },
+    
+    # Limits & Settings
+    "soc_charge_limit": {
+        "json_key": "socChgLimit",
+        "name": "SOC Charge Limit",
+        "unit": PERCENTAGE,
+        "icon": "mdi:battery-arrow-up",
+        "device_class": None,
+        "state_class": SensorStateClass.MEASUREMENT,
+    },
+    "soc_discharge_limit": {
+        "json_key": "socDischgLimit",
+        "name": "SOC Discharge Limit",
+        "unit": PERCENTAGE,
+        "icon": "mdi:battery-arrow-down",
+        "device_class": None,
+        "state_class": SensorStateClass.MEASUREMENT,
+    }
+}
+
+
+class JackeryDataCoordinator:
+    """协调器：管理MQTT订阅和数据获取，供所有传感器实体共享使用."""
+
+    def __init__(self, hass: HomeAssistant, topic_prefix: str) -> None:
+        """初始化协调器."""
+        self.hass = hass
+        self._topic_prefix = topic_prefix
+        # The new protocol generally uses 'hb' as root, but we respect the configured prefix if given.
+        # If the user configured 'homeassistant/sensor' (default), we might want to ignore it 
+        # and use 'hb' if the new protocol is strict. 
+        # For now, let's assume 'hb' is the fixed root for this new protocol version.
+        self._topic_root = "hb" 
+        
+        self._device_sn = ""  # 设备序列号
+        self._sensors = {}  # {sensor_id: entity}
+        self._data_task = None
+        self._subscribed = False
+        
+        # Topic patterns
+        self._topic_status_wildcard = f"{self._topic_root}/device/+/status"
+    
+    def register_sensor(self, sensor_id: str, entity: "JackerySensor") -> None:
+        """注册传感器实体."""
+        self._sensors[sensor_id] = entity
+
+    def unregister_sensor(self, sensor_id: str) -> None:
+        """注销传感器实体."""
+        if sensor_id in self._sensors:
+            del self._sensors[sensor_id]
+
+    async def async_start(self) -> None:
+        """启动协调器."""
+        if self._subscribed:
+            return
+        
+        try:
+            # 订阅状态主题 (Wildcard) 以发现设备和接收数据
+            @callback
+            def message_received(msg):
+                self._handle_message(msg)
+            
+            await ha_mqtt.async_subscribe(
+                self.hass,
+                self._topic_status_wildcard,
+                message_received,
+                1
+            )
+            _LOGGER.info(f"Coordinator subscribed to: {self._topic_status_wildcard}")
+            
+            self._subscribed = True
+            
+            # 启动定时轮询
+            self._data_task = asyncio.create_task(self._periodic_data_request())
+            
+        except Exception as e:
+            _LOGGER.error(f"Failed to start coordinator: {e}")
+
+    async def async_stop(self) -> None:
+        """停止协调器."""
+        if self._data_task and not self._data_task.done():
+            self._data_task.cancel()
+            try:
+                await self._data_task
+            except asyncio.CancelledError:
+                pass
+        _LOGGER.info("Coordinator stopped")
+
+    def _handle_message(self, msg) -> None:
+        """处理接收到的 MQTT 消息."""
+        try:
+            topic = msg.topic
+            payload = msg.payload
+            if isinstance(payload, bytes):
+                payload = payload.decode("utf-8")
+            
+            # Extract device SN from topic: hb/device/{sn}/status
+            match = re.search(r"hb/device/([^/]+)/status", topic)
+            if match:
+                sn = match.group(1)
+                if not self._device_sn:
+                    self._device_sn = sn
+                    _LOGGER.info(f"Discovered device SN: {self._device_sn}")
+                elif self._device_sn != sn:
+                    _LOGGER.debug(f"Received data from another device: {sn}")
+
+            # Parse Payload
+            try:
+                data = json.loads(payload)
+            except json.JSONDecodeError:
+                _LOGGER.warning(f"Invalid JSON payload on {topic}")
+                return
+
+            self._distribute_data(data)
+
+        except Exception as e:
+            _LOGGER.error(f"Error handling message: {e}")
+
+    def _distribute_data(self, data: dict) -> None:
+        """分发数据给传感器."""
+        for sensor_id, entity in self._sensors.items():
+            json_key = SENSORS[sensor_id].get("json_key")
+            if json_key and json_key in data:
+                raw_value = data[json_key]
+                entity._update_from_coordinator(raw_value)
+
+    async def _periodic_data_request(self) -> None:
+        """定期发送 'type: 25' 指令请求全量数据."""
+        _LOGGER.info("Starting periodic data polling...")
+        await asyncio.sleep(2) 
+        
+        while True:
+            try:
+                if not self._device_sn:
+                    _LOGGER.debug("Waiting for device SN discovery...")
+                    await asyncio.sleep(5)
+                    continue
+                
+                # Construct Action Topic
+                action_topic = f"{self._topic_root}/device/{self._device_sn}/action"
+                
+                # Construct Payload
+                payload = {
+                    "type": 25,
+                    "eventId": 0,
+                    "messageId": random.randint(1000, 9999),
+                    "ts": int(time.time()),
+                    "body": None
+                }
+                
+                await ha_mqtt.async_publish(
+                    self.hass,
+                    action_topic,
+                    json.dumps(payload),
+                    0,
+                    False
+                )
+                _LOGGER.debug(f"Sent poll request to {action_topic}")
+                
+                await asyncio.sleep(REQUEST_INTERVAL)
+                
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                _LOGGER.error(f"Error in polling task: {e}")
+                await asyncio.sleep(REQUEST_INTERVAL)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up Jackery sensors."""
+    config = config_entry.data
+    topic_prefix = config.get("topic_prefix", "hb") 
+    
+    coordinator = JackeryDataCoordinator(hass, topic_prefix)
+    hass.data[DOMAIN][config_entry.entry_id]["coordinator"] = coordinator
+    
+    entities = []
+    for sensor_id, sensor_config in SENSORS.items():
+        if sensor_config.get("json_key") is None: 
+            continue 
+            
+        entity = JackerySensor(
+            sensor_id=sensor_id,
+            coordinator=coordinator,
+            config_entry_id=config_entry.entry_id,
+        )
+        entities.append(entity)
+    
+    async_add_entities(entities)
+    await coordinator.async_start()
+
+
+class JackerySensor(SensorEntity):
+    """Jackery Sensor."""
+
+    def __init__(
+        self,
+        sensor_id: str,
+        coordinator: JackeryDataCoordinator,
+        config_entry_id: str,
+    ) -> None:
+        """Initialize."""
+        self._sensor_id = sensor_id
+        self._coordinator = coordinator
+        self._config = SENSORS[sensor_id]
+        
+        self._attr_name = self._config["name"]
+        self._attr_native_unit_of_measurement = self._config["unit"]
+        self._attr_icon = self._config["icon"]
+        self._attr_device_class = self._config["device_class"]
+        self._attr_state_class = self._config["state_class"]
+        self._attr_unique_id = f"jackery_{sensor_id}"
+        self._attr_has_entity_name = True
+        
+        self._attr_device_info = {
+            "identifiers": {(DOMAIN, config_entry_id)},
+            "name": "Jackery",
+            "manufacturer": "Jackery",
+            "model": "Energy Monitor", 
+        }
+
+    @property
+    def should_poll(self) -> bool:
+        return False
+
+    async def async_added_to_hass(self) -> None:
+        await super().async_added_to_hass()
+        self._coordinator.register_sensor(self._sensor_id, self)
+
+    async def async_will_remove_from_hass(self) -> None:
+        self._coordinator.unregister_sensor(self._sensor_id)
+        await super().async_will_remove_from_hass()
+
+    def _update_from_coordinator(self, value: Any) -> None:
+        """Receive data from coordinator."""
+        # Process specific conversions
+        if self._sensor_id == "battery_temperature":
+            # cellTemp is 0.1 C
+            try:
+                self._attr_native_value = float(value) * 0.1
+            except (TypeError, ValueError):
+                pass
+        elif self._sensor_id == "battery_soc":
+             self._attr_native_value = value
+        else:
+             self._attr_native_value = value
+             
+        self._attr_available = True
+        self.async_write_ha_state()
+
+    @property
+    def extra_state_attributes(self) -> dict[str, Any]:
+        return {
+            "device_sn": self._coordinator._device_sn,
+            "raw_key": self._config.get("json_key")
+        }

custom_components/jackery/strings.json

@@ -0,0 +1,22 @@
+{
+    "config": {
+        "step": {
+            "user": {
+                "title": "配置 Jackery",
+                "description": "设置您的 Jackery 能源监控集成。注意：必须先配置 MQTT 集成。",
+                "data": {
+                    "topic_prefix": "MQTT 主题前缀"
+                }
+            }
+        },
+        "error": {
+            "already_configured": "该集成已配置",
+            "mqtt_not_configured": "MQTT 集成未配置或不可用。请先设置 MQTT 集成：设置 -> 设备与服务 -> 添加集成 -> MQTT",
+            "single_instance_allowed": "只允许一个此集成的实例"
+        },
+        "abort": {
+            "already_configured": "该集成已配置",
+            "single_instance_allowed": "只允许一个此集成的实例"
+        }
+    }
+}

custom_components/jackery/translations/zh-Hans.json

@@ -0,0 +1,22 @@
+{
+    "config": {
+        "step": {
+            "user": {
+                "title": "配置 Jackery",
+                "description": "设置您的 Jackery 能源监控集成。注意：必须先配置 MQTT 集成。",
+                "data": {
+                    "topic_prefix": "MQTT 主题前缀"
+                }
+            }
+        },
+        "error": {
+            "already_configured": "该集成已配置",
+            "mqtt_not_configured": "MQTT 集成未配置或不可用。请先设置 MQTT 集成：设置 -> 设备与服务 -> 添加集成 -> MQTT",
+            "single_instance_allowed": "只允许一个此集成的实例"
+        },
+        "abort": {
+            "already_configured": "该集成已配置",
+            "single_instance_allowed": "只允许一个此集成的实例"
+        }
+    }
+}