OHV/Dev/OHV/VehicleControlSystem/VCSystem.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using GSG.NET;
using GSG.NET.Extensions;
using GSG.NET.Logging;
using GSG.NET.ObjectBase;
using GSG.NET.Quartz;
using OHV.Common.Events;
using OHV.Common.Model;
using OHV.Common.Shareds;
using OHV.SqliteDAL;
using Prism.Events;
using Prism.Ioc;
using Prism.Modularity;
using VehicleControlSystem.ControlLayer;
using VehicleControlSystem.ControlLayer.IO;
using VehicleControlSystem.Managers;

namespace VehicleControlSystem
{
    [Module(ModuleName = "VCSystem")]
    public class VCSystem : IModule, IDisposable
    {
        Logger logger = Logger.GetLogger();

        Scheduler scheduler = null;
        IEventAggregator eventAggregator = null;
        public IIO IO = null;
        public AutoManager autoManager = null;
        HostManager hostManager = null;
        Vehicle vehicle = null;
        SqliteManager sql = null;

        public VCSystem(IEventAggregator ea, SqliteManager sql)
        {
            this.sql = sql;

            this.eventAggregator = ea;

            this.eventAggregator.GetEvent<ApplicationExitEvent>().Subscribe((o) => Dispose(), true);

            this.eventAggregator.GetEvent<VCSMessagePubSubEvent>().Unsubscribe(ReceivedMessageEvent);
            this.eventAggregator.GetEvent<VCSMessagePubSubEvent>().Subscribe(this.ReceivedMessageEvent, ThreadOption.BackgroundThread);
        }

        public void Init()
        {
            QuartzUtils.Invoke("HIS_ALARM", QuartzUtils.GetExpnMinute(1), this.CleanHisAlarm);

            //Create IO
            this.IO = new EzIO();
            var mapPath = Path.Combine(System.Environment.CurrentDirectory) + @"\Config\IO.xlsx";
            this.IO.LoadIOMap(mapPath);
            this.IO.RunIOThread();

            var ezIO = this.IO as EzIO;
            ezIO.OnContd += EzIO_OnContd;
            ezIO.OnDiscontd += EzIO_OnDiscontd;
            ezIO.OnChangedIO += EzIO_OnChangedIO;

            this.autoManager = new AutoManager(this.IO, this.eventAggregator, this.sql);
            this.scheduler = new Scheduler(eventAggregator, this.autoManager, this.sql );
            this.vehicle = new Vehicle(this.IO, this.sql, this.eventAggregator, this.autoManager);
            this.vehicle.PropertyChanged += Vehicle_PropertyChanged;

            this.hostManager = new HostManager(this.eventAggregator, this.vehicle, this.sql, this.autoManager, this.scheduler);

            this.hostManager.Init();
            this.vehicle.Init();
            this.scheduler.Init();
            this.autoManager.Init(this.vehicle);

        }

        private void Vehicle_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            var arg = new GUIMessageEventArgs();
            arg.Kind = GUIMessageEventArgs.eGUIMessageKind.ModelPropertyChange;
            arg.MessageKey = MessageKey.Vehicle;
            arg.ModelPropertyName = e.PropertyName;

            var property = sender.GetType().GetProperty(e.PropertyName);
            var newValue = property.GetValue(sender, null);

            arg.ModelPropertyName = e.PropertyName;
            arg.Args = newValue;

            GUIMessageEventPublish(arg);
        }

        public void CleanHisAlarm()
        {
            sql.HisAlarmDAL.Delete(20);
        }

        #region EzIO Event
        private void EzIO_OnChangedIO(BitBlock bit)
        {
            this.eventAggregator.GetEvent<IOChangedPubSubEvent>().Publish(new IOChangedMessageEventArgs { Args = bit });
        }
        private void EzIO_OnDiscontd(string ID)
        {
            //throw new NotImplementedException();
        }
        private void EzIO_OnContd(string ID)
        {
            this.IO.OutputOn( "OUT_TEACH_MODE" );

            //throw new NotImplementedException();
        }
        #endregion

        #region ReqMessage Method
        void ReceivedMessageEvent(VCSMessageEventArgs msg)
        {
            switch ( msg.Kind )
            {
                case VCSMessageEventArgs.eVCSMessageKind.ReqIOObject:
                    ReqIOObjectMessage();
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqIOMapList:
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqCommandList:
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqAutoModeChange:
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqManualModeChange:
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ModelPropertyChange:
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqAlarmReset:
                    ReqAlarmReset();
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqVehicleModeChange:
                    this.ReqVehicleModeChange( msg );
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqEStop:
                    ReqEStop();
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqBuzzerStop:
                    ReqBuzzerStop();
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqMachineModeChg:
                    ReqMachineModeChg( msg );
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqAddCommand:
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqTest:
                    ReqTest();
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqConveyorLoad:
                    ReqConveyorLoad();
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqConveyorUnload:
                    ReqConveyorUnload();
                    break;
                default:
                    break;
            }
        }

        private void ReqConveyorUnload()
        {
            int result = 0;
            result = this.vehicle.ConveyorUnload();
        }

        private void ReqConveyorLoad()
        {
            int result = 0;
            result = this.vehicle.ConveyorLoad();
        }

        private void ReqTest()
        {
            logger.D( "Test Request" );
            if ( this.IO.WaitChangeInputIO( true, 30000, "IN_CV_DETECT_00" ) )
                logger.D( "Test - Time in" );
            else
                logger.D( "Test - Time out" );
        }

        private void ReqMachineModeChg( VCSMessageEventArgs msg )
        {
            var reply = new GUIMessageEventArgs();
            reply.Kind = GUIMessageEventArgs.eGUIMessageKind.RspMachineModeChg;

            var mode = CastTo<eMachineMode>.From<object>( msg.Arg );
            if ( mode == eMachineMode.HostMode )
            {
                if (this.autoManager.OperationModeProperty != eOperatationMode.AutoMode )
                    reply.Result = FluentResults.Results.Fail( "Vehicle Not Start" );
                else
                {
                    this.vehicle.MachineMode = eMachineMode.HostMode;
                    reply.Result = FluentResults.Results.Ok();
                    reply.Args = eMachineMode.HostMode;
                }
            }
            else
            {
                this.vehicle.MachineMode = eMachineMode.LocalMode;
                reply.Result = FluentResults.Results.Ok<eMachineMode>( eMachineMode.LocalMode );
                reply.Args = eMachineMode.LocalMode;
            }

            GUIMessageEventPublish( reply );
        }

        private void ReqBuzzerStop( )
        {
            this.IO.OutputOff( "OUT_BUZZER_00" );
            this.IO.OutputOff( "OUT_BUZZER_01" );
            this.IO.OutputOff( "OUT_BUZZER_02" );
        }

        private void ReqAlarmReset()
        {
            this.autoManager.IsErrorProcessing = false;
            this.vehicle.VehicleStateProperty = eVehicleState.Idle;

            if ( !this.IO.IsOn( "IN_MC_ON" ) )
            {
                this.IO.WriteOutputIO( "OUT_SAFETY_RESET", true );
                this.IO.WriteOutputIO( "OUT_SAFETY_RESET", false, 3000 );
            }
        }

        private void ReqEStop()
        {
            this.vehicle.EStop();
        }

        private void ReqVehicleModeChange(VCSMessageEventArgs msg)
        {
            GUIMessageEventArgs reply;

            if (msg.MessageKey.Equals(MessageKey.AutoMode))
            {
                int result = vehicle.InitializationVehicle();
                if (result != 0)
                {
                    this.autoManager.ProcessAlarm(result); //Alarm 내용을 UI로 전달 해주니까 Reply 가 필요 없다.
                    return;
                }

                this.autoManager.AutoModeStateProperty = eAutoModeState.StartRun;
                this.autoManager.OperationModeProperty = eOperatationMode.AutoMode;
                reply = new GUIMessageEventArgs { Kind = GUIMessageEventArgs.eGUIMessageKind.RspVehicleModeChange, Result = FluentResults.Results.Ok(), MessageKey = MessageKey.AutoMode };
            }
            else
            {
                this.autoManager.AutoModeStateProperty = OHV.Common.Shareds.eAutoModeState.WaitStop;
                reply = new GUIMessageEventArgs { Kind = GUIMessageEventArgs.eGUIMessageKind.RspVehicleModeChange, Result = FluentResults.Results.Ok(), MessageKey = MessageKey.ManualMode };
            }

            GUIMessageEventPublish(reply);
        }

        void ReqIOObjectMessage()
        {
            var rspMsg = new GUIMessageEventArgs { Kind = GUIMessageEventArgs.eGUIMessageKind.RspIOObject, Args = this.IO };
            this.eventAggregator.GetEvent<GUIMessagePubSubEvent>().Publish(rspMsg);
        }

        #endregion

        /// <summary>
        /// GUI 로 보내는 Event
        /// </summary>
        /// <param name="args"></param>
        public void GUIMessageEventPublish(GUIMessageEventArgs args)
        {
            this.eventAggregator.GetEvent<GUIMessagePubSubEvent>().Publish(args);
        }

        public void Dispose()
        {
            this.scheduler.Dispose();
            this.autoManager.Dispose();
            this.hostManager.Dispose();
            this.vehicle.Dispose();
            (this.IO as IDisposable).Dispose(); //IO 는 마지막에 정리함.
        }

        public void RegisterTypes(IContainerRegistry containerRegistry)
        {
            if (!containerRegistry.IsRegistered<VCSystem>())
                containerRegistry.RegisterSingleton<VCSystem>();
        }

        public void OnInitialized(IContainerProvider containerProvider)
        {
            this.Init();
        }
    }
}