ECS / WCS_LiuzhouZhituo · Files

using HHWCS.Bll;

using HHWCS.Model;

using HHWCSHost.Controls;
using OPCHelper;

using System;

using System.Collections.Generic;

using System.Configuration;

using System.Linq;

using System.Threading;

using System.Threading.Tasks;

using System.Timers;

using System.Windows;
using System.Windows.Controls;

using System.Windows.Media;

using LEDhelp;

namespace HHWCSHost.View
{
    /// <summary>
    /// Frm_Main.xaml 的交互逻辑
    /// </summary>
    public partial class Frm_Main : Window
    {

        #region 属性

        //const string plcAdressPrefix = "S7:[S7 connection_1]";
        private object locker = new object();

        //所有子窗口
        Dictionary<string, Window> windows = new Dictionary<string, Window>();

        private System.Timers.Timer timer = new System.Timers.Timer();

        int inTimer = 0;

        //OPC相关
        /// <summary>
        /// OPC地址
        /// </summary>
        public string PLCIP { get; set; }

        public OPCHelp PLC { get; set; }

        /// <summary>
        /// 创建item后返回的索引值，需要用到这个去进行数据读取
        /// </summary>

        public int[] ServerHandle { get; set; }

        //堆垛机

        //public List<StockerMonitor> StockerMonitors { get; set; }

        public LogInfo LogInfo { get; set; }

        public List<DeviceAddressEntity> DeviceAddressEntities { get; set; }
        public List<DeviceEntity> DeviceEntities { get; set; }
        public List<DevicePropEntity> DevicePropEntities { get; set; }
        public List<DeviceTypeEntity> DeviceTypeEntities { get; set; }

        /// <summary>
        /// 时钟控制器
        /// </summary>
        bool stop = false;

        public LEDHelper led { get; set; }

        #endregion

        public Frm_Main()

        {
            InitializeComponent();

            //日志组件最先初始化

            LogInfo = new LogInfo(450, 500);

            panel_Bottom.Children.Add(LogInfo);

            InitMenu();
            InitStatusBar();

            InitTimer();

            InitOPC();

            InitDeviceData();

            led = new LEDHelper(AppCommon.LedIP, AppCommon.LedPort, AppCommon.LedTimer);

            //InitStockerAndStationMonitor();

        }

        #region 初始化
        private void InitDeviceData()
        {

            var temp = Bll.GetAllDevice();
            var temp2 = Bll.GetAllDeviceAddress();
            var temp3 = Bll.GetAllDeviceProp();
            var temp4 = Bll.GetAllDeviceType();
            if (!temp.Success || !temp2.Success || !temp3.Success || !temp4.Success)

            {
                btn_OpenPLCConnect.IsEnabled = false;
                MessageBox.Show("获取设备数据出错");
                AddLogToUI("获取设备数据出错", 2);
                return;
            }
            DeviceEntities = temp.Data;
            DeviceAddressEntities = temp2.Data;
            DevicePropEntities = temp3.Data;
            DeviceTypeEntities = temp4.Data;
            //属性地址校验

            foreach (var item in DeviceEntities)
            {
                if (DeviceAddressEntities.Count(t => t.DeviceId == item.Id) == 0)
                {
                    String msg = "错误：设备" + item.Code + " " + item.Name + "无属性地址";

                    MessageBox.Show(msg);

                    AddLogToUI(msg, 2);
                    btn_OpenPLCConnect.IsEnabled = false;
                    return;
                }
                //todo:校验属性是否都存在
                if (DevicePropEntities.Count(t => t.DeviceTypeId == item.DeviceTypeId) != DeviceAddressEntities.Count(t => t.DeviceId == item.Id))
                {
                    String msg = "错误：设备" + item.Code + " " + item.Name + "属性地址与类型属性规定不一致";

                    MessageBox.Show(msg);

                    AddLogToUI(msg, 2);
                    btn_OpenPLCConnect.IsEnabled = false;
                    return;
                }
            }

            //属性地址获取无误后初始化监控

            InitStockerAndStationMonitor();

        }

        private void InitStockerAndStationMonitor()

        {

            //堆垛机
            var stockers = FindDevByType("stocker").Data;

            foreach (var item in stockers)
            {

                StockerMonitor stockerMonitor = new StockerMonitor(32, false, false, 1200, 100)

                {
                    ControlName = item.Name,
                    Name = item.Code
                };

                this.RegisterName(item.Code, stockerMonitor);

                panel_Stocker.Children.Add(stockerMonitor);

                StockerInfo stockerInfo = new StockerInfo(450, 500)
                {
                    ControlName = item.Name,
                    Name = item.Code
                };
                stockerInfo.DoubleInEvent += this.DoubleInHandle;

                stockerInfo.EmptyOutEvent += this.EmptyOutHandle;

                panel_Bottom.Children.Add(stockerInfo);

            }

            //接入站台
            var staionForStockerIn = FindDevByType("stationForStockerIn").Data;
            foreach (var item in staionForStockerIn)
            {

                StationInfo stationInfo = new StationInfo(450, 500)
                {
                    ControlName = item.Name,
                    Name = item.Code
                };

                panel_Bottom.Children.Add(stationInfo);
            }

            //接出站台
            var staionForStockerOut = FindDevByType("stationForStockerOut").Data;
            foreach (var item in staionForStockerOut)
            {

                StationInfo stationInfo = new StationInfo(450, 500)
                {
                    ControlName = item.Name,
                    Name = item.Code
                };

                panel_Bottom.Children.Add(stationInfo);
            }

            //出入站台
            var station = FindDevByType("station").Data;
            foreach (var item in station)
            {

                StationInfo stationInfo = new StationInfo(450, 500)
                {
                    ControlName = item.Name,
                    Name = item.Code
                };

                panel_Bottom.Children.Add(stationInfo);
            }

            //出入站台
            var stationIn = FindDevByType("stationIn").Data;
            foreach (var item in stationIn)
            {

                StationInfo stationInfo = new StationInfo(450, 500)
                {
                    ControlName = item.Name,
                    Name = item.Code
                };

                panel_Bottom.Children.Add(stationInfo);
            }

        }

        private void InitOPC()

        {

            try

            {

                PLCIP = ConfigurationManager.AppSettings["OPCServerIP"];

                PLC = new OPCHelp(PLCIP);

            }

            catch (Exception)

            {

                MessageBox.Show("未能获取到OPC配置，请检查。", "注意", MessageBoxButton.OK, MessageBoxImage.Error);

            }

        }

        private void InitStatusBar()
        {

            statusBar.Items.Add("欢迎：" + AppCommon.User.UserName + " 登录时间：" + DateTime.Now.ToString());

        }

        private void InitMenu()
        {
            //构建菜单
            //系统

            MenuItem menu_sys = new MenuItem
            {
                Header = "系统"
            };
            MenuItem menu_sys_exit = new MenuItem
            {
                Header = "退出"
            };

            menu_sys_exit.Click += Menu_sys_exit_Click;
            menu_sys.Items.Add(menu_sys_exit);

            //设备

            MenuItem menu_device = new MenuItem
            {
                Header = "设备管理"
            };
            MenuItem menu_device_info = new MenuItem
            {
                Header = "设备信息管理"
            };

            menu_device_info.Click += Menu_device_info_Click;
            menu_device.Items.Add(menu_device_info);

            MenuItem menu_device_OPCTest = new MenuItem
            {
                Header = "OPC测试"
            };

            menu_device_OPCTest.Click += Menu_device_OPCTest_Click;
            menu_device.Items.Add(menu_device_OPCTest);

            //任务

            MenuItem menu_task = new MenuItem
            {
                Header = "任务管理"
            };
            MenuItem menu_task_info = new MenuItem
            {
                Header = "任务查看"
            };

            menu_task_info.Click += Menu_task_info_Click;
            menu_task.Items.Add(menu_task_info);

            //仓库

            MenuItem menu_warehouse = new MenuItem
            {
                Header = "仓库信息"
            };
            MenuItem menu_location = new MenuItem
            {
                Header = "货位"
            };

            menu_location.Click += Menu_location_Click;

            MenuItem menu_pallet = new MenuItem
            {
                Header = "托盘"
            };

            menu_pallet.Click += Menu_pallet_Click;
            menu_warehouse.Items.Add(menu_location);
            menu_warehouse.Items.Add(menu_pallet);

            menu.Items.Add(menu_sys);
            menu.Items.Add(menu_device);
            menu.Items.Add(menu_task);

            menu.Items.Add(menu_warehouse);

            //工具栏
            btn_OpenPLCConnect.IsEnabled = true;
            btn_ClosePLCConnect.IsEnabled = false;

        }

        /// <summary>
        /// 打开监控
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_OpenPLCConnect_Click(object sender, RoutedEventArgs e)

        {

            if (PLC == null)
            {
                MessageBox.Show("PLC连接初始化失败！ 请检查PLC配置然后重启本程序", "注意", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
            if (PLC.OpenConn() == false)
            {
                MessageBox.Show("打开PLC连接失败");
                return;
            }
            PLC.CreateGroup("group1");
            AddOPCItems();
            //
            btn_ClosePLCConnect.IsEnabled = true;
            btn_OpenPLCConnect.IsEnabled = false;

            //同步锁置0

            stop = false;

            timer.Enabled = true;
        }

        private void AddOPCItems()
        {
            ServerHandle = new int[DeviceAddressEntities.Count];
            for (int i = 0; i < DeviceAddressEntities.Count; i++)
            {
                var temp = DeviceAddressEntities[i];

                ServerHandle[i] = PLC.AddAddr(temp.Address, i);

                temp.ServerHandle = ServerHandle[i];
            }
        }

        /// <summary>
        /// 关闭监控
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_ClosePLCConnect_Click(object sender, RoutedEventArgs e)
        {

            //if (PLC.GetConnStatus())
            //{
            //    if (!PLC.CloseConn())
            //    {
            //        MessageBox.Show("关闭失败请稍后重试");
            //    };
            //}
            //btn_ClosePLCConnect.IsEnabled = false;
            //btn_OpenPLCConnect.IsEnabled = true;
            //timer.Enabled = false;

            //同步锁置1

            stop = true;

        }

        private void InitTimer()
        {

            timer.Interval = 1000; //3秒触发一次

            timer.Elapsed += new System.Timers.ElapsedEventHandler(OnTimedEvent);
            timer.AutoReset = true;//每到指定时间Elapsed事件是到时间就触发

            timer.Enabled = false; //指示 Timer 是否应引发 Elapsed 事件。

        }

        #endregion

        /// <summary>
        /// 程序主时钟

        /// 出库优先

        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnTimedEvent(object sender, ElapsedEventArgs e)
        {
            //同步线程防止重入

            //if (Interlocked.Exchange(ref inTimer, 1) == 0)
            //{
            lock (locker)

            {

                #region 是否结束处理

                if (stop)
                {
                    if (PLC.GetConnStatus())
                    {
                        PLC.CloseConn();
                    }

                    Dispatcher.Invoke(() =>
                    {
                        btn_ClosePLCConnect.IsEnabled = false;
                        btn_OpenPLCConnect.IsEnabled = true;
                        timer.Enabled = false;
                    });

                    return;
                }

                #endregion

                #region 检查是否连接正常
                if (PLC.GetConnStatus())
                {
                    this.Dispatcher.Invoke(new Action(() =>
                    {
                        if (this.grid.Background == Brushes.Red)
                        {
                            this.grid.Background = Brushes.White;
                        }
                    }));
                }
                else
                {
                    this.Dispatcher.Invoke(new Action(() =>
                    {
                        if (this.grid.Background != Brushes.Red)
                        {
                            this.grid.Background = Brushes.Red;
                        }
                        if (!((TextBlock)this.LogInfo.list_Log.SelectedItem).Text.Contains("失去通讯连接，请关闭连接后重新打开"))
                        {
                            this.LogInfo.AddLogs("失去通讯连接，请关闭连接后重新打开", 2);
                        }
                    }));
                    //这里直接retrun，并没有更改inTimer的值，后续不会再次进入这个循环，需要关闭连接然后重新打开连接来重置这个参数；
                    return;
                }
                #endregion

                #region 测试监控赋值

                //测试值读取
                var readAllAddressDataResult = ReadAllAddressData();
                if (!readAllAddressDataResult.Success)
                {
                    AddLogToUI("读取地址数据失败，请尝试关闭连接后重新连接；", 2);
                    return;
                }

                //日志
                DeviceEntities.ForEach(item => DeviceAddressEntities.FindAll(t => t.DeviceId == item.Id).Join(DevicePropEntities.FindAll(t => t.DeviceTypeId == item.DeviceTypeId && t.IsMonitor == 1), t => t.DevicePropCode, a => a.Code, (a, b) => new { a, b }).Where(t => t.a.value != t.b.MonitorCompareValue).Select(t => t.b).ToList().ForEach(t => AddLogToUI("报警：" + t.Name + " 信息：" + t.MonitorFailure, 2)));
                //底部面板
                Dispatcher.Invoke(new Action(() =>

                {
                    foreach (var item in panel_Bottom.Children)
                    {
                        if (item is StockerInfo temp)

                        {

                            var a = DeviceEntities.Find(t => t.Code == temp.Name);
                            temp.SetProps(DeviceEntities.Find(t => t.Code == temp.Name), DevicePropEntities.FindAll(t => t.DeviceTypeId == a.DeviceTypeId), DeviceAddressEntities.FindAll(t => t.DeviceId == a.Id));

                        }

                        if (item is StationInfo station)

                        {
                            var a = DeviceEntities.Find(t => t.Code == station.Name);
                            station.SetProp(DeviceAddressEntities.FindAll(t => t.DeviceId == a.Id));
                        }

                    };
                }

                    ));
                //图形监控
                Dispatcher.Invoke(new Action(() =>
                {
                    foreach (var item in FindDevByType("stocker").Data)
                    {
                        //货架监控方面先不实现
                        var addressEntities = DeviceAddressEntities.FindAll(t => t.DeviceId == item.Id);
                        var stockerMonitor = (StockerMonitor)panel_Stocker.FindName(item.Code);

                        stockerMonitor.SetProp(addressEntities);

                    }
                    foreach (var item in FindDevByType("conveyor").Data)
                    {

                        var cv = this.FindName(item.Code);

                        if (cv is StationV stationV)

                        {
                            stationV.SetProp(DeviceAddressEntities.FindAll(t => t.DeviceId == item.Id));
                        }

                        if (cv is StationH stationH)

                        {
                            stationH.SetProp(DeviceAddressEntities.FindAll(t => t.DeviceId == item.Id));
                        }

                    }
                }));

                #endregion

                #region 堆垛机操作
                //找出所有堆垛机

                var stockersResult = FindDevByType("stocker");

                if (stockersResult.Success)
                {
                    var stockers = stockersResult.Data;
                    //遍历所有出库性质的任务
                    ExcuteTaskOut(stockers);

                    //响应任务完成

                    ExcuteTaskComplete(stockers);

                    //响应入库任务
                    ExcuteTaskIn(stockers);

                    //同巷道内的移库，当堆垛机状态为0,1,2时，均可以响应巷道内的移库
                    ExcuteTaskTransferInRoadway(stockers);

                }

                #endregion

                #region 响应堆垛机接入站台

                var stationForStockerInResult = FindDevByType("stationForStockerIn");

                if (stationForStockerInResult.Success)
                {
                    foreach (var stationForStockerIn in stationForStockerInResult.Data)
                    {

                        var addresses = DeviceAddressEntities.FindAll(t => t.DeviceId == stationForStockerIn.Id);
                        var readResult = ReadAddress(addresses);
                        if (readResult.Success)

                        {

                            //这里先直接回应一个响应
                            //如果PLC标记为3，则表示解析有误，这里报警
                            if (addresses.Find(t => t.DevicePropCode == "Flag").value == "3")

                            {

                                AddLogToUI("PLC解析站台" + stationForStockerIn + "数据失败，请检查基础数据！", 2);
                                continue;
                            }

                            //PLC 有新消息标记 && WCS回复有新消息标记：此时WCS已经回复了消息，等待PLC响应，不做处理，如果PLC新标记为3，表示解析错误
                            if (addresses.Find(t => t.DevicePropCode == "Flag").value == "1" && addresses.Find(t => t.DevicePropCode == "WCSFlag").value == "1")
                            {
                                continue;
                            }

                            //PLC没有新消息标记 && WCS有新消息标记：此时PLC已经确认消息，清除WCS回复消息
                            if (addresses.Find(t => t.DevicePropCode == "Flag").value != "1" && addresses.Find(t => t.DevicePropCode == "WCSFlag").value == "1")
                            {
                                var result = WriteWCSStationDataAddress(addresses, "0", "0", "0", "0", "0", "0", "", "0", "0");
                                if (result.Success)

                                {

                                    AddLogToUI("清空" + stationForStockerIn + "WCS区地址成功", 1);
                                }
                                else
                                {
                                    AddLogToUI("清空" + stationForStockerIn + "WCS区地址失败：" + result.Msg, 2);
                                }
                                continue;
                            }

                            //PLC有新消息标记 && WCS没有新消息标记：此时PLC发送了消息而WCS没有响应，写响应逻辑发送地址数据给PLC

                            if (addresses.Find(t => t.DevicePropCode == "Flag").value == "1"
                                && addresses.Find(t => t.DevicePropCode == "WCSFlag").value != "1"
                                //这里做一次校验防止与PLC扫描冲突
                                && addresses.Find(t => t.DevicePropCode == "Type").value != "0"
                                && addresses.Find(t => t.DevicePropCode == "PLCNo").value != "0"
                                && addresses.Find(t => t.DevicePropCode == "StationNo").value != "0"
                                && !String.IsNullOrWhiteSpace(addresses.Find(t => t.DevicePropCode == "Barcode").value))

                            {
                                //判断报文类型
                                if (addresses.Find(t => t.DevicePropCode == "Type").value == "1")
                                {
                                    //地址请求

                                    AddLogToUI("堆垛机接入站台" + stationForStockerIn + "暂时没有实现地址请求", 3);

                                    continue;
                                }
                                if (addresses.Find(t => t.DevicePropCode == "Type").value == "2")
                                {

                                    //响应一个位置到达请求
                                    //更新任务状态为35
                                    String palletCode = addresses.Find(t => t.DevicePropCode == "Barcode").value;
                                    var bllResult = Bll.GetTaskUncompleteByPalletCode(palletCode);
                                    if (!bllResult.Success)
                                    {
                                        AddLogToUI("站台" + stationForStockerIn + "对应托盘" + palletCode + "没有查找到任务数据", 2);
                                        continue;
                                    }

                                    var task = bllResult.Data;
                                    if (task.Status > 31)
                                    {

                                        AddLogToUI("站台" + stationForStockerIn + "对应托盘" + palletCode + "没有查找到任务" + task.Id + "状态已经超过30，应已响应，请检查", 2);

                                        continue;
                                    }

                                    //给他回一个位置到达

                                    var temp = WriteWCSStationDataAddress(addresses, "1", "8", addresses.Find(t => t.DevicePropCode == "PLCNo").value, "0", addresses.Find(t => t.DevicePropCode == "StationNo").value, addresses.Find(t => t.DevicePropCode == "TaskNo").value, addresses.Find(t => t.DevicePropCode == "Barcode").value, "0", "0");

                                    if (temp.Success)
                                    {

                                        //位置到达回复成功后，更新任务状态
                                        Bll.SetTaskStatus(task.Id, 35);

                                        AddLogToUI("位置到达：任务" + task.Id + "位置到达写入" + stationForStockerIn + "WCS区地址成功", 1);

                                    }

                                    else
                                    {

                                        AddLogToUI("位置到达：写入" + stationForStockerIn + "WCS区地址失败：" + temp.Msg, 2);

                                    }
                                    continue;

                                }

                                //判断报文类型
                                if (addresses.Find(t => t.DevicePropCode == "Type").value == "3")
                                {
                                    //地址请求
                                    AddLogToUI("堆垛机接入站台" + stationForStockerIn + "暂时没有控制指令请求", 3);
                                    continue;
                                }

                            }
                        }

                        else
                        {
                            AddLogToUI(readResult.Msg, 2);
                        }

                    }
                }

                #endregion

                #region 响应堆垛机接出站台

                var stationForStockerOutResult = FindDevByType("stationForStockerOut");

                if (stationForStockerOutResult.Success)
                {
                    foreach (var stationForStockerOut in stationForStockerOutResult.Data)
                    {

                        var addresses = DeviceAddressEntities.FindAll(t => t.DeviceId == stationForStockerOut.Id);
                        var readResult = ReadAddress(addresses);
                        if (readResult.Success)

                        {

                            //如果PLC标记为3，则表示解析有误，这里报警
                            if (addresses.Find(t => t.DevicePropCode == "Flag").value == "3")
                            {
                                AddLogToUI("PLC解析站台" + stationForStockerOut + "数据失败，请检查基础数据！", 2);
                                continue;
                            }

                            //PLC 有新消息标记 && WCS回复有新消息标记：此时WCS已经回复了消息，等待PLC响应，不做处理，如果PLC新标记为3，表示解析错误

                            if (addresses.Find(t => t.DevicePropCode == "Flag").value == "1" && addresses.Find(t => t.DevicePropCode == "WCSFlag").value == "1")
                            {
                                continue;
                            }

                            //PLC没有新消息标记 && WCS有新消息标记：此时PLC已经确认消息，清除WCS回复消息

                            if (addresses.Find(t => t.DevicePropCode == "Flag").value != "1" && addresses.Find(t => t.DevicePropCode == "WCSFlag").value == "1")
                            {

                                var result = WriteWCSStationDataAddress(addresses, "0", "0", "0", "0", "0", "0", "", "0", "0");

                                if (result.Success)
                                {
                                    AddLogToUI("清空" + stationForStockerOut + "WCS区地址成功", 1);
                                }
                                else
                                {
                                    AddLogToUI("清空" + stationForStockerOut + "WCS区地址失败：" + result.Msg, 2);
                                }
                                continue;
                            }

                            //PLC有新消息标记 && WCS没有新消息标记：此时PLC发送了消息而WCS没有响应，写响应逻辑发送地址数据给PLC

                            //加入地址校验，防止PLC写入与WCS读取冲突；堆垛机接出站台，地址请求时时没有带条码的，需要我们写入

                            if (addresses.Find(t => t.DevicePropCode == "Flag").value == "1"
                                && addresses.Find(t => t.DevicePropCode == "WCSFlag").value != "1"
                                && addresses.Find(t => t.DevicePropCode == "Type").value != "0"
                                && addresses.Find(t => t.DevicePropCode == "PLCNo").value != "0"
                                && addresses.Find(t => t.DevicePropCode == "StationNo").value != "0"

                                )

                            {
                                //判断报文类型
                                if (addresses.Find(t => t.DevicePropCode == "Type").value == "1")
                                {
                                    //表示地址请求

                                    //hack:假设没有移库任务
                                    //获取任务状态为25的任务
                                    var tasksResult = Bll.GetTasks("25", null, null, null, null);
                                    if (!tasksResult.Success || tasksResult.Data.Count == 0)
                                    {

                                        AddLogToUI("未找到站台" + stationForStockerOut + "对应的任务，无法响应地址请求", 2);

                                        continue;
                                    }
                                    int roadWay = stationForStockerOut.Roadway;
                                    string palletCode = "";
                                    TaskEntity task = null;
                                    foreach (var item in tasksResult.Data)
                                    {
                                        var locationResult = Bll.GetAllLocations(item.ContainerCode, null, null, null, null, null, null);
                                        if (locationResult.Success)
                                        {
                                            LocationEntity locationEntity = locationResult.Data[0];
                                            if (locationEntity.Roadway == roadWay)
                                            {
                                                //说明这个任务是这个巷道的，则获取他的托盘号
                                                palletCode = item.ContainerCode;
                                                task = item;
                                                break;
                                            }
                                        }
                                    }
                                    if (string.IsNullOrEmpty(palletCode))
                                    {
                                        AddLogToUI("未找到站台" + stationForStockerOut + "对应的任务，无法响应地址请求", 2);
                                        continue;
                                    }

                                    //判断是不是移库，如果是移库则是去堆垛机接入站台
                                    if (task.Type == 800)

                                    {

                                        //todo:移库堆垛机接入站台处理
                                    }
                                    else
                                    {
                                        //获取一个站台
                                        var station = DeviceEntities.Join(DeviceTypeEntities, a => a.DeviceTypeId, b => b.Id, (a, b) => new { a, b }).Where(t => t.b.Code == "stationOut" || t.b.Code == "station").Select(t => t.a).FirstOrDefault();
                                        if (station != null)