Explorar el Código

modify missing data logic

highing666 hace 2 años
padre
commit
356bd7b6df

+ 6 - 65
app/controllers/equipment/ahu/basic.py

@@ -3,14 +3,10 @@
 from typing import List, Optional
 
 import numpy as np
-from httpx import AsyncClient
-from loguru import logger
 
 from app.models.domain.devices import ACATAHFreqSetRequest
 from app.schemas.equipment import AHU
 from app.schemas.system import ACAT
-from app.services.platform import DataPlatformService, InfoCode
-from app.services.transfer import Duoduo
 
 
 class AHUController:
@@ -19,28 +15,20 @@ class AHUController:
         self._equipment = equipment
         self._system = system
 
-    async def build_freq_set(
-            self, supply_air_temperature_set_duration: List, hot_rate: float
-    ) -> float:
+    async def build_freq_set(self, supply_air_temperature_set_duration: List, hot_rate: float) -> float:
         extent = 5
         if (
-                np.isnan(self._equipment.freq_set)
-                or np.isnan(self._system.supply_static_press)
-                or np.isnan(self._system.supply_static_press_set)
+                self._equipment.freq_set is None
+                or self._system.supply_static_press is None
+                or self._system.supply_static_press_set is None
         ):
             temp_freq_set = 80.0
         else:
             pre_fan_freq_set = self._equipment.freq_set
 
-            if (
-                    self._system.supply_static_press
-                    < self._system.supply_static_press_set - extent
-            ):
+            if self._system.supply_static_press < self._system.supply_static_press_set - extent:
                 temp_freq_set = pre_fan_freq_set + 2
-            elif (
-                    self._system.supply_static_press
-                    > self._system.supply_static_press_set + extent
-            ):
+            elif self._system.supply_static_press > self._system.supply_static_press_set + extent:
                 temp_freq_set = pre_fan_freq_set - 2
             else:
                 temp_freq_set = pre_fan_freq_set
@@ -61,53 +49,6 @@ class AHUController:
         return freq_set
 
 
-@logger.catch()
-async def get_freq_controlled(project_id: str, equipment_id: str) -> None:
-    async with AsyncClient() as client:
-        platform = DataPlatformService(client, project_id)
-        review_service = Duoduo(client, project_id)
-
-        fan_freq_set = await platform.get_realtime_fan_freq_set(equipment_id)
-        # system = await equip_service.get_system_by_equipment(equipment_id)
-        system = ["Sy1101050030eab54ad66b084a1cb1b919950b263280"]
-        press = await platform.get_realtime_supply_static_press(system[0])
-        press_set = await platform.get_realtime_supply_static_press_set(system[0])
-        count = await review_service.get_fill_count()
-        try:
-            hot_rate = count.get("hotNum") / (
-                    count.get("hotNum") + count.get("coldNum") + count.get("normalNum")
-            )
-        except (ZeroDivisionError, KeyError):
-            hot_rate = 0.0
-        raw_supply_air_temperature_set = await platform.get_duration(
-            InfoCode.supply_air_temperature_set, equipment_id, 30 * 60
-        )
-        supply_air_temperature_set = [
-            item["value"] for item in raw_supply_air_temperature_set
-        ]
-
-    equip_params = {"id": equipment_id, "freq_set": fan_freq_set}
-    ahu = AHU(**equip_params)
-
-    system_params = {
-        "id": system[0],
-        "supply_static_press": press,
-        "supply_static_press_set": press_set,
-    }
-    acat_system = ACAT(**system_params)
-
-    ahu_controller = AHUController(ahu, acat_system)
-    new_freq_set = await ahu_controller.build_freq_set(
-        supply_air_temperature_set, hot_rate
-    )
-    logger.debug(f"{equipment_id} freq set: {new_freq_set}")
-
-    async with AsyncClient() as client:
-        platform = DataPlatformService(client, project_id)
-        await platform.set_code_value(equipment_id, InfoCode.fan_freq_set, new_freq_set)
-
-
-@logger.catch()
 async def build_acatah_freq_set(params: ACATAHFreqSetRequest) -> float:
     acat_system = ACAT(
         supply_static_press=params.system_supply_static_press,

+ 15 - 12
app/controllers/equipment/ahu/common.py

@@ -6,6 +6,7 @@ from typing import List, Tuple
 import numpy as np
 from loguru import logger
 
+from app.api.errors.iot import MissingIOTDataError
 from app.models.domain.devices import ACATAHInstructionsRequest
 from app.schemas.equipment import AHU
 from app.schemas.season import Season
@@ -22,7 +23,7 @@ class ATAHController:
     def get_switch_set(self) -> str:
         switch_set = "off"
         for sp in self._spaces:
-            if not np.isnan(sp.temperature_target):
+            if sp.temperature_target:
                 switch_set = "on"
 
         return switch_set
@@ -105,7 +106,7 @@ class ATAHController:
     def get_valid_spaces(self) -> List:
         valid_spaces = list()
         for sp in self._spaces:
-            if not np.isnan(sp.realtime_temperature) and not np.isnan(sp.temperature_target):
+            if sp.realtime_temperature and sp.temperature_target:
                 valid_spaces.append(sp)
 
         return valid_spaces
@@ -143,20 +144,22 @@ class ATAHController:
         return virtual_realtime, virtual_target
 
     def run(self) -> Tuple[str, float, float, float]:
-        virtual_realtime, virtual_target = self.build_virtual_temperature()
-        new_switch_set = self.get_switch_set()
-        if np.isnan(self._ahu.return_air_temperature_set):
-            new_freq_set = self.get_freq_set(new_switch_set, virtual_target)
-            new_return_air_temp_set = np.NAN
-        else:
-            new_return_air_temp_set = self.get_return_air_temp_set(virtual_target)
-            new_freq_set = np.NAN
-        new_supply_air_temp_set = self.get_supply_air_temp_set(new_switch_set, virtual_realtime)
+        try:
+            virtual_realtime, virtual_target = self.build_virtual_temperature()
+            new_switch_set = self.get_switch_set()
+            if not self._ahu.return_air_temperature_set:
+                new_freq_set = self.get_freq_set(new_switch_set, virtual_target)
+                new_return_air_temp_set = np.NAN
+            else:
+                new_return_air_temp_set = self.get_return_air_temp_set(virtual_target)
+                new_freq_set = np.NAN
+            new_supply_air_temp_set = self.get_supply_air_temp_set(new_switch_set, virtual_realtime)
+        except TypeError:
+            raise MissingIOTDataError
 
         return new_switch_set, new_return_air_temp_set, new_freq_set, new_supply_air_temp_set
 
 
-@logger.catch()
 async def build_acatah_instructions(params: ACATAHInstructionsRequest):
     space_params = []
     for sp in params.spaces:

+ 23 - 105
app/controllers/equipment/ahu/supply_air_temperature_set.py

@@ -2,15 +2,13 @@ from typing import List
 
 import arrow
 import numpy as np
-from httpx import AsyncClient
 from loguru import logger
 
-from app.controllers.equipment.ahu.thermal_mode import count_vav_box_weight, fetch_status_params
+from app.api.errors.iot import MissingIOTDataError
+from app.controllers.equipment.ahu.thermal_mode import count_vav_box_weight
 from app.models.domain.devices import ThermalMode, ACATAHSupplyAirTempSetRequest
 from app.schemas.equipment import VAVBox
-from app.services.platform import DataPlatformService, InfoCode
-from app.services.transfer import Duoduo, Season
-from app.services.weather import WeatherService
+from app.services.transfer import Season
 from app.utils.date import get_time_str, TIME_FMT
 
 
@@ -108,25 +106,28 @@ class ACATAHSupplyAirTemperatureController:
         return ratio
 
     def build(self) -> float:
-        if not self.is_off_to_on:
-            normal_ratio = self.get_normal_ratio()
-            if normal_ratio < 0.9:
-                cold_ratio = self.get_cold_ratio()
-                temperature = self.calculate_by_cold_vav(cold_ratio)
+        try:
+            if not self.is_off_to_on:
+                normal_ratio = self.get_normal_ratio()
+                if normal_ratio < 0.9:
+                    cold_ratio = self.get_cold_ratio()
+                    temperature = self.calculate_by_cold_vav(cold_ratio)
+                else:
+                    temperature = self.current_set
             else:
-                temperature = self.current_set
-        else:
+                if self.season == Season.heating:
+                    temperature = 27.0
+                elif self.season == Season.cooling:
+                    temperature = 20.0
+                else:
+                    temperature = 25.0
+
             if self.season == Season.heating:
-                temperature = 27.0
-            elif self.season == Season.cooling:
-                temperature = 20.0
+                temperature = max(20.0, min(30.0, temperature))
             else:
-                temperature = 25.0
-
-        if self.season == Season.heating:
-            temperature = max(20.0, min(30.0, temperature))
-        else:
-            temperature = max(18.0, min(25.0, temperature))
+                temperature = max(18.0, min(25.0, temperature))
+        except TypeError:
+            raise MissingIOTDataError
 
         return temperature
 
@@ -159,90 +160,7 @@ class ACATAHSupplyAirTemperatureDefaultController:
         return temperature
 
 
-async def get_planned(project_id: str, device_id: str) -> float:
-    vav_boxes_params = await fetch_status_params(project_id, device_id)
-    vav_boxes_lit = vav_boxes_params["vav_boxes_list"]
-    async with AsyncClient() as client:
-        platform = DataPlatformService(client, project_id)
-        duoduo = Duoduo(client, project_id)
-
-        current_supply_air_temperature = await platform.get_realtime_supply_air_temperature(device_id)
-        return_air_temperature = await platform.query_realtime_return_air_temperature(device_id)
-
-        hot_water_valve_opening_set_duration = await platform.get_duration(
-            InfoCode.hot_water_valve_opening_set, device_id, 15 * 60
-        )
-        chill_water_valve_opening_set_duration = await platform.get_duration(
-            InfoCode.chill_water_valve_opening_set, device_id, 15 * 60
-        )
-        on_off_set_duration = await platform.get_duration(InfoCode.equip_switch_set, device_id, 20 * 60)
-
-        season = await duoduo.get_season()
-
-        if chill_water_valve_opening_set_duration[-1]["value"] == 0.0:
-            thermal_mode = ThermalMode.heating
-        else:
-            thermal_mode = ThermalMode.cooling
-
-        is_off_to_on = False
-        if on_off_set_duration[-1]["value"] == 1.0:
-            for item in on_off_set_duration[::-1]:
-                if item["value"] == 0.0:
-                    is_off_to_on = True
-                    break
-
-        is_thermal_mode_switched = False
-        if len(set([item["value"] for item in hot_water_valve_opening_set_duration])) > 1:
-            is_thermal_mode_switched = True
-        if len(set([item["value"] for item in chill_water_valve_opening_set_duration])) > 1:
-            is_thermal_mode_switched = True
-
-    controller = ACATAHSupplyAirTemperatureController(
-        vav_boxes_lit,
-        current_supply_air_temperature,
-        return_air_temperature,
-        thermal_mode,
-        is_off_to_on,
-        is_thermal_mode_switched,
-        season,
-    )
-    next_supply_air_temperature_set = controller.build()
-
-    return next_supply_air_temperature_set
-
-
-async def get_default(project_id: str) -> float:
-    async with AsyncClient() as client:
-        weather_service = WeatherService(client)
-        realtime_weather = await weather_service.get_realtime_weather(project_id)
-
-        if realtime_weather.get("text") == "晴":
-            is_clear_day = True
-        else:
-            is_clear_day = False
-
-    controller = ACATAHSupplyAirTemperatureDefaultController(is_clear_day)
-    next_supply_air_temperature_set = controller.build()
-
-    return next_supply_air_temperature_set
-
-
-@logger.catch
-async def get_next_supply_air_temperature_set(project_id: str, device_id: str) -> float:
-    try:
-        new = await get_planned(project_id, device_id)
-    except KeyError and IndexError:
-        new = await get_default(project_id)
-
-    logger.debug(f"next supply air temperature set: {device_id} - {new}")
-
-    return new
-
-
-@logger.catch
-def build_acatah_supply_air_temperature_set(
-        params: ACATAHSupplyAirTempSetRequest,
-) -> float:
+def build_acatah_supply_air_temperature_set(params: ACATAHSupplyAirTempSetRequest) -> float:
     try:
         vav_list = list()
         for raw_vav in params.vav_list:

+ 19 - 22
app/controllers/equipment/ahu/switch.py

@@ -1,14 +1,9 @@
 # -*- coding: utf-8 -*-
 
-from typing import Tuple
-
-from httpx import AsyncClient
-from loguru import logger
-
+from app.api.errors.iot import MissingIOTDataError
 from app.controllers.equipment.switch import Switch, SwitchSet
 from app.models.domain.devices import ACATAHSwitchSetRequest
 from app.schemas.equipment import AHU
-from app.services.platform import DataPlatformService
 
 
 class AHUSwitch(Switch):
@@ -16,32 +11,34 @@ class AHUSwitch(Switch):
         super(AHUSwitch, self).__init__(equipment)
 
     def break_time_action(self, begin: str, end: str, is_workday: bool) -> SwitchSet:
-        if self._equip.in_cloud_status:
-            if is_workday:
-                if begin and end:
-                    switch_flag = True
-                    if begin <= end:
-                        if begin <= self._now_time <= end:
-                            switch_flag = False
-                    else:
-                        if not end <= self._now_time <= begin:
-                            switch_flag = False
-
-                    if not switch_flag:
-                        action = SwitchSet.off
+        try:
+            if self._equip.in_cloud_status:
+                if is_workday:
+                    if begin and end:
+                        switch_flag = True
+                        if begin <= end:
+                            if begin <= self._now_time <= end:
+                                switch_flag = False
+                        else:
+                            if not end <= self._now_time <= begin:
+                                switch_flag = False
+
+                        if not switch_flag:
+                            action = SwitchSet.off
+                        else:
+                            action = SwitchSet.hold
                     else:
                         action = SwitchSet.hold
                 else:
                     action = SwitchSet.hold
             else:
                 action = SwitchSet.hold
-        else:
-            action = SwitchSet.hold
+        except TypeError:
+            raise MissingIOTDataError
 
         return action
 
 
-@logger.catch()
 async def build_acatah_switch_set(params: ACATAHSwitchSetRequest) -> SwitchSet:
     ahu = AHU(
         running_status=params.running_status,

+ 15 - 70
app/controllers/equipment/ahu/thermal_mode.py

@@ -1,13 +1,9 @@
-from typing import Dict, List
-
-from httpx import AsyncClient
-from loguru import logger
+from typing import List
 
+from app.api.errors.iot import MissingIOTDataError
 from app.models.domain.devices import ACATAHThermalModeSetRequest
-from app.models.domain.devices import ThermalMode
 from app.schemas.equipment import VAVBox
-from app.services.platform import DataPlatformService, InfoCode
-from app.services.transfer import Duoduo, Season
+from app.services.transfer import Season
 
 
 def count_vav_box_weight(
@@ -63,15 +59,18 @@ class ACATAHThermalModeController:
     def build(self) -> str:
         weight = 0.0
         for box in self.vav_boxes_list:
-            weight += count_vav_box_weight(
-                box.virtual_realtime_temperature,
-                box.virtual_target_temperature,
-                box.supply_air_flow_upper_limit,
-                box.supply_air_flow_lower_limit,
-                box.supply_air_flow_set,
-                box.valve_opening,
-                box.supply_air_temperature
-            )
+            try:
+                weight += count_vav_box_weight(
+                    box.virtual_realtime_temperature,
+                    box.virtual_target_temperature,
+                    box.supply_air_flow_upper_limit,
+                    box.supply_air_flow_lower_limit,
+                    box.supply_air_flow_set,
+                    box.valve_opening,
+                    box.supply_air_temperature
+                )
+            except TypeError:
+                raise MissingIOTDataError
 
         if weight > 0:
             mode = "cooling"
@@ -83,60 +82,6 @@ class ACATAHThermalModeController:
         return mode
 
 
-async def fetch_status_params(project_id: str, device_id: str) -> Dict:
-    async with AsyncClient() as client:
-        platform = DataPlatformService(client, project_id)
-        duoduo = Duoduo(client, project_id)
-
-        season = duoduo.get_season()
-        relations = await platform.query_relations(
-            from_id=device_id, graph_id="GtControlEquipNetwork001"
-        )
-        vav_id_list = [item.get("to_id") for item in relations]
-        vav_boxes_list = []
-        for vav_id in vav_id_list:
-            virtual_realtime_temperature = await duoduo.query_device_virtual_data(
-                vav_id, "VirtualRealtimeTemperature"
-            )
-            virtual_temperature_target = await duoduo.query_device_virtual_data(
-                vav_id, "TargetTemperatureSet"
-            )
-            lower_limit_flow, upper_limit_flow = await platform.get_air_flow_limit(
-                vav_id
-            )
-            current_flow_set = await platform.get_realtime_data(
-                InfoCode.supply_air_flow_set, vav_id
-            )
-            valve_opening = await platform.get_realtime_data(
-                InfoCode.valve_opening, vav_id
-            )
-            vav_params = {
-                "id": vav_id,
-                "virtual_realtime_temperature": virtual_realtime_temperature,
-                "virtual_target_temperature": virtual_temperature_target,
-                "supply_air_flow_lower_limit": lower_limit_flow,
-                "supply_air_flow_upper_limit": upper_limit_flow,
-                "supply_air_flow_set": current_flow_set,
-                "valve_opening": valve_opening,
-            }
-            vav = VAVBox(**vav_params)
-            vav_boxes_list.append(vav)
-
-        return {"vav_boxes_list": vav_boxes_list, "season": season}
-
-
-@logger.catch()
-async def get_thermal_mode(project_id: str, device_id: str) -> ThermalMode:
-    prams = await fetch_status_params(project_id, device_id)
-    controller = ACATAHThermalModeController(
-        prams.get("vav_boxes_list"), prams.get("season")
-    )
-    mode = controller.build()
-
-    return ThermalMode(mode)
-
-
-@logger.catch()
 def build_acatah_thermal_mode_set(params: ACATAHThermalModeSetRequest) -> str:
     vav_list = list()
     for raw_vav in params.vav_list: