XS202408319330/Models/AGVInfoModel.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using AGV_WPF_Global;

namespace AGV_WPF.Models
{
    public class AGVInfoModel : INotifyPropertyChanged
    {
        #region 属性
        private int _AGVNUM { get; set; }
        /// <summary>
        /// AGV编号
        /// </summary>
        public int AGVNUM
        {
            get
            {
                return _AGVNUM;
            }
            set
            {
                if (_AGVNUM != value)
                {
                    _AGVNUM = value;
                }
            }
        }
        /// <summary>
        /// AGV编号
        /// </summary>
        private string _AGVNAME { get; set; }
        /// <summary>
        /// AGV编号
        /// </summary>
        public string AGVNAME
        {
            get
            {
                return _AGVNAME;
            }
            set
            {
                if (_AGVNAME != value)
                {
                    _AGVNAME = value;
                }
            }
        }
        /// <summary>
        /// AGV变成运行状态的次数
        /// </summary>
        private int _AGVRunningCount { get; set; }
        /// <summary>
        /// AGV收到运行信号的次数
        /// </summary>
        public int AGVRunningCount
        {
            get
            {
                return _AGVRunningCount;
            }
            set
            {
                if (_AGVRunningCount != value)
                {
                    _AGVRunningCount = value;
                }
            }
        }
        /// <summary>
        /// 地标卡号
        /// </summary>
        private int _MARKNUM;
        /// <summary>
        /// 地标卡号
        /// </summary>
        public int MARKNUM 
        {
            get
            {
                return _MARKNUM;
            }
            set
            {
                if (_MARKNUM != value)
                {
                    _MARKNUM=value;
                }
            }
        }
        /// <summary>
        /// 地标卡号
        /// </summary>
        private List<TrafficAreaModel> _PTRAFFICNUM;
        /// <summary>
        /// 地标卡号
        /// </summary>
        public List<TrafficAreaModel> PTRAFFICNUM
        {
            get
            {
                return _PTRAFFICNUM;
            }
            set
            {
                if (_PTRAFFICNUM != value)
                {
                    _PTRAFFICNUM = value;
                }
            }
        }
        /// <summary>
        /// 地标功能
        /// </summary>
        private int _MARKFUN;
        /// <summary>
        /// 地标功能
        /// </summary>
        public int MARKFUN
        {
            get
            {
                return _MARKFUN;
            }
            set
            {
                if (_MARKFUN != value)
                {
                    _MARKFUN = value;
                }
            }
        }
        /// <summary>
        /// 运行状态
        /// </summary>
        private int _RUNSTATUS;
        /// <summary>
        /// 运行状态
        /// </summary>
        public int RUNSTATUS
        {
            get
            {
                return _RUNSTATUS;
            }
            set
            {
                if (_RUNSTATUS != value)
                {
                    _RUNSTATUS = value;
                }
            }
        }
        /// <summary>
        /// 运行状态
        /// </summary>
        private int _RUNSTATUS_Cur;
        /// <summary>
        /// 运行状态
        /// </summary>
        public int RUNSTATUS_Cur
        {
            get
            {
                return _RUNSTATUS_Cur;
            }
            set
            {
                if (_RUNSTATUS_Cur != value)
                {
                    _RUNSTATUS_Cur = value;
                }
            }
        }
        /// <summary>
        /// 路线编号
        /// </summary>
        private int _ROUTENUM;
        /// <summary>
        /// 路线编号
        /// </summary>
        public int ROUTENUM
        {
            get
            {
                return _ROUTENUM;
            }
            set
            {
                if (_ROUTENUM != value)
                {
                    _ROUTENUM = value;
                }
            }
        }

        private int _SPEEDLEVEL;
        /// <summary>
        /// 速度等级
        /// </summary>
        public int SPEEDLEVEL
        {
            get
            {
                return _SPEEDLEVEL;
            }
            set
            {
                if(_SPEEDLEVEL != value)
                {
                    _SPEEDLEVEL = value;
                }
            }
        }

        private string _ALARMCODE;
        /// <summary>
        /// 报警代码（或报警编码）
        /// </summary>
        public string ALARMCODE
        {
            get
            {
                return _ALARMCODE;
            }
            set
            {
                if (_ALARMCODE != value)
                {
                    _ALARMCODE = value;
                }
            }
        }

        private string _ALARMINFO;
        /// <summary>
        /// 报警信息描述
        /// </summary>
        public string ALARMINFO
        {
            get
            {
                return _ALARMINFO;
            }
            set
            {
                if (_ALARMINFO != value)
                {
                    _ALARMINFO = value;
                }
            }
        }

        private bool _ConnectStatus;//通讯连接状态
        /// <summary>
        /// 通讯连接状态
        /// </summary>
        public bool ConnectStatus
        {
            get
            {
                return _ConnectStatus;
            }
            set
            {
                if (_ConnectStatus != value)
                {
                    _ConnectStatus = value;
                }
            }
        }
        private bool _StatusChangeFlag;//通讯连接状态
        public bool StatusChangeFlag
        {
            get
            {
                return _StatusChangeFlag;
            }
            set
            {
                if (_StatusChangeFlag != value)
                {
                    _StatusChangeFlag = value;
                }
            }
        }

        private int _OffLineCount;

        public int OffLineCount
        {
            get
            {
                return _OffLineCount;
            }
            set
            {
                if (_OffLineCount != value)
                {
                    _OffLineCount = value;
                }
            }
        }

        private decimal battery_Voltage;

        public decimal Bttery_Voltage
        {
            get
            {
                return battery_Voltage;
            }
            set
            {
                if (battery_Voltage != value)
                {
                    battery_Voltage = value;
                }
            }
        }

        private decimal battery_Electricity;

        public decimal Battery_Electricity
        {
            get
            {
                return battery_Electricity;
            }
            set
            {
                if (battery_Electricity != value)
                {
                    battery_Electricity = value;
                }
            }
        }

        private decimal battery_Temperature;

        public decimal Battery_Temperature
        {
            get
            {
                return battery_Temperature;
            }
            set
            {
                if (battery_Temperature != value)
                {
                    battery_Temperature = value;
                }
            }
        }

        private decimal battery_Power;

        public decimal Battery_Power
        {
            get
            {
                return battery_Power;
            }
            set
            {
                if (battery_Power != value)
                {
                    battery_Power = value;
                }
            }
        }

        public IList<string> batteryDatas { get; set; }//电池信息

        public event PropertyChangedEventHandler PropertyChanged;

        public event PropertyChangedEventHandler PropertyAddAction;

        public event PropertyChangedEventHandler PropertyRemoveAction;

        public int ReleaseCount { get; set; }
        /// <summary>
        /// 是否是管制区主机
        /// </summary>
        private bool _IsMainAgv;
        /// <summary>
        /// 是否是管制区主机
        /// </summary>
        public bool IsMainAgv
        {
            get
            {
                return _IsMainAgv;
            }
            set
            {
                if (_IsMainAgv != value)
                {
                    _IsMainAgv = value;
                }
            }
        }

        private List<TrafficAreaModel> _TRAFFICNUM;//管制区号为-1则表示不在管制区内。
        /// <summary>
        /// 管制区号为-1则表示不在管制区内。
        /// </summary>
        public List<TrafficAreaModel> TRAFFICNUM
        {
            get
            {
                return _TRAFFICNUM;
            }
            set
            {
                if (_TRAFFICNUM != value)
                {
                    _TRAFFICNUM = value;
                }
            }
        }

        /// <summary>
        /// 管制AGV编号
        /// </summary>
        private AGVInfoModel _TRAFFICAGV;

        public AGVInfoModel TRAFFICAGV
        {
            get { return _TRAFFICAGV; }
            set
            {
                if (_TRAFFICAGV != value)
                {
                    _TRAFFICAGV = value;
                }
            }
        }
        /// <summary>
        /// 管制AGV编号
        /// </summary>
        private bool _TrafficFlag;

        public bool TrafficFlag
        {
            get { return _TrafficFlag; }
            set
            {
                if (_TrafficFlag != value)
                {
                    _TrafficFlag = value;
                }
            }
        }

        /// <summary>
        /// 管制AGV平行标志
        /// </summary>
        private bool _ParallelFlag;

        public bool ParallelFlag
        {
            get { return _ParallelFlag; }
            set
            {
                if (_ParallelFlag != value)
                {
                    _ParallelFlag = value;
                }
            }
        }

        /// <summary>
        /// 管制AGV方向标志
        /// </summary>
        private List<int> _Direction;

        public List<int> Direction
        {
            get { return _Direction; }
            set
            {
                if (_Direction != value)
                {
                    _Direction = value;
                }
            }
        }

        /// <summary>
        /// 帧数据编号
        /// </summary>
        private int _FPS;

        public int FPS
        {
            get { return _FPS; }
            set
            {
                if (_FPS != value)
                {
                    _FPS = value;
                }
            }
        }

        /// <summary>
        /// 最后更新地标时间
        /// </summary>
        private DateTime _lastModifyMarkTime;

        public DateTime LastModifyMarkTime
        {
            get { return _lastModifyMarkTime; }
            set
            {
                if (_lastModifyMarkTime != value)
                {
                    _lastModifyMarkTime = value;
                }
            }
        }

        /// <summary>
        ///读到停止卡时间 EOL放行使用
        /// </summary>
        private DateTime _lastStopMarkTime;

        public DateTime LastStopMarkTime
        {
            get { return _lastStopMarkTime; }
            set
            {
                if (_lastStopMarkTime != value)
                {
                    _lastStopMarkTime = value;
                }
            }
        }

        /// <summary>
        /// EOL补位标志
        /// </summary>
        private bool _EollFlag;

        public bool EollFlag
        {
            get { return _EollFlag; }
            set
            {
                if (_EollFlag != value)
                {
                    _EollFlag = value;
                }
            }
        }

        /// <summary>
        /// 急停标志
        /// </summary>
        private bool _AllowReleaseFlag;

        public bool AllowReleaseFlag
        {
            get { return _AllowReleaseFlag; }
            set
            {
                if (_AllowReleaseFlag != value)
                {
                    _AllowReleaseFlag = value;
                }
            }
        }


        private bool _AllowMesReleaseFlag;

        public bool AllowMesReleaseFlag
        {
            get { return _AllowMesReleaseFlag; }
            set
            {
                if (_AllowMesReleaseFlag != value)
                {
                    _AllowMesReleaseFlag = value;
                }
            }
        }


        /// <summary>
        /// 到港信号
        /// </summary>
        private bool _IsReachFlag;

        public bool IsReachFlag
        {
            get { return _IsReachFlag; }
            set
            {
                if (_IsReachFlag != value)
                {
                    _IsReachFlag = value;
                }
            }
        }

        private bool _IsOutFlag;

        public bool IsOutFlag
        {
            get { return _IsOutFlag; }
            set
            {
                if (_IsOutFlag != value)
                {
                    _IsOutFlag = value;
                }
            }
        }


        private bool _EmergencyCar = true;

        public bool EmergencyCar
        {
            get { return _EmergencyCar; }
            set
            {
                if (_EmergencyCar != value)
                {
                    _EmergencyCar = value;
                }
            }
        }

        /// <summary>
        /// 急停标志
        /// </summary>
        private bool _EmergencyFlag;

        public bool EmergencyFlag
        {
            get { return _EmergencyFlag; }
            set
            {
                if (_EmergencyFlag != value)
                {
                    _EmergencyFlag = value;
                }
            }
        }

        private DateTime _Recieve55Time;
        public DateTime Recieve55Time
        {
            get { return _Recieve55Time; }
            set { if(_Recieve55Time!=value)
                {
                    _Recieve55Time = value;
                }
                 }
           
        }

        #endregion

        #region 初始化

        public AGVInfoModel()
        {
            //AGVNUM=0;
            AGVNAME = "初始化...";
            MARKNUM=0;
            MARKFUN=0;
            RUNSTATUS=0;
            ROUTENUM=0;
            SPEEDLEVEL = 0;
            ALARMCODE="";
            ALARMINFO = "初始化...";
            ConnectStatus = false;
            batteryDatas=new List<string>();
            IsMainAgv = false;
            TRAFFICNUM = new List<TrafficAreaModel>();
            TRAFFICAGV = null;
            //TRAFFICAGV = new AGVInfoModel();
            FPS = 0;
            OffLineCount = 0;
            TrafficFlag = false;
            ReleaseCount = 0;//允许被放行
            EollFlag = false;
            EmergencyFlag = false;
            StatusChangeFlag = true;
        }

        public AGVInfoModel(int agvid)
        {
            AGVNUM = agvid;
            this.AGVNUM = agvid;
            AGVNAME = "初始化...";
            MARKNUM = 0;
            MARKFUN = 0;
            RUNSTATUS = 0;
            ROUTENUM = 0;
            SPEEDLEVEL = 0;
            ALARMCODE = "";
            ALARMINFO = "初始化...";
            ConnectStatus = false;
            batteryDatas = new List<string>();
            IsMainAgv = false;
            TRAFFICNUM = new List<TrafficAreaModel>();
            PTRAFFICNUM = new List<TrafficAreaModel>();
            TRAFFICAGV = null;
            OffLineCount = 0;
            TrafficFlag = false;
            FPS = 0;
            EmergencyFlag = false;
        }

        #endregion

        #region 方法
        /// <summary>
        /// 添加管制区
        /// </summary>
        /// <param name="traffic"></param>
        public void AddTraffic(TrafficAreaModel traffic)
        {
            if (this.TRAFFICNUM == null)
            {
                this.TRAFFICNUM = new List<TrafficAreaModel>();
            }
            if (!this.TRAFFICNUM.Contains(traffic))
            {
                this.TRAFFICNUM.Add(traffic);
                //InTraffic(traffic, this);
            }

        }
        /// <summary>
        /// 移除管制区
        /// </summary>
        /// <param name="traffic"></param>
        public void RemoveTraffic(TrafficAreaModel traffic)
        {
            if (this.TRAFFICNUM != null && this.TRAFFICNUM.Contains(traffic))
            {
                this.TRAFFICNUM.Remove(traffic);
                OutTraffic(traffic, this);
            }

        }

        /// <summary>
        /// 清楚所有管制区
        /// </summary>
        public void ClearTraffic()
        {
            if (this.TRAFFICNUM != null)
            {
                if (this.TRAFFICNUM.Count > 0)
                {
                    this.TRAFFICNUM.Clear();

                    RemoveAction("0");
                }
            }
        }

        /// <summary>
        /// 等待事件方法函数
        /// </summary>
        /// <param name="traffic"></param>
        public void Waiting(TrafficAreaModel traffic)
        {
            if(!this.TRAFFICNUM.Contains(traffic))
            {
                this.TRAFFICNUM.Add(traffic);
            }
            if (this.IsMainAgv)
            {
                this.IsMainAgv = false;
            }
            if(!this.TrafficFlag)
            {
                this.TrafficFlag = true;
            }
            if (this.TRAFFICAGV == null)
            {
                this.TRAFFICAGV = traffic.MainAgv;
            }
            if (!traffic.listAgvQueue.Contains(this))
            {
                traffic.listAgvQueue.Add(this);
            }
        }

        /// <summary>
        /// 占领管制区事件方法函数
        /// </summary>
        /// <param name="traffic"></param>
        public void Occupy(TrafficAreaModel traffic)
        {
            if (!this.IsMainAgv)
            {
                this.IsMainAgv = true;
            }
            if (this.TrafficFlag)
            {
                this.TrafficFlag = false;
            }
            if (this.TRAFFICAGV != null)
            {
                this.TRAFFICAGV = null;
            }
            
        }

        /// <summary>
        /// 属性改变事件触发方法函数
        /// </summary>
        /// <param name="info"></param>
        private void NotifyPropertyChanged(String info)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(info));
            }
        }

        private void AddAction(String traffic)
        {
            if (PropertyAddAction != null)
            {
                PropertyAddAction(this,new PropertyChangedEventArgs(traffic));
            }

        }

        private void RemoveAction(String traffic)
        {
            if (PropertyRemoveAction != null)
            {
                PropertyRemoveAction(this, new PropertyChangedEventArgs(traffic));
            }

        }

        /// <summary>
        /// 进管制区方法函数
        /// </summary>
        /// <param name="traffic"></param>
        /// <param name="agv"></param>
        /// <returns></returns>
        public bool InTraffic(TrafficAreaModel traffic, AGVInfoModel agv)
        {
            if (traffic != null && agv != null)
            {  
                //加入管制区agv列表
                if (!traffic.listAgvQueue.Contains(agv))
                {
                    traffic.listAgvQueue.Add(agv);
                }
                //判断管制区是否有主机
                if (traffic.MainAgv == null)
                {
                    //把队列中的第一位变成agv
                    traffic.MainAgv = traffic.listAgvQueue[0];
                    //检查管制区管制状态
                    if (!traffic.IsTraffic)
                    {
                        traffic.IsTraffic = true;
                    }
                }
                else
                {
                    //判断我是不是主机
                    if (traffic.MainAgv != agv)
                    {
                        //非主机：返回管制状态为true，管制agv为管制区主机agv编号
                        agv.TRAFFICAGV = traffic.MainAgv;
                        agv.TrafficFlag = true;
                        return true;
                    }
                    else
                    {
                        //是主机：管制状态为false，管制agv为0
                        agv.TRAFFICAGV = null;
                        agv.TrafficFlag = false;
                        return false;
                    }
                }
            }

            return agv.TrafficFlag;
        }

        /// <summary>
        /// 出管制区方法函数
        /// </summary>
        /// <param name="traffic"></param>
        /// <param name="agv"></param>
        /// <returns></returns>
        public bool OutTraffic(TrafficAreaModel traffic, AGVInfoModel agv)
        {
            if (agv == null){ return false; }
            
            //把我从就管制区的agv列表中删除
            if (traffic.listAgvQueue.Contains(agv)){ traffic.listAgvQueue.Remove(agv); }
            //我是旧管制区的主机,更新旧管制区数据
            if (traffic.MainAgv == agv)
            {
                if (traffic.listAgvQueue.Count > 0)
                {
                    traffic.MainAgv = traffic.listAgvQueue[0];
                    traffic.IsTraffic = true;
                    AGVInfoModel newMainAgv = traffic.MainAgv;
                    
                    newMainAgv.TRAFFICAGV = null;
                    newMainAgv.TrafficFlag = false;
                }
                else
                {
                    traffic.IsTraffic = false;
                    traffic.MainAgv = null;
                }
            }

            if (agv.TRAFFICNUM.Contains(traffic))
            {
                agv.TRAFFICNUM.Remove(traffic);//更新agv管制区编号
            }
            agv.TrafficFlag = false;
            agv.TRAFFICAGV = null;
            return true;
        }

        #endregion
    }
}