FurnaceELK/Furnace/FurnaceRT/Extraction/MinicsManager.cs

using Aitex.Core.RT.Event;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using DocumentFormat.OpenXml.Wordprocessing;
using FurnaceRT.Equipments.PMs;
using FurnaceRT.Equipments.Systems;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Event;
using MECF.Framework.UI.Client.CenterViews.Editors.Recipe;
using RTCommunicatorBase;
using RTCommunicatorTLV;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace FurnaceRT.Extraction
{
    public class MinicsManager : Singleton<MinicsManager>, IRTMini8Provider
    {
        private readonly object _lock = new object();
        public void Connected(string ip, int port)
        {
            Console.WriteLine($"DisconnectedNotify {ip} {port}");

        }
        public void DisConnected(string ip, int port)
        {
            Console.WriteLine($"DisconnectedNotify {ip} {port}");
        }
        private RTCommunicator_TLV communicator = new RTCommunicator_TLV();
        public void Initialize(string ip = "127.0.0.1", int port = 50052)
        {
            if (SC.GetValue<bool>("System.IsSimulatorMode"))
            {
                return;
            }
            communicator.Initialize(this);
            SWJConnectedMinics(ip, port);

            //  AlarmIndefinx();
        }

        public void SWJConnectedMinics(string ip, int port)
        {
            if (communicator.StartService(ip, port))
            {
                EV.PostInfoLog(ModuleName.Minics.ToString(), $"minics  Connected {ip}:{port} sucessful");
            }
            else
            {
                for (int i = 1; i <= 3; i++)
                {
                    var status = this.communicator.StartService(ip, port);

                    try
                    {
                        if (status)
                            break;
                    }
                    catch
                    {
                        if (i == 3)
                            return;
                        Thread.Sleep(300);
                        EV.PostAlarmLog(ModuleName.Minics.ToString(), $"retry minics  Connected {ip}:{port} error {i} times");
                    }
                }

            }
        }
        public void End()
        {

        }
        public void SelectMinicsConfig(string minicsConfigName)
        {
            bool result = communicator.SelectConfigFile(minicsConfigName);
            if (!result)
            {
                EV.PostAlarmLog(ModuleName.Minics.ToString(), $"SendMinicsConfig {minicsConfigName} fail!");
            }
        }
        public Dictionary<string, Tuple<AlarmEventItem, AlarmEventItem, AlarmEventItem>> MinicsAlarmDic { get; set; } = new Dictionary<string, Tuple<AlarmEventItem, AlarmEventItem, AlarmEventItem>>();

        public void AlarmIndefinx()
        {
            var pm = Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule;
            for (int i = 1; i < 9; i++)
            {
                for (int j = 1; j < 17; j++)
                {
                    MinicsAlarmDic.Add($"{i}_{j}", pm.AddMini8ChannelAlarm(i, j));
                }
            }
        }
        public void CurrentTempConfigFile(string fileName)
        {

        }

        public void Mini8ConnectNotify(byte mini8Index)
        {
            var pm = Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule;
            pm.Mini8ConnectAlarm.Reset();
        }

        public void Mini8DisconnectNotify(byte mini8)
        {
            var pm = Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule;
            pm.Mini8ConnectAlarm.Set();
        }

        public void ChannelAlarmNotify(ST_ALARM_Notify alarm)
        {
            var gasLineHeaterIndex = $"{alarm.Mini8Index}_{alarm.ChannelIndex}";
            var pm = Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule;
            lock (_lock)
            {
                var alarmValue = MinicsAlarmDic[gasLineHeaterIndex];
                string message;

                switch (alarm.AlarmType)
                {
                    case RTCommunicatorBase.AlarmType.CapsOverFlow:
                        message = $"Unit{alarm.Mini8Index}CH{alarm.ChannelIndex} Feedback:{alarm.PV} limit is ({alarm.Caps}~{alarm.Floor}) ";
                        var alarmEvent = alarm.HeaterType == HeaterType.GaseLine ? pm.GasLineOverTempAlarm : pm.ForLineOverTempAlarm;
                        alarmEvent.Set(message);
                        break;
                    case RTCommunicatorBase.AlarmType.FloorOverFlow:
                        message = $"Unit{alarm.Mini8Index}CH{alarm.ChannelIndex} Feedback:{alarm.PV} limit is ({alarm.Caps}~{alarm.Floor}) ";
                        alarmEvent = alarm.HeaterType == HeaterType.GaseLine ? pm.GasLineOverTempAlarm : pm.ForLineOverTempAlarm;
                        alarmEvent.Set(message);
                        break;
                    case RTCommunicatorBase.AlarmType.TcBroken:
                        message = $"Unit{alarm.Mini8Index}CH{alarm.ChannelIndex} is TcBroken";
                        alarmEvent = alarm.HeaterType == HeaterType.GaseLine ? pm.GasLineOverTempAlarm : pm.ForLineOverTempAlarm;
                        alarmEvent.Set(message);
                        break;
                    default:
                        // Handle other cases or log an error
                        break;
                }

            }
        }
    }
}