OHV/Dev/OHV/VehicleControlSystem/ControlLayer/MQ/ZmqManager.cs

using GSG.NET.Concurrent;
using GSG.NET.Logging;
using GSG.NET.ObjectBase;
using NetMQ;
using NetMQ.Monitoring;
using NetMQ.Sockets;
using OHV.Common.Model;
using OHV.Common.Shareds;
using StackExchange.Redis.Extensions.Core.Extensions;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace VehicleControlSystem.ControlLayer.MQ
{
    public class ZmqManager : ControlObjectBase, IDisposable
    {
        Logger logger = Logger.GetLogger();

        SubscriberSocket sub = null;
        RequestSocket req = null;
        ResponseSocket rep = null;

        NetMQPoller poller = null;
        NetMQMonitor monitor = null;

        ThreadCancel threadCancel = new ThreadCancel();

        private bool isReqConnected;

        public bool IsReqConnected
        {
            get { return isReqConnected; }
            set { isReqConnected = value; }
        }

        #region Properties
        private eSteeringState requestSteering;

        public eSteeringState RequestSteering
        {
            get { return requestSteering; }
            set { SetField( ref this.requestSteering, value ); }
        }

        private bool isDriveMoving;

        public bool IsDriveMoving
        {
            get { return isDriveMoving; }
            set { SetField( ref isDriveMoving, value ); }
        }

        private eRoadForm currentLoadForm;

        public eRoadForm CurrentLoadForm
        {
            get { return currentLoadForm; }
            set { SetField( ref currentLoadForm, value ); }
        }

        private eOperatationMode operatationMode;

        public eOperatationMode OperationMode
        {
            get { return operatationMode; }
            set { operatationMode = value; }
        }




        #endregion

        public ZmqManager()
        {
            NetMQ.NetMQConfig.Cleanup();
        }

        public void Init()
        {
            rep = new ResponseSocket();
            rep.Bind( "tcp://127.0.0.1:5568" );
            rep.ReceiveReady += Rep_ReceiveReady;

            sub = new SubscriberSocket();
            sub.Connect( "tcp://127.0.0.1:5565" );
            sub.Connect( "tcp://127.0.0.1:5566" );
            sub.Subscribe( "" ); //All
            sub.ReceiveReady += Sub_ReceiveReady;

            req = new RequestSocket();
            this.monitor = new NetMQMonitor( req, "inproc://rep.inproc", SocketEvents.Disconnected | SocketEvents.Connected );
            this.monitor.Connected += ( s, a ) => { this.IsReqConnected = true; };
            this.monitor.Disconnected += ( s, a ) => { this.IsReqConnected = false; };
            this.monitor.StartAsync();

            req.Connect( "tcp://127.0.0.1:5567" );

            this.poller = new NetMQPoller { this.sub, this.rep };
            this.poller.RunAsync();
        }

        public void Dispose()
        {
            this.threadCancel.Cancel();

            this.monitor.Stop();
            this.monitor.Dispose();

            this.poller.Stop();
            this.poller.Dispose();

            this.sub.Dispose();
            this.req.Dispose();
        }

        private void Rep_ReceiveReady( object sender, NetMQSocketEventArgs e )
        {
            var ret = e.Socket.ReceiveMultipartStrings();
            logger.D( $"[rep] - {ret}" );

            if ( ret[0].Equals( "setm" ) )
            {
                var v = ret[1].Split( '/' );
                switch ( v[0] )
                {
                    case "3050":
                        {
                            switch ( v[1] )
                            {
                                case "1":
                                    this.RequestSteering = eSteeringState.Left;
                                    break;
                                case "-1":
                                    this.RequestSteering = eSteeringState.Right;
                                    break;
                                default:
                                    this.RequestSteering = eSteeringState.None;
                                    break;
                            }
                        }
                        break;

                    case "111":
                        {
                            if ( v[1].Equals( "1" ) )
                                OperationMode = eOperatationMode.AutoMode;
                            else
                                OperationMode = eOperatationMode.ManualMode;
                        }
                        break;

                    case "113":
                        {
                        }
                        break;
                    default:
                        break;
                }
                rep.SendMoreFrame( "setm" ).SendFrame( $"ok/{v[0]}" );
            }
        }

        private void Sub_ReceiveReady( object sender, NetMQ.NetMQSocketEventArgs e )
        {
            var ret = e.Socket.ReceiveMultipartStrings();
            logger.I( ret );

            switch ( ret[0] )
            {
                case "3050": //TargetSteering
                    {
                        //switch ( ret[1] )
                        //{
                        //    case "1":
                        //        this.RequestSteering = eSteeringState.Left;
                        //        break;
                        //    case "-1":
                        //        this.RequestSteering = eSteeringState.Right;
                        //        break;
                        //    default:
                        //        this.RequestSteering = eSteeringState.None;
                        //        break;
                        //}
                    }
                    break;

                case "111": //0=StartUp, 1=DeviceOpened, 2=DiviceOpenFailed, 3=ManualOP, 4=AutomaticOp, 5=DeviceCloseed, 6=Finished
                    break;

                case "3010": //진행중의 길의 모양, 0이면 정지 상태
                    {
                        var v = ret[1].Split( ';' );
                        switch ( v[0] )
                        {
                            case "1":
                                //this.RequestSteering = eSteeringState.Left;
                                break;
                            case "-1":
                                //this.RequestSteering = eSteeringState.Right;
                                break;
                            default:
                                //this.RequestSteering = eSteeringState.None;
                                break;
                        }
                    }
                    break;

                default:
                    break;
            }
        }

        void Th_SubPoller()
        {
            while ( !this.threadCancel.Canceled )
            {
                LockUtils.Wait( 1000 );
                //this.pub.SendMoreFrame( "1000" ).SendFrame( "Test" );
                LockUtils.Wait( 100 );

                NetMQMessage msg = new NetMQMessage();
                if ( this.sub.TryReceiveMultipartMessage( TimeSpan.FromSeconds( 1 ), ref msg ) )
                {
                    var m = msg;
                }
            }
        }

        bool Request( string topic, string value, out string response )
        {
            List<string> repll = new List<string>();
            response = string.Empty;

            if ( !this.IsReqConnected )
                return false;

            if ( !this.req.HasIn )
                this.req.SendMoreFrame( topic ).SendFrame( value );

            if ( this.req.TryReceiveMultipartStrings( TimeSpan.FromSeconds( 5 ), ref repll ) )
                return true;
            else
                return false;
        }

        bool SetRequest(string index, string value )
        {
            List<string> repll = new List<string>();

            if ( !this.IsReqConnected )
                return false;

            if ( !this.req.HasIn )
                this.req.SendMoreFrame( "setm" ).SendFrame( index + "/" + value );

            if ( !this.req.TryReceiveMultipartStrings( TimeSpan.FromSeconds( 5 ), ref repll ) )
                return false;

            return true;
        }

        bool GetRequst( string index, out List<string> vll) 
        {
            vll = new List<string>();

            if ( !this.IsReqConnected )
                return false;

            if ( !this.req.HasIn )
                this.req.SendMoreFrame( "getm" ).SendFrame( index );

            List<string> repll = new List<string>();

            if ( this.req.TryReceiveMultipartStrings( TimeSpan.FromSeconds( 5 ), ref repll ) )
            {
                repll.RemoveAt( 0 );

                var ret = repll[0].Split( '/' );
                repll.Clear();

                ret.ForEach( s => 
                {
                    if ( s.Equals( "ok" ) || s.Equals( "nok" ) || s.Equals( index ) )
                        repll.Add( s );
                } );

                vll = repll;

                return true;
            }
            else
                return false;
        }

        #region Get Request Method
        public eOperatationMode GetOperationMode()
        {
            List<string> rll;
            this.GetRequst( "111", out rll );

            if ( rll[0].Equals( "1" ) )
                return eOperatationMode.AutoMode;
            else
                return eOperatationMode.ManualMode;
        }

        public int CurrentPointNo()
        {
            List<string> rll;
            this.GetRequst( "111", out rll );

            int ret = 0;
            int.TryParse( rll[1], out ret );

            return ret;
        }
        #endregion

        #region Set Request Method

        internal void SetObstruction( eObstacleState state )
        {
            string outStr = string.Empty;

            switch ( state )
            {
                case eObstacleState.Normal:
                    this.Request( "setm", "5001/0", out outStr );
                    break;
                case eObstacleState.Abnormal:
                    this.Request( "setm", "5001/3", out outStr );
                    break;
                case eObstacleState.Blocked:
                    this.Request( "setm", "5001/2", out outStr );
                    break;
                case eObstacleState.Decelerate:
                    this.Request( "setm", "5001/1", out outStr );
                    break;
                default:
                    break;
            }
        }

        internal void SetOperationSate(eOperatationMode mode)
        {
            string outStr = string.Empty;

            if ( mode == eOperatationMode.AutoMode )
                this.Request( "set", "112/1", out outStr );
            else if ( mode == eOperatationMode.ManualMode )
                this.Request( "set", "112/0", out outStr );
            else
            { }
        }

        internal void SetMCState(bool isOn )
        {
            string outStr = string.Empty;
            if ( isOn )
                this.Request( "setm", "5000/1", out outStr );
            else
                this.Request( "setm", "5000/0", out outStr );
        }

        internal void SetCurrentSteeringState( eSteeringState state )
        {
            string outStr = string.Empty;
            bool ret = false;
            switch ( state )
            {
                case eSteeringState.None:
                    ret = this.Request( "set", "3060/0/0", out outStr );
                    break;
                case eSteeringState.Left:
                    ret = this.Request( "set", "3060/0/1", out outStr );
                    break;
                case eSteeringState.Right:
                    ret = this.Request( "set", "3060/0/-1", out outStr );
                    break;
                default:
                    break;
            }
        }
        #endregion
    }
}