Add support for River mini (non-wireless version).

mik9 · mik9 · commit ef86b8c31d58 · 2022-12-30T17:15:13.000+02:00
diff --git a/custom_components/ecoflow/binary_sensor.py b/custom_components/ecoflow/binary_sensor.py
@@ -9,7 +9,7 @@
 
 from . import (DOMAIN, EcoFlowBaseEntity, EcoFlowData, EcoFlowDevice,
                EcoFlowEntity, EcoFlowExtraDevice, EcoFlowMainDevice)
-from .ecoflow import is_delta, is_river
+from .ecoflow import is_delta, is_river, is_river_mini
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback):
@@ -35,6 +35,10 @@ def device_added(device: EcoFlowDevice):
                 entities.extend([
                     InputEntity(device, device.inverter, "in_type", "Input"),
                 ])
+            elif is_river_mini(device.product):
+                entities.extend([
+                    InputEntity(device, device.inverter, "in_type", "Input"),
+                ])
         elif type(device) is EcoFlowExtraDevice:
             entities.extend([
                 ExtraErrorEntity(device, device.bms,
diff --git a/custom_components/ecoflow/ecoflow/receive.py b/custom_components/ecoflow/ecoflow/receive.py
@@ -6,7 +6,7 @@
 
 from reactivex import Observable, Observer
 
-from . import calcCrc8, calcCrc16, is_delta, is_river
+from . import calcCrc8, calcCrc16, is_delta, is_river, is_river_mini
 
 
 class Serial(TypedDict):
@@ -69,6 +69,8 @@ def _to_float(d: bytes) -> float:
 def _to_int(d: bytes):
     return int.from_bytes(d, "little")
 
+def _to_hex_debug(d: bytes):
+    return " ".join("0x{:02x}".format(x) for x in d)
 
 def _to_int_ex(div: int = 1):
     def f(d: bytes):
@@ -299,8 +301,8 @@ def parse_inverter(d: bytes, product: int):
         return parse_inverter_delta(d)
     if is_river(product):
         return parse_inverter_river(d)
-    # if is_river_mini(product):
-    #     return parse_pd_river_mini(d)
+    if is_river_mini(product):
+        return parse_inverter_river_mini(d)
     return {}
 
 
@@ -364,6 +366,43 @@ def parse_inverter_river(d: bytes):
         ("fan_config", 1, _to_int),
     ])
 
+def parse_inverter_river_mini(d: bytes):
+    return _parse_dict(d, [
+        ("ac_error", 4, _to_int),
+        ("ac_version", 4, _to_ver_reversed),
+        ("in_type", 1, _to_int),
+        ("in_power", 2, _to_int),
+        ("ac_out_power", 2, _to_int),
+        ("ac_type", 1, _to_int),
+        ("ac_out_voltage", 4, _to_int_ex(div=1000)),
+        ("ac_out_current", 4, _to_int_ex(div=1000)),
+        ("ac_out_freq", 1, _to_int),
+        ("ac_in_voltage", 4, _to_int_ex(div=1000)),
+        ("ac_in_current", 4, _to_int_ex(div=1000)),
+        ("ac_in_freq", 1, _to_int),
+        ("ac_out_temp", 1, _to_int),
+        ("dc_in_voltage", 4, _to_int_ex(div=1000)),
+        ("dc_in_current", 4, _to_int_ex(div=1000)),
+        ("ac_in_temp", 1, _to_int),
+        ("fan_state", 1, _to_int),
+        ("ac_out_state", 1, _to_int),
+        ("ac_out_xboost", 1, _to_int),
+        ("ac_out_voltage_config", 4, _to_int_ex(div=1000)),
+        ("ac_out_freq_config", 1, _to_int),
+        ("ac_in_slow", 1, _to_int),
+        ("battery_main_level", 1, _to_int),
+        ("battery_main_voltage", 4, _to_int_ex(div=1000)),
+        ("battery_current", 4, _to_int),
+        ("battery_main_temp", 1, _to_int),
+        ("_open_bms_idx", 1, _to_int),
+        ("battery_capacity_remain", 4, _to_int),
+        ("battery_capacity_full", 4, _to_int),
+        ("battery_cycles", 4, _to_int),
+        ("battery_level_max", 1, _to_int),
+        ("battery_main_level_f32", 4, _to_float),
+        ("ac_out_timeout", 2, _to_int),
+    ])
+
 
 def parse_lcd_timeout(d: bytes):
     return int.from_bytes(d[1:3], "little")
@@ -412,8 +451,8 @@ def parse_pd(d: bytes, product: int):
         return parse_pd_delta(d)
     if is_river(product):
         return parse_pd_river(d)
-    # if is_river_mini(product):
-    #     return parse_pd_river_mini(d)
+    if is_river_mini(product):
+        return parse_pd_river_mini(d)
     return {}
 
 
@@ -498,49 +537,47 @@ def parse_pd_river(d: bytes):
     ])
 
 
-# def parse_pd_river_mini(d: bytes):
-#     return _parse_dict(d, [
-#         ("model", 1, _to_int),
-#         ("pd_error", 4, _to_int),
-#         ("pd_version", 4, _to_ver_reversed),
-#         ("wifi_version", 4, _to_ver_reversed),
-#         ("wifi_autorecovery", 1,),
-#         ("soc_sum", 1, _to_int),
-#         ("watts_out_sum", 2, _to_int),
-#         ("watts_in_sum", 2, _to_int),
-#         ("remain_time", 4, _to_int),
-#         ("beep", 1, _to_int),
-#         ("dc_out", 1, _to_int),
-#         ("usb1_watts", 1, _to_int),
-#         ("usb2_watts", 1, _to_int),
-#         ("usbqc1_watts", 1, _to_int),
-#         ("usbqc2_watts", 1, _to_int),
-#         ("typec1_watts", 1, _to_int),
-#         ("typec2_watts", 1, _to_int),
-#         ("typec1_temp", 1, _to_int),
-#         ("typec2_temp", 1, _to_int),
-#         ("dc_out_watts", 1, _to_int),
-#         ("car_out_temp", 1, _to_int),
-#         ("standby_timeout", 2, _to_int),
-#         ("lcd_sec", 2, _to_int),
-#         ("lcd_brightness", 1, _to_int),
-#         ("chg_power_dc", 4, _to_int),
-#         ("chg_power_mppt", 4, _to_int),
-#         ("chg_power_ac", 4, _to_int),
-#         ("dsg_power_dc", 4, _to_int),
-#         ("dsg_power_ac", 4, _to_int),
-#         ("usb_used_time", 4, _to_int),
-#         ("usbqc_used_time", 4, _to_int),
-#         ("typec_used_time", 4, _to_int),
-#         ("dc_out_used_time", 4, _to_int),
-#         ("ac_out_used_time", 4, _to_int),
-#         ("dc_in_used_time", 4, _to_int),
-#         ("mppt_used_time", 4, _to_int),
-#         (None, 5, None),
-#         ("sys_chg_flag", 1, _to_int),
-#         ("wifi_rssi", 1, _to_int),
-#         ("wifi_watts", 1, _to_int),
-#     ])
+def parse_pd_river_mini(d: bytes):
+    return _parse_dict(d, [
+        ("model", 1, _to_int),
+        ("pd_error", 4, _to_int),
+        ("pd_version", 4, _to_ver_reversed),
+        ("wifi_version", 4, _to_ver_reversed),
+        ("wifi_autorecovery", 1, _to_int),
+        ("battery_level", 1, _to_int),
+        ("out_power", 2, _to_int),
+        ("in_power", 2, _to_int),
+        ("remain_display", 4, _to_timedelta_min),
+        ("beep", 1, _to_int),
+        ("usb_out1_state", 1, _to_int),
+        ("usb_out1_power", 1, _to_int),
+        ("usb2_watts", 1, _to_int),
+        ("usbqc1_watts", 1, _to_int),
+        ("usbqc2_watts", 1, _to_int),
+        ("typec1_watts", 1, _to_int),
+        ("typec2_watts", 1, _to_int),
+        ("typec1_temp", 1, _to_int),
+        ("typec2_temp", 1, _to_int),
+        ("car_out_state", 1, _to_int),
+        ("car_out_power", 1, _to_int),
+        ("car_out_temp", 1, _to_int),
+        ("standby_timeout", 1, _to_int),
+        ("unknown_1", 1, _to_hex_debug),
+        ("lcd_timeout", 2, _to_int),
+        ("lcd_brightness", 1, _to_int),
+        ("car_in_energy", 4, _to_int),
+        ("mppt_in_energy", 4, _to_int),
+        ("ac_in_energy", 4, _to_int),
+        ("dc_out_energy", 4, _to_int),
+        ("ac_out_energy", 4, _to_int),
+        ("usb_time", 4, _to_timedelta_sec),
+        ("unknown_2", 8, _to_hex_debug),
+        ("car_out_time", 4, _to_timedelta_sec),
+        ("ac_out_time", 4, _to_timedelta_sec),
+        ("car_in_time", 4, _to_timedelta_sec),
+        ("mppt_time", 4, _to_timedelta_sec),
+        ("unknown_3", 30, _to_hex_debug),
+    ])
 
 
 def parse_serial(d: bytes) -> Serial:
diff --git a/custom_components/ecoflow/select.py b/custom_components/ecoflow/select.py
@@ -9,10 +9,11 @@
 
 from . import (DOMAIN, EcoFlowConfigEntity, EcoFlowData, EcoFlowDevice,
                EcoFlowEntity, EcoFlowMainDevice)
-from .ecoflow import is_delta, is_river, send
+from .ecoflow import is_delta, is_river, is_river_mini, send
 
 _AC_OPTIONS = {
     "Never": 0,
+    "30min": 30,
     "2hour": 120,
     "4hour": 240,
     "6hour": 360,
@@ -80,6 +81,11 @@ def device_added(device: EcoFlowDevice):
                 DcInTypeEntity(device),
                 LcdTimeoutPollEntity(device, "lcd_timeout", "Screen timeout"),
             ])
+        if is_river_mini(device.product):
+            entities.extend([
+                LcdTimeoutPushEntity(device, device.pd,
+                                     "lcd_timeout", "Screen timeout"),
+            ])
         async_add_entities(entities)
 
     entry.async_on_unload(data.device_added.subscribe(device_added).dispose)
diff --git a/custom_components/ecoflow/sensor.py b/custom_components/ecoflow/sensor.py
@@ -18,7 +18,7 @@
 
 from . import (DOMAIN, EcoFlowData, EcoFlowDevice, EcoFlowEntity,
                EcoFlowExtraDevice, EcoFlowMainDevice)
-from .ecoflow import is_delta, is_delta_mini, is_delta_pro, is_river
+from .ecoflow import is_delta, is_delta_mini, is_delta_pro, is_river, is_river_mini
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback):
@@ -58,11 +58,14 @@ def device_added(device: EcoFlowDevice):
                             "ac_consumption", "AC output + loss", real=True),
                 WattsEntity(device, device.inverter, "ac_out_power",
                             "AC output", real=False),
-                WattsEntity(device, device.pd, "usb_out1_power",
-                            "USB-A left output"),
-                WattsEntity(device, device.pd, "usb_out2_power",
-                            "USB-A right output"),
             ])
+            if not is_river_mini(device.product):
+                entities.extend([
+                    WattsEntity(device, device.pd, "usb_out1_power",
+                                "USB-A left output"),
+                    WattsEntity(device, device.pd, "usb_out2_power",
+                                "USB-A right output"),
+                ])
             if is_delta(device.product):
                 entities.extend([
                     CurrentEntity(device, device.mppt, "dc_in_current",
@@ -154,6 +157,31 @@ def device_added(device: EcoFlowDevice):
                     WattsEntity(device, device.pd, "typec_out1_power",
                                 "USB-C output"),
                 ])
+            if is_river_mini(device.product):
+                entities.extend([
+                        CurrentEntity(device, device.inverter, "dc_in_current",
+                                    "DC input current"),
+                        CyclesEntity(device, device.inverter, "battery_cycles",
+                                 "Battery cycles"),
+                        LevelEntity(device, device.pd, "battery_level",
+                                    "Total battery level"),
+                        TempEntity(device, device.inverter, "ac_in_temp",
+                                   "AC input temperature"),
+                        TempEntity(device, device.inverter, "ac_out_temp",
+                                   "AC output temperature"),
+                        TempEntity(device, device.inverter, "battery_main_temp",
+                                   "Battery temperature"),
+                        TempEntity(device, device.pd, "car_out_temp",
+                                   "Car output temperature"),
+                        VoltageEntity(device, device.inverter, "dc_in_voltage",
+                                      "Car input voltage"),
+                        WattsEntity(device, device.pd, "usb_out1_power",
+                                "USB-A output"),
+                        WattsEntity(device, device.pd,
+                                    "car_out_power", "Car output"),
+                        VoltageEntity(device, device.inverter, "battery_main_voltage",
+                                    "Battery voltage"),
+                    ])
         elif type(device) is EcoFlowExtraDevice:
             if is_delta(device.product):
                 entities.extend([
diff --git a/custom_components/ecoflow/switch.py b/custom_components/ecoflow/switch.py
@@ -20,6 +20,8 @@ def device_added(device: EcoFlowDevice):
             entities.extend([
                 AcEntity(device, device.inverter, "ac_out_state", "AC output"),
                 BeepEntity(device, device.pd, "beep", "Beep"),
+                XBoostEntity(device, device.inverter,
+                                "ac_out_xboost", "AC X-Boost"),
             ])
             if is_delta(device.product):
                 entities.extend([
@@ -40,8 +42,17 @@ def device_added(device: EcoFlowDevice):
                 ])
             if not is_river_mini(device.product):
                 entities.extend([
-                    XBoostEntity(device, device.inverter,
-                                "ac_out_xboost", "AC X-Boost"),
+                    DcEntity(device, device.mppt,
+                             "car_out_state", "DC output"),
+                    FanAutoEntity(device, device.inverter,
+                        "fan_config", "Auto fan speed"),
+                ])
+            if is_river_mini(device.product):
+                entities.extend([
+                    DcEntity(device, device.pd,
+                             "car_out_state", "DC output"),
+                    UsbEntity(device, device.pd,
+                             "usb_out1_state", "USB output"),
                 ])
         elif type(device) is EcoFlowExtraDevice:
             if device.product == 5:  # RIVER Max
@@ -143,6 +154,14 @@ async def async_turn_off(self, **kwargs: Any):
     async def async_turn_on(self, **kwargs: Any):
         self._device.send(send.set_dc_out(self._device.product, True))
 
+class UsbEntity(SimpleEntity):
+    _attr_device_class = SwitchDeviceClass.OUTLET
+
+    async def async_turn_off(self, **kwargs: Any):
+        self._device.send(send.set_usb(False))
+
+    async def async_turn_on(self, **kwargs: Any):
+        self._device.send(send.set_usb(True))
 
 class FanAutoEntity(SimpleEntity):
     _attr_entity_category = EntityCategory.CONFIG
