jikong_backend_code/001_H511/jikong_script/auto_feeding.py

"""
@Date  :2021/6/16/14:47
@Author:zz
@Desc  :投喂数据统计
"""

import time
import json
import threading


from event_storage import EventStorage
from utility import Utility
from log import OutPutLog
from apis.get_feeding_advise import GetFeedingAdvise


class AutoFeeding:
    def __init__(self):
        self._storage = EventStorage()
        self._log = OutPutLog()
        self._run_time = None
        self._run_timing = 0
        self._feed_diameter = 0
        self._error = 0

    def t2s(self, t):
        h, m = t.strip().split(":")
        return int(h) * 3600 + int(m) * 60

    # 历史存储主函数
    def run(self):
        self._log.info('[AutoFeeding] - AutoFeeding module is running!')
        # c741功能选择，1：投喂功能
        # 1号供料器频率：c659，2号供料器频率：c663，3号供料器频率：c667
        # c737状态显示 0：无状态  1：手动模式  2：投喂模式  3：冲刷模式 4：烘干模式
        list = ["c659", "c663", "c667", "c737", "c741"]
        # 获取配置信息
        while 1:
            time.sleep(1)
            # thread_num = len(threading.enumerate())
            # print("线程数量是%d" % thread_num)
            # print(str(threading.enumerate()))
            self._error = 0
            real_data_dict = self._storage.get_real_data(list)
            feeding_connectors = Utility.available_connectors["touwei"]
            try:
                for k, v in real_data_dict.items():
                    if v is None:
                        real_data_dict[k] = -9999

                system_status = int(real_data_dict["c737"])
                system_mode = int(real_data_dict["c741"])
                # 自动投饵逻辑
                feeder_frequency = 0
                tank_number = 1
                # 获取供料器频率及料罐信息
                if float(real_data_dict['c659']) > 1:
                    feeder_frequency = float(real_data_dict['c659'])
                    tank_number = 1
                elif float(real_data_dict['c663']) > 1:
                    feeder_frequency = float(real_data_dict['c663'])
                    tank_number = 2
                elif float(real_data_dict['c667']) > 1:
                    feeder_frequency = float(real_data_dict['c667'])
                    tank_number = 3

                sql_get_task_info = "SELECT * FROM touer_set;"
                task_info = self._storage.execute_sql(sql_get_task_info)
                task_info = task_info[0]
                task_mode = int(task_info['feed_mode'])
                # bait_name = tank_number_info['name']
                # feed_weight = int(tank_number_info['weight'])
                # shelf_life = tank_number_info['shelf_life']
                tank_number_info = eval(task_info["tank" + str(tank_number)])

                feed_diameter = int(tank_number_info['diameter'])

                if feeder_frequency > 1:
                    if self._run_time == None:
                        self._run_time = time.time()

                    feeding_speed = 1440 / 67 * feeder_frequency / 50 * (8 - 0.5 * feed_diameter) * 1 / 60
                    now_time = time.time()
                    self._run_timing = self._run_timing + (now_time - self._run_time)
                    self._feed_diameter = self._feed_diameter + feeding_speed * (now_time - self._run_time)
                    self._run_time = now_time
                else:
                    self._run_time = None
                    self._run_timing = 0
                    self._feed_diameter = 0
                print("累计运行时间"+str(self._run_timing))
            except Exception as e:
                self._error = 1
                print("get tank_number_info in AutoFeeding [ERROR]:" + str(e))
                self._log.error("get tank_number_info in AutoFeeding [ERROR]:" + str(e))

            # 通讯保护逻辑
            if int(time.time()) % 10 == 0:
                if int(time.time() / 10) % 2 == 0:
                    print("1")
                    feeding_connectors.send_command([{"addr_data": "DB5.DBX66.0", "data_type": "BOOL", "data": 1}])  # 保护置1
                else:
                    print("2")
                    feeding_connectors.send_command([{"addr_data": "DB5.DBX66.0", "data_type": "BOOL", "data": 0}])  # 保护置0

            if self._error == 0 and task_mode == 1:
                # 获取投喂配置参数
                sql_get_automatic_feeding_configuration = "SELECT * FROM automatic_feeding_configuration WHERE activation = 1;"
                automatic_feeding_configuration = self._storage.execute_sql(sql_get_automatic_feeding_configuration)
                # print(self._error)
                # 自动投饵逻辑
                if len(automatic_feeding_configuration) > 0:
                    weekday = int(time.strftime('%w', time.localtime(time.time())))
                    feedingAdvise = GetFeedingAdvise()
                    feeding_port = feedingAdvise.operation(None)['port']
                    if feeding_port > 0:
                        # print(feeding_port)
                        for task in automatic_feeding_configuration:
                            try:
                                time_begin = self.t2s(task['time_begin'])
                                time_end = int(task['time_end'])
                                feeding_port_select = int(task['feeding_port'])
                                feeding_port = int(task['feeding_port'])
                                feeding_line = int(task['feeding_line'])
                                task_info = eval(task['phase_frequency'])
                                feeder_frequency_set_stage1 = int(task_info['stage1']['frequency'])
                                feeder_frequency_set_stage2 = int(task_info['stage2']['frequency'])
                                feeder_frequency_set_stage3 = int(task_info['stage3']['frequency'])
                                time_stage1 = int(task_info['stage1']['time'])
                                time_stage2 = int(task_info['stage2']['time'])
                                time_stage3 = int(task_info['stage3']['time'])
                                feeding_amount_end = float(task['feeding_amount'])
                                weekday_task = eval(task['date_bait'])
                            except Exception as e:
                                self._error = 1
                                print(e)
                                self._log.error("get tank_number_info in AutoFeeding [ERROR]:" + str(e))
                            if self._error == 0:
                                # 判断当日是否进行投饵
                                if weekday_task.count(weekday) > 0:
                                    # 判断是否到达开启时间，系统未运行，模式为投喂模式
                                    time_now = time.strftime('%H:%M', time.localtime(time.time()))
                                    time_now = self.t2s(time_now)
                                    # 自动投饵操作
                                    print("准备自动投饵")
                                    # # 调试代码
                                    # if time_begin == time_now:
                                    #     # 开始投饵
                                    #     print("开始投饵")
                                    #
                                    # if task['mode'] == "timing":
                                    #     # 变频逻辑
                                    #     if self._run_timing > time_stage1*60 and self._run_timing< time_stage2*60:
                                    #         print("开始变频1")
                                    #     elif self._run_timing > time_stage2*60 and self._run_timing < time_stage3*60:
                                    #         print("开始变频2")
                                    #     # 停止逻辑
                                    #     if time_now == time_end:
                                    #         print("停止")

                                    if time_begin == time_now and system_status == 0 and system_mode == 1:
                                        # 开始投饵
                                        print("开始投饵")
                                        if feeding_port_select > 0 :
                                            feeding_port = feeding_port_select
                                        feeding_connectors.send_command([{"addr_data": "DB14.DBB1",
                                                                          "data_type": "UINT8",
                                                                          "data": feeding_port}])  # 设置投饵口
                                        feeding_connectors.send_command([{"addr_data": "DB14.DBB0",
                                                                          "data_type": "UINT8",
                                                                          "data": feeding_line}])  # 设置投饵线路
                                        feeding_connectors.send_command([{"addr_data": "DB14.DBD4",
                                                                          "data_type": "FLOAT32",
                                                                          "data": feeder_frequency_set_stage1}])  # 设置频率
                                        feeding_connectors.send_command([{"addr_data": "DB14.DBB3", "data_type": "UINT8", "data": 1}])  # 启动置1
                                        time.sleep(1)
                                        feeding_connectors.send_command([{"addr_data": "DB14.DBB3", "data_type": "UINT8", "data": 0}])  # 启动置0
                                    if task['mode'] == "timing" and system_status == 2 and system_mode == 1:
                                        # 变频逻辑
                                        if self._run_timing > time_stage1*60 and self._run_timing< time_stage2*60 and feeder_frequency_set_stage2 != int(feeder_frequency):
                                            print("开始变频1")
                                            feeding_connectors.send_command([{"addr_data": "DB14.DBD4",
                                                                              "data_type": "FLOAT32",
                                                                              "data": feeder_frequency_set_stage2}])  # 设置频率
                                        elif self._run_timing > time_stage2*60 and self._run_timing < time_stage3*60 and feeder_frequency_set_stage3 != int(feeder_frequency):
                                            print("开始变频2")
                                            feeding_connectors.send_command([{"addr_data": "DB14.DBD4",
                                                                              "data_type": "FLOAT32",
                                                                              "data": feeder_frequency_set_stage3}])  # 设置频率
                                        # 停止逻辑
                                        if self._run_timing > time_end*60:
                                            print("停止")
                                            feeding_connectors.send_command([{"addr_data": "DB14.DBB3", "data_type": "UINT8", "data": 2}])
                                            time.sleep(1)
                                            feeding_connectors.send_command([{"addr_data": "DB14.DBB3", "data_type": "UINT8", "data": 0}])

                                    elif task['mode'] == "ration" and system_status == 2 and system_mode == 1:
                                        # 变频逻辑
                                        if self._feed_diameter > time_stage1 and self._feed_diameter < time_stage2 and feeder_frequency_set_stage2 != int(feeder_frequency):
                                            feeding_connectors.send_command([{"addr_data": "DB14.DBD4",
                                                                              "data_type": "FLOAT32",
                                                                              "data": feeder_frequency_set_stage2}])  # 设置频率
                                        elif self._feed_diameter > time_stage2 and self._feed_diameter < time_stage3 and feeder_frequency_set_stage3 != int(feeder_frequency):
                                            feeding_connectors.send_command([{"addr_data": "DB14.DBD4",
                                                                              "data_type": "FLOAT32",
                                                                              "data": feeder_frequency_set_stage3}])  # 设置频率
                                        # 停止逻辑
                                        if self._feed_diameter > feeding_amount_end:
                                            feeding_connectors.send_command([{"addr_data": "DB14.DBB3", "data_type": "UINT8", "data": 2}])
                                            time.sleep(1)
                                            feeding_connectors.send_command([{"addr_data": "DB14.DBB3", "data_type": "UINT8", "data": 0}])
                    else:
                        if system_status == 2:
                            print("停止")
                            feeding_connectors.send_command([{"addr_data": "DB14.DBB3", "data_type": "UINT8", "data": 2}])
                            time.sleep(1)
                            feeding_connectors.send_command([{"addr_data": "DB14.DBB3", "data_type": "UINT8", "data": 0}])
                            self._log.info('[AutoFeeding]—自然环境恶劣或系统存在异常，自动停止投饵！')
                        else:
                            self._log.info('[AutoFeeding]—自然环境恶劣或系统存在异常，无法执行自动投饵！')