OHV/Dev/OHV/OHV.Module.Status/VehicleStatusViewModel.cs

using GSG.NET.Extensions;
using OHV.Common.Events;
using OHV.Common.Model;
using OHV.Common.Shareds;
using OHV.SqliteDAL;
using Prism.Events;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using VehicleControlSystem;
using VehicleControlSystem.ControlLayer.IO;

namespace OHV.Module.Status
{
    public class VehicleStatusViewModel : BindableBase
    {
        VCSystem vcSystem;

        string _vehicleState;
        public string VehicleState
        {
            get { return vcSystem.autoManager.OperationModeProperty.ToString(); }
            set { this.SetProperty( ref this._vehicleState , value ); }
        }
        IEventAggregator eventAggregator;


        string _clampState = string.Empty;
        public string ClampState
        {
            get { return this._clampState; }
            set { this.SetProperty( ref this._clampState , value ); }
        }

        string _cvState = string.Empty;
        public string CvState
        {
            get { return this._cvState; }
            set { this.SetProperty( ref this._cvState , value ); }
        }

        string _cvDir = "IDLE";
        public string CvDir
        {
            get { return this._cvDir; }
            set { this.SetProperty( ref this._cvDir , value ); }
        }

        double _vehicleCurrentPos;
        public double VehicleCurrentPos
        {
            get { return this._vehicleCurrentPos; }
            set { this.SetProperty( ref this._vehicleCurrentPos , value ); }
        }

        string _vehicleCurrentTag;
        public string VehicleCurrentTag
        {
            get { return this._vehicleCurrentTag; }
            set { this.SetProperty( ref this._vehicleCurrentTag , value ); }
        }

        EzIO IO = null;
        SqliteManager sqliteManager;

        public VehicleStatusViewModel(IEventAggregator _ea, VCSystem _vcSystem , SqliteManager sql)
        {
            this.eventAggregator = _ea;
            this.eventAggregator.GetEvent<GUIMessagePubSubEvent>().Unsubscribe( UICallBackCommunication );
            this.eventAggregator.GetEvent<GUIMessagePubSubEvent>().Subscribe( UICallBackCommunication , ThreadOption.UIThread );

            this.eventAggregator.GetEvent<DriveControlPubSubEvent>().Unsubscribe( DriveUICallBackCommunication );
            this.eventAggregator.GetEvent<DriveControlPubSubEvent>().Subscribe( DriveUICallBackCommunication , ThreadOption.UIThread );
            this.eventAggregator.GetEvent<DriveControlPubSubEvent>().Publish( new DriveControlEventArgs { EventDir = DriveControlEventArgs.eEventDir.ToBack , ControlKind = DriveControlEventArgs.eControlKind.VehicleState } );

            this.eventAggregator.GetEvent<AxisControlPubSubEvent>().Publish( new AxisControlEventArgs { Dir = AxisControlEventArgs.eEventDir.ToBack , Kind = AxisControlEventArgs.eAxisControlKind.SyncState } );

            this.vcSystem = _vcSystem;

            vcSystem.autoManager.OnOperationModeChanged += ( mode ) => { this.VehicleState = mode.ToString(); };
            
            this.IO = _vcSystem.IO as EzIO;
            this.IO.OnChangedIO += IO_OnChangedIO;
            if ( IO.IsOn( "OUT_CV_RUN", false ) )
                this.CvState = "RUN";
            else
                this.CvState = "IDLE";

            this.sqliteManager = sql;

            this.VehicleCurrentTag = sql.VehicleInfoDAL.GetInfo().CurrentTag;
        }

        private void DriveUICallBackCommunication( DriveControlEventArgs obj )
        {
            if(obj.EventDir == DriveControlEventArgs.eEventDir.ToFront)
            {
                switch ( obj.ControlKind )
                {
                    case DriveControlEventArgs.eControlKind.MOVE:
                        break;
                    case DriveControlEventArgs.eControlKind.STOP:
                        break;
                    case DriveControlEventArgs.eControlKind.Steering:
                        break;
                    case DriveControlEventArgs.eControlKind.SteeringState:
                        break;
                    case DriveControlEventArgs.eControlKind.ReqCurrentPos:
                        break;
                    case DriveControlEventArgs.eControlKind.ReqStopCurrentPos:
                        break;
                    case DriveControlEventArgs.eControlKind.FaultReset:
                        break;
                    case DriveControlEventArgs.eControlKind.DriveON:
                        break;
                    case DriveControlEventArgs.eControlKind.DriveOFF:
                        break;
                    case DriveControlEventArgs.eControlKind.JOG:
                        break;
                    case DriveControlEventArgs.eControlKind.VehicleState:
                        var state = CastTo<VehicleInfo>.From<object>( obj.Args );
                        this.VehicleCurrentPos = state.CurrentPosition;
                        break;
                }
            }
        }

        private void IO_OnChangedIO( BitBlock bit )
        {
            if ( bit.Tag.Equals( "OUT_CV_RUN" ) )
                this.CvState = "RUN";

            if ( bit.Tag.Equals( "OUT_CV_CWCCW" ) && bit.Tag.Equals("OUT_CV_RUN"))
                this.CvDir = "CW";
            else if ( !bit.Tag.Equals( "OUT_CV_CWCCW" ) && bit.Tag.Equals( "OUT_CV_RUN" ) )
                this.CvDir = "CCW";
            else
                this.CvDir = "IDLE";
                
            if ( bit.Tag.Equals( "IN_CV_ERROR" ) )
                this.CvState = "ERROR";
            else
                this.CvState = "IDLE";
        }

        private void UICallBackCommunication( GUIMessageEventArgs obj )
        {
            if(obj.Kind == GUIMessageEventArgs.eGUIMessageKind.ModelPropertyChange)
            {
                if(obj.MessageKey.Equals(MessageKey.Vehicle))
                {
                    switch(obj.ModelPropertyName)
                    {
                        case "ClampState":
                            var state = CastTo<eClampState>.From<object>( obj.Args );
                            this.ChangedClampState( state );
                            break;
                        case "Currenttag":
                            var tag = CastTo<string>.From<object>(obj.Args);
                            this.VehicleCurrentTag = tag;
                            break;
                    }
                }
            }
        }

        private void ChangedClampState( eClampState state )
        {
            switch ( state )
            {
                case eClampState.NONE:
                    this.ClampState = eClampState.NONE.ToString();
                    break;
                case eClampState.LOCK:
                    this.ClampState = eClampState.LOCK.ToString();
                    break;
                case eClampState.UNLOCK:
                    this.ClampState = eClampState.UNLOCK.ToString();
                    break;
            }
        }

        public void Init( ) { }
    }
}